ext/CrashServer/external/WTL/Include/atlctrls.h

   1 // Windows Template Library - WTL version 9.0
   2 // Copyright (C) Microsoft Corporation, WTL Team. All rights reserved.
   3 //
   4 // This file is a part of the Windows Template Library.
   5 // The use and distribution terms for this software are covered by the
   6 // Common Public License 1.0 (http://opensource.org/licenses/cpl1.0.php)
   7 // which can be found in the file CPL.TXT at the root of this distribution.
   8 // By using this software in any fashion, you are agreeing to be bound by
   9 // the terms of this license. You must not remove this notice, or
  10 // any other, from this software.
  11
  12 #ifndef __ATLCTRLS_H__
  13 #define __ATLCTRLS_H__
  14
  15 #pragma once
  16
  17 #ifndef __ATLAPP_H__
  18     #error atlctrls.h requires atlapp.h to be included first
  19 #endif
  20
  21 #ifndef __ATLWIN_H__
  22     #error atlctrls.h requires atlwin.h to be included first
  23 #endif
  24
  25 #ifndef _WIN32_WCE
  26   #include <richedit.h>
  27   #include <richole.h>
  28 #elif defined(WIN32_PLATFORM_WFSP) && !defined(_WINUSERM_H_)
  29   #include <winuserm.h>
  30 #endif // !_WIN32_WCE
  31
  32 // protect template members from windowsx.h macros
  33 #ifdef _INC_WINDOWSX
  34   #undef GetNextSibling
  35   #undef GetPrevSibling
  36 #endif // _INC_WINDOWSX
  37
  38
  39 ///////////////////////////////////////////////////////////////////////////////
  40 // Classes in this file:
  41 //
  42 // CStaticT<TBase> - CStatic
  43 // CButtonT<TBase> - CButton
  44 // CListBoxT<TBase> - CListBox
  45 // CComboBoxT<TBase> - CComboBox
  46 // CEditT<TBase> - CEdit
  47 // CEditCommands<T>
  48 // CScrollBarT<TBase> - CScrollBar
  49 //
  50 // CImageListT<t_bManaged> - CImageList, CImageListManaged
  51 // CListViewCtrlT<TBase> - CListViewCtrl
  52 // CTreeViewCtrlT<TBase> - CTreeViewCtrl
  53 // CTreeItemT<TBase> - CTreeItem
  54 // CTreeViewCtrlExT<TBase> - CTreeViewCtrlEx
  55 // CHeaderCtrlT<TBase> - CHeaderCtrl
  56 // CToolBarCtrlT<TBase> - CToolBarCtrl
  57 // CStatusBarCtrlT<TBase> - CStatusBarCtrl
  58 // CTabCtrlT<TBase> - CTabCtrl
  59 // CToolInfo
  60 // CToolTipCtrlT<TBase> - CToolTipCtrl
  61 // CTrackBarCtrlT<TBase> - CTrackBarCtrl
  62 // CUpDownCtrlT<TBase> - CUpDownCtrl
  63 // CProgressBarCtrlT<TBase> - CProgressBarCtrl
  64 // CHotKeyCtrlT<TBase> - CHotKeyCtrl
  65 // CAnimateCtrlT<TBase> - CAnimateCtrl
  66 // CRichEditCtrlT<TBase> - CRichEditCtrl
  67 // CRichEditCommands<T>
  68 // CDragListBoxT<TBase> - CDragListBox
  69 // CDragListNotifyImpl<T>
  70 // CReBarCtrlT<TBase> - CReBarCtrl
  71 // CComboBoxExT<TBase> - CComboBoxEx
  72 // CDateTimePickerCtrlT<TBase> - CDateTimePickerCtrl
  73 // CMonthCalendarCtrlT<TBase> - CMonthCalendarCtrl
  74 // CFlatScrollBarImpl<T>
  75 // CFlatScrollBarT<TBase> - CFlatScrollBar
  76 // CIPAddressCtrlT<TBase> - CIPAddressCtrl
  77 // CPagerCtrlT<TBase> - CPagerCtrl
  78 // CLinkCtrlT<TBase> - CLinkCtrl
  79 //
  80 // CCustomDraw<T>
  81 //
  82 // CCECommandBarCtrlT<TBase> - CCECommandBarCtrl
  83 // CCECommandBandsCtrlT<TBase> - CCECommandBandsCtrl
  84
  85
  86 namespace WTL
  87 {
  88
  89 // These are wrapper classes for Windows standard and common controls.
  90 // To implement a window based on a control, use following:
  91 // Example: Implementing a window based on a list box
  92 //
  93 // class CMyListBox : CWindowImpl<CMyListBox, CListBox>
  94 // {
  95 // public:
  96 //      BEGIN_MSG_MAP(CMyListBox)
  97 //          // put your message handler entries here
  98 //      END_MSG_MAP()
  99 // };
 100
 101
 102
 103 // --- Standard Windows controls ---
 104
 105 ///////////////////////////////////////////////////////////////////////////////
 106 // CStatic - client side for a Windows STATIC control
 107
 108 template <class TBase>
 109 class CStaticT : public TBase
 110 {
 111 public:
 112 // Constructors
 113     CStaticT(HWND hWnd = NULL) : TBase(hWnd)
 114     { }
 115
 116     CStaticT< TBase >& operator =(HWND hWnd)
 117     {
 118         m_hWnd = hWnd;
 119         return *this;
 120     }
 121
 122     HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
 123             DWORD dwStyle = 0, DWORD dwExStyle = 0,
 124             ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
 125     {
 126         return TBase::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);
 127     }
 128
 129 // Attributes
 130     static LPCTSTR GetWndClassName()
 131     {
 132         return _T("STATIC");
 133     }
 134
 135 #ifndef _WIN32_WCE
 136     HICON GetIcon() const
 137     {
 138         ATLASSERT(::IsWindow(m_hWnd));
 139         return (HICON)::SendMessage(m_hWnd, STM_GETICON, 0, 0L);
 140     }
 141
 142     HICON SetIcon(HICON hIcon)
 143     {
 144         ATLASSERT(::IsWindow(m_hWnd));
 145         return (HICON)::SendMessage(m_hWnd, STM_SETICON, (WPARAM)hIcon, 0L);
 146     }
 147
 148     HENHMETAFILE GetEnhMetaFile() const
 149     {
 150         ATLASSERT(::IsWindow(m_hWnd));
 151         return (HENHMETAFILE)::SendMessage(m_hWnd, STM_GETIMAGE, IMAGE_ENHMETAFILE, 0L);
 152     }
 153
 154     HENHMETAFILE SetEnhMetaFile(HENHMETAFILE hMetaFile)
 155     {
 156         ATLASSERT(::IsWindow(m_hWnd));
 157         return (HENHMETAFILE)::SendMessage(m_hWnd, STM_SETIMAGE, IMAGE_ENHMETAFILE, (LPARAM)hMetaFile);
 158     }
 159 #else // CE specific
 160     HICON GetIcon() const
 161     {
 162         ATLASSERT(::IsWindow(m_hWnd));
 163         return (HICON)::SendMessage(m_hWnd, STM_GETIMAGE, IMAGE_ICON, 0L);
 164     }
 165
 166     HICON SetIcon(HICON hIcon)
 167     {
 168         ATLASSERT(::IsWindow(m_hWnd));
 169         return (HICON)::SendMessage(m_hWnd, STM_SETIMAGE, IMAGE_ICON, (LPARAM)hIcon);
 170     }
 171 #endif // _WIN32_WCE
 172
 173     CBitmapHandle GetBitmap() const
 174     {
 175         ATLASSERT(::IsWindow(m_hWnd));
 176         return CBitmapHandle((HBITMAP)::SendMessage(m_hWnd, STM_GETIMAGE, IMAGE_BITMAP, 0L));
 177     }
 178
 179     CBitmapHandle SetBitmap(HBITMAP hBitmap)
 180     {
 181         ATLASSERT(::IsWindow(m_hWnd));
 182         return CBitmapHandle((HBITMAP)::SendMessage(m_hWnd, STM_SETIMAGE, IMAGE_BITMAP, (LPARAM)hBitmap));
 183     }
 184
 185     HCURSOR GetCursor() const
 186     {
 187         ATLASSERT(::IsWindow(m_hWnd));
 188         return (HCURSOR)::SendMessage(m_hWnd, STM_GETIMAGE, IMAGE_CURSOR, 0L);
 189     }
 190
 191     HCURSOR SetCursor(HCURSOR hCursor)
 192     {
 193         ATLASSERT(::IsWindow(m_hWnd));
 194         return (HCURSOR)::SendMessage(m_hWnd, STM_SETIMAGE, IMAGE_CURSOR, (LPARAM)hCursor);
 195     }
 196 };
 197
 198 typedef CStaticT<ATL::CWindow>   CStatic;
 199
 200
 201 ///////////////////////////////////////////////////////////////////////////////
 202 // CButton - client side for a Windows BUTTON control
 203
 204 template <class TBase>
 205 class CButtonT : public TBase
 206 {
 207 public:
 208 // Constructors
 209     CButtonT(HWND hWnd = NULL) : TBase(hWnd)
 210     { }
 211
 212     CButtonT< TBase >& operator =(HWND hWnd)
 213     {
 214         m_hWnd = hWnd;
 215         return *this;
 216     }
 217
 218     HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
 219             DWORD dwStyle = 0, DWORD dwExStyle = 0,
 220             ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
 221     {
 222         return TBase::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);
 223     }
 224
 225 // Attributes
 226     static LPCTSTR GetWndClassName()
 227     {
 228         return _T("BUTTON");
 229     }
 230
 231     UINT GetState() const
 232     {
 233         ATLASSERT(::IsWindow(m_hWnd));
 234         return (UINT)::SendMessage(m_hWnd, BM_GETSTATE, 0, 0L);
 235     }
 236
 237     void SetState(BOOL bHighlight)
 238     {
 239         ATLASSERT(::IsWindow(m_hWnd));
 240         ::SendMessage(m_hWnd, BM_SETSTATE, bHighlight, 0L);
 241     }
 242
 243     int GetCheck() const
 244     {
 245         ATLASSERT(::IsWindow(m_hWnd));
 246         return (int)::SendMessage(m_hWnd, BM_GETCHECK, 0, 0L);
 247     }
 248
 249     void SetCheck(int nCheck)
 250     {
 251         ATLASSERT(::IsWindow(m_hWnd));
 252         ::SendMessage(m_hWnd, BM_SETCHECK, nCheck, 0L);
 253     }
 254
 255     UINT GetButtonStyle() const
 256     {
 257         ATLASSERT(::IsWindow(m_hWnd));
 258         return (UINT)::GetWindowLong(m_hWnd, GWL_STYLE) & 0xFFFF;
 259     }
 260
 261     void SetButtonStyle(UINT nStyle, BOOL bRedraw = TRUE)
 262     {
 263         ATLASSERT(::IsWindow(m_hWnd));
 264         ::SendMessage(m_hWnd, BM_SETSTYLE, nStyle, (LPARAM)bRedraw);
 265     }
 266
 267 #ifndef _WIN32_WCE
 268     HICON GetIcon() const
 269     {
 270         ATLASSERT(::IsWindow(m_hWnd));
 271         return (HICON)::SendMessage(m_hWnd, BM_GETIMAGE, IMAGE_ICON, 0L);
 272     }
 273
 274     HICON SetIcon(HICON hIcon)
 275     {
 276         ATLASSERT(::IsWindow(m_hWnd));
 277         return (HICON)::SendMessage(m_hWnd, BM_SETIMAGE, IMAGE_ICON, (LPARAM)hIcon);
 278     }
 279
 280     CBitmapHandle GetBitmap() const
 281     {
 282         ATLASSERT(::IsWindow(m_hWnd));
 283         return CBitmapHandle((HBITMAP)::SendMessage(m_hWnd, BM_GETIMAGE, IMAGE_BITMAP, 0L));
 284     }
 285
 286     CBitmapHandle SetBitmap(HBITMAP hBitmap)
 287     {
 288         ATLASSERT(::IsWindow(m_hWnd));
 289         return CBitmapHandle((HBITMAP)::SendMessage(m_hWnd, BM_SETIMAGE, IMAGE_BITMAP, (LPARAM)hBitmap));
 290     }
 291 #endif // !_WIN32_WCE
 292
 293 #if (_WIN32_WINNT >= 0x0501)
 294     BOOL GetIdealSize(LPSIZE lpSize) const
 295     {
 296         ATLASSERT(::IsWindow(m_hWnd));
 297         return (BOOL)::SendMessage(m_hWnd, BCM_GETIDEALSIZE, 0, (LPARAM)lpSize);
 298     }
 299
 300     BOOL GetImageList(PBUTTON_IMAGELIST pButtonImagelist) const
 301     {
 302         ATLASSERT(::IsWindow(m_hWnd));
 303         return (BOOL)::SendMessage(m_hWnd, BCM_GETIMAGELIST, 0, (LPARAM)pButtonImagelist);
 304     }
 305
 306     BOOL SetImageList(PBUTTON_IMAGELIST pButtonImagelist)
 307     {
 308         ATLASSERT(::IsWindow(m_hWnd));
 309         return (BOOL)::SendMessage(m_hWnd, BCM_SETIMAGELIST, 0, (LPARAM)pButtonImagelist);
 310     }
 311
 312     BOOL GetTextMargin(LPRECT lpRect) const
 313     {
 314         ATLASSERT(::IsWindow(m_hWnd));
 315         return (BOOL)::SendMessage(m_hWnd, BCM_GETTEXTMARGIN, 0, (LPARAM)lpRect);
 316     }
 317
 318     BOOL SetTextMargin(LPRECT lpRect)
 319     {
 320         ATLASSERT(::IsWindow(m_hWnd));
 321         return (BOOL)::SendMessage(m_hWnd, BCM_SETTEXTMARGIN, 0, (LPARAM)lpRect);
 322     }
 323 #endif // (_WIN32_WINNT >= 0x0501)
 324
 325 #if (WINVER >= 0x0600)
 326     void SetDontClick(BOOL bDontClick)
 327     {
 328         ATLASSERT(::IsWindow(m_hWnd));
 329         ::SendMessage(m_hWnd, BM_SETDONTCLICK, (WPARAM)bDontClick, 0L);
 330     }
 331 #endif // (WINVER >= 0x0600)
 332
 333 #if (_WIN32_WINNT >= 0x0600)
 334     BOOL SetDropDownState(BOOL bDropDown)
 335     {
 336         ATLASSERT(::IsWindow(m_hWnd));
 337         ATLASSERT((GetStyle() & (BS_SPLITBUTTON | BS_DEFSPLITBUTTON)) != 0);
 338         return (BOOL)::SendMessage(m_hWnd, BCM_SETDROPDOWNSTATE, (WPARAM)bDropDown, 0L);
 339     }
 340
 341     BOOL GetSplitInfo(PBUTTON_SPLITINFO pSplitInfo) const
 342     {
 343         ATLASSERT(::IsWindow(m_hWnd));
 344         ATLASSERT((GetStyle() & (BS_SPLITBUTTON | BS_DEFSPLITBUTTON)) != 0);
 345         return (BOOL)::SendMessage(m_hWnd, BCM_GETSPLITINFO, 0, (LPARAM)pSplitInfo);
 346     }
 347
 348     BOOL SetSplitInfo(PBUTTON_SPLITINFO pSplitInfo)
 349     {
 350         ATLASSERT(::IsWindow(m_hWnd));
 351         ATLASSERT((GetStyle() & (BS_SPLITBUTTON | BS_DEFSPLITBUTTON)) != 0);
 352         return (BOOL)::SendMessage(m_hWnd, BCM_SETSPLITINFO, 0, (LPARAM)pSplitInfo);
 353     }
 354
 355     int GetNoteLength() const
 356     {
 357         ATLASSERT(::IsWindow(m_hWnd));
 358         ATLASSERT((GetStyle() & (BS_COMMANDLINK | BS_DEFCOMMANDLINK)) != 0);
 359         return (int)::SendMessage(m_hWnd, BCM_GETNOTELENGTH, 0, 0L);
 360     }
 361
 362     BOOL GetNote(LPWSTR lpstrNoteText, int cchNoteText) const
 363     {
 364         ATLASSERT(::IsWindow(m_hWnd));
 365         ATLASSERT((GetStyle() & (BS_COMMANDLINK | BS_DEFCOMMANDLINK)) != 0);
 366         return (BOOL)::SendMessage(m_hWnd, BCM_GETNOTE, cchNoteText, (LPARAM)lpstrNoteText);
 367     }
 368
 369     BOOL SetNote(LPCWSTR lpstrNoteText)
 370     {
 371         ATLASSERT(::IsWindow(m_hWnd));
 372         ATLASSERT((GetStyle() & (BS_COMMANDLINK | BS_DEFCOMMANDLINK)) != 0);
 373         return (BOOL)::SendMessage(m_hWnd, BCM_SETNOTE, 0, (LPARAM)lpstrNoteText);
 374     }
 375
 376     LRESULT SetElevationRequiredState(BOOL bSet)
 377     {
 378         ATLASSERT(::IsWindow(m_hWnd));
 379         return ::SendMessage(m_hWnd, BCM_SETSHIELD, 0, (LPARAM)bSet);
 380     }
 381 #endif // (_WIN32_WINNT >= 0x0600)
 382
 383 // Operations
 384     void Click()
 385     {
 386         ATLASSERT(::IsWindow(m_hWnd));
 387         ::SendMessage(m_hWnd, BM_CLICK, 0, 0L);
 388     }
 389 };
 390
 391 typedef CButtonT<ATL::CWindow>   CButton;
 392
 393
 394 ///////////////////////////////////////////////////////////////////////////////
 395 // CListBox - client side for a Windows LISTBOX control
 396
 397 template <class TBase>
 398 class CListBoxT : public TBase
 399 {
 400 public:
 401 // Constructors
 402     CListBoxT(HWND hWnd = NULL) : TBase(hWnd)
 403     { }
 404
 405     CListBoxT< TBase >& operator =(HWND hWnd)
 406     {
 407         m_hWnd = hWnd;
 408         return *this;
 409     }
 410
 411     HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
 412             DWORD dwStyle = 0, DWORD dwExStyle = 0,
 413             ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
 414     {
 415         return TBase::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);
 416     }
 417
 418 // Attributes
 419     static LPCTSTR GetWndClassName()
 420     {
 421         return _T("LISTBOX");
 422     }
 423
 424     // for entire listbox
 425     int GetCount() const
 426     {
 427         ATLASSERT(::IsWindow(m_hWnd));
 428         return (int)::SendMessage(m_hWnd, LB_GETCOUNT, 0, 0L);
 429     }
 430
 431 #ifndef _WIN32_WCE
 432     int SetCount(int cItems)
 433     {
 434         ATLASSERT(::IsWindow(m_hWnd));
 435         ATLASSERT(((GetStyle() & LBS_NODATA) != 0) && ((GetStyle() & LBS_HASSTRINGS) == 0));
 436         return (int)::SendMessage(m_hWnd, LB_SETCOUNT, cItems, 0L);
 437     }
 438 #endif // !_WIN32_WCE
 439
 440     int GetHorizontalExtent() const
 441     {
 442         ATLASSERT(::IsWindow(m_hWnd));
 443         return (int)::SendMessage(m_hWnd, LB_GETHORIZONTALEXTENT, 0, 0L);
 444     }
 445
 446     void SetHorizontalExtent(int cxExtent)
 447     {
 448         ATLASSERT(::IsWindow(m_hWnd));
 449         ::SendMessage(m_hWnd, LB_SETHORIZONTALEXTENT, cxExtent, 0L);
 450     }
 451
 452     int GetTopIndex() const
 453     {
 454         ATLASSERT(::IsWindow(m_hWnd));
 455         return (int)::SendMessage(m_hWnd, LB_GETTOPINDEX, 0, 0L);
 456     }
 457
 458     int SetTopIndex(int nIndex)
 459     {
 460         ATLASSERT(::IsWindow(m_hWnd));
 461         return (int)::SendMessage(m_hWnd, LB_SETTOPINDEX, nIndex, 0L);
 462     }
 463
 464     LCID GetLocale() const
 465     {
 466         ATLASSERT(::IsWindow(m_hWnd));
 467         return (LCID)::SendMessage(m_hWnd, LB_GETLOCALE, 0, 0L);
 468     }
 469
 470     LCID SetLocale(LCID nNewLocale)
 471     {
 472         ATLASSERT(::IsWindow(m_hWnd));
 473         return (LCID)::SendMessage(m_hWnd, LB_SETLOCALE, (WPARAM)nNewLocale, 0L);
 474     }
 475
 476 #if (WINVER >= 0x0500) && !defined(_WIN32_WCE)
 477     DWORD GetListBoxInfo() const
 478     {
 479         ATLASSERT(::IsWindow(m_hWnd));
 480 #if (_WIN32_WINNT >= 0x0501)
 481         return (DWORD)::SendMessage(m_hWnd, LB_GETLISTBOXINFO, 0, 0L);
 482 #else // !(_WIN32_WINNT >= 0x0501)
 483         return ::GetListBoxInfo(m_hWnd);
 484 #endif // !(_WIN32_WINNT >= 0x0501)
 485     }
 486 #endif // (WINVER >= 0x0500) && !defined(_WIN32_WCE)
 487
 488     // for single-selection listboxes
 489     int GetCurSel() const
 490     {
 491         ATLASSERT(::IsWindow(m_hWnd));
 492         ATLASSERT((GetStyle() & (LBS_MULTIPLESEL | LBS_EXTENDEDSEL)) == 0);
 493         return (int)::SendMessage(m_hWnd, LB_GETCURSEL, 0, 0L);
 494     }
 495
 496     int SetCurSel(int nSelect)
 497     {
 498         ATLASSERT(::IsWindow(m_hWnd));
 499         ATLASSERT((GetStyle() & (LBS_MULTIPLESEL | LBS_EXTENDEDSEL)) == 0);
 500         return (int)::SendMessage(m_hWnd, LB_SETCURSEL, nSelect, 0L);
 501     }
 502
 503     // for multiple-selection listboxes
 504     int GetSel(int nIndex) const           // also works for single-selection
 505     {
 506         ATLASSERT(::IsWindow(m_hWnd));
 507         return (int)::SendMessage(m_hWnd, LB_GETSEL, nIndex, 0L);
 508     }
 509
 510     int SetSel(int nIndex, BOOL bSelect = TRUE)
 511     {
 512         ATLASSERT(::IsWindow(m_hWnd));
 513         ATLASSERT((GetStyle() & (LBS_MULTIPLESEL | LBS_EXTENDEDSEL)) != 0);
 514         return (int)::SendMessage(m_hWnd, LB_SETSEL, bSelect, nIndex);
 515     }
 516
 517     int GetSelCount() const
 518     {
 519         ATLASSERT(::IsWindow(m_hWnd));
 520         ATLASSERT((GetStyle() & (LBS_MULTIPLESEL | LBS_EXTENDEDSEL)) != 0);
 521         return (int)::SendMessage(m_hWnd, LB_GETSELCOUNT, 0, 0L);
 522     }
 523
 524     int GetSelItems(int nMaxItems, LPINT rgIndex) const
 525     {
 526         ATLASSERT(::IsWindow(m_hWnd));
 527         ATLASSERT((GetStyle() & (LBS_MULTIPLESEL | LBS_EXTENDEDSEL)) != 0);
 528         return (int)::SendMessage(m_hWnd, LB_GETSELITEMS, nMaxItems, (LPARAM)rgIndex);
 529     }
 530
 531     int GetAnchorIndex() const
 532     {
 533         ATLASSERT(::IsWindow(m_hWnd));
 534         ATLASSERT((GetStyle() & (LBS_MULTIPLESEL | LBS_EXTENDEDSEL)) != 0);
 535         return (int)::SendMessage(m_hWnd, LB_GETANCHORINDEX, 0, 0L);
 536     }
 537
 538     void SetAnchorIndex(int nIndex)
 539     {
 540         ATLASSERT(::IsWindow(m_hWnd));
 541         ATLASSERT((GetStyle() & (LBS_MULTIPLESEL | LBS_EXTENDEDSEL)) != 0);
 542         ::SendMessage(m_hWnd, LB_SETANCHORINDEX, nIndex, 0L);
 543     }
 544
 545     int GetCaretIndex() const
 546     {
 547         ATLASSERT(::IsWindow(m_hWnd));
 548         return (int)::SendMessage(m_hWnd, LB_GETCARETINDEX, 0, 0);
 549     }
 550
 551     int SetCaretIndex(int nIndex, BOOL bScroll = TRUE)
 552     {
 553         ATLASSERT(::IsWindow(m_hWnd));
 554         return (int)::SendMessage(m_hWnd, LB_SETCARETINDEX, nIndex, MAKELONG(bScroll, 0));
 555     }
 556
 557     // for listbox items
 558     DWORD_PTR GetItemData(int nIndex) const
 559     {
 560         ATLASSERT(::IsWindow(m_hWnd));
 561         return (DWORD_PTR)::SendMessage(m_hWnd, LB_GETITEMDATA, nIndex, 0L);
 562     }
 563
 564     int SetItemData(int nIndex, DWORD_PTR dwItemData)
 565     {
 566         ATLASSERT(::IsWindow(m_hWnd));
 567         return (int)::SendMessage(m_hWnd, LB_SETITEMDATA, nIndex, (LPARAM)dwItemData);
 568     }
 569
 570     void* GetItemDataPtr(int nIndex) const
 571     {
 572         ATLASSERT(::IsWindow(m_hWnd));
 573         return (void*)::SendMessage(m_hWnd, LB_GETITEMDATA, nIndex, 0L);
 574     }
 575
 576     int SetItemDataPtr(int nIndex, void* pData)
 577     {
 578         ATLASSERT(::IsWindow(m_hWnd));
 579         return SetItemData(nIndex, (DWORD_PTR)pData);
 580     }
 581
 582     int GetItemRect(int nIndex, LPRECT lpRect) const
 583     {
 584         ATLASSERT(::IsWindow(m_hWnd));
 585         return (int)::SendMessage(m_hWnd, LB_GETITEMRECT, nIndex, (LPARAM)lpRect);
 586     }
 587
 588     int GetText(int nIndex, LPTSTR lpszBuffer) const
 589     {
 590         ATLASSERT(::IsWindow(m_hWnd));
 591         return (int)::SendMessage(m_hWnd, LB_GETTEXT, nIndex, (LPARAM)lpszBuffer);
 592     }
 593
 594 #ifndef _ATL_NO_COM
 595 #ifdef _OLEAUTO_H_
 596     BOOL GetTextBSTR(int nIndex, BSTR& bstrText) const
 597     {
 598         USES_CONVERSION;
 599         ATLASSERT(::IsWindow(m_hWnd));
 600         ATLASSERT(bstrText == NULL);
 601
 602         int nLen = GetTextLen(nIndex);
 603         if(nLen == LB_ERR)
 604             return FALSE;
 605
 606         CTempBuffer<TCHAR, _WTL_STACK_ALLOC_THRESHOLD> buff;
 607         LPTSTR lpstrText = buff.Allocate(nLen + 1);
 608         if(lpstrText == NULL)
 609             return FALSE;
 610
 611         if(GetText(nIndex, lpstrText) == LB_ERR)
 612             return FALSE;
 613
 614         bstrText = ::SysAllocString(T2OLE(lpstrText));
 615         return (bstrText != NULL) ? TRUE : FALSE;
 616     }
 617 #endif // _OLEAUTO_H_
 618 #endif // !_ATL_NO_COM
 619
 620 #if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
 621     int GetText(int nIndex, _CSTRING_NS::CString& strText) const
 622     {
 623         ATLASSERT(::IsWindow(m_hWnd));
 624         int cchLen = GetTextLen(nIndex);
 625         if(cchLen == LB_ERR)
 626             return LB_ERR;
 627         int nRet = LB_ERR;
 628         LPTSTR lpstr = strText.GetBufferSetLength(cchLen);
 629         if(lpstr != NULL)
 630         {
 631             nRet = GetText(nIndex, lpstr);
 632             strText.ReleaseBuffer();
 633         }
 634         return nRet;
 635     }
 636 #endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
 637
 638     int GetTextLen(int nIndex) const
 639     {
 640         ATLASSERT(::IsWindow(m_hWnd));
 641         return (int)::SendMessage(m_hWnd, LB_GETTEXTLEN, nIndex, 0L);
 642     }
 643
 644     int GetItemHeight(int nIndex) const
 645     {
 646         ATLASSERT(::IsWindow(m_hWnd));
 647         return (int)::SendMessage(m_hWnd, LB_GETITEMHEIGHT, nIndex, 0L);
 648     }
 649
 650     int SetItemHeight(int nIndex, UINT cyItemHeight)
 651     {
 652         ATLASSERT(::IsWindow(m_hWnd));
 653         return (int)::SendMessage(m_hWnd, LB_SETITEMHEIGHT, nIndex, MAKELONG(cyItemHeight, 0));
 654     }
 655
 656     // Settable only attributes
 657     void SetColumnWidth(int cxWidth)
 658     {
 659         ATLASSERT(::IsWindow(m_hWnd));
 660         ::SendMessage(m_hWnd, LB_SETCOLUMNWIDTH, cxWidth, 0L);
 661     }
 662
 663     BOOL SetTabStops(int nTabStops, LPINT rgTabStops)
 664     {
 665         ATLASSERT(::IsWindow(m_hWnd));
 666         ATLASSERT((GetStyle() & LBS_USETABSTOPS) != 0);
 667         return (BOOL)::SendMessage(m_hWnd, LB_SETTABSTOPS, nTabStops, (LPARAM)rgTabStops);
 668     }
 669
 670     BOOL SetTabStops()
 671     {
 672         ATLASSERT(::IsWindow(m_hWnd));
 673         ATLASSERT((GetStyle() & LBS_USETABSTOPS) != 0);
 674         return (BOOL)::SendMessage(m_hWnd, LB_SETTABSTOPS, 0, 0L);
 675     }
 676
 677     BOOL SetTabStops(const int& cxEachStop)    // takes an 'int'
 678     {
 679         ATLASSERT(::IsWindow(m_hWnd));
 680         ATLASSERT((GetStyle() & LBS_USETABSTOPS) != 0);
 681         return (BOOL)::SendMessage(m_hWnd, LB_SETTABSTOPS, 1, (LPARAM)(LPINT)&cxEachStop);
 682     }
 683
 684 // Operations
 685     int InitStorage(int nItems, UINT nBytes)
 686     {
 687         ATLASSERT(::IsWindow(m_hWnd));
 688         return (int)::SendMessage(m_hWnd, LB_INITSTORAGE, (WPARAM)nItems, nBytes);
 689     }
 690
 691     void ResetContent()
 692     {
 693         ATLASSERT(::IsWindow(m_hWnd));
 694         ::SendMessage(m_hWnd, LB_RESETCONTENT, 0, 0L);
 695     }
 696
 697     UINT ItemFromPoint(POINT pt, BOOL& bOutside) const
 698     {
 699         ATLASSERT(::IsWindow(m_hWnd));
 700         DWORD dw = (DWORD)::SendMessage(m_hWnd, LB_ITEMFROMPOINT, 0, MAKELPARAM(pt.x, pt.y));
 701         bOutside = (BOOL)HIWORD(dw);
 702         return (UINT)LOWORD(dw);
 703     }
 704
 705     // manipulating listbox items
 706     int AddString(LPCTSTR lpszItem)
 707     {
 708         ATLASSERT(::IsWindow(m_hWnd));
 709         return (int)::SendMessage(m_hWnd, LB_ADDSTRING, 0, (LPARAM)lpszItem);
 710     }
 711
 712     int DeleteString(UINT nIndex)
 713     {
 714         ATLASSERT(::IsWindow(m_hWnd));
 715         return (int)::SendMessage(m_hWnd, LB_DELETESTRING, nIndex, 0L);
 716     }
 717
 718     int InsertString(int nIndex, LPCTSTR lpszItem)
 719     {
 720         ATLASSERT(::IsWindow(m_hWnd));
 721         return (int)::SendMessage(m_hWnd, LB_INSERTSTRING, nIndex, (LPARAM)lpszItem);
 722     }
 723
 724 #ifndef _WIN32_WCE
 725     int Dir(UINT attr, LPCTSTR lpszWildCard)
 726     {
 727         ATLASSERT(::IsWindow(m_hWnd));
 728         return (int)::SendMessage(m_hWnd, LB_DIR, attr, (LPARAM)lpszWildCard);
 729     }
 730
 731     int AddFile(LPCTSTR lpstrFileName)
 732     {
 733         ATLASSERT(::IsWindow(m_hWnd));
 734         return (int)::SendMessage(m_hWnd, LB_ADDFILE, 0, (LPARAM)lpstrFileName);
 735     }
 736 #endif // !_WIN32_WCE
 737
 738     // selection helpers
 739     int FindString(int nStartAfter, LPCTSTR lpszItem) const
 740     {
 741         ATLASSERT(::IsWindow(m_hWnd));
 742         return (int)::SendMessage(m_hWnd, LB_FINDSTRING, nStartAfter, (LPARAM)lpszItem);
 743     }
 744
 745     int FindStringExact(int nIndexStart, LPCTSTR lpszFind) const
 746     {
 747         ATLASSERT(::IsWindow(m_hWnd));
 748         return (int)::SendMessage(m_hWnd, LB_FINDSTRINGEXACT, nIndexStart, (LPARAM)lpszFind);
 749     }
 750
 751     int SelectString(int nStartAfter, LPCTSTR lpszItem)
 752     {
 753         ATLASSERT(::IsWindow(m_hWnd));
 754         return (int)::SendMessage(m_hWnd, LB_SELECTSTRING, nStartAfter, (LPARAM)lpszItem);
 755     }
 756
 757     int SelItemRange(BOOL bSelect, int nFirstItem, int nLastItem)
 758     {
 759         ATLASSERT(::IsWindow(m_hWnd));
 760         ATLASSERT((GetStyle() & (LBS_MULTIPLESEL | LBS_EXTENDEDSEL)) != 0);
 761         ATLASSERT(nFirstItem <= nLastItem);
 762         return bSelect ? (int)::SendMessage(m_hWnd, LB_SELITEMRANGEEX, nFirstItem, nLastItem) : (int)::SendMessage(m_hWnd, LB_SELITEMRANGEEX, nLastItem, nFirstItem);
 763     }
 764
 765 #ifdef WIN32_PLATFORM_WFSP   // SmartPhone only messages
 766     DWORD GetInputMode(BOOL bCurrentMode = TRUE)
 767     {
 768         return SendMessage(LB_GETINPUTMODE, 0, (LPARAM)bCurrentMode);
 769     }
 770
 771     BOOL SetInputMode(DWORD dwMode)
 772     {
 773         return SendMessage(LB_SETINPUTMODE, 0, (LPARAM)dwMode);
 774     }
 775 #endif // WIN32_PLATFORM_WFSP
 776 };
 777
 778 typedef CListBoxT<ATL::CWindow>   CListBox;
 779
 780
 781 ///////////////////////////////////////////////////////////////////////////////
 782 // CComboBox - client side for a Windows COMBOBOX control
 783
 784 #ifndef WIN32_PLATFORM_WFSP   // No COMBOBOX on SmartPhones
 785
 786 template <class TBase>
 787 class CComboBoxT : public TBase
 788 {
 789 public:
 790 // Constructors
 791     CComboBoxT(HWND hWnd = NULL) : TBase(hWnd)
 792     { }
 793
 794     CComboBoxT< TBase >& operator =(HWND hWnd)
 795     {
 796         m_hWnd = hWnd;
 797         return *this;
 798     }
 799
 800     HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
 801             DWORD dwStyle = 0, DWORD dwExStyle = 0,
 802             ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
 803     {
 804         return TBase::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);
 805     }
 806
 807 // Attributes
 808     static LPCTSTR GetWndClassName()
 809     {
 810         return _T("COMBOBOX");
 811     }
 812
 813     // for entire combo box
 814     int GetCount() const
 815     {
 816         ATLASSERT(::IsWindow(m_hWnd));
 817         return (int)::SendMessage(m_hWnd, CB_GETCOUNT, 0, 0L);
 818     }
 819
 820     int GetCurSel() const
 821     {
 822         ATLASSERT(::IsWindow(m_hWnd));
 823         return (int)::SendMessage(m_hWnd, CB_GETCURSEL, 0, 0L);
 824     }
 825
 826     int SetCurSel(int nSelect)
 827     {
 828         ATLASSERT(::IsWindow(m_hWnd));
 829         return (int)::SendMessage(m_hWnd, CB_SETCURSEL, nSelect, 0L);
 830     }
 831
 832     LCID GetLocale() const
 833     {
 834         ATLASSERT(::IsWindow(m_hWnd));
 835         return (LCID)::SendMessage(m_hWnd, CB_GETLOCALE, 0, 0L);
 836     }
 837
 838     LCID SetLocale(LCID nNewLocale)
 839     {
 840         ATLASSERT(::IsWindow(m_hWnd));
 841         return (LCID)::SendMessage(m_hWnd, CB_SETLOCALE, (WPARAM)nNewLocale, 0L);
 842     }
 843
 844     int GetTopIndex() const
 845     {
 846         ATLASSERT(::IsWindow(m_hWnd));
 847         return (int)::SendMessage(m_hWnd, CB_GETTOPINDEX, 0, 0L);
 848     }
 849
 850     int SetTopIndex(int nIndex)
 851     {
 852         ATLASSERT(::IsWindow(m_hWnd));
 853         return (int)::SendMessage(m_hWnd, CB_SETTOPINDEX, nIndex, 0L);
 854     }
 855
 856     UINT GetHorizontalExtent() const
 857     {
 858         ATLASSERT(::IsWindow(m_hWnd));
 859         return (UINT)::SendMessage(m_hWnd, CB_GETHORIZONTALEXTENT, 0, 0L);
 860     }
 861
 862     void SetHorizontalExtent(UINT nExtent)
 863     {
 864         ATLASSERT(::IsWindow(m_hWnd));
 865         ::SendMessage(m_hWnd, CB_SETHORIZONTALEXTENT, nExtent, 0L);
 866     }
 867
 868     int GetDroppedWidth() const
 869     {
 870         ATLASSERT(::IsWindow(m_hWnd));
 871         return (int)::SendMessage(m_hWnd, CB_GETDROPPEDWIDTH, 0, 0L);
 872     }
 873
 874     int SetDroppedWidth(UINT nWidth)
 875     {
 876         ATLASSERT(::IsWindow(m_hWnd));
 877         return (int)::SendMessage(m_hWnd, CB_SETDROPPEDWIDTH, nWidth, 0L);
 878     }
 879
 880 #if ((WINVER >= 0x0500) && !defined(_WIN32_WCE)) || (defined(_WIN32_WCE) && (_WIN32_WCE >= 420))
 881     BOOL GetComboBoxInfo(PCOMBOBOXINFO pComboBoxInfo) const
 882     {
 883         ATLASSERT(::IsWindow(m_hWnd));
 884 #if ((_WIN32_WINNT >= 0x0501) && !defined(_WIN32_WCE)) || (defined(_WIN32_WCE) && (_WIN32_WCE >= 420))
 885         return (BOOL)::SendMessage(m_hWnd, CB_GETCOMBOBOXINFO, 0, (LPARAM)pComboBoxInfo);
 886 #else // !((_WIN32_WINNT >= 0x0501) && !defined(_WIN32_WCE)) || (defined(_WIN32_WCE) && (_WIN32_WCE >= 420))
 887         return ::GetComboBoxInfo(m_hWnd, pComboBoxInfo);
 888 #endif // !((_WIN32_WINNT >= 0x0501) && !defined(_WIN32_WCE)) || (defined(_WIN32_WCE) && (_WIN32_WCE >= 420))
 889     }
 890 #endif // ((WINVER >= 0x0500) && !defined(_WIN32_WCE)) || (defined(_WIN32_WCE) && (_WIN32_WCE >= 420))
 891
 892     // for edit control
 893     DWORD GetEditSel() const
 894     {
 895         ATLASSERT(::IsWindow(m_hWnd));
 896         return (DWORD)::SendMessage(m_hWnd, CB_GETEDITSEL, 0, 0L);
 897     }
 898
 899     BOOL SetEditSel(int nStartChar, int nEndChar)
 900     {
 901         ATLASSERT(::IsWindow(m_hWnd));
 902         return (BOOL)::SendMessage(m_hWnd, CB_SETEDITSEL, 0, MAKELONG(nStartChar, nEndChar));
 903     }
 904
 905     // for combobox item
 906     DWORD_PTR GetItemData(int nIndex) const
 907     {
 908         ATLASSERT(::IsWindow(m_hWnd));
 909         return (DWORD_PTR)::SendMessage(m_hWnd, CB_GETITEMDATA, nIndex, 0L);
 910     }
 911
 912     int SetItemData(int nIndex, DWORD_PTR dwItemData)
 913     {
 914         ATLASSERT(::IsWindow(m_hWnd));
 915         return (int)::SendMessage(m_hWnd, CB_SETITEMDATA, nIndex, (LPARAM)dwItemData);
 916     }
 917
 918     void* GetItemDataPtr(int nIndex) const
 919     {
 920         ATLASSERT(::IsWindow(m_hWnd));
 921         return (void*)GetItemData(nIndex);
 922     }
 923
 924     int SetItemDataPtr(int nIndex, void* pData)
 925     {
 926         ATLASSERT(::IsWindow(m_hWnd));
 927         return SetItemData(nIndex, (DWORD_PTR)pData);
 928     }
 929
 930     int GetLBText(int nIndex, LPTSTR lpszText) const
 931     {
 932         ATLASSERT(::IsWindow(m_hWnd));
 933         return (int)::SendMessage(m_hWnd, CB_GETLBTEXT, nIndex, (LPARAM)lpszText);
 934     }
 935
 936 #ifndef _ATL_NO_COM
 937     BOOL GetLBTextBSTR(int nIndex, BSTR& bstrText) const
 938     {
 939         USES_CONVERSION;
 940         ATLASSERT(::IsWindow(m_hWnd));
 941         ATLASSERT(bstrText == NULL);
 942
 943         int nLen = GetLBTextLen(nIndex);
 944         if(nLen == CB_ERR)
 945             return FALSE;
 946
 947         CTempBuffer<TCHAR, _WTL_STACK_ALLOC_THRESHOLD> buff;
 948         LPTSTR lpstrText = buff.Allocate(nLen + 1);
 949         if(lpstrText == NULL)
 950             return FALSE;
 951
 952         if(GetLBText(nIndex, lpstrText) == CB_ERR)
 953             return FALSE;
 954
 955         bstrText = ::SysAllocString(T2OLE(lpstrText));
 956         return (bstrText != NULL) ? TRUE : FALSE;
 957     }
 958 #endif // !_ATL_NO_COM
 959
 960 #if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
 961     int GetLBText(int nIndex, _CSTRING_NS::CString& strText) const
 962     {
 963         ATLASSERT(::IsWindow(m_hWnd));
 964         int cchLen = GetLBTextLen(nIndex);
 965         if(cchLen == CB_ERR)
 966             return CB_ERR;
 967         int nRet = CB_ERR;
 968         LPTSTR lpstr = strText.GetBufferSetLength(cchLen);
 969         if(lpstr != NULL)
 970         {
 971             nRet = GetLBText(nIndex, lpstr);
 972             strText.ReleaseBuffer();
 973         }
 974         return nRet;
 975     }
 976 #endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
 977
 978     int GetLBTextLen(int nIndex) const
 979     {
 980         ATLASSERT(::IsWindow(m_hWnd));
 981         return (int)::SendMessage(m_hWnd, CB_GETLBTEXTLEN, nIndex, 0L);
 982     }
 983
 984     int GetItemHeight(int nIndex) const
 985     {
 986         ATLASSERT(::IsWindow(m_hWnd));
 987         return (int)::SendMessage(m_hWnd, CB_GETITEMHEIGHT, nIndex, 0L);
 988     }
 989
 990     int SetItemHeight(int nIndex, UINT cyItemHeight)
 991     {
 992         ATLASSERT(::IsWindow(m_hWnd));
 993         return (int)::SendMessage(m_hWnd, CB_SETITEMHEIGHT, nIndex, MAKELONG(cyItemHeight, 0));
 994     }
 995
 996     BOOL GetExtendedUI() const
 997     {
 998         ATLASSERT(::IsWindow(m_hWnd));
 999         return (BOOL)::SendMessage(m_hWnd, CB_GETEXTENDEDUI, 0, 0L);
1000     }
1001
1002     int SetExtendedUI(BOOL bExtended = TRUE)
1003     {
1004         ATLASSERT(::IsWindow(m_hWnd));
1005         return (int)::SendMessage(m_hWnd, CB_SETEXTENDEDUI, bExtended, 0L);
1006     }
1007
1008     void GetDroppedControlRect(LPRECT lprect) const
1009     {
1010         ATLASSERT(::IsWindow(m_hWnd));
1011         ::SendMessage(m_hWnd, CB_GETDROPPEDCONTROLRECT, 0, (LPARAM)lprect);
1012     }
1013
1014     BOOL GetDroppedState() const
1015     {
1016         ATLASSERT(::IsWindow(m_hWnd));
1017         return (BOOL)::SendMessage(m_hWnd, CB_GETDROPPEDSTATE, 0, 0L);
1018     }
1019
1020 #if (_WIN32_WINNT >= 0x0501)
1021     int GetMinVisible() const
1022     {
1023         ATLASSERT(::IsWindow(m_hWnd));
1024         return (int)::SendMessage(m_hWnd, CB_GETMINVISIBLE, 0, 0L);
1025     }
1026
1027     BOOL SetMinVisible(int nMinVisible)
1028     {
1029         ATLASSERT(::IsWindow(m_hWnd));
1030         return (BOOL)::SendMessage(m_hWnd, CB_SETMINVISIBLE, nMinVisible, 0L);
1031     }
1032
1033     // Vista only
1034     BOOL GetCueBannerText(LPWSTR lpwText, int cchText) const
1035     {
1036 #ifndef CB_GETCUEBANNER
1037         const UINT CB_GETCUEBANNER = (CBM_FIRST + 4);
1038 #endif
1039         ATLASSERT(::IsWindow(m_hWnd));
1040         return (BOOL)::SendMessage(m_hWnd, CB_GETCUEBANNER, (WPARAM)lpwText, cchText);
1041     }
1042
1043     // Vista only
1044     BOOL SetCueBannerText(LPCWSTR lpcwText)
1045     {
1046 #ifndef CB_SETCUEBANNER
1047         const UINT CB_SETCUEBANNER = (CBM_FIRST + 3);
1048 #endif
1049         ATLASSERT(::IsWindow(m_hWnd));
1050         return (BOOL)::SendMessage(m_hWnd, CB_SETCUEBANNER, 0, (LPARAM)lpcwText);
1051     }
1052 #endif // (_WIN32_WINNT >= 0x0501)
1053
1054 // Operations
1055     int InitStorage(int nItems, UINT nBytes)
1056     {
1057         ATLASSERT(::IsWindow(m_hWnd));
1058         return (int)::SendMessage(m_hWnd, CB_INITSTORAGE, (WPARAM)nItems, nBytes);
1059     }
1060
1061     void ResetContent()
1062     {
1063         ATLASSERT(::IsWindow(m_hWnd));
1064         ::SendMessage(m_hWnd, CB_RESETCONTENT, 0, 0L);
1065     }
1066
1067     // for edit control
1068     BOOL LimitText(int nMaxChars)
1069     {
1070         ATLASSERT(::IsWindow(m_hWnd));
1071         return (BOOL)::SendMessage(m_hWnd, CB_LIMITTEXT, nMaxChars, 0L);
1072     }
1073
1074     // for drop-down combo boxes
1075     void ShowDropDown(BOOL bShowIt = TRUE)
1076     {
1077         ATLASSERT(::IsWindow(m_hWnd));
1078         ::SendMessage(m_hWnd, CB_SHOWDROPDOWN, bShowIt, 0L);
1079     }
1080
1081     // manipulating listbox items
1082     int AddString(LPCTSTR lpszString)
1083     {
1084         ATLASSERT(::IsWindow(m_hWnd));
1085         return (int)::SendMessage(m_hWnd, CB_ADDSTRING, 0, (LPARAM)lpszString);
1086     }
1087
1088     int DeleteString(UINT nIndex)
1089     {
1090         ATLASSERT(::IsWindow(m_hWnd));
1091         return (int)::SendMessage(m_hWnd, CB_DELETESTRING, nIndex, 0L);
1092     }
1093
1094     int InsertString(int nIndex, LPCTSTR lpszString)
1095     {
1096         ATLASSERT(::IsWindow(m_hWnd));
1097         return (int)::SendMessage(m_hWnd, CB_INSERTSTRING, nIndex, (LPARAM)lpszString);
1098     }
1099
1100 #ifndef _WIN32_WCE
1101     int Dir(UINT attr, LPCTSTR lpszWildCard)
1102     {
1103         ATLASSERT(::IsWindow(m_hWnd));
1104         return (int)::SendMessage(m_hWnd, CB_DIR, attr, (LPARAM)lpszWildCard);
1105     }
1106 #endif // !_WIN32_WCE
1107
1108     // selection helpers
1109     int FindString(int nStartAfter, LPCTSTR lpszString) const
1110     {
1111         ATLASSERT(::IsWindow(m_hWnd));
1112         return (int)::SendMessage(m_hWnd, CB_FINDSTRING, nStartAfter, (LPARAM)lpszString);
1113     }
1114
1115     int FindStringExact(int nIndexStart, LPCTSTR lpszFind) const
1116     {
1117         ATLASSERT(::IsWindow(m_hWnd));
1118         return (int)::SendMessage(m_hWnd, CB_FINDSTRINGEXACT, nIndexStart, (LPARAM)lpszFind);
1119     }
1120
1121     int SelectString(int nStartAfter, LPCTSTR lpszString)
1122     {
1123         ATLASSERT(::IsWindow(m_hWnd));
1124         return (int)::SendMessage(m_hWnd, CB_SELECTSTRING, nStartAfter, (LPARAM)lpszString);
1125     }
1126
1127     // Clipboard operations
1128     void Clear()
1129     {
1130         ATLASSERT(::IsWindow(m_hWnd));
1131         ::SendMessage(m_hWnd, WM_CLEAR, 0, 0L);
1132     }
1133
1134     void Copy()
1135     {
1136         ATLASSERT(::IsWindow(m_hWnd));
1137         ::SendMessage(m_hWnd, WM_COPY, 0, 0L);
1138     }
1139
1140     void Cut()
1141     {
1142         ATLASSERT(::IsWindow(m_hWnd));
1143         ::SendMessage(m_hWnd, WM_CUT, 0, 0L);
1144     }
1145
1146     void Paste()
1147     {
1148         ATLASSERT(::IsWindow(m_hWnd));
1149         ::SendMessage(m_hWnd, WM_PASTE, 0, 0L);
1150     }
1151 };
1152
1153 typedef CComboBoxT<ATL::CWindow>   CComboBox;
1154
1155 #endif // !WIN32_PLATFORM_WFSP
1156
1157 ///////////////////////////////////////////////////////////////////////////////
1158 // CEdit - client side for a Windows EDIT control
1159
1160 template <class TBase>
1161 class CEditT : public TBase
1162 {
1163 public:
1164 // Constructors
1165     CEditT(HWND hWnd = NULL) : TBase(hWnd)
1166     { }
1167
1168     CEditT< TBase >& operator =(HWND hWnd)
1169     {
1170         m_hWnd = hWnd;
1171         return *this;
1172     }
1173
1174     HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
1175             DWORD dwStyle = 0, DWORD dwExStyle = 0,
1176             ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
1177     {
1178         return TBase::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);
1179     }
1180
1181 // Attributes
1182     static LPCTSTR GetWndClassName()
1183     {
1184         return _T("EDIT");
1185     }
1186
1187     BOOL CanUndo() const
1188     {
1189         ATLASSERT(::IsWindow(m_hWnd));
1190         return (BOOL)::SendMessage(m_hWnd, EM_CANUNDO, 0, 0L);
1191     }
1192
1193     int GetLineCount() const
1194     {
1195         ATLASSERT(::IsWindow(m_hWnd));
1196         return (int)::SendMessage(m_hWnd, EM_GETLINECOUNT, 0, 0L);
1197     }
1198
1199     BOOL GetModify() const
1200     {
1201         ATLASSERT(::IsWindow(m_hWnd));
1202         return (BOOL)::SendMessage(m_hWnd, EM_GETMODIFY, 0, 0L);
1203     }
1204
1205     void SetModify(BOOL bModified = TRUE)
1206     {
1207         ATLASSERT(::IsWindow(m_hWnd));
1208         ::SendMessage(m_hWnd, EM_SETMODIFY, bModified, 0L);
1209     }
1210
1211     void GetRect(LPRECT lpRect) const
1212     {
1213         ATLASSERT(::IsWindow(m_hWnd));
1214         ::SendMessage(m_hWnd, EM_GETRECT, 0, (LPARAM)lpRect);
1215     }
1216
1217     DWORD GetSel() const
1218     {
1219         ATLASSERT(::IsWindow(m_hWnd));
1220         return (DWORD)::SendMessage(m_hWnd, EM_GETSEL, 0, 0L);
1221     }
1222
1223     void GetSel(int& nStartChar, int& nEndChar) const
1224     {
1225         ATLASSERT(::IsWindow(m_hWnd));
1226         ::SendMessage(m_hWnd, EM_GETSEL, (WPARAM)&nStartChar, (LPARAM)&nEndChar);
1227     }
1228
1229 #ifndef _WIN32_WCE
1230     HLOCAL GetHandle() const
1231     {
1232         ATLASSERT(::IsWindow(m_hWnd));
1233         return (HLOCAL)::SendMessage(m_hWnd, EM_GETHANDLE, 0, 0L);
1234     }
1235
1236     void SetHandle(HLOCAL hBuffer)
1237     {
1238         ATLASSERT(::IsWindow(m_hWnd));
1239         ::SendMessage(m_hWnd, EM_SETHANDLE, (WPARAM)hBuffer, 0L);
1240     }
1241 #endif // !_WIN32_WCE
1242
1243     DWORD GetMargins() const
1244     {
1245         ATLASSERT(::IsWindow(m_hWnd));
1246         return (DWORD)::SendMessage(m_hWnd, EM_GETMARGINS, 0, 0L);
1247     }
1248
1249     void GetMargins(UINT& nLeft, UINT& nRight) const
1250     {
1251         ATLASSERT(::IsWindow(m_hWnd));
1252         DWORD dwRet = (DWORD)::SendMessage(m_hWnd, EM_GETMARGINS, 0, 0L);
1253         nLeft = LOWORD(dwRet);
1254         nRight = HIWORD(dwRet);
1255     }
1256
1257     void SetMargins(UINT nLeft, UINT nRight, WORD wFlags = EC_LEFTMARGIN | EC_RIGHTMARGIN)
1258     {
1259         ATLASSERT(::IsWindow(m_hWnd));
1260         ::SendMessage(m_hWnd, EM_SETMARGINS, wFlags, MAKELONG(nLeft, nRight));
1261     }
1262
1263     UINT GetLimitText() const
1264     {
1265         ATLASSERT(::IsWindow(m_hWnd));
1266         return (UINT)::SendMessage(m_hWnd, EM_GETLIMITTEXT, 0, 0L);
1267     }
1268
1269     void SetLimitText(UINT nMax)
1270     {
1271         ATLASSERT(::IsWindow(m_hWnd));
1272         ::SendMessage(m_hWnd, EM_SETLIMITTEXT, nMax, 0L);
1273     }
1274
1275     POINT PosFromChar(UINT nChar) const
1276     {
1277         ATLASSERT(::IsWindow(m_hWnd));
1278         DWORD dwRet = (DWORD)::SendMessage(m_hWnd, EM_POSFROMCHAR, nChar, 0);
1279         POINT point = { GET_X_LPARAM(dwRet), GET_Y_LPARAM(dwRet) };
1280         return point;
1281     }
1282
1283     int CharFromPos(POINT pt, int* pLine = NULL) const
1284     {
1285         ATLASSERT(::IsWindow(m_hWnd));
1286         DWORD dwRet = (DWORD)::SendMessage(m_hWnd, EM_CHARFROMPOS, 0, MAKELPARAM(pt.x, pt.y));
1287         if(pLine != NULL)
1288             *pLine = (int)(short)HIWORD(dwRet);
1289         return (int)(short)LOWORD(dwRet);
1290     }
1291
1292     // NOTE: first word in lpszBuffer must contain the size of the buffer!
1293     int GetLine(int nIndex, LPTSTR lpszBuffer) const
1294     {
1295         ATLASSERT(::IsWindow(m_hWnd));
1296         return (int)::SendMessage(m_hWnd, EM_GETLINE, nIndex, (LPARAM)lpszBuffer);
1297     }
1298
1299     int GetLine(int nIndex, LPTSTR lpszBuffer, int nMaxLength) const
1300     {
1301         ATLASSERT(::IsWindow(m_hWnd));
1302         *(LPWORD)lpszBuffer = (WORD)nMaxLength;
1303         return (int)::SendMessage(m_hWnd, EM_GETLINE, nIndex, (LPARAM)lpszBuffer);
1304     }
1305
1306     TCHAR GetPasswordChar() const
1307     {
1308         ATLASSERT(::IsWindow(m_hWnd));
1309         return (TCHAR)::SendMessage(m_hWnd, EM_GETPASSWORDCHAR, 0, 0L);
1310     }
1311
1312     void SetPasswordChar(TCHAR ch)
1313     {
1314         ATLASSERT(::IsWindow(m_hWnd));
1315         ::SendMessage(m_hWnd, EM_SETPASSWORDCHAR, ch, 0L);
1316     }
1317
1318 #ifndef _WIN32_WCE
1319     EDITWORDBREAKPROC GetWordBreakProc() const
1320     {
1321         ATLASSERT(::IsWindow(m_hWnd));
1322         return (EDITWORDBREAKPROC)::SendMessage(m_hWnd, EM_GETWORDBREAKPROC, 0, 0L);
1323     }
1324
1325     void SetWordBreakProc(EDITWORDBREAKPROC ewbprc)
1326     {
1327         ATLASSERT(::IsWindow(m_hWnd));
1328         ::SendMessage(m_hWnd, EM_SETWORDBREAKPROC, 0, (LPARAM)ewbprc);
1329     }
1330 #endif // !_WIN32_WCE
1331
1332     int GetFirstVisibleLine() const
1333     {
1334         ATLASSERT(::IsWindow(m_hWnd));
1335         return (int)::SendMessage(m_hWnd, EM_GETFIRSTVISIBLELINE, 0, 0L);
1336     }
1337
1338 #ifndef _WIN32_WCE
1339     int GetThumb() const
1340     {
1341         ATLASSERT(::IsWindow(m_hWnd));
1342         ATLASSERT((GetStyle() & ES_MULTILINE) != 0);
1343         return (int)::SendMessage(m_hWnd, EM_GETTHUMB, 0, 0L);
1344     }
1345 #endif // !_WIN32_WCE
1346
1347     BOOL SetReadOnly(BOOL bReadOnly = TRUE)
1348     {
1349         ATLASSERT(::IsWindow(m_hWnd));
1350         return (BOOL)::SendMessage(m_hWnd, EM_SETREADONLY, bReadOnly, 0L);
1351     }
1352
1353 #if (WINVER >= 0x0500) && !defined(_WIN32_WCE)
1354     UINT GetImeStatus(UINT uStatus) const
1355     {
1356         ATLASSERT(::IsWindow(m_hWnd));
1357         return (UINT)::SendMessage(m_hWnd, EM_GETIMESTATUS, uStatus, 0L);
1358     }
1359
1360     UINT SetImeStatus(UINT uStatus, UINT uData)
1361     {
1362         ATLASSERT(::IsWindow(m_hWnd));
1363         return (UINT)::SendMessage(m_hWnd, EM_SETIMESTATUS, uStatus, uData);
1364     }
1365 #endif // (WINVER >= 0x0500) && !defined(_WIN32_WCE)
1366
1367 #if (_WIN32_WINNT >= 0x0501)
1368     BOOL GetCueBannerText(LPCWSTR lpstrText, int cchText) const
1369     {
1370         ATLASSERT(::IsWindow(m_hWnd));
1371         return (BOOL)::SendMessage(m_hWnd, EM_GETCUEBANNER, (WPARAM)lpstrText, cchText);
1372     }
1373
1374     // bKeepWithFocus - Vista only
1375     BOOL SetCueBannerText(LPCWSTR lpstrText, BOOL bKeepWithFocus = FALSE)
1376     {
1377         ATLASSERT(::IsWindow(m_hWnd));
1378         return (BOOL)::SendMessage(m_hWnd, EM_SETCUEBANNER, (WPARAM)bKeepWithFocus, (LPARAM)(lpstrText));
1379     }
1380 #endif // (_WIN32_WINNT >= 0x0501)
1381
1382 // Operations
1383     void EmptyUndoBuffer()
1384     {
1385         ATLASSERT(::IsWindow(m_hWnd));
1386         ::SendMessage(m_hWnd, EM_EMPTYUNDOBUFFER, 0, 0L);
1387     }
1388
1389     BOOL FmtLines(BOOL bAddEOL)
1390     {
1391         ATLASSERT(::IsWindow(m_hWnd));
1392         return (BOOL)::SendMessage(m_hWnd, EM_FMTLINES, bAddEOL, 0L);
1393     }
1394
1395     void LimitText(int nChars = 0)
1396     {
1397         ATLASSERT(::IsWindow(m_hWnd));
1398         ::SendMessage(m_hWnd, EM_LIMITTEXT, nChars, 0L);
1399     }
1400
1401     int LineFromChar(int nIndex = -1) const
1402     {
1403         ATLASSERT(::IsWindow(m_hWnd));
1404         return (int)::SendMessage(m_hWnd, EM_LINEFROMCHAR, nIndex, 0L);
1405     }
1406
1407     int LineIndex(int nLine = -1) const
1408     {
1409         ATLASSERT(::IsWindow(m_hWnd));
1410         return (int)::SendMessage(m_hWnd, EM_LINEINDEX, nLine, 0L);
1411     }
1412
1413     int LineLength(int nLine = -1) const
1414     {
1415         ATLASSERT(::IsWindow(m_hWnd));
1416         return (int)::SendMessage(m_hWnd, EM_LINELENGTH, nLine, 0L);
1417     }
1418
1419     void LineScroll(int nLines, int nChars = 0)
1420     {
1421         ATLASSERT(::IsWindow(m_hWnd));
1422         ::SendMessage(m_hWnd, EM_LINESCROLL, nChars, nLines);
1423     }
1424
1425     void ReplaceSel(LPCTSTR lpszNewText, BOOL bCanUndo = FALSE)
1426     {
1427         ATLASSERT(::IsWindow(m_hWnd));
1428         ::SendMessage(m_hWnd, EM_REPLACESEL, (WPARAM) bCanUndo, (LPARAM)lpszNewText);
1429     }
1430
1431     void SetRect(LPCRECT lpRect)
1432     {
1433         ATLASSERT(::IsWindow(m_hWnd));
1434         ::SendMessage(m_hWnd, EM_SETRECT, 0, (LPARAM)lpRect);
1435     }
1436
1437     void SetRectNP(LPCRECT lpRect)
1438     {
1439         ATLASSERT(::IsWindow(m_hWnd));
1440         ::SendMessage(m_hWnd, EM_SETRECTNP, 0, (LPARAM)lpRect);
1441     }
1442
1443     void SetSel(DWORD dwSelection, BOOL bNoScroll = FALSE)
1444     {
1445         ATLASSERT(::IsWindow(m_hWnd));
1446         ::SendMessage(m_hWnd, EM_SETSEL, LOWORD(dwSelection), HIWORD(dwSelection));
1447         if(!bNoScroll)
1448             ::SendMessage(m_hWnd, EM_SCROLLCARET, 0, 0L);
1449     }
1450
1451     void SetSel(int nStartChar, int nEndChar, BOOL bNoScroll = FALSE)
1452     {
1453         ATLASSERT(::IsWindow(m_hWnd));
1454         ::SendMessage(m_hWnd, EM_SETSEL, nStartChar, nEndChar);
1455         if(!bNoScroll)
1456             ::SendMessage(m_hWnd, EM_SCROLLCARET, 0, 0L);
1457     }
1458
1459     void SetSelAll(BOOL bNoScroll = FALSE)
1460     {
1461         SetSel(0, -1, bNoScroll);
1462     }
1463
1464     void SetSelNone(BOOL bNoScroll = FALSE)
1465     {
1466         SetSel(-1, 0, bNoScroll);
1467     }
1468
1469     BOOL SetTabStops(int nTabStops, LPINT rgTabStops)
1470     {
1471         ATLASSERT(::IsWindow(m_hWnd));
1472         return (BOOL)::SendMessage(m_hWnd, EM_SETTABSTOPS, nTabStops, (LPARAM)rgTabStops);
1473     }
1474
1475     BOOL SetTabStops()
1476     {
1477         ATLASSERT(::IsWindow(m_hWnd));
1478         return (BOOL)::SendMessage(m_hWnd, EM_SETTABSTOPS, 0, 0L);
1479     }
1480
1481     BOOL SetTabStops(const int& cxEachStop)    // takes an 'int'
1482     {
1483         ATLASSERT(::IsWindow(m_hWnd));
1484         return (BOOL)::SendMessage(m_hWnd, EM_SETTABSTOPS, 1, (LPARAM)(LPINT)&cxEachStop);
1485     }
1486
1487     void ScrollCaret()
1488     {
1489         ATLASSERT(::IsWindow(m_hWnd));
1490         ::SendMessage(m_hWnd, EM_SCROLLCARET, 0, 0L);
1491     }
1492
1493     int Scroll(int nScrollAction)
1494     {
1495         ATLASSERT(::IsWindow(m_hWnd));
1496         ATLASSERT((GetStyle() & ES_MULTILINE) != 0);
1497         LRESULT lRet = ::SendMessage(m_hWnd, EM_SCROLL, nScrollAction, 0L);
1498         if(!(BOOL)HIWORD(lRet))
1499             return -1;   // failed
1500         return (int)(short)LOWORD(lRet);
1501
1502     }
1503
1504     void InsertText(int nInsertAfterChar, LPCTSTR lpstrText, BOOL bNoScroll = FALSE, BOOL bCanUndo = FALSE)
1505     {
1506         SetSel(nInsertAfterChar, nInsertAfterChar, bNoScroll);
1507         ReplaceSel(lpstrText, bCanUndo);
1508     }
1509
1510     void AppendText(LPCTSTR lpstrText, BOOL bNoScroll = FALSE, BOOL bCanUndo = FALSE)
1511     {
1512         InsertText(GetWindowTextLength(), lpstrText, bNoScroll, bCanUndo);
1513     }
1514
1515 #if (_WIN32_WINNT >= 0x0501)
1516     BOOL ShowBalloonTip(PEDITBALLOONTIP pEditBaloonTip)
1517     {
1518         ATLASSERT(::IsWindow(m_hWnd));
1519         return (BOOL)::SendMessage(m_hWnd, EM_SHOWBALLOONTIP, 0, (LPARAM)pEditBaloonTip);
1520     }
1521
1522     BOOL HideBalloonTip()
1523     {
1524         ATLASSERT(::IsWindow(m_hWnd));
1525         return (BOOL)::SendMessage(m_hWnd, EM_HIDEBALLOONTIP, 0, 0L);
1526     }
1527 #endif // (_WIN32_WINNT >= 0x0501)
1528
1529 #if (_WIN32_WINNT >= 0x0600)
1530     DWORD GetHilite() const
1531     {
1532         ATLASSERT(::IsWindow(m_hWnd));
1533         return (DWORD)::SendMessage(m_hWnd, EM_GETHILITE, 0, 0L);
1534     }
1535
1536     void GetHilite(int& nStartChar, int& nEndChar) const
1537     {
1538         ATLASSERT(::IsWindow(m_hWnd));
1539         DWORD dwRet = (DWORD)::SendMessage(m_hWnd, EM_GETHILITE, 0, 0L);
1540         nStartChar = (int)(short)LOWORD(dwRet);
1541         nEndChar = (int)(short)HIWORD(dwRet);
1542     }
1543
1544     void SetHilite(int nStartChar, int nEndChar)
1545     {
1546         ATLASSERT(::IsWindow(m_hWnd));
1547         ::SendMessage(m_hWnd, EM_SETHILITE, nStartChar, nEndChar);
1548     }
1549 #endif // (_WIN32_WINNT >= 0x0600)
1550
1551     // Clipboard operations
1552     BOOL Undo()
1553     {
1554         ATLASSERT(::IsWindow(m_hWnd));
1555         return (BOOL)::SendMessage(m_hWnd, EM_UNDO, 0, 0L);
1556     }
1557
1558     void Clear()
1559     {
1560         ATLASSERT(::IsWindow(m_hWnd));
1561         ::SendMessage(m_hWnd, WM_CLEAR, 0, 0L);
1562     }
1563
1564     void Copy()
1565     {
1566         ATLASSERT(::IsWindow(m_hWnd));
1567         ::SendMessage(m_hWnd, WM_COPY, 0, 0L);
1568     }
1569
1570     void Cut()
1571     {
1572         ATLASSERT(::IsWindow(m_hWnd));
1573         ::SendMessage(m_hWnd, WM_CUT, 0, 0L);
1574     }
1575
1576     void Paste()
1577     {
1578         ATLASSERT(::IsWindow(m_hWnd));
1579         ::SendMessage(m_hWnd, WM_PASTE, 0, 0L);
1580     }
1581
1582 #ifdef WIN32_PLATFORM_WFSP   // SmartPhone only messages
1583     DWORD GetExtendedStyle()
1584     {
1585         return SendMessage(EM_GETEXTENDEDSTYLE);
1586     }
1587
1588     DWORD SetExtendedStyle(DWORD dwMask, DWORD dwExStyle)
1589     {
1590         return SendMessage(EM_SETEXTENDEDSTYLE, (WPARAM)dwMask, (LPARAM)dwExStyle);
1591     }
1592
1593     DWORD GetInputMode(BOOL bCurrentMode = TRUE)
1594     {
1595         return SendMessage(EM_GETINPUTMODE, 0, (LPARAM)bCurrentMode);
1596     }
1597
1598     BOOL SetInputMode(DWORD dwMode)
1599     {
1600         return SendMessage(EM_SETINPUTMODE, 0, (LPARAM)dwMode);
1601     }
1602
1603     BOOL SetSymbols(LPCTSTR szSymbols)
1604     {
1605         return SendMessage(EM_SETSYMBOLS, 0, (LPARAM)szSymbols);
1606     }
1607
1608     BOOL ResetSymbols()
1609     {
1610         return SendMessage(EM_SETSYMBOLS);
1611     }
1612 #endif // WIN32_PLATFORM_WFSP
1613 };
1614
1615 typedef CEditT<ATL::CWindow>   CEdit;
1616
1617
1618 ///////////////////////////////////////////////////////////////////////////////
1619 // CEditCommands - message handlers for standard EDIT commands
1620
1621 // Chain to CEditCommands message map. Your class must also derive from CEdit.
1622 // Example:
1623 // class CMyEdit : public CWindowImpl<CMyEdit, CEdit>,
1624 //                 public CEditCommands<CMyEdit>
1625 // {
1626 // public:
1627 //      BEGIN_MSG_MAP(CMyEdit)
1628 //              // your handlers...
1629 //              CHAIN_MSG_MAP_ALT(CEditCommands<CMyEdit>, 1)
1630 //      END_MSG_MAP()
1631 //      // other stuff...
1632 // };
1633
1634 template <class T>
1635 class CEditCommands
1636 {
1637 public:
1638     BEGIN_MSG_MAP(CEditCommands< T >)
1639     ALT_MSG_MAP(1)
1640         COMMAND_ID_HANDLER(ID_EDIT_CLEAR, OnEditClear)
1641         COMMAND_ID_HANDLER(ID_EDIT_CLEAR_ALL, OnEditClearAll)
1642         COMMAND_ID_HANDLER(ID_EDIT_COPY, OnEditCopy)
1643         COMMAND_ID_HANDLER(ID_EDIT_CUT, OnEditCut)
1644         COMMAND_ID_HANDLER(ID_EDIT_PASTE, OnEditPaste)
1645         COMMAND_ID_HANDLER(ID_EDIT_SELECT_ALL, OnEditSelectAll)
1646         COMMAND_ID_HANDLER(ID_EDIT_UNDO, OnEditUndo)
1647     END_MSG_MAP()
1648
1649     LRESULT OnEditClear(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
1650     {
1651         T* pT = static_cast<T*>(this);
1652         pT->Clear();
1653         return 0;
1654     }
1655
1656     LRESULT OnEditClearAll(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
1657     {
1658         T* pT = static_cast<T*>(this);
1659         pT->SetSel(0, -1);
1660         pT->Clear();
1661         return 0;
1662     }
1663
1664     LRESULT OnEditCopy(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
1665     {
1666         T* pT = static_cast<T*>(this);
1667         pT->Copy();
1668         return 0;
1669     }
1670
1671     LRESULT OnEditCut(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
1672     {
1673         T* pT = static_cast<T*>(this);
1674         pT->Cut();
1675         return 0;
1676     }
1677
1678     LRESULT OnEditPaste(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
1679     {
1680         T* pT = static_cast<T*>(this);
1681         pT->Paste();
1682         return 0;
1683     }
1684
1685     LRESULT OnEditSelectAll(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
1686     {
1687         T* pT = static_cast<T*>(this);
1688         pT->SetSel(0, -1);
1689         return 0;
1690     }
1691
1692     LRESULT OnEditUndo(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
1693     {
1694         T* pT = static_cast<T*>(this);
1695         pT->Undo();
1696         return 0;
1697     }
1698
1699 // State (update UI) helpers
1700     BOOL CanCut() const
1701     { return HasSelection(); }
1702
1703     BOOL CanCopy() const
1704     { return HasSelection(); }
1705
1706     BOOL CanClear() const
1707     { return HasSelection(); }
1708
1709     BOOL CanSelectAll() const
1710     { return HasText(); }
1711
1712     BOOL CanFind() const
1713     { return HasText(); }
1714
1715     BOOL CanRepeat() const
1716     { return HasText(); }
1717
1718     BOOL CanReplace() const
1719     { return HasText(); }
1720
1721     BOOL CanClearAll() const
1722     { return HasText(); }
1723
1724 // Implementation
1725     BOOL HasSelection() const
1726     {
1727         const T* pT = static_cast<const T*>(this);
1728         int nMin, nMax;
1729         ::SendMessage(pT->m_hWnd, EM_GETSEL, (WPARAM)&nMin, (LPARAM)&nMax);
1730         return (nMin != nMax);
1731     }
1732
1733     BOOL HasText() const
1734     {
1735         const T* pT = static_cast<const T*>(this);
1736         return (pT->GetWindowTextLength() > 0);
1737     }
1738 };
1739
1740
1741 ///////////////////////////////////////////////////////////////////////////////
1742 // CScrollBar - client side for a Windows SCROLLBAR control
1743
1744 template <class TBase>
1745 class CScrollBarT : public TBase
1746 {
1747 public:
1748 // Constructors
1749     CScrollBarT(HWND hWnd = NULL) : TBase(hWnd)
1750     { }
1751
1752     CScrollBarT< TBase >& operator =(HWND hWnd)
1753     {
1754         m_hWnd = hWnd;
1755         return *this;
1756     }
1757
1758     HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
1759             DWORD dwStyle = 0, DWORD dwExStyle = 0,
1760             ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
1761     {
1762         return TBase::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);
1763     }
1764
1765 // Attributes
1766     static LPCTSTR GetWndClassName()
1767     {
1768         return _T("SCROLLBAR");
1769     }
1770
1771 #ifndef _WIN32_WCE
1772     int GetScrollPos() const
1773     {
1774         ATLASSERT(::IsWindow(m_hWnd));
1775         return ::GetScrollPos(m_hWnd, SB_CTL);
1776     }
1777 #endif // !_WIN32_WCE
1778
1779     int SetScrollPos(int nPos, BOOL bRedraw = TRUE)
1780     {
1781         ATLASSERT(::IsWindow(m_hWnd));
1782         return ::SetScrollPos(m_hWnd, SB_CTL, nPos, bRedraw);
1783     }
1784
1785 #ifndef _WIN32_WCE
1786     void GetScrollRange(LPINT lpMinPos, LPINT lpMaxPos) const
1787     {
1788         ATLASSERT(::IsWindow(m_hWnd));
1789         ::GetScrollRange(m_hWnd, SB_CTL, lpMinPos, lpMaxPos);
1790     }
1791 #endif // !_WIN32_WCE
1792
1793     void SetScrollRange(int nMinPos, int nMaxPos, BOOL bRedraw = TRUE)
1794     {
1795         ATLASSERT(::IsWindow(m_hWnd));
1796         ::SetScrollRange(m_hWnd, SB_CTL, nMinPos, nMaxPos, bRedraw);
1797     }
1798
1799     BOOL GetScrollInfo(LPSCROLLINFO lpScrollInfo) const
1800     {
1801         ATLASSERT(::IsWindow(m_hWnd));
1802         return ::GetScrollInfo(m_hWnd, SB_CTL, lpScrollInfo);
1803     }
1804
1805     int SetScrollInfo(LPSCROLLINFO lpScrollInfo, BOOL bRedraw = TRUE)
1806     {
1807         ATLASSERT(::IsWindow(m_hWnd));
1808         return ::SetScrollInfo(m_hWnd, SB_CTL, lpScrollInfo, bRedraw);
1809     }
1810
1811 #ifndef _WIN32_WCE
1812     int GetScrollLimit() const
1813     {
1814         int nMin = 0, nMax = 0;
1815         ::GetScrollRange(m_hWnd, SB_CTL, &nMin, &nMax);
1816         SCROLLINFO info = { sizeof(SCROLLINFO), SIF_PAGE };
1817         if(::GetScrollInfo(m_hWnd, SB_CTL, &info))
1818             nMax -= ((info.nPage - 1) > 0) ? (info.nPage - 1) : 0;
1819
1820         return nMax;
1821     }
1822
1823 #if (WINVER >= 0x0500)
1824     BOOL GetScrollBarInfo(PSCROLLBARINFO pScrollBarInfo) const
1825     {
1826         ATLASSERT(::IsWindow(m_hWnd));
1827 #if (_WIN32_WINNT >= 0x0501)
1828         return (BOOL)::SendMessage(m_hWnd, SBM_GETSCROLLBARINFO, 0, (LPARAM)pScrollBarInfo);
1829 #else // !(_WIN32_WINNT >= 0x0501)
1830         return ::GetScrollBarInfo(m_hWnd, OBJID_CLIENT, pScrollBarInfo);
1831 #endif // !(_WIN32_WINNT >= 0x0501)
1832     }
1833 #endif // (WINVER >= 0x0500)
1834
1835 // Operations
1836     void ShowScrollBar(BOOL bShow = TRUE)
1837     {
1838         ATLASSERT(::IsWindow(m_hWnd));
1839         ::ShowScrollBar(m_hWnd, SB_CTL, bShow);
1840     }
1841
1842     BOOL EnableScrollBar(UINT nArrowFlags = ESB_ENABLE_BOTH)
1843     {
1844         ATLASSERT(::IsWindow(m_hWnd));
1845         return ::EnableScrollBar(m_hWnd, SB_CTL, nArrowFlags);
1846     }
1847 #endif // !_WIN32_WCE
1848 };
1849
1850 typedef CScrollBarT<ATL::CWindow>   CScrollBar;
1851
1852
1853 // --- Windows Common Controls ---
1854
1855 ///////////////////////////////////////////////////////////////////////////////
1856 // CImageList
1857
1858 // forward declarations
1859 template <bool t_bManaged> class CImageListT;
1860 typedef CImageListT<false>   CImageList;
1861 typedef CImageListT<true>    CImageListManaged;
1862
1863
1864 template <bool t_bManaged>
1865 class CImageListT
1866 {
1867 public:
1868 // Data members
1869     HIMAGELIST m_hImageList;
1870
1871 // Constructor/destructor/operators
1872     CImageListT(HIMAGELIST hImageList = NULL) : m_hImageList(hImageList)
1873     { }
1874
1875     ~CImageListT()
1876     {
1877         if(t_bManaged && (m_hImageList != NULL))
1878             Destroy();
1879     }
1880
1881     CImageListT<t_bManaged>& operator =(HIMAGELIST hImageList)
1882     {
1883         Attach(hImageList);
1884         return *this;
1885     }
1886
1887     void Attach(HIMAGELIST hImageList)
1888     {
1889         ATLASSERT(m_hImageList == NULL);
1890         ATLASSERT(hImageList != NULL);
1891         if(t_bManaged && (m_hImageList != NULL) && (m_hImageList != hImageList))
1892             ImageList_Destroy(m_hImageList);
1893         m_hImageList = hImageList;
1894     }
1895
1896     HIMAGELIST Detach()
1897     {
1898         HIMAGELIST hImageList = m_hImageList;
1899         m_hImageList = NULL;
1900         return hImageList;
1901     }
1902
1903     operator HIMAGELIST() const { return m_hImageList; }
1904
1905     bool IsNull() const { return (m_hImageList == NULL); }
1906
1907 // Attributes
1908     int GetImageCount() const
1909     {
1910         ATLASSERT(m_hImageList != NULL);
1911         return ImageList_GetImageCount(m_hImageList);
1912     }
1913
1914     COLORREF GetBkColor() const
1915     {
1916         ATLASSERT(m_hImageList != NULL);
1917         return ImageList_GetBkColor(m_hImageList);
1918     }
1919
1920     COLORREF SetBkColor(COLORREF cr)
1921     {
1922         ATLASSERT(m_hImageList != NULL);
1923         return ImageList_SetBkColor(m_hImageList, cr);
1924     }
1925
1926     BOOL GetImageInfo(int nImage, IMAGEINFO* pImageInfo) const
1927     {
1928         ATLASSERT(m_hImageList != NULL);
1929         return ImageList_GetImageInfo(m_hImageList, nImage, pImageInfo);
1930     }
1931
1932     HICON GetIcon(int nIndex, UINT uFlags = ILD_NORMAL) const
1933     {
1934         ATLASSERT(m_hImageList != NULL);
1935         return ImageList_GetIcon(m_hImageList, nIndex, uFlags);
1936     }
1937
1938     BOOL GetIconSize(int& cx, int& cy) const
1939     {
1940         ATLASSERT(m_hImageList != NULL);
1941         return ImageList_GetIconSize(m_hImageList, &cx, &cy);
1942     }
1943
1944     BOOL GetIconSize(SIZE& size) const
1945     {
1946         ATLASSERT(m_hImageList != NULL);
1947         return ImageList_GetIconSize(m_hImageList, (int*)&size.cx, (int*)&size.cy);
1948     }
1949
1950     BOOL SetIconSize(int cx, int cy)
1951     {
1952         ATLASSERT(m_hImageList != NULL);
1953         return ImageList_SetIconSize(m_hImageList, cx, cy);
1954     }
1955
1956     BOOL SetIconSize(SIZE size)
1957     {
1958         ATLASSERT(m_hImageList != NULL);
1959         return ImageList_SetIconSize(m_hImageList, size.cx, size.cy);
1960     }
1961
1962     BOOL SetImageCount(UINT uNewCount)
1963     {
1964         ATLASSERT(m_hImageList != NULL);
1965         return ImageList_SetImageCount(m_hImageList, uNewCount);
1966     }
1967
1968     BOOL SetOverlayImage(int nImage, int nOverlay)
1969     {
1970         ATLASSERT(m_hImageList != NULL);
1971         return ImageList_SetOverlayImage(m_hImageList, nImage, nOverlay);
1972     }
1973
1974 // Operations
1975     BOOL Create(int cx, int cy, UINT nFlags, int nInitial, int nGrow)
1976     {
1977         ATLASSERT(m_hImageList == NULL);
1978         m_hImageList = ImageList_Create(cx, cy, nFlags, nInitial, nGrow);
1979         return (m_hImageList != NULL) ? TRUE : FALSE;
1980     }
1981
1982     BOOL Create(ATL::_U_STRINGorID bitmap, int cx, int nGrow, COLORREF crMask)
1983     {
1984         ATLASSERT(m_hImageList == NULL);
1985         m_hImageList = ImageList_LoadBitmap(ModuleHelper::GetResourceInstance(), bitmap.m_lpstr, cx, nGrow, crMask);
1986         return (m_hImageList != NULL) ? TRUE : FALSE;
1987     }
1988
1989     BOOL CreateFromImage(ATL::_U_STRINGorID image, int cx, int nGrow, COLORREF crMask, UINT uType, UINT uFlags = LR_DEFAULTCOLOR | LR_DEFAULTSIZE)
1990     {
1991         ATLASSERT(m_hImageList == NULL);
1992         m_hImageList = ImageList_LoadImage(ModuleHelper::GetResourceInstance(), image.m_lpstr, cx, nGrow, crMask, uType, uFlags);
1993         return (m_hImageList != NULL) ? TRUE : FALSE;
1994     }
1995
1996     BOOL Merge(HIMAGELIST hImageList1, int nImage1, HIMAGELIST hImageList2, int nImage2, int dx, int dy)
1997     {
1998         ATLASSERT(m_hImageList == NULL);
1999         m_hImageList = ImageList_Merge(hImageList1, nImage1, hImageList2, nImage2, dx, dy);
2000         return (m_hImageList != NULL) ? TRUE : FALSE;
2001     }
2002
2003 #ifndef _WIN32_WCE
2004 #ifdef __IStream_INTERFACE_DEFINED__
2005     BOOL CreateFromStream(LPSTREAM lpStream)
2006     {
2007         ATLASSERT(m_hImageList == NULL);
2008         m_hImageList = ImageList_Read(lpStream);
2009         return (m_hImageList != NULL) ? TRUE : FALSE;
2010     }
2011 #endif // __IStream_INTERFACE_DEFINED__
2012 #endif // !_WIN32_WCE
2013
2014     BOOL Destroy()
2015     {
2016         if (m_hImageList == NULL)
2017             return FALSE;
2018         BOOL bRet = ImageList_Destroy(m_hImageList);
2019         if(bRet)
2020             m_hImageList = NULL;
2021         return bRet;
2022     }
2023
2024     int Add(HBITMAP hBitmap, HBITMAP hBitmapMask = NULL)
2025     {
2026         ATLASSERT(m_hImageList != NULL);
2027         return ImageList_Add(m_hImageList, hBitmap, hBitmapMask);
2028     }
2029
2030     int Add(HBITMAP hBitmap, COLORREF crMask)
2031     {
2032         ATLASSERT(m_hImageList != NULL);
2033         return ImageList_AddMasked(m_hImageList, hBitmap, crMask);
2034     }
2035
2036     BOOL Remove(int nImage)
2037     {
2038         ATLASSERT(m_hImageList != NULL);
2039         return ImageList_Remove(m_hImageList, nImage);
2040     }
2041
2042     BOOL RemoveAll()
2043     {
2044         ATLASSERT(m_hImageList != NULL);
2045         return ImageList_RemoveAll(m_hImageList);
2046     }
2047
2048     BOOL Replace(int nImage, HBITMAP hBitmap, HBITMAP hBitmapMask)
2049     {
2050         ATLASSERT(m_hImageList != NULL);
2051         return ImageList_Replace(m_hImageList, nImage, hBitmap, hBitmapMask);
2052     }
2053
2054     int AddIcon(HICON hIcon)
2055     {
2056         ATLASSERT(m_hImageList != NULL);
2057         return ImageList_AddIcon(m_hImageList, hIcon);
2058     }
2059
2060     int ReplaceIcon(int nImage, HICON hIcon)
2061     {
2062         ATLASSERT(m_hImageList != NULL);
2063         return ImageList_ReplaceIcon(m_hImageList, nImage, hIcon);
2064     }
2065
2066     HICON ExtractIcon(int nImage)
2067     {
2068         ATLASSERT(m_hImageList != NULL);
2069         return ImageList_ExtractIcon(NULL, m_hImageList, nImage);
2070     }
2071
2072     BOOL Draw(HDC hDC, int nImage, int x, int y, UINT nStyle)
2073     {
2074         ATLASSERT(m_hImageList != NULL);
2075         ATLASSERT(hDC != NULL);
2076         return ImageList_Draw(m_hImageList, nImage, hDC, x, y, nStyle);
2077     }
2078
2079     BOOL Draw(HDC hDC, int nImage, POINT pt, UINT nStyle)
2080     {
2081         ATLASSERT(m_hImageList != NULL);
2082         ATLASSERT(hDC != NULL);
2083         return ImageList_Draw(m_hImageList, nImage, hDC, pt.x, pt.y, nStyle);
2084     }
2085
2086     BOOL DrawEx(int nImage, HDC hDC, int x, int y, int dx, int dy, COLORREF rgbBk, COLORREF rgbFg, UINT fStyle)
2087     {
2088         ATLASSERT(m_hImageList != NULL);
2089         ATLASSERT(hDC != NULL);
2090         return ImageList_DrawEx(m_hImageList, nImage, hDC, x, y, dx, dy, rgbBk, rgbFg, fStyle);
2091     }
2092
2093     BOOL DrawEx(int nImage, HDC hDC, RECT& rect, COLORREF rgbBk, COLORREF rgbFg, UINT fStyle)
2094     {
2095         ATLASSERT(m_hImageList != NULL);
2096         ATLASSERT(hDC != NULL);
2097         return ImageList_DrawEx(m_hImageList, nImage, hDC, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, rgbBk, rgbFg, fStyle);
2098     }
2099
2100     static BOOL DrawIndirect(IMAGELISTDRAWPARAMS* pimldp)
2101     {
2102         return ImageList_DrawIndirect(pimldp);
2103     }
2104
2105     BOOL Copy(int nSrc, int nDst, UINT uFlags = ILCF_MOVE)
2106     {
2107         ATLASSERT(m_hImageList != NULL);
2108         return ImageList_Copy(m_hImageList, nDst, m_hImageList, nSrc, uFlags);
2109     }
2110
2111 #ifdef __IStream_INTERFACE_DEFINED__
2112 #ifndef _WIN32_WCE
2113     static HIMAGELIST Read(LPSTREAM lpStream)
2114     {
2115         return ImageList_Read(lpStream);
2116     }
2117
2118     BOOL Write(LPSTREAM lpStream)
2119     {
2120         ATLASSERT(m_hImageList != NULL);
2121         return ImageList_Write(m_hImageList, lpStream);
2122     }
2123 #endif // !_WIN32_WCE
2124
2125 #if (_WIN32_WINNT >= 0x0501)
2126     static HRESULT ReadEx(DWORD dwFlags, LPSTREAM lpStream, REFIID riid, PVOID* ppv)
2127     {
2128         return ImageList_ReadEx(dwFlags, lpStream, riid, ppv);
2129     }
2130
2131     HRESULT WriteEx(DWORD dwFlags, LPSTREAM lpStream)
2132     {
2133         ATLASSERT(m_hImageList != NULL);
2134         return ImageList_WriteEx(m_hImageList, dwFlags, lpStream);
2135     }
2136 #endif // (_WIN32_WINNT >= 0x0501)
2137 #endif // __IStream_INTERFACE_DEFINED__
2138
2139     // Drag operations
2140     BOOL BeginDrag(int nImage, POINT ptHotSpot)
2141     {
2142         ATLASSERT(m_hImageList != NULL);
2143         return ImageList_BeginDrag(m_hImageList, nImage, ptHotSpot.x, ptHotSpot.y);
2144     }
2145
2146     BOOL BeginDrag(int nImage, int xHotSpot, int yHotSpot)
2147     {
2148         ATLASSERT(m_hImageList != NULL);
2149         return ImageList_BeginDrag(m_hImageList, nImage, xHotSpot, yHotSpot);
2150     }
2151
2152     static void EndDrag()
2153     {
2154         ImageList_EndDrag();
2155     }
2156
2157     static BOOL DragMove(POINT pt)
2158     {
2159         return ImageList_DragMove(pt.x, pt.y);
2160     }
2161
2162     static BOOL DragMove(int x, int y)
2163     {
2164         return ImageList_DragMove(x, y);
2165     }
2166
2167     BOOL SetDragCursorImage(int nDrag, POINT ptHotSpot)
2168     {
2169         ATLASSERT(m_hImageList != NULL);
2170         return ImageList_SetDragCursorImage(m_hImageList, nDrag, ptHotSpot.x, ptHotSpot.y);
2171     }
2172
2173     BOOL SetDragCursorImage(int nDrag, int xHotSpot, int yHotSpot)
2174     {
2175         ATLASSERT(m_hImageList != NULL);
2176         return ImageList_SetDragCursorImage(m_hImageList, nDrag, xHotSpot, yHotSpot);
2177     }
2178
2179     static BOOL DragShowNolock(BOOL bShow = TRUE)
2180     {
2181         return ImageList_DragShowNolock(bShow);
2182     }
2183
2184     static CImageList GetDragImage(LPPOINT lpPoint, LPPOINT lpPointHotSpot)
2185     {
2186         return CImageList(ImageList_GetDragImage(lpPoint, lpPointHotSpot));
2187     }
2188
2189     static BOOL DragEnter(HWND hWnd, POINT point)
2190     {
2191         return ImageList_DragEnter(hWnd, point.x, point.y);
2192     }
2193
2194     static BOOL DragEnter(HWND hWnd, int x, int y)
2195     {
2196         return ImageList_DragEnter(hWnd, x, y);
2197     }
2198
2199     static BOOL DragLeave(HWND hWnd)
2200     {
2201         return ImageList_DragLeave(hWnd);
2202     }
2203
2204 #if (_WIN32_IE >= 0x0400)
2205     CImageList Duplicate() const
2206     {
2207         ATLASSERT(m_hImageList != NULL);
2208         return CImageList(ImageList_Duplicate(m_hImageList));
2209     }
2210
2211     static CImageList Duplicate(HIMAGELIST hImageList)
2212     {
2213         ATLASSERT(hImageList != NULL);
2214         return CImageList(ImageList_Duplicate(hImageList));
2215     }
2216 #endif // (_WIN32_IE >= 0x0400)
2217 };
2218
2219
2220 ///////////////////////////////////////////////////////////////////////////////
2221 // CToolTipCtrl
2222
2223 #ifndef _WIN32_WCE
2224
2225 class CToolInfo : public TOOLINFO
2226 {
2227 public:
2228     CToolInfo(UINT nFlags, HWND hWnd, UINT nIDTool = 0, LPRECT lpRect = NULL, LPTSTR lpstrText = LPSTR_TEXTCALLBACK, LPARAM lUserParam = NULL)
2229     {
2230         Init(nFlags, hWnd, nIDTool, lpRect, lpstrText, lUserParam);
2231     }
2232
2233     operator LPTOOLINFO() { return this; }
2234
2235     operator LPARAM() { return (LPARAM)this; }
2236
2237     void Init(UINT nFlags, HWND hWnd, UINT nIDTool = 0, LPRECT lpRect = NULL, LPTSTR lpstrText = LPSTR_TEXTCALLBACK, LPARAM lUserParam = NULL)
2238     {
2239         ATLASSERT(::IsWindow(hWnd));
2240         memset(this, 0, sizeof(TOOLINFO));
2241         cbSize = RunTimeHelper::SizeOf_TOOLINFO();
2242         uFlags = nFlags;
2243         if(nIDTool == 0)
2244         {
2245             hwnd = ::GetParent(hWnd);
2246             uFlags |= TTF_IDISHWND;
2247             uId = (UINT_PTR)hWnd;
2248         }
2249         else
2250         {
2251             hwnd = hWnd;
2252             uId = nIDTool;
2253         }
2254         if(lpRect != NULL)
2255             rect = *lpRect;
2256         hinst = ModuleHelper::GetResourceInstance();
2257         lpszText = lpstrText;
2258         lParam = lUserParam;
2259     }
2260 };
2261
2262 template <class TBase>
2263 class CToolTipCtrlT : public TBase
2264 {
2265 public:
2266 // Constructors
2267     CToolTipCtrlT(HWND hWnd = NULL) : TBase(hWnd)
2268     { }
2269
2270     CToolTipCtrlT< TBase >& operator =(HWND hWnd)
2271     {
2272         m_hWnd = hWnd;
2273         return *this;
2274     }
2275
2276     HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
2277             DWORD dwStyle = 0, DWORD dwExStyle = 0,
2278             ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
2279     {
2280         return TBase::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);
2281     }
2282
2283 // Attributes
2284     static LPCTSTR GetWndClassName()
2285     {
2286         return TOOLTIPS_CLASS;
2287     }
2288
2289     void GetText(LPTOOLINFO lpToolInfo) const
2290     {
2291         ATLASSERT(::IsWindow(m_hWnd));
2292         ::SendMessage(m_hWnd, TTM_GETTEXT, 0, (LPARAM)&lpToolInfo);
2293     }
2294
2295     void GetText(LPTSTR lpstrText, HWND hWnd, UINT nIDTool = 0) const
2296     {
2297         ATLASSERT(::IsWindow(m_hWnd));
2298         ATLASSERT(hWnd != NULL);
2299         CToolInfo ti(0, hWnd, nIDTool, NULL, lpstrText);
2300         ::SendMessage(m_hWnd, TTM_GETTEXT, 0, ti);
2301     }
2302
2303     BOOL GetToolInfo(LPTOOLINFO lpToolInfo) const
2304     {
2305         ATLASSERT(::IsWindow(m_hWnd));
2306         return (BOOL)::SendMessage(m_hWnd, TTM_GETTOOLINFO, 0, (LPARAM)lpToolInfo);
2307     }
2308
2309     BOOL GetToolInfo(HWND hWnd, UINT nIDTool, UINT* puFlags, LPRECT lpRect, LPTSTR lpstrText) const
2310     {
2311         ATLASSERT(::IsWindow(m_hWnd));
2312         ATLASSERT(hWnd != NULL);
2313         ATLASSERT(puFlags != NULL);
2314         ATLASSERT(lpRect != NULL);
2315         CToolInfo ti(0, hWnd, nIDTool, NULL, lpstrText);
2316         BOOL bRet = (BOOL)::SendMessage(m_hWnd, TTM_GETTOOLINFO, 0, ti);
2317         if(bRet != FALSE)
2318         {
2319             *puFlags = ti.uFlags;
2320             *lpRect = ti.rect;
2321         }
2322         return bRet;
2323     }
2324
2325     void SetToolInfo(LPTOOLINFO lpToolInfo)
2326     {
2327         ATLASSERT(::IsWindow(m_hWnd));
2328         ::SendMessage(m_hWnd, TTM_SETTOOLINFO, 0, (LPARAM)lpToolInfo);
2329     }
2330
2331     void SetToolRect(LPTOOLINFO lpToolInfo)
2332     {
2333         ATLASSERT(::IsWindow(m_hWnd));
2334         ::SendMessage(m_hWnd, TTM_NEWTOOLRECT, 0, (LPARAM)lpToolInfo);
2335     }
2336
2337     void SetToolRect(HWND hWnd, UINT nIDTool, LPCRECT lpRect)
2338     {
2339         ATLASSERT(::IsWindow(m_hWnd));
2340         ATLASSERT(hWnd != NULL);
2341         ATLASSERT(nIDTool != 0);
2342
2343         CToolInfo ti(0, hWnd, nIDTool, (LPRECT)lpRect, NULL);
2344         ::SendMessage(m_hWnd, TTM_NEWTOOLRECT, 0, ti);
2345     }
2346
2347     int GetToolCount() const
2348     {
2349         ATLASSERT(::IsWindow(m_hWnd));
2350         return (int)::SendMessage(m_hWnd, TTM_GETTOOLCOUNT, 0, 0L);
2351     }
2352
2353     int GetDelayTime(DWORD dwType) const
2354     {
2355         ATLASSERT(::IsWindow(m_hWnd));
2356         return (int)::SendMessage(m_hWnd, TTM_GETDELAYTIME, dwType, 0L);
2357     }
2358
2359     void SetDelayTime(DWORD dwType, int nTime)
2360     {
2361         ATLASSERT(::IsWindow(m_hWnd));
2362         ::SendMessage(m_hWnd, TTM_SETDELAYTIME, dwType, MAKELPARAM(nTime, 0));
2363     }
2364
2365     void GetMargin(LPRECT lpRect) const
2366     {
2367         ATLASSERT(::IsWindow(m_hWnd));
2368         ::SendMessage(m_hWnd, TTM_GETMARGIN, 0, (LPARAM)lpRect);
2369     }
2370
2371     void SetMargin(LPRECT lpRect)
2372     {
2373         ATLASSERT(::IsWindow(m_hWnd));
2374         ::SendMessage(m_hWnd, TTM_SETMARGIN, 0, (LPARAM)lpRect);
2375     }
2376
2377     int GetMaxTipWidth() const
2378     {
2379         ATLASSERT(::IsWindow(m_hWnd));
2380         return (int)::SendMessage(m_hWnd, TTM_GETMAXTIPWIDTH, 0, 0L);
2381     }
2382
2383     int SetMaxTipWidth(int nWidth)
2384     {
2385         ATLASSERT(::IsWindow(m_hWnd));
2386         return (int)::SendMessage(m_hWnd, TTM_SETMAXTIPWIDTH, 0, nWidth);
2387     }
2388
2389     COLORREF GetTipBkColor() const
2390     {
2391         ATLASSERT(::IsWindow(m_hWnd));
2392         return (COLORREF)::SendMessage(m_hWnd, TTM_GETTIPBKCOLOR, 0, 0L);
2393     }
2394
2395     void SetTipBkColor(COLORREF clr)
2396     {
2397         ATLASSERT(::IsWindow(m_hWnd));
2398         ::SendMessage(m_hWnd, TTM_SETTIPBKCOLOR, (WPARAM)clr, 0L);
2399     }
2400
2401     COLORREF GetTipTextColor() const
2402     {
2403         ATLASSERT(::IsWindow(m_hWnd));
2404         return (COLORREF)::SendMessage(m_hWnd, TTM_GETTIPTEXTCOLOR, 0, 0L);
2405     }
2406
2407     void SetTipTextColor(COLORREF clr)
2408     {
2409         ATLASSERT(::IsWindow(m_hWnd));
2410         ::SendMessage(m_hWnd, TTM_SETTIPTEXTCOLOR, (WPARAM)clr, 0L);
2411     }
2412
2413     BOOL GetCurrentTool(LPTOOLINFO lpToolInfo) const
2414     {
2415         ATLASSERT(::IsWindow(m_hWnd));
2416         return (BOOL)::SendMessage(m_hWnd, TTM_GETCURRENTTOOL, 0, (LPARAM)lpToolInfo);
2417     }
2418
2419 #if (_WIN32_IE >= 0x0500)
2420     SIZE GetBubbleSize(LPTOOLINFO lpToolInfo) const
2421     {
2422         ATLASSERT(::IsWindow(m_hWnd));
2423         DWORD dwRet = (DWORD)::SendMessage(m_hWnd, TTM_GETBUBBLESIZE, 0, (LPARAM)lpToolInfo);
2424         SIZE size = { GET_X_LPARAM(dwRet), GET_Y_LPARAM(dwRet) };
2425         return size;
2426     }
2427
2428     BOOL SetTitle(UINT uIcon, LPCTSTR lpstrTitle)
2429     {
2430         ATLASSERT(::IsWindow(m_hWnd));
2431         return (BOOL)::SendMessage(m_hWnd, TTM_SETTITLE, uIcon, (LPARAM)lpstrTitle);
2432     }
2433 #endif // (_WIN32_IE >= 0x0500)
2434
2435 #if (_WIN32_WINNT >= 0x0501)
2436     void GetTitle(PTTGETTITLE pTTGetTitle) const
2437     {
2438         ATLASSERT(::IsWindow(m_hWnd));
2439         ::SendMessage(m_hWnd, TTM_GETTITLE, 0, (LPARAM)pTTGetTitle);
2440     }
2441
2442     void SetWindowTheme(LPCWSTR lpstrTheme)
2443     {
2444         ATLASSERT(::IsWindow(m_hWnd));
2445         ::SendMessage(m_hWnd, TTM_SETWINDOWTHEME, 0, (LPARAM)lpstrTheme);
2446     }
2447 #endif // (_WIN32_WINNT >= 0x0501)
2448
2449 // Operations
2450     void Activate(BOOL bActivate)
2451     {
2452         ATLASSERT(::IsWindow(m_hWnd));
2453         ::SendMessage(m_hWnd, TTM_ACTIVATE, bActivate, 0L);
2454     }
2455
2456     BOOL AddTool(LPTOOLINFO lpToolInfo)
2457     {
2458         ATLASSERT(::IsWindow(m_hWnd));
2459         return (BOOL)::SendMessage(m_hWnd, TTM_ADDTOOL, 0, (LPARAM)lpToolInfo);
2460     }
2461
2462     BOOL AddTool(HWND hWnd, ATL::_U_STRINGorID text = LPSTR_TEXTCALLBACK, LPCRECT lpRectTool = NULL, UINT nIDTool = 0)
2463     {
2464         ATLASSERT(::IsWindow(m_hWnd));
2465         ATLASSERT(hWnd != NULL);
2466         // the toolrect and toolid must both be zero or both valid
2467         ATLASSERT((lpRectTool != NULL && nIDTool != 0) || (lpRectTool == NULL && nIDTool == 0));
2468
2469         CToolInfo ti(0, hWnd, nIDTool, (LPRECT)lpRectTool, (LPTSTR)text.m_lpstr);
2470         return (BOOL)::SendMessage(m_hWnd, TTM_ADDTOOL, 0, ti);
2471     }
2472
2473     void DelTool(LPTOOLINFO lpToolInfo)
2474     {
2475         ATLASSERT(::IsWindow(m_hWnd));
2476         ::SendMessage(m_hWnd, TTM_DELTOOL, 0, (LPARAM)lpToolInfo);
2477     }
2478
2479     void DelTool(HWND hWnd, UINT nIDTool = 0)
2480     {
2481         ATLASSERT(::IsWindow(m_hWnd));
2482         ATLASSERT(hWnd != NULL);
2483
2484         CToolInfo ti(0, hWnd, nIDTool, NULL, NULL);
2485         ::SendMessage(m_hWnd, TTM_DELTOOL, 0, ti);
2486     }
2487
2488     BOOL HitTest(LPTTHITTESTINFO lpHitTestInfo) const
2489     {
2490         ATLASSERT(::IsWindow(m_hWnd));
2491         return (BOOL)::SendMessage(m_hWnd, TTM_HITTEST, 0, (LPARAM)lpHitTestInfo);
2492     }
2493
2494     BOOL HitTest(HWND hWnd, POINT pt, LPTOOLINFO lpToolInfo) const
2495     {
2496         ATLASSERT(::IsWindow(m_hWnd));
2497         ATLASSERT(hWnd != NULL);
2498         ATLASSERT(lpToolInfo != NULL);
2499
2500         TTHITTESTINFO hti = { 0 };
2501         hti.ti.cbSize = RunTimeHelper::SizeOf_TOOLINFO();
2502         hti.hwnd = hWnd;
2503         hti.pt.x = pt.x;
2504         hti.pt.y = pt.y;
2505         if((BOOL)::SendMessage(m_hWnd, TTM_HITTEST, 0, (LPARAM)&hti) != FALSE)
2506         {
2507             *lpToolInfo = hti.ti;
2508             return TRUE;
2509         }
2510         return FALSE;
2511     }
2512
2513     void RelayEvent(LPMSG lpMsg)
2514     {
2515         ATLASSERT(::IsWindow(m_hWnd));
2516         ::SendMessage(m_hWnd, TTM_RELAYEVENT, 0, (LPARAM)lpMsg);
2517     }
2518
2519     void UpdateTipText(LPTOOLINFO lpToolInfo)
2520     {
2521         ATLASSERT(::IsWindow(m_hWnd));
2522         ::SendMessage(m_hWnd, TTM_UPDATETIPTEXT, 0, (LPARAM)lpToolInfo);
2523     }
2524
2525     void UpdateTipText(ATL::_U_STRINGorID text, HWND hWnd, UINT nIDTool = 0)
2526     {
2527         ATLASSERT(::IsWindow(m_hWnd));
2528         ATLASSERT(hWnd != NULL);
2529
2530         CToolInfo ti(0, hWnd, nIDTool, NULL, (LPTSTR)text.m_lpstr);
2531         ::SendMessage(m_hWnd, TTM_UPDATETIPTEXT, 0, ti);
2532     }
2533
2534     BOOL EnumTools(UINT nTool, LPTOOLINFO lpToolInfo) const
2535     {
2536         ATLASSERT(::IsWindow(m_hWnd));
2537         return (BOOL)::SendMessage(m_hWnd, TTM_ENUMTOOLS, nTool, (LPARAM)lpToolInfo);
2538     }
2539
2540     void Pop()
2541     {
2542         ATLASSERT(::IsWindow(m_hWnd));
2543         ::SendMessage(m_hWnd, TTM_POP, 0, 0L);
2544     }
2545
2546     void TrackActivate(LPTOOLINFO lpToolInfo, BOOL bActivate)
2547     {
2548         ATLASSERT(::IsWindow(m_hWnd));
2549         ::SendMessage(m_hWnd, TTM_TRACKACTIVATE, bActivate, (LPARAM)lpToolInfo);
2550     }
2551
2552     void TrackActivate(HWND hWnd, UINT nIDTool, BOOL bActivate)
2553     {
2554         ATLASSERT(::IsWindow(m_hWnd));
2555         ATLASSERT(hWnd != NULL);
2556
2557         CToolInfo ti(0, hWnd, nIDTool);
2558         ::SendMessage(m_hWnd, TTM_TRACKACTIVATE, bActivate, ti);
2559     }
2560
2561     void TrackPosition(int xPos, int yPos)
2562     {
2563         ATLASSERT(::IsWindow(m_hWnd));
2564         ::SendMessage(m_hWnd, TTM_TRACKPOSITION, 0, MAKELPARAM(xPos, yPos));
2565     }
2566
2567 #if (_WIN32_IE >= 0x0400)
2568     void Update()
2569     {
2570         ATLASSERT(::IsWindow(m_hWnd));
2571         ::SendMessage(m_hWnd, TTM_UPDATE, 0, 0L);
2572     }
2573 #endif // (_WIN32_IE >= 0x0400)
2574
2575 #if (_WIN32_IE >= 0x0500)
2576     BOOL AdjustRect(LPRECT lpRect, BOOL bLarger /*= TRUE*/)
2577     {
2578         ATLASSERT(::IsWindow(m_hWnd));
2579         return (BOOL)::SendMessage(m_hWnd, TTM_ADJUSTRECT, bLarger, (LPARAM)lpRect);
2580     }
2581 #endif // (_WIN32_IE >= 0x0500)
2582
2583 #if (_WIN32_WINNT >= 0x0501)
2584     void Popup()
2585     {
2586         ATLASSERT(::IsWindow(m_hWnd));
2587         ::SendMessage(m_hWnd, TTM_POPUP, 0, 0L);
2588     }
2589 #endif // (_WIN32_WINNT >= 0x0501)
2590 };
2591
2592 typedef CToolTipCtrlT<ATL::CWindow>   CToolTipCtrl;
2593
2594 #endif // !_WIN32_WCE
2595
2596
2597 ///////////////////////////////////////////////////////////////////////////////
2598 // CHeaderCtrl
2599
2600 template <class TBase>
2601 class CHeaderCtrlT : public TBase
2602 {
2603 public:
2604 // Constructors
2605     CHeaderCtrlT(HWND hWnd = NULL) : TBase(hWnd)
2606     { }
2607
2608     CHeaderCtrlT< TBase >& operator =(HWND hWnd)
2609     {
2610         m_hWnd = hWnd;
2611         return *this;
2612     }
2613
2614     HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
2615             DWORD dwStyle = 0, DWORD dwExStyle = 0,
2616             ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
2617     {
2618         return TBase::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);
2619     }
2620
2621 // Attributes
2622     static LPCTSTR GetWndClassName()
2623     {
2624         return WC_HEADER;
2625     }
2626
2627     int GetItemCount() const
2628     {
2629         ATLASSERT(::IsWindow(m_hWnd));
2630         return (int)::SendMessage(m_hWnd, HDM_GETITEMCOUNT, 0, 0L);
2631     }
2632
2633     BOOL GetItem(int nIndex, LPHDITEM pHeaderItem) const
2634     {
2635         ATLASSERT(::IsWindow(m_hWnd));
2636         return (BOOL)::SendMessage(m_hWnd, HDM_GETITEM, nIndex, (LPARAM)pHeaderItem);
2637     }
2638
2639     BOOL SetItem(int nIndex, LPHDITEM pHeaderItem)
2640     {
2641         ATLASSERT(::IsWindow(m_hWnd));
2642         return (BOOL)::SendMessage(m_hWnd, HDM_SETITEM, nIndex, (LPARAM)pHeaderItem);
2643     }
2644
2645     CImageList GetImageList() const
2646     {
2647         ATLASSERT(::IsWindow(m_hWnd));
2648         return CImageList((HIMAGELIST)::SendMessage(m_hWnd, HDM_GETIMAGELIST, 0, 0L));
2649     }
2650
2651     CImageList SetImageList(HIMAGELIST hImageList)
2652     {
2653         ATLASSERT(::IsWindow(m_hWnd));
2654         return CImageList((HIMAGELIST)::SendMessage(m_hWnd, HDM_SETIMAGELIST, 0, (LPARAM)hImageList));
2655     }
2656
2657     BOOL GetOrderArray(int nSize, int* lpnArray) const
2658     {
2659         ATLASSERT(::IsWindow(m_hWnd));
2660         return (BOOL)::SendMessage(m_hWnd, HDM_GETORDERARRAY, nSize, (LPARAM)lpnArray);
2661     }
2662
2663     BOOL SetOrderArray(int nSize, int* lpnArray)
2664     {
2665         ATLASSERT(::IsWindow(m_hWnd));
2666         return (BOOL)::SendMessage(m_hWnd, HDM_SETORDERARRAY, nSize, (LPARAM)lpnArray);
2667     }
2668
2669     BOOL GetItemRect(int nIndex, LPRECT lpItemRect) const
2670     {
2671         ATLASSERT(::IsWindow(m_hWnd));
2672         return (BOOL)::SendMessage(m_hWnd, HDM_GETITEMRECT, nIndex, (LPARAM)lpItemRect);
2673     }
2674
2675     int SetHotDivider(BOOL bPos, DWORD dwInputValue)
2676     {
2677         ATLASSERT(::IsWindow(m_hWnd));
2678         return (int)::SendMessage(m_hWnd, HDM_SETHOTDIVIDER, bPos, dwInputValue);
2679     }
2680
2681 #if (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
2682     BOOL GetUnicodeFormat() const
2683     {
2684         ATLASSERT(::IsWindow(m_hWnd));
2685         return (BOOL)::SendMessage(m_hWnd, HDM_GETUNICODEFORMAT, 0, 0L);
2686     }
2687
2688     BOOL SetUnicodeFormat(BOOL bUnicode = TRUE)
2689     {
2690         ATLASSERT(::IsWindow(m_hWnd));
2691         return (BOOL)::SendMessage(m_hWnd, HDM_SETUNICODEFORMAT, bUnicode, 0L);
2692     }
2693 #endif // (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
2694
2695 #if (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
2696     int GetBitmapMargin() const
2697     {
2698         ATLASSERT(::IsWindow(m_hWnd));
2699         return (int)::SendMessage(m_hWnd, HDM_GETBITMAPMARGIN, 0, 0L);
2700     }
2701
2702     int SetBitmapMargin(int nWidth)
2703     {
2704         ATLASSERT(::IsWindow(m_hWnd));
2705         return (int)::SendMessage(m_hWnd, HDM_SETBITMAPMARGIN, nWidth, 0L);
2706     }
2707
2708     int SetFilterChangeTimeout(DWORD dwTimeOut)
2709     {
2710         ATLASSERT(::IsWindow(m_hWnd));
2711         return (int)::SendMessage(m_hWnd, HDM_SETFILTERCHANGETIMEOUT, 0, dwTimeOut);
2712     }
2713 #endif // (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
2714
2715 #if (_WIN32_WINNT >= 0x0600)
2716     BOOL GetItemDropDownRect(int nIndex, LPRECT lpRect) const
2717     {
2718         ATLASSERT(::IsWindow(m_hWnd));
2719         return (BOOL)::SendMessage(m_hWnd, HDM_GETITEMDROPDOWNRECT, nIndex, (LPARAM)lpRect);
2720     }
2721
2722     BOOL GetOverflowRect(LPRECT lpRect) const
2723     {
2724         ATLASSERT(::IsWindow(m_hWnd));
2725         return (BOOL)::SendMessage(m_hWnd, HDM_GETOVERFLOWRECT, 0, (LPARAM)lpRect);
2726     }
2727
2728     int GetFocusedItem() const
2729     {
2730         ATLASSERT(::IsWindow(m_hWnd));
2731         return (int)::SendMessage(m_hWnd, HDM_GETFOCUSEDITEM, 0, 0L);
2732     }
2733
2734     BOOL SetFocusedItem(int nIndex)
2735     {
2736         ATLASSERT(::IsWindow(m_hWnd));
2737         return (BOOL)::SendMessage(m_hWnd, HDM_SETFOCUSEDITEM, 0, nIndex);
2738     }
2739 #endif // (_WIN32_WINNT >= 0x0600)
2740
2741 // Operations
2742     int InsertItem(int nIndex, LPHDITEM phdi)
2743     {
2744         ATLASSERT(::IsWindow(m_hWnd));
2745         return (int)::SendMessage(m_hWnd, HDM_INSERTITEM, nIndex, (LPARAM)phdi);
2746     }
2747
2748     int AddItem(LPHDITEM phdi)
2749     {
2750         return InsertItem(GetItemCount(), phdi);
2751     }
2752
2753     BOOL DeleteItem(int nIndex)
2754     {
2755         ATLASSERT(::IsWindow(m_hWnd));
2756         return (BOOL)::SendMessage(m_hWnd, HDM_DELETEITEM, nIndex, 0L);
2757     }
2758
2759     BOOL Layout(HD_LAYOUT* pHeaderLayout)
2760     {
2761         ATLASSERT(::IsWindow(m_hWnd));
2762         return (BOOL)::SendMessage(m_hWnd, HDM_LAYOUT, 0, (LPARAM)pHeaderLayout);
2763     }
2764
2765     int HitTest(LPHDHITTESTINFO lpHitTestInfo) const
2766     {
2767         ATLASSERT(::IsWindow(m_hWnd));
2768         return (int)::SendMessage(m_hWnd, HDM_HITTEST, 0, (LPARAM)lpHitTestInfo);
2769     }
2770
2771     int OrderToIndex(int nOrder)
2772     {
2773         ATLASSERT(::IsWindow(m_hWnd));
2774         return (int)::SendMessage(m_hWnd, HDM_ORDERTOINDEX, nOrder, 0L);
2775     }
2776
2777     CImageList CreateDragImage(int nIndex)
2778     {
2779         ATLASSERT(::IsWindow(m_hWnd));
2780         return CImageList((HIMAGELIST)::SendMessage(m_hWnd, HDM_CREATEDRAGIMAGE, nIndex, 0L));
2781     }
2782
2783 #if (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
2784     int EditFilter(int nColumn, BOOL bDiscardChanges)
2785     {
2786         ATLASSERT(::IsWindow(m_hWnd));
2787         return (int)::SendMessage(m_hWnd, HDM_EDITFILTER, nColumn, MAKELPARAM(bDiscardChanges, 0));
2788     }
2789
2790     int ClearFilter(int nColumn)
2791     {
2792         ATLASSERT(::IsWindow(m_hWnd));
2793         return (int)::SendMessage(m_hWnd, HDM_CLEARFILTER, nColumn, 0L);
2794     }
2795
2796     int ClearAllFilters()
2797     {
2798         ATLASSERT(::IsWindow(m_hWnd));
2799         return (int)::SendMessage(m_hWnd, HDM_CLEARFILTER, (WPARAM)-1, 0L);
2800     }
2801 #endif // (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
2802 };
2803
2804 typedef CHeaderCtrlT<ATL::CWindow>   CHeaderCtrl;
2805
2806
2807 ///////////////////////////////////////////////////////////////////////////////
2808 // CListViewCtrl
2809
2810 template <class TBase>
2811 class CListViewCtrlT : public TBase
2812 {
2813 public:
2814 // Constructors
2815     CListViewCtrlT(HWND hWnd = NULL) : TBase(hWnd)
2816     { }
2817
2818     CListViewCtrlT< TBase >& operator =(HWND hWnd)
2819     {
2820         m_hWnd = hWnd;
2821         return *this;
2822     }
2823
2824     HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
2825             DWORD dwStyle = 0, DWORD dwExStyle = 0,
2826             ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
2827     {
2828         return TBase::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);
2829     }
2830
2831 // Attributes
2832     static LPCTSTR GetWndClassName()
2833     {
2834         return WC_LISTVIEW;
2835     }
2836
2837     COLORREF GetBkColor() const
2838     {
2839         ATLASSERT(::IsWindow(m_hWnd));
2840         return (COLORREF)::SendMessage(m_hWnd, LVM_GETBKCOLOR, 0, 0L);
2841     }
2842
2843     BOOL SetBkColor(COLORREF cr)
2844     {
2845         ATLASSERT(::IsWindow(m_hWnd));
2846         return (BOOL)::SendMessage(m_hWnd, LVM_SETBKCOLOR, 0, cr);
2847     }
2848
2849     CImageList GetImageList(int nImageListType) const
2850     {
2851         ATLASSERT(::IsWindow(m_hWnd));
2852         return CImageList((HIMAGELIST)::SendMessage(m_hWnd, LVM_GETIMAGELIST, nImageListType, 0L));
2853     }
2854
2855     CImageList SetImageList(HIMAGELIST hImageList, int nImageList)
2856     {
2857         ATLASSERT(::IsWindow(m_hWnd));
2858         return CImageList((HIMAGELIST)::SendMessage(m_hWnd, LVM_SETIMAGELIST, nImageList, (LPARAM)hImageList));
2859     }
2860
2861     int GetItemCount() const
2862     {
2863         ATLASSERT(::IsWindow(m_hWnd));
2864         return (int)::SendMessage(m_hWnd, LVM_GETITEMCOUNT, 0, 0L);
2865     }
2866
2867     BOOL SetItemCount(int nItems)
2868     {
2869         ATLASSERT(::IsWindow(m_hWnd));
2870         return (BOOL)::SendMessage(m_hWnd, LVM_SETITEMCOUNT, nItems, 0L);
2871     }
2872
2873     BOOL GetItem(LPLVITEM pItem) const
2874     {
2875         ATLASSERT(::IsWindow(m_hWnd));
2876         return (BOOL)::SendMessage(m_hWnd, LVM_GETITEM, 0, (LPARAM)pItem);
2877     }
2878
2879     BOOL SetItem(const LVITEM* pItem)
2880     {
2881         ATLASSERT(::IsWindow(m_hWnd));
2882         return (BOOL)::SendMessage(m_hWnd, LVM_SETITEM, 0, (LPARAM)pItem);
2883     }
2884
2885     BOOL SetItem(int nItem, int nSubItem, UINT nMask, LPCTSTR lpszItem,
2886         int nImage, UINT nState, UINT nStateMask, LPARAM lParam)
2887     {
2888         ATLASSERT(::IsWindow(m_hWnd));
2889         LVITEM lvi = { 0 };
2890         lvi.mask = nMask;
2891         lvi.iItem = nItem;
2892         lvi.iSubItem = nSubItem;
2893         lvi.stateMask = nStateMask;
2894         lvi.state = nState;
2895         lvi.pszText = (LPTSTR) lpszItem;
2896         lvi.iImage = nImage;
2897         lvi.lParam = lParam;
2898         return (BOOL)::SendMessage(m_hWnd, LVM_SETITEM, 0, (LPARAM)&lvi);
2899     }
2900
2901     UINT GetItemState(int nItem, UINT nMask) const
2902     {
2903         ATLASSERT(::IsWindow(m_hWnd));
2904         return (UINT)::SendMessage(m_hWnd, LVM_GETITEMSTATE, nItem, nMask);
2905     }
2906
2907     BOOL SetItemState(int nItem, UINT nState, UINT nStateMask)
2908     {
2909         ATLASSERT(::IsWindow(m_hWnd));
2910         LVITEM lvi = { 0 };
2911         lvi.state = nState;
2912         lvi.stateMask = nStateMask;
2913         return (BOOL)::SendMessage(m_hWnd, LVM_SETITEMSTATE, nItem, (LPARAM)&lvi);
2914     }
2915
2916     BOOL SetItemState(int nItem, LPLVITEM pItem)
2917     {
2918         ATLASSERT(::IsWindow(m_hWnd));
2919         return (BOOL)::SendMessage(m_hWnd, LVM_SETITEMSTATE, nItem, (LPARAM)pItem);
2920     }
2921
2922 #ifndef _ATL_NO_COM
2923     BOOL GetItemText(int nItem, int nSubItem, BSTR& bstrText) const
2924     {
2925         USES_CONVERSION;
2926         ATLASSERT(::IsWindow(m_hWnd));
2927         ATLASSERT(bstrText == NULL);
2928         LVITEM lvi = { 0 };
2929         lvi.iSubItem = nSubItem;
2930
2931         LPTSTR lpstrText = NULL;
2932         int nRes = 0;
2933         for(int nLen = 256; ; nLen *= 2)
2934         {
2935             ATLTRY(lpstrText = new TCHAR[nLen]);
2936             if(lpstrText == NULL)
2937                 break;
2938             lpstrText[0] = NULL;
2939             lvi.cchTextMax = nLen;
2940             lvi.pszText = lpstrText;
2941             nRes  = (int)::SendMessage(m_hWnd, LVM_GETITEMTEXT, (WPARAM)nItem, (LPARAM)&lvi);
2942             if(nRes < nLen - 1)
2943                 break;
2944             delete [] lpstrText;
2945             lpstrText = NULL;
2946         }
2947
2948         if(lpstrText != NULL)
2949         {
2950             if(nRes != 0)
2951                 bstrText = ::SysAllocString(T2OLE(lpstrText));
2952             delete [] lpstrText;
2953         }
2954
2955         return (bstrText != NULL) ? TRUE : FALSE;
2956     }
2957 #endif // !_ATL_NO_COM
2958
2959 #if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
2960     int GetItemText(int nItem, int nSubItem, _CSTRING_NS::CString& strText) const
2961     {
2962         ATLASSERT(::IsWindow(m_hWnd));
2963         LVITEM lvi = { 0 };
2964         lvi.iSubItem = nSubItem;
2965
2966         strText.Empty();
2967         int nRes = 0;
2968         for(int nLen = 256; ; nLen *= 2)
2969         {
2970             lvi.cchTextMax = nLen;
2971             lvi.pszText = strText.GetBufferSetLength(nLen);
2972             if(lvi.pszText == NULL)
2973             {
2974                 nRes = 0;
2975                 break;
2976             }
2977             nRes  = (int)::SendMessage(m_hWnd, LVM_GETITEMTEXT, (WPARAM)nItem, (LPARAM)&lvi);
2978             if(nRes < nLen - 1)
2979                 break;
2980         }
2981         strText.ReleaseBuffer();
2982         return nRes;
2983     }
2984 #endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
2985
2986     int GetItemText(int nItem, int nSubItem, LPTSTR lpszText, int nLen) const
2987     {
2988         ATLASSERT(::IsWindow(m_hWnd));
2989         LVITEM lvi = { 0 };
2990         lvi.iSubItem = nSubItem;
2991         lvi.cchTextMax = nLen;
2992         lvi.pszText = lpszText;
2993         return (int)::SendMessage(m_hWnd, LVM_GETITEMTEXT, (WPARAM)nItem, (LPARAM)&lvi);
2994     }
2995
2996     BOOL SetItemText(int nItem, int nSubItem, LPCTSTR lpszText)
2997     {
2998         ATLASSERT(::IsWindow(m_hWnd));
2999         return SetItem(nItem, nSubItem, LVIF_TEXT, lpszText, 0, 0, 0, 0);
3000     }
3001
3002     DWORD_PTR GetItemData(int nItem) const
3003     {
3004         ATLASSERT(::IsWindow(m_hWnd));
3005         LVITEM lvi = { 0 };
3006         lvi.iItem = nItem;
3007         lvi.mask = LVIF_PARAM;
3008         BOOL bRet = (BOOL)::SendMessage(m_hWnd, LVM_GETITEM, 0, (LPARAM)&lvi);
3009         return (DWORD_PTR)(bRet ? lvi.lParam : NULL);
3010     }
3011
3012     BOOL SetItemData(int nItem, DWORD_PTR dwData)
3013     {
3014         ATLASSERT(::IsWindow(m_hWnd));
3015         return SetItem(nItem, 0, LVIF_PARAM, NULL, 0, 0, 0, (LPARAM)dwData);
3016     }
3017
3018     UINT GetCallbackMask() const
3019     {
3020         ATLASSERT(::IsWindow(m_hWnd));
3021         return (UINT)::SendMessage(m_hWnd, LVM_GETCALLBACKMASK, 0, 0L);
3022     }
3023
3024     BOOL SetCallbackMask(UINT nMask)
3025     {
3026         ATLASSERT(::IsWindow(m_hWnd));
3027         return (BOOL)::SendMessage(m_hWnd, LVM_SETCALLBACKMASK, nMask, 0L);
3028     }
3029
3030     BOOL GetItemPosition(int nItem, LPPOINT lpPoint) const
3031     {
3032         ATLASSERT(::IsWindow(m_hWnd));
3033         return (BOOL)::SendMessage(m_hWnd, LVM_GETITEMPOSITION, nItem, (LPARAM)lpPoint);
3034     }
3035
3036     BOOL SetItemPosition(int nItem, POINT pt)
3037     {
3038         ATLASSERT(::IsWindow(m_hWnd));
3039         ATLASSERT(((GetStyle() & LVS_TYPEMASK) == LVS_ICON) || ((GetStyle() & LVS_TYPEMASK) == LVS_SMALLICON));
3040         return (BOOL)::SendMessage(m_hWnd, LVM_SETITEMPOSITION32, nItem, (LPARAM)&pt);
3041     }
3042
3043     BOOL SetItemPosition(int nItem, int x, int y)
3044     {
3045         ATLASSERT(::IsWindow(m_hWnd));
3046         ATLASSERT(((GetStyle() & LVS_TYPEMASK) == LVS_ICON) || ((GetStyle() & LVS_TYPEMASK) == LVS_SMALLICON));
3047         POINT pt = { x, y };
3048         return (BOOL)::SendMessage(m_hWnd, LVM_SETITEMPOSITION32, nItem, (LPARAM)&pt);
3049     }
3050
3051     int GetStringWidth(LPCTSTR lpsz) const
3052     {
3053         ATLASSERT(::IsWindow(m_hWnd));
3054         return (int)::SendMessage(m_hWnd, LVM_GETSTRINGWIDTH, 0, (LPARAM)lpsz);
3055     }
3056
3057     CEdit GetEditControl() const
3058     {
3059         ATLASSERT(::IsWindow(m_hWnd));
3060         return CEdit((HWND)::SendMessage(m_hWnd, LVM_GETEDITCONTROL, 0, 0L));
3061     }
3062
3063     BOOL GetColumn(int nCol, LVCOLUMN* pColumn) const
3064     {
3065         ATLASSERT(::IsWindow(m_hWnd));
3066         return (BOOL)::SendMessage(m_hWnd, LVM_GETCOLUMN, nCol, (LPARAM)pColumn);
3067     }
3068
3069     BOOL SetColumn(int nCol, const LVCOLUMN* pColumn)
3070     {
3071         ATLASSERT(::IsWindow(m_hWnd));
3072         return (BOOL)::SendMessage(m_hWnd, LVM_SETCOLUMN, nCol, (LPARAM)pColumn);
3073     }
3074
3075     int GetColumnWidth(int nCol) const
3076     {
3077         ATLASSERT(::IsWindow(m_hWnd));
3078         return (int)::SendMessage(m_hWnd, LVM_GETCOLUMNWIDTH, nCol, 0L);
3079     }
3080
3081     BOOL SetColumnWidth(int nCol, int cx)
3082     {
3083         ATLASSERT(::IsWindow(m_hWnd));
3084         return (BOOL)::SendMessage(m_hWnd, LVM_SETCOLUMNWIDTH, nCol, MAKELPARAM(cx, 0));
3085     }
3086
3087     BOOL GetViewRect(LPRECT lpRect) const
3088     {
3089         ATLASSERT(::IsWindow(m_hWnd));
3090         return (BOOL)::SendMessage(m_hWnd, LVM_GETVIEWRECT, 0, (LPARAM)lpRect);
3091     }
3092
3093     COLORREF GetTextColor() const
3094     {
3095         ATLASSERT(::IsWindow(m_hWnd));
3096         return (COLORREF)::SendMessage(m_hWnd, LVM_GETTEXTCOLOR, 0, 0L);
3097     }
3098
3099     BOOL SetTextColor(COLORREF cr)
3100     {
3101         ATLASSERT(::IsWindow(m_hWnd));
3102         return (BOOL)::SendMessage(m_hWnd, LVM_SETTEXTCOLOR, 0, cr);
3103     }
3104
3105     COLORREF GetTextBkColor() const
3106     {
3107         ATLASSERT(::IsWindow(m_hWnd));
3108         return (COLORREF)::SendMessage(m_hWnd, LVM_GETTEXTBKCOLOR, 0, 0L);
3109     }
3110
3111     BOOL SetTextBkColor(COLORREF cr)
3112     {
3113         ATLASSERT(::IsWindow(m_hWnd));
3114         return (BOOL)::SendMessage(m_hWnd, LVM_SETTEXTBKCOLOR, 0, cr);
3115     }
3116
3117     int GetTopIndex() const
3118     {
3119         ATLASSERT(::IsWindow(m_hWnd));
3120         return (int)::SendMessage(m_hWnd, LVM_GETTOPINDEX, 0, 0L);
3121     }
3122
3123     int GetCountPerPage() const
3124     {
3125         ATLASSERT(::IsWindow(m_hWnd));
3126         return (int)::SendMessage(m_hWnd, LVM_GETCOUNTPERPAGE, 0, 0L);
3127     }
3128
3129     BOOL GetOrigin(LPPOINT lpPoint) const
3130     {
3131         ATLASSERT(::IsWindow(m_hWnd));
3132         return (BOOL)::SendMessage(m_hWnd, LVM_GETORIGIN, 0, (LPARAM)lpPoint);
3133     }
3134
3135     UINT GetSelectedCount() const
3136     {
3137         ATLASSERT(::IsWindow(m_hWnd));
3138         return (UINT)::SendMessage(m_hWnd, LVM_GETSELECTEDCOUNT, 0, 0L);
3139     }
3140
3141     BOOL GetItemRect(int nItem, LPRECT lpRect, UINT nCode) const
3142     {
3143         ATLASSERT(::IsWindow(m_hWnd));
3144         lpRect->left = nCode;
3145         return (BOOL)::SendMessage(m_hWnd, LVM_GETITEMRECT, (WPARAM)nItem, (LPARAM)lpRect);
3146     }
3147
3148 #ifndef _WIN32_WCE
3149     HCURSOR GetHotCursor() const
3150     {
3151         ATLASSERT(::IsWindow(m_hWnd));
3152         return (HCURSOR)::SendMessage(m_hWnd, LVM_GETHOTCURSOR, 0, 0L);
3153     }
3154
3155     HCURSOR SetHotCursor(HCURSOR hHotCursor)
3156     {
3157         ATLASSERT(::IsWindow(m_hWnd));
3158         return (HCURSOR)::SendMessage(m_hWnd, LVM_SETHOTCURSOR, 0, (LPARAM)hHotCursor);
3159     }
3160
3161     int GetHotItem() const
3162     {
3163         ATLASSERT(::IsWindow(m_hWnd));
3164         return (int)::SendMessage(m_hWnd, LVM_GETHOTITEM, 0, 0L);
3165     }
3166
3167     int SetHotItem(int nIndex)
3168     {
3169         ATLASSERT(::IsWindow(m_hWnd));
3170         return (int)::SendMessage(m_hWnd, LVM_SETHOTITEM, nIndex, 0L);
3171     }
3172 #endif // !_WIN32_WCE
3173
3174     BOOL GetColumnOrderArray(int nCount, int* lpnArray) const
3175     {
3176         ATLASSERT(::IsWindow(m_hWnd));
3177         return (BOOL)::SendMessage(m_hWnd, LVM_GETCOLUMNORDERARRAY, nCount, (LPARAM)lpnArray);
3178     }
3179
3180     BOOL SetColumnOrderArray(int nCount, int* lpnArray)
3181     {
3182         ATLASSERT(::IsWindow(m_hWnd));
3183         return (BOOL)::SendMessage(m_hWnd, LVM_SETCOLUMNORDERARRAY, nCount, (LPARAM)lpnArray);
3184     }
3185
3186     CHeaderCtrl GetHeader() const
3187     {
3188         ATLASSERT(::IsWindow(m_hWnd));
3189         return CHeaderCtrl((HWND)::SendMessage(m_hWnd, LVM_GETHEADER, 0, 0L));
3190     }
3191
3192     BOOL GetSubItemRect(int nItem, int nSubItem, int nFlag, LPRECT lpRect) const
3193     {
3194         ATLASSERT(::IsWindow(m_hWnd));
3195         ATLASSERT((GetStyle() & LVS_TYPEMASK) == LVS_REPORT);
3196         ATLASSERT(lpRect != NULL);
3197         lpRect->top = nSubItem;
3198         lpRect->left = nFlag;
3199         return (BOOL)::SendMessage(m_hWnd, LVM_GETSUBITEMRECT, nItem, (LPARAM)lpRect);
3200     }
3201
3202     DWORD SetIconSpacing(int cx, int cy)
3203     {
3204         ATLASSERT(::IsWindow(m_hWnd));
3205         ATLASSERT((GetStyle() & LVS_TYPEMASK) == LVS_ICON);
3206         return (DWORD)::SendMessage(m_hWnd, LVM_SETICONSPACING, 0, MAKELPARAM(cx, cy));
3207     }
3208
3209     int GetISearchString(LPTSTR lpstr) const
3210     {
3211         ATLASSERT(::IsWindow(m_hWnd));
3212         return (int)::SendMessage(m_hWnd, LVM_GETISEARCHSTRING, 0, (LPARAM)lpstr);
3213     }
3214
3215     void GetItemSpacing(SIZE& sizeSpacing, BOOL bSmallIconView = FALSE) const
3216     {
3217         ATLASSERT(::IsWindow(m_hWnd));
3218         DWORD dwRet = (DWORD)::SendMessage(m_hWnd, LVM_GETITEMSPACING, bSmallIconView, 0L);
3219         sizeSpacing.cx = GET_X_LPARAM(dwRet);
3220         sizeSpacing.cy = GET_Y_LPARAM(dwRet);
3221     }
3222
3223 #if (_WIN32_WCE >= 410)
3224     void SetItemSpacing(INT cySpacing)
3225     {
3226         ATLASSERT(::IsWindow(m_hWnd));
3227         ListView_SetItemSpacing(m_hWnd, cySpacing);
3228     }
3229 #endif // (_WIN32_WCE >= 410)
3230
3231     // single-selection only
3232     int GetSelectedIndex() const
3233     {
3234         ATLASSERT(::IsWindow(m_hWnd));
3235         ATLASSERT((GetStyle() & LVS_SINGLESEL) != 0);
3236         return (int)::SendMessage(m_hWnd, LVM_GETNEXTITEM, (WPARAM)-1, MAKELPARAM(LVNI_ALL | LVNI_SELECTED, 0));
3237     }
3238
3239     BOOL GetSelectedItem(LPLVITEM pItem) const
3240     {
3241         ATLASSERT(::IsWindow(m_hWnd));
3242         ATLASSERT((GetStyle() & LVS_SINGLESEL) != 0);
3243         ATLASSERT(pItem != NULL);
3244         pItem->iItem = (int)::SendMessage(m_hWnd, LVM_GETNEXTITEM, (WPARAM)-1, MAKELPARAM(LVNI_ALL | LVNI_SELECTED, 0));
3245         if(pItem->iItem == -1)
3246             return FALSE;
3247         return (BOOL)::SendMessage(m_hWnd, LVM_GETITEM, 0, (LPARAM)pItem);
3248     }
3249
3250     // extended list view styles
3251     DWORD GetExtendedListViewStyle() const
3252     {
3253         ATLASSERT(::IsWindow(m_hWnd));
3254         return (DWORD)::SendMessage(m_hWnd, LVM_GETEXTENDEDLISTVIEWSTYLE, 0, 0L);
3255     }
3256
3257     // dwExMask = 0 means all styles
3258     DWORD SetExtendedListViewStyle(DWORD dwExStyle, DWORD dwExMask = 0)
3259     {
3260         ATLASSERT(::IsWindow(m_hWnd));
3261         return (DWORD)::SendMessage(m_hWnd, LVM_SETEXTENDEDLISTVIEWSTYLE, dwExMask, dwExStyle);
3262     }
3263
3264     // checkboxes only
3265     BOOL GetCheckState(int nIndex) const
3266     {
3267         ATLASSERT(::IsWindow(m_hWnd));
3268         ATLASSERT((GetExtendedListViewStyle() & LVS_EX_CHECKBOXES) != 0);
3269         UINT uRet = GetItemState(nIndex, LVIS_STATEIMAGEMASK);
3270         return (uRet >> 12) - 1;
3271     }
3272
3273     BOOL SetCheckState(int nItem, BOOL bCheck)
3274     {
3275         int nCheck = bCheck ? 2 : 1;   // one based index
3276         return SetItemState(nItem, INDEXTOSTATEIMAGEMASK(nCheck), LVIS_STATEIMAGEMASK);
3277     }
3278
3279     // view type
3280     DWORD GetViewType() const
3281     {
3282         ATLASSERT(::IsWindow(m_hWnd));
3283         return (GetStyle() & LVS_TYPEMASK);
3284     }
3285
3286     DWORD SetViewType(DWORD dwType)
3287     {
3288         ATLASSERT(::IsWindow(m_hWnd));
3289         ATLASSERT(dwType == LVS_ICON || dwType == LVS_SMALLICON || dwType == LVS_LIST || dwType == LVS_REPORT);
3290         DWORD dwOldType = GetViewType();
3291         if(dwType != dwOldType)
3292             ModifyStyle(LVS_TYPEMASK, (dwType & LVS_TYPEMASK));
3293         return dwOldType;
3294     }
3295
3296 #if (_WIN32_IE >= 0x0400)
3297 #ifndef _WIN32_WCE
3298     BOOL GetBkImage(LPLVBKIMAGE plvbki) const
3299     {
3300         ATLASSERT(::IsWindow(m_hWnd));
3301         return (BOOL)::SendMessage(m_hWnd, LVM_GETBKIMAGE, 0, (LPARAM)plvbki);
3302     }
3303
3304     BOOL SetBkImage(LPLVBKIMAGE plvbki)
3305     {
3306         ATLASSERT(::IsWindow(m_hWnd));
3307         return (BOOL)::SendMessage(m_hWnd, LVM_SETBKIMAGE, 0, (LPARAM)plvbki);
3308     }
3309 #endif // !_WIN32_WCE
3310
3311     int GetSelectionMark() const
3312     {
3313         ATLASSERT(::IsWindow(m_hWnd));
3314         return (int)::SendMessage(m_hWnd, LVM_GETSELECTIONMARK, 0, 0L);
3315     }
3316
3317     int SetSelectionMark(int nIndex)
3318     {
3319         ATLASSERT(::IsWindow(m_hWnd));
3320         return (int)::SendMessage(m_hWnd, LVM_SETSELECTIONMARK, 0, nIndex);
3321     }
3322
3323 #ifndef _WIN32_WCE
3324     BOOL GetWorkAreas(int nWorkAreas, LPRECT lpRect) const
3325     {
3326         ATLASSERT(::IsWindow(m_hWnd));
3327         return (BOOL)::SendMessage(m_hWnd, LVM_GETWORKAREAS, nWorkAreas, (LPARAM)lpRect);
3328     }
3329
3330     BOOL SetWorkAreas(int nWorkAreas, LPRECT lpRect)
3331     {
3332         ATLASSERT(::IsWindow(m_hWnd));
3333         return (BOOL)::SendMessage(m_hWnd, LVM_SETWORKAREAS, nWorkAreas, (LPARAM)lpRect);
3334     }
3335
3336     DWORD GetHoverTime() const
3337     {
3338         ATLASSERT(::IsWindow(m_hWnd));
3339         ATLASSERT((GetExtendedListViewStyle() & (LVS_EX_TRACKSELECT | LVS_EX_ONECLICKACTIVATE | LVS_EX_TWOCLICKACTIVATE)) != 0);
3340         return (DWORD)::SendMessage(m_hWnd, LVM_GETHOVERTIME, 0, 0L);
3341     }
3342
3343     DWORD SetHoverTime(DWORD dwHoverTime)
3344     {
3345         ATLASSERT(::IsWindow(m_hWnd));
3346         ATLASSERT((GetExtendedListViewStyle() & (LVS_EX_TRACKSELECT | LVS_EX_ONECLICKACTIVATE | LVS_EX_TWOCLICKACTIVATE)) != 0);
3347         return (DWORD)::SendMessage(m_hWnd, LVM_SETHOVERTIME, 0, dwHoverTime);
3348     }
3349
3350     BOOL GetNumberOfWorkAreas(int* pnWorkAreas) const
3351     {
3352         ATLASSERT(::IsWindow(m_hWnd));
3353         return (BOOL)::SendMessage(m_hWnd, LVM_GETNUMBEROFWORKAREAS, 0, (LPARAM)pnWorkAreas);
3354     }
3355 #endif // !_WIN32_WCE
3356
3357     BOOL SetItemCountEx(int nItems, DWORD dwFlags)
3358     {
3359         ATLASSERT(::IsWindow(m_hWnd));
3360         ATLASSERT(((GetStyle() & LVS_OWNERDATA) != 0) && (((GetStyle() & LVS_TYPEMASK) == LVS_REPORT) || ((GetStyle() & LVS_TYPEMASK) == LVS_LIST)));
3361         return (BOOL)::SendMessage(m_hWnd, LVM_SETITEMCOUNT, nItems, dwFlags);
3362     }
3363
3364 #ifndef _WIN32_WCE
3365     CToolTipCtrl GetToolTips() const
3366     {
3367         ATLASSERT(::IsWindow(m_hWnd));
3368         return CToolTipCtrl((HWND)::SendMessage(m_hWnd, LVM_GETTOOLTIPS, 0, 0L));
3369     }
3370
3371     CToolTipCtrl SetToolTips(HWND hWndTT)
3372     {
3373         ATLASSERT(::IsWindow(m_hWnd));
3374         return CToolTipCtrl((HWND)::SendMessage(m_hWnd, LVM_SETTOOLTIPS, (WPARAM)hWndTT, 0L));
3375     }
3376
3377     BOOL GetUnicodeFormat() const
3378     {
3379         ATLASSERT(::IsWindow(m_hWnd));
3380         return (BOOL)::SendMessage(m_hWnd, LVM_GETUNICODEFORMAT, 0, 0L);
3381     }
3382
3383     BOOL SetUnicodeFormat(BOOL bUnicode = TRUE)
3384     {
3385         ATLASSERT(::IsWindow(m_hWnd));
3386         return (BOOL)::SendMessage(m_hWnd, LVM_SETUNICODEFORMAT, bUnicode, 0L);
3387     }
3388 #endif // !_WIN32_WCE
3389 #endif // (_WIN32_IE >= 0x0400)
3390
3391 #if (_WIN32_WINNT >= 0x0501)
3392     int GetSelectedColumn() const
3393     {
3394         ATLASSERT(::IsWindow(m_hWnd));
3395         return (int)::SendMessage(m_hWnd, LVM_GETSELECTEDCOLUMN, 0, 0L);
3396     }
3397
3398     void SetSelectedColumn(int nColumn)
3399     {
3400         ATLASSERT(::IsWindow(m_hWnd));
3401         ::SendMessage(m_hWnd, LVM_SETSELECTEDCOLUMN, nColumn, 0L);
3402     }
3403
3404     DWORD GetView() const
3405     {
3406         ATLASSERT(::IsWindow(m_hWnd));
3407         return (DWORD)::SendMessage(m_hWnd, LVM_GETVIEW, 0, 0L);
3408     }
3409
3410     int SetView(DWORD dwView)
3411     {
3412         ATLASSERT(::IsWindow(m_hWnd));
3413         return (int)::SendMessage(m_hWnd, LVM_SETVIEW, dwView, 0L);
3414     }
3415
3416     BOOL IsGroupViewEnabled() const
3417     {
3418         ATLASSERT(::IsWindow(m_hWnd));
3419         return (BOOL)::SendMessage(m_hWnd, LVM_ISGROUPVIEWENABLED, 0, 0L);
3420     }
3421
3422     int GetGroupInfo(int nGroupID, PLVGROUP pGroup) const
3423     {
3424         ATLASSERT(::IsWindow(m_hWnd));
3425         return (int)::SendMessage(m_hWnd, LVM_GETGROUPINFO, nGroupID, (LPARAM)pGroup);
3426     }
3427
3428     int SetGroupInfo(int nGroupID, PLVGROUP pGroup)
3429     {
3430         ATLASSERT(::IsWindow(m_hWnd));
3431         return (int)::SendMessage(m_hWnd, LVM_SETGROUPINFO, nGroupID, (LPARAM)pGroup);
3432     }
3433
3434     void GetGroupMetrics(PLVGROUPMETRICS pGroupMetrics) const
3435     {
3436         ATLASSERT(::IsWindow(m_hWnd));
3437         ::SendMessage(m_hWnd, LVM_GETGROUPMETRICS, 0, (LPARAM)pGroupMetrics);
3438     }
3439
3440     void SetGroupMetrics(PLVGROUPMETRICS pGroupMetrics)
3441     {
3442         ATLASSERT(::IsWindow(m_hWnd));
3443         ::SendMessage(m_hWnd, LVM_SETGROUPMETRICS, 0, (LPARAM)pGroupMetrics);
3444     }
3445
3446     void GetTileViewInfo(PLVTILEVIEWINFO pTileViewInfo) const
3447     {
3448         ATLASSERT(::IsWindow(m_hWnd));
3449         ::SendMessage(m_hWnd, LVM_GETTILEVIEWINFO, 0, (LPARAM)pTileViewInfo);
3450     }
3451
3452     BOOL SetTileViewInfo(PLVTILEVIEWINFO pTileViewInfo)
3453     {
3454         ATLASSERT(::IsWindow(m_hWnd));
3455         return (BOOL)::SendMessage(m_hWnd, LVM_SETTILEVIEWINFO, 0, (LPARAM)pTileViewInfo);
3456     }
3457
3458     void GetTileInfo(PLVTILEINFO pTileInfo) const
3459     {
3460         ATLASSERT(::IsWindow(m_hWnd));
3461         ::SendMessage(m_hWnd, LVM_GETTILEINFO, 0, (LPARAM)pTileInfo);
3462     }
3463
3464     BOOL SetTileInfo(PLVTILEINFO pTileInfo)
3465     {
3466         ATLASSERT(::IsWindow(m_hWnd));
3467         return (BOOL)::SendMessage(m_hWnd, LVM_SETTILEINFO, 0, (LPARAM)pTileInfo);
3468     }
3469
3470     BOOL GetInsertMark(LPLVINSERTMARK pInsertMark) const
3471     {
3472         ATLASSERT(::IsWindow(m_hWnd));
3473         return (BOOL)::SendMessage(m_hWnd, LVM_GETINSERTMARK, 0, (LPARAM)pInsertMark);
3474     }
3475
3476     BOOL SetInsertMark(LPLVINSERTMARK pInsertMark)
3477     {
3478         ATLASSERT(::IsWindow(m_hWnd));
3479         return (BOOL)::SendMessage(m_hWnd, LVM_SETINSERTMARK, 0, (LPARAM)pInsertMark);
3480     }
3481
3482     int GetInsertMarkRect(LPRECT lpRect) const
3483     {
3484         ATLASSERT(::IsWindow(m_hWnd));
3485         return (int)::SendMessage(m_hWnd, LVM_GETINSERTMARKRECT, 0, (LPARAM)lpRect);
3486     }
3487
3488     COLORREF GetInsertMarkColor() const
3489     {
3490         ATLASSERT(::IsWindow(m_hWnd));
3491         return (COLORREF)::SendMessage(m_hWnd, LVM_GETINSERTMARKCOLOR, 0, 0L);
3492     }
3493
3494     COLORREF SetInsertMarkColor(COLORREF clr)
3495     {
3496         ATLASSERT(::IsWindow(m_hWnd));
3497         return (COLORREF)::SendMessage(m_hWnd, LVM_SETINSERTMARKCOLOR, 0, clr);
3498     }
3499
3500     COLORREF GetOutlineColor() const
3501     {
3502         ATLASSERT(::IsWindow(m_hWnd));
3503         return (COLORREF)::SendMessage(m_hWnd, LVM_GETOUTLINECOLOR, 0, 0L);
3504     }
3505
3506     COLORREF SetOutlineColor(COLORREF clr)
3507     {
3508         ATLASSERT(::IsWindow(m_hWnd));
3509         return (COLORREF)::SendMessage(m_hWnd, LVM_SETOUTLINECOLOR, 0, clr);
3510     }
3511 #endif // (_WIN32_WINNT >= 0x0501)
3512
3513 #if (_WIN32_WINNT >= 0x0600)
3514     int GetGroupCount() const
3515     {
3516         ATLASSERT(::IsWindow(m_hWnd));
3517         return (int)::SendMessage(m_hWnd, LVM_GETGROUPCOUNT, 0, 0L);
3518     }
3519
3520     BOOL GetGroupInfoByIndex(int nIndex, PLVGROUP pGroup) const
3521     {
3522         ATLASSERT(::IsWindow(m_hWnd));
3523         return (BOOL)::SendMessage(m_hWnd, LVM_GETGROUPINFOBYINDEX, nIndex, (LPARAM)pGroup);
3524     }
3525
3526     BOOL GetGroupRect(int nGroupID, int nType, LPRECT lpRect) const
3527     {
3528         ATLASSERT(::IsWindow(m_hWnd));
3529         ATLASSERT(lpRect != NULL);
3530         if(lpRect != NULL)
3531             lpRect->top = nType;
3532         return (BOOL)::SendMessage(m_hWnd, LVM_GETGROUPRECT, nGroupID, (LPARAM)lpRect);
3533     }
3534
3535     UINT GetGroupState(int nGroupID, UINT uMask) const
3536     {
3537         ATLASSERT(::IsWindow(m_hWnd));
3538         return (UINT)::SendMessage(m_hWnd, LVM_GETGROUPSTATE, nGroupID, (LPARAM)uMask);
3539     }
3540
3541     int GetFocusedGroup() const
3542     {
3543         ATLASSERT(::IsWindow(m_hWnd));
3544         return (int)::SendMessage(m_hWnd, LVM_GETFOCUSEDGROUP, 0, 0L);
3545     }
3546
3547     BOOL GetEmptyText(LPWSTR lpstrText, int cchText) const
3548     {
3549         ATLASSERT(::IsWindow(m_hWnd));
3550         return (BOOL)::SendMessage(m_hWnd, LVM_GETEMPTYTEXT, cchText, (LPARAM)lpstrText);
3551     }
3552
3553     BOOL GetFooterRect(LPRECT lpRect) const
3554     {
3555         ATLASSERT(::IsWindow(m_hWnd));
3556         return (BOOL)::SendMessage(m_hWnd, LVM_GETFOOTERRECT, 0, (LPARAM)lpRect);
3557     }
3558
3559     BOOL GetFooterInfo(LPLVFOOTERINFO lpFooterInfo) const
3560     {
3561         ATLASSERT(::IsWindow(m_hWnd));
3562         return (BOOL)::SendMessage(m_hWnd, LVM_GETFOOTERINFO, 0, (LPARAM)lpFooterInfo);
3563     }
3564
3565     BOOL GetFooterItemRect(int nItem, LPRECT lpRect) const
3566     {
3567         ATLASSERT(::IsWindow(m_hWnd));
3568         return (BOOL)::SendMessage(m_hWnd, LVM_GETFOOTERITEMRECT, nItem, (LPARAM)lpRect);
3569     }
3570
3571     BOOL GetFooterItem(int nItem, LPLVFOOTERITEM lpFooterItem) const
3572     {
3573         ATLASSERT(::IsWindow(m_hWnd));
3574         return (BOOL)::SendMessage(m_hWnd, LVM_GETFOOTERITEM, nItem, (LPARAM)lpFooterItem);
3575     }
3576
3577     BOOL GetItemIndexRect(PLVITEMINDEX pItemIndex, int nSubItem, int nType, LPRECT lpRect) const
3578     {
3579         ATLASSERT(::IsWindow(m_hWnd));
3580         ATLASSERT(pItemIndex != NULL);
3581         ATLASSERT(lpRect != NULL);
3582         if(lpRect != NULL)
3583         {
3584             lpRect->top = nSubItem;
3585             lpRect->left = nType;
3586         }
3587         return (BOOL)::SendMessage(m_hWnd, LVM_GETITEMINDEXRECT, (WPARAM)pItemIndex, (LPARAM)lpRect);
3588     }
3589
3590     BOOL SetItemIndexState(PLVITEMINDEX pItemIndex, UINT uState, UINT dwMask)
3591     {
3592         ATLASSERT(::IsWindow(m_hWnd));
3593         LVITEM lvi = { 0 };
3594         lvi.state = uState;
3595         lvi.stateMask = dwMask;
3596         return (BOOL)::SendMessage(m_hWnd, LVM_SETITEMINDEXSTATE, (WPARAM)pItemIndex, (LPARAM)&lvi);
3597     }
3598
3599     BOOL GetNextItemIndex(PLVITEMINDEX pItemIndex, WORD wFlags) const
3600     {
3601         ATLASSERT(::IsWindow(m_hWnd));
3602         return (BOOL)::SendMessage(m_hWnd, LVM_GETNEXTITEMINDEX, (WPARAM)pItemIndex, MAKELPARAM(wFlags, 0));
3603     }
3604 #endif // (_WIN32_WINNT >= 0x0600)
3605
3606 // Operations
3607     int InsertColumn(int nCol, const LVCOLUMN* pColumn)
3608     {
3609         ATLASSERT(::IsWindow(m_hWnd));
3610         return (int)::SendMessage(m_hWnd, LVM_INSERTCOLUMN, nCol, (LPARAM)pColumn);
3611     }
3612
3613     int InsertColumn(int nCol, LPCTSTR lpszColumnHeading, int nFormat = LVCFMT_LEFT,
3614             int nWidth = -1, int nSubItem = -1, int iImage = -1, int iOrder = -1)
3615     {
3616         LVCOLUMN column = { 0 };
3617         column.mask = LVCF_TEXT|LVCF_FMT;
3618         column.pszText = (LPTSTR)lpszColumnHeading;
3619         column.fmt = nFormat;
3620         if (nWidth != -1)
3621         {
3622             column.mask |= LVCF_WIDTH;
3623             column.cx = nWidth;
3624         }
3625         if (nSubItem != -1)
3626         {
3627             column.mask |= LVCF_SUBITEM;
3628             column.iSubItem = nSubItem;
3629         }
3630         if (iImage != -1)
3631         {
3632             column.mask |= LVCF_IMAGE;
3633             column.iImage = iImage;
3634         }
3635         if (iOrder != -1)
3636         {
3637             column.mask |= LVCF_ORDER;
3638             column.iOrder = iOrder;
3639         }
3640         return InsertColumn(nCol, &column);
3641     }
3642
3643     BOOL DeleteColumn(int nCol)
3644     {
3645         ATLASSERT(::IsWindow(m_hWnd));
3646         return (BOOL)::SendMessage(m_hWnd, LVM_DELETECOLUMN, nCol, 0L);
3647     }
3648
3649     int InsertItem(UINT nMask, int nItem, LPCTSTR lpszItem, UINT nState, UINT nStateMask, int nImage, LPARAM lParam)
3650     {
3651         ATLASSERT(::IsWindow(m_hWnd));
3652         LVITEM item = { 0 };
3653         item.mask = nMask;
3654         item.iItem = nItem;
3655         item.iSubItem = 0;
3656         item.pszText = (LPTSTR)lpszItem;
3657         item.state = nState;
3658         item.stateMask = nStateMask;
3659         item.iImage = nImage;
3660         item.lParam = lParam;
3661         return InsertItem(&item);
3662     }
3663
3664     int InsertItem(const LVITEM* pItem)
3665     {
3666         ATLASSERT(::IsWindow(m_hWnd));
3667         return (int)::SendMessage(m_hWnd, LVM_INSERTITEM, 0, (LPARAM)pItem);
3668     }
3669
3670     int InsertItem(int nItem, LPCTSTR lpszItem)
3671     {
3672         ATLASSERT(::IsWindow(m_hWnd));
3673         return InsertItem(LVIF_TEXT, nItem, lpszItem, 0, 0, 0, 0);
3674     }
3675
3676     int InsertItem(int nItem, LPCTSTR lpszItem, int nImage)
3677     {
3678         ATLASSERT(::IsWindow(m_hWnd));
3679         return InsertItem(LVIF_TEXT|LVIF_IMAGE, nItem, lpszItem, 0, 0, nImage, 0);
3680     }
3681
3682     int GetNextItem(int nItem, int nFlags) const
3683     {
3684         ATLASSERT(::IsWindow(m_hWnd));
3685         return (int)::SendMessage(m_hWnd, LVM_GETNEXTITEM, nItem, MAKELPARAM(nFlags, 0));
3686     }
3687
3688     BOOL DeleteItem(int nItem)
3689     {
3690         ATLASSERT(::IsWindow(m_hWnd));
3691         return (BOOL)::SendMessage(m_hWnd, LVM_DELETEITEM, nItem, 0L);
3692     }
3693
3694     BOOL DeleteAllItems()
3695     {
3696         ATLASSERT(::IsWindow(m_hWnd));
3697         return (BOOL)::SendMessage(m_hWnd, LVM_DELETEALLITEMS, 0, 0L);
3698     }
3699
3700     int FindItem(LVFINDINFO* pFindInfo, int nStart = -1) const
3701     {
3702         ATLASSERT(::IsWindow(m_hWnd));
3703         return (int)::SendMessage(m_hWnd, LVM_FINDITEM, nStart, (LPARAM)pFindInfo);
3704     }
3705
3706     int FindItem(LPCTSTR lpstrFind, bool bPartial = true, bool bWrap = false, int nStart = -1) const
3707     {
3708         ATLASSERT(::IsWindow(m_hWnd));
3709         LVFINDINFO lvfi = { 0 };
3710         lvfi.flags = LVFI_STRING | (bWrap ? LVFI_WRAP : 0) | (bPartial ? LVFI_PARTIAL : 0);
3711         lvfi.psz = lpstrFind;
3712         return (int)::SendMessage(m_hWnd, LVM_FINDITEM, nStart, (LPARAM)&lvfi);
3713     }
3714
3715     int HitTest(LVHITTESTINFO* pHitTestInfo) const
3716     {
3717         ATLASSERT(::IsWindow(m_hWnd));
3718         return (int)::SendMessage(m_hWnd, LVM_HITTEST, 0, (LPARAM)pHitTestInfo);
3719     }
3720
3721     int HitTest(POINT pt, UINT* pFlags) const
3722     {
3723         ATLASSERT(::IsWindow(m_hWnd));
3724         LVHITTESTINFO hti = { 0 };
3725         hti.pt = pt;
3726         int nRes = (int)::SendMessage(m_hWnd, LVM_HITTEST, 0, (LPARAM)&hti);
3727         if (pFlags != NULL)
3728             *pFlags = hti.flags;
3729         return nRes;
3730     }
3731
3732     BOOL EnsureVisible(int nItem, BOOL bPartialOK)
3733     {
3734         ATLASSERT(::IsWindow(m_hWnd));
3735         return (BOOL)::SendMessage(m_hWnd, LVM_ENSUREVISIBLE, nItem, MAKELPARAM(bPartialOK, 0));
3736     }
3737
3738     BOOL Scroll(SIZE size)
3739     {
3740         ATLASSERT(::IsWindow(m_hWnd));
3741         return (BOOL)::SendMessage(m_hWnd, LVM_SCROLL, size.cx, size.cy);
3742     }
3743
3744     BOOL RedrawItems(int nFirst, int nLast)
3745     {
3746         ATLASSERT(::IsWindow(m_hWnd));
3747         return (BOOL)::SendMessage(m_hWnd, LVM_REDRAWITEMS, nFirst, nLast);
3748     }
3749
3750     BOOL Arrange(UINT nCode)
3751     {
3752         ATLASSERT(::IsWindow(m_hWnd));
3753         return (BOOL)::SendMessage(m_hWnd, LVM_ARRANGE, nCode, 0L);
3754     }
3755
3756     CEdit EditLabel(int nItem)
3757     {
3758         ATLASSERT(::IsWindow(m_hWnd));
3759         return CEdit((HWND)::SendMessage(m_hWnd, LVM_EDITLABEL, nItem, 0L));
3760     }
3761
3762     BOOL Update(int nItem)
3763     {
3764         ATLASSERT(::IsWindow(m_hWnd));
3765         return (BOOL)::SendMessage(m_hWnd, LVM_UPDATE, nItem, 0L);
3766     }
3767
3768     BOOL SortItems(PFNLVCOMPARE pfnCompare, LPARAM lParamSort)
3769     {
3770         ATLASSERT(::IsWindow(m_hWnd));
3771         return (BOOL)::SendMessage(m_hWnd, LVM_SORTITEMS, (WPARAM)lParamSort, (LPARAM)pfnCompare);
3772     }
3773
3774     CImageList RemoveImageList(int nImageList)
3775     {
3776         ATLASSERT(::IsWindow(m_hWnd));
3777         return CImageList((HIMAGELIST)::SendMessage(m_hWnd, LVM_SETIMAGELIST, (WPARAM)nImageList, NULL));
3778     }
3779
3780     CImageList CreateDragImage(int nItem, LPPOINT lpPoint)
3781     {
3782         ATLASSERT(::IsWindow(m_hWnd));
3783         return CImageList((HIMAGELIST)::SendMessage(m_hWnd, LVM_CREATEDRAGIMAGE, nItem, (LPARAM)lpPoint));
3784     }
3785
3786     DWORD ApproximateViewRect(int cx = -1, int cy = -1, int nCount = -1)
3787     {
3788         ATLASSERT(::IsWindow(m_hWnd));
3789         return (DWORD)::SendMessage(m_hWnd, LVM_APPROXIMATEVIEWRECT, nCount, MAKELPARAM(cx, cy));
3790     }
3791
3792     int SubItemHitTest(LPLVHITTESTINFO lpInfo) const
3793     {
3794         ATLASSERT(::IsWindow(m_hWnd));
3795         return (int)::SendMessage(m_hWnd, LVM_SUBITEMHITTEST, 0, (LPARAM)lpInfo);
3796     }
3797
3798     int AddColumn(LPCTSTR strItem, int nItem, int nSubItem = -1,
3799             int nMask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM,
3800             int nFmt = LVCFMT_LEFT)
3801     {
3802         const int cxOffset = 15;
3803         ATLASSERT(::IsWindow(m_hWnd));
3804         LVCOLUMN lvc = { 0 };
3805         lvc.mask = nMask;
3806         lvc.fmt = nFmt;
3807         lvc.pszText = (LPTSTR)strItem;
3808         lvc.cx = GetStringWidth(lvc.pszText) + cxOffset;
3809         if(nMask & LVCF_SUBITEM)
3810             lvc.iSubItem = (nSubItem != -1) ? nSubItem : nItem;
3811         return InsertColumn(nItem, &lvc);
3812     }
3813
3814     int AddItem(int nItem, int nSubItem, LPCTSTR strItem, int nImageIndex = -3)
3815     {
3816         ATLASSERT(::IsWindow(m_hWnd));
3817         LVITEM lvItem = { 0 };
3818         lvItem.mask = LVIF_TEXT;
3819         lvItem.iItem = nItem;
3820         lvItem.iSubItem = nSubItem;
3821         lvItem.pszText = (LPTSTR)strItem;
3822         if(nImageIndex != -3)
3823         {
3824             lvItem.mask |= LVIF_IMAGE;
3825             lvItem.iImage = nImageIndex;
3826         }
3827         if(nSubItem == 0)
3828             return InsertItem(&lvItem);
3829         return SetItem(&lvItem) ? nItem : -1;
3830     }
3831
3832 #if (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
3833     BOOL SortItemsEx(PFNLVCOMPARE pfnCompare, LPARAM lParamSort)
3834     {
3835         ATLASSERT(::IsWindow(m_hWnd));
3836         return (BOOL)::SendMessage(m_hWnd, LVM_SORTITEMSEX, (WPARAM)lParamSort, (LPARAM)pfnCompare);
3837     }
3838 #endif // (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
3839
3840 #if (_WIN32_WINNT >= 0x0501)
3841     int InsertGroup(int nItem, PLVGROUP pGroup)
3842     {
3843         ATLASSERT(::IsWindow(m_hWnd));
3844         return (int)::SendMessage(m_hWnd, LVM_INSERTGROUP, nItem, (LPARAM)pGroup);
3845     }
3846
3847     int AddGroup(PLVGROUP pGroup)
3848     {
3849         return InsertGroup(-1, pGroup);
3850     }
3851
3852     int RemoveGroup(int nGroupID)
3853     {
3854         ATLASSERT(::IsWindow(m_hWnd));
3855         return (int)::SendMessage(m_hWnd, LVM_REMOVEGROUP, nGroupID, 0L);
3856     }
3857
3858     void MoveGroup(int nGroupID, int nItem)
3859     {
3860         ATLASSERT(::IsWindow(m_hWnd));
3861         ::SendMessage(m_hWnd, LVM_MOVEGROUP, nGroupID, nItem);
3862     }
3863
3864     void MoveItemToGroup(int nItem, int nGroupID)
3865     {
3866         ATLASSERT(::IsWindow(m_hWnd));
3867         ::SendMessage(m_hWnd, LVM_MOVEITEMTOGROUP, nItem, nGroupID);
3868     }
3869
3870     int EnableGroupView(BOOL bEnable)
3871     {
3872         ATLASSERT(::IsWindow(m_hWnd));
3873         return (int)::SendMessage(m_hWnd, LVM_ENABLEGROUPVIEW, bEnable, 0L);
3874     }
3875
3876     int SortGroups(PFNLVGROUPCOMPARE pCompareFunc, LPVOID lpVoid = NULL)
3877     {
3878         ATLASSERT(::IsWindow(m_hWnd));
3879         return (int)::SendMessage(m_hWnd, LVM_SORTGROUPS, (WPARAM)pCompareFunc, (LPARAM)lpVoid);
3880     }
3881
3882     void InsertGroupSorted(PLVINSERTGROUPSORTED pInsertGroupSorted)
3883     {
3884         ATLASSERT(::IsWindow(m_hWnd));
3885         ::SendMessage(m_hWnd, LVM_INSERTGROUPSORTED, (WPARAM)pInsertGroupSorted, 0L);
3886     }
3887
3888     void RemoveAllGroups()
3889     {
3890         ATLASSERT(::IsWindow(m_hWnd));
3891         ::SendMessage(m_hWnd, LVM_REMOVEALLGROUPS, 0, 0L);
3892     }
3893
3894     BOOL HasGroup(int nGroupID)
3895     {
3896         ATLASSERT(::IsWindow(m_hWnd));
3897         return (BOOL)::SendMessage(m_hWnd, LVM_HASGROUP, nGroupID, 0L);
3898     }
3899
3900     BOOL InsertMarkHitTest(LPPOINT lpPoint, LPLVINSERTMARK pInsertMark) const
3901     {
3902         ATLASSERT(::IsWindow(m_hWnd));
3903         return (BOOL)::SendMessage(m_hWnd, LVM_INSERTMARKHITTEST, (WPARAM)lpPoint, (LPARAM)pInsertMark);
3904     }
3905
3906     BOOL SetInfoTip(PLVSETINFOTIP pSetInfoTip)
3907     {
3908         ATLASSERT(::IsWindow(m_hWnd));
3909         return (BOOL)::SendMessage(m_hWnd, LVM_SETINFOTIP, 0, (LPARAM)pSetInfoTip);
3910     }
3911
3912     void CancelEditLabel()
3913     {
3914         ATLASSERT(::IsWindow(m_hWnd));
3915         ::SendMessage(m_hWnd, LVM_CANCELEDITLABEL, 0, 0L);
3916     }
3917
3918     UINT MapIndexToID(int nIndex) const
3919     {
3920         ATLASSERT(::IsWindow(m_hWnd));
3921         return (UINT)::SendMessage(m_hWnd, LVM_MAPINDEXTOID, nIndex, 0L);
3922     }
3923
3924     int MapIDToIndex(UINT uID) const
3925     {
3926         ATLASSERT(::IsWindow(m_hWnd));
3927         return (int)::SendMessage(m_hWnd, LVM_MAPIDTOINDEX, uID, 0L);
3928     }
3929 #endif // (_WIN32_WINNT >= 0x0501)
3930
3931 #if (_WIN32_WINNT >= 0x0600)
3932     int HitTestEx(LPLVHITTESTINFO lpHitTestInfo) const
3933     {
3934         ATLASSERT(::IsWindow(m_hWnd));
3935         return (int)::SendMessage(m_hWnd, LVM_HITTEST, (WPARAM)-1, (LPARAM)lpHitTestInfo);
3936     }
3937
3938     int HitTestEx(POINT pt, UINT* pFlags) const
3939     {
3940         ATLASSERT(::IsWindow(m_hWnd));
3941         LVHITTESTINFO hti = { 0 };
3942         hti.pt = pt;
3943         int nRes = (int)::SendMessage(m_hWnd, LVM_HITTEST, (WPARAM)-1, (LPARAM)&hti);
3944         if (pFlags != NULL)
3945             *pFlags = hti.flags;
3946         return nRes;
3947     }
3948
3949     int SubItemHitTestEx(LPLVHITTESTINFO lpHitTestInfo) const
3950     {
3951         ATLASSERT(::IsWindow(m_hWnd));
3952         return (int)::SendMessage(m_hWnd, LVM_SUBITEMHITTEST, (WPARAM)-1, (LPARAM)lpHitTestInfo);
3953     }
3954 #endif // (_WIN32_WINNT >= 0x0600)
3955
3956     // Note: selects only one item
3957     BOOL SelectItem(int nIndex)
3958     {
3959         ATLASSERT(::IsWindow(m_hWnd));
3960
3961         // multi-selection only: de-select all items
3962         if((GetStyle() & LVS_SINGLESEL) == 0)
3963             SetItemState(-1, 0, LVIS_SELECTED);
3964
3965         BOOL bRet = SetItemState(nIndex, LVIS_SELECTED | LVIS_FOCUSED, LVIS_SELECTED | LVIS_FOCUSED);
3966         if(bRet)
3967             bRet = EnsureVisible(nIndex, FALSE);
3968
3969         return bRet;
3970     }
3971 };
3972
3973 typedef CListViewCtrlT<ATL::CWindow>   CListViewCtrl;
3974
3975
3976 ///////////////////////////////////////////////////////////////////////////////
3977 // CTreeViewCtrl
3978
3979 template <class TBase>
3980 class CTreeViewCtrlT : public TBase
3981 {
3982 public:
3983 // Constructors
3984     CTreeViewCtrlT(HWND hWnd = NULL) : TBase(hWnd)
3985     { }
3986
3987     CTreeViewCtrlT< TBase >& operator =(HWND hWnd)
3988     {
3989         m_hWnd = hWnd;
3990         return *this;
3991     }
3992
3993     HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
3994             DWORD dwStyle = 0, DWORD dwExStyle = 0,
3995             ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
3996     {
3997         return TBase::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);
3998     }
3999
4000 // Attributes
4001     static LPCTSTR GetWndClassName()
4002     {
4003         return WC_TREEVIEW;
4004     }
4005
4006     UINT GetCount() const
4007     {
4008         ATLASSERT(::IsWindow(m_hWnd));
4009         return (UINT)::SendMessage(m_hWnd, TVM_GETCOUNT, 0, 0L);
4010     }
4011
4012     UINT GetIndent() const
4013     {
4014         ATLASSERT(::IsWindow(m_hWnd));
4015         return (UINT)::SendMessage(m_hWnd, TVM_GETINDENT, 0, 0L);
4016     }
4017
4018     void SetIndent(UINT nIndent)
4019     {
4020         ATLASSERT(::IsWindow(m_hWnd));
4021         ::SendMessage(m_hWnd, TVM_SETINDENT, nIndent, 0L);
4022     }
4023
4024     CImageList GetImageList(int nImageListType = TVSIL_NORMAL) const
4025     {
4026         ATLASSERT(::IsWindow(m_hWnd));
4027         return CImageList((HIMAGELIST)::SendMessage(m_hWnd, TVM_GETIMAGELIST, (WPARAM)nImageListType, 0L));
4028     }
4029
4030     CImageList SetImageList(HIMAGELIST hImageList, int nImageListType = TVSIL_NORMAL)
4031     {
4032         ATLASSERT(::IsWindow(m_hWnd));
4033         return CImageList((HIMAGELIST)::SendMessage(m_hWnd, TVM_SETIMAGELIST, (WPARAM)nImageListType, (LPARAM)hImageList));
4034     }
4035
4036     BOOL GetItem(LPTVITEM pItem) const
4037     {
4038         ATLASSERT(::IsWindow(m_hWnd));
4039         return (BOOL)::SendMessage(m_hWnd, TVM_GETITEM, 0, (LPARAM)pItem);
4040     }
4041
4042     BOOL SetItem(LPTVITEM pItem)
4043     {
4044         ATLASSERT(::IsWindow(m_hWnd));
4045         return (BOOL)::SendMessage(m_hWnd, TVM_SETITEM, 0, (LPARAM)pItem);
4046     }
4047
4048     BOOL SetItem(HTREEITEM hItem, UINT nMask, LPCTSTR lpszItem, int nImage,
4049         int nSelectedImage, UINT nState, UINT nStateMask, LPARAM lParam)
4050     {
4051         ATLASSERT(::IsWindow(m_hWnd));
4052         TVITEM item = { 0 };
4053         item.hItem = hItem;
4054         item.mask = nMask;
4055         item.pszText = (LPTSTR) lpszItem;
4056         item.iImage = nImage;
4057         item.iSelectedImage = nSelectedImage;
4058         item.state = nState;
4059         item.stateMask = nStateMask;
4060         item.lParam = lParam;
4061         return (BOOL)::SendMessage(m_hWnd, TVM_SETITEM, 0, (LPARAM)&item);
4062     }
4063
4064     BOOL GetItemText(HTREEITEM hItem, LPTSTR lpstrText, int nLen) const
4065     {
4066         ATLASSERT(::IsWindow(m_hWnd));
4067         ATLASSERT(lpstrText != NULL);
4068
4069         TVITEM item = { 0 };
4070         item.hItem = hItem;
4071         item.mask = TVIF_TEXT;
4072         item.pszText = lpstrText;
4073         item.cchTextMax = nLen;
4074
4075         return (BOOL)::SendMessage(m_hWnd, TVM_GETITEM, 0, (LPARAM)&item);
4076     }
4077
4078 #ifndef _ATL_NO_COM
4079     BOOL GetItemText(HTREEITEM hItem, BSTR& bstrText) const
4080     {
4081         USES_CONVERSION;
4082         ATLASSERT(::IsWindow(m_hWnd));
4083         ATLASSERT(bstrText == NULL);
4084         TVITEM item = { 0 };
4085         item.hItem = hItem;
4086         item.mask = TVIF_TEXT;
4087
4088         LPTSTR lpstrText = NULL;
4089         BOOL bRet = FALSE;
4090         for(int nLen = 256; ; nLen *= 2)
4091         {
4092             ATLTRY(lpstrText = new TCHAR[nLen]);
4093             if(lpstrText == NULL)
4094                 break;
4095             lpstrText[0] = NULL;
4096             item.pszText = lpstrText;
4097             item.cchTextMax = nLen;
4098             bRet = (BOOL)::SendMessage(m_hWnd, TVM_GETITEM, 0, (LPARAM)&item);
4099             if(!bRet || (lstrlen(item.pszText) < nLen - 1))
4100                 break;
4101             delete [] lpstrText;
4102             lpstrText = NULL;
4103         }
4104
4105         if(lpstrText != NULL)
4106         {
4107             if(bRet)
4108                 bstrText = ::SysAllocString(T2OLE(lpstrText));
4109             delete [] lpstrText;
4110         }
4111
4112         return (bstrText != NULL) ? TRUE : FALSE;
4113     }
4114 #endif // !_ATL_NO_COM
4115
4116 #if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
4117     BOOL GetItemText(HTREEITEM hItem, _CSTRING_NS::CString& strText) const
4118     {
4119         ATLASSERT(::IsWindow(m_hWnd));
4120         TVITEM item = { 0 };
4121         item.hItem = hItem;
4122         item.mask = TVIF_TEXT;
4123
4124         strText.Empty();
4125         BOOL bRet = FALSE;
4126         for(int nLen = 256; ; nLen *= 2)
4127         {
4128             item.pszText = strText.GetBufferSetLength(nLen);
4129             if(item.pszText == NULL)
4130             {
4131                 bRet = FALSE;
4132                 break;
4133             }
4134             item.cchTextMax = nLen;
4135             bRet = (BOOL)::SendMessage(m_hWnd, TVM_GETITEM, 0, (LPARAM)&item);
4136             if(!bRet || (lstrlen(item.pszText) < nLen - 1))
4137                 break;
4138         }
4139         strText.ReleaseBuffer();
4140         return bRet;
4141     }
4142 #endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
4143
4144     BOOL SetItemText(HTREEITEM hItem, LPCTSTR lpszItem)
4145     {
4146         ATLASSERT(::IsWindow(m_hWnd));
4147         return SetItem(hItem, TVIF_TEXT, lpszItem, 0, 0, 0, 0, NULL);
4148     }
4149
4150     BOOL GetItemImage(HTREEITEM hItem, int& nImage, int& nSelectedImage) const
4151     {
4152         ATLASSERT(::IsWindow(m_hWnd));
4153         TVITEM item = { 0 };
4154         item.hItem = hItem;
4155         item.mask = TVIF_IMAGE|TVIF_SELECTEDIMAGE;
4156         BOOL bRes = (BOOL)::SendMessage(m_hWnd, TVM_GETITEM, 0, (LPARAM)&item);
4157         if (bRes)
4158         {
4159             nImage = item.iImage;
4160             nSelectedImage = item.iSelectedImage;
4161         }
4162         return bRes;
4163     }
4164
4165     BOOL SetItemImage(HTREEITEM hItem, int nImage, int nSelectedImage)
4166     {
4167         ATLASSERT(::IsWindow(m_hWnd));
4168         return SetItem(hItem, TVIF_IMAGE|TVIF_SELECTEDIMAGE, NULL, nImage, nSelectedImage, 0, 0, NULL);
4169     }
4170
4171     UINT GetItemState(HTREEITEM hItem, UINT nStateMask) const
4172     {
4173         ATLASSERT(::IsWindow(m_hWnd));
4174 #if (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
4175         return (((UINT)::SendMessage(m_hWnd, TVM_GETITEMSTATE, (WPARAM)hItem, (LPARAM)nStateMask)) & nStateMask);
4176 #else // !((_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE))
4177         TVITEM item = { 0 };
4178         item.hItem = hItem;
4179         item.mask = TVIF_STATE;
4180         item.state = 0;
4181         item.stateMask = nStateMask;
4182         ::SendMessage(m_hWnd, TVM_GETITEM, 0, (LPARAM)&item);
4183         return (item.state & nStateMask);
4184 #endif // !((_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE))
4185     }
4186
4187     BOOL SetItemState(HTREEITEM hItem, UINT nState, UINT nStateMask)
4188     {
4189         ATLASSERT(::IsWindow(m_hWnd));
4190         return SetItem(hItem, TVIF_STATE, NULL, 0, 0, nState, nStateMask, NULL);
4191     }
4192
4193     DWORD_PTR GetItemData(HTREEITEM hItem) const
4194     {
4195         ATLASSERT(::IsWindow(m_hWnd));
4196         TVITEM item = { 0 };
4197         item.hItem = hItem;
4198         item.mask = TVIF_PARAM;
4199         BOOL bRet = (BOOL)::SendMessage(m_hWnd, TVM_GETITEM, 0, (LPARAM)&item);
4200         return (DWORD_PTR)(bRet ? item.lParam : NULL);
4201     }
4202
4203     BOOL SetItemData(HTREEITEM hItem, DWORD_PTR dwData)
4204     {
4205         ATLASSERT(::IsWindow(m_hWnd));
4206         return SetItem(hItem, TVIF_PARAM, NULL, 0, 0, 0, 0, (LPARAM)dwData);
4207     }
4208
4209     CEdit GetEditControl() const
4210     {
4211         ATLASSERT(::IsWindow(m_hWnd));
4212         return CEdit((HWND)::SendMessage(m_hWnd, TVM_GETEDITCONTROL, 0, 0L));
4213     }
4214
4215     UINT GetVisibleCount() const
4216     {
4217         ATLASSERT(::IsWindow(m_hWnd));
4218         return (UINT)::SendMessage(m_hWnd, TVM_GETVISIBLECOUNT, 0, 0L);
4219     }
4220
4221     BOOL GetItemRect(HTREEITEM hItem, LPRECT lpRect, BOOL bTextOnly) const
4222     {
4223         ATLASSERT(::IsWindow(m_hWnd));
4224         *(HTREEITEM*)lpRect = hItem;
4225         return (BOOL)::SendMessage(m_hWnd, TVM_GETITEMRECT, (WPARAM)bTextOnly, (LPARAM)lpRect);
4226     }
4227
4228     BOOL ItemHasChildren(HTREEITEM hItem) const
4229     {
4230         ATLASSERT(::IsWindow(m_hWnd));
4231         TVITEM item = { 0 };
4232         item.hItem = hItem;
4233         item.mask = TVIF_CHILDREN;
4234         ::SendMessage(m_hWnd, TVM_GETITEM, 0, (LPARAM)&item);
4235         return item.cChildren;
4236     }
4237
4238 #ifndef _WIN32_WCE
4239     CToolTipCtrl GetToolTips() const
4240     {
4241         ATLASSERT(::IsWindow(m_hWnd));
4242         return CToolTipCtrl((HWND)::SendMessage(m_hWnd, TVM_GETTOOLTIPS, 0, 0L));
4243     }
4244
4245     CToolTipCtrl SetToolTips(HWND hWndTT)
4246     {
4247         ATLASSERT(::IsWindow(m_hWnd));
4248         return CToolTipCtrl((HWND)::SendMessage(m_hWnd, TVM_SETTOOLTIPS, (WPARAM)hWndTT, 0L));
4249     }
4250 #endif // !_WIN32_WCE
4251
4252     int GetISearchString(LPTSTR lpstr) const
4253     {
4254         ATLASSERT(::IsWindow(m_hWnd));
4255         return (int)::SendMessage(m_hWnd, TVM_GETISEARCHSTRING, 0, (LPARAM)lpstr);
4256     }
4257
4258     // checkboxes only
4259     BOOL GetCheckState(HTREEITEM hItem) const
4260     {
4261         ATLASSERT(::IsWindow(m_hWnd));
4262         ATLASSERT((GetStyle() & TVS_CHECKBOXES) != 0);
4263         UINT uRet = GetItemState(hItem, TVIS_STATEIMAGEMASK);
4264         return (uRet >> 12) - 1;
4265     }
4266
4267     BOOL SetCheckState(HTREEITEM hItem, BOOL bCheck)
4268     {
4269         int nCheck = bCheck ? 2 : 1;   // one based index
4270         return SetItemState(hItem, INDEXTOSTATEIMAGEMASK(nCheck), TVIS_STATEIMAGEMASK);
4271     }
4272
4273 #if (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
4274     COLORREF GetBkColor() const
4275     {
4276         ATLASSERT(::IsWindow(m_hWnd));
4277         return (COLORREF)::SendMessage(m_hWnd, TVM_GETBKCOLOR, 0, 0L);
4278     }
4279
4280     COLORREF SetBkColor(COLORREF clr)
4281     {
4282         ATLASSERT(::IsWindow(m_hWnd));
4283         return (COLORREF)::SendMessage(m_hWnd, TVM_SETBKCOLOR, 0, (LPARAM)clr);
4284     }
4285
4286     COLORREF GetInsertMarkColor() const
4287     {
4288         ATLASSERT(::IsWindow(m_hWnd));
4289         return (COLORREF)::SendMessage(m_hWnd, TVM_GETINSERTMARKCOLOR, 0, 0L);
4290     }
4291
4292     COLORREF SetInsertMarkColor(COLORREF clr)
4293     {
4294         ATLASSERT(::IsWindow(m_hWnd));
4295         return (COLORREF)::SendMessage(m_hWnd, TVM_SETINSERTMARKCOLOR, 0, (LPARAM)clr);
4296     }
4297
4298     int GetItemHeight() const
4299     {
4300         ATLASSERT(::IsWindow(m_hWnd));
4301         return (int)::SendMessage(m_hWnd, TVM_GETITEMHEIGHT, 0, 0L);
4302     }
4303
4304     int SetItemHeight(int cyHeight)
4305     {
4306         ATLASSERT(::IsWindow(m_hWnd));
4307         return (int)::SendMessage(m_hWnd, TVM_SETITEMHEIGHT, cyHeight, 0L);
4308     }
4309
4310     int GetScrollTime() const
4311     {
4312         ATLASSERT(::IsWindow(m_hWnd));
4313         return (int)::SendMessage(m_hWnd, TVM_GETSCROLLTIME, 0, 0L);
4314     }
4315
4316     int SetScrollTime(int nScrollTime)
4317     {
4318         ATLASSERT(::IsWindow(m_hWnd));
4319         return (int)::SendMessage(m_hWnd, TVM_SETSCROLLTIME, nScrollTime, 0L);
4320     }
4321
4322     COLORREF GetTextColor() const
4323     {
4324         ATLASSERT(::IsWindow(m_hWnd));
4325         return (COLORREF)::SendMessage(m_hWnd, TVM_GETTEXTCOLOR, 0, 0L);
4326     }
4327
4328     COLORREF SetTextColor(COLORREF clr)
4329     {
4330         ATLASSERT(::IsWindow(m_hWnd));
4331         return (COLORREF)::SendMessage(m_hWnd, TVM_SETTEXTCOLOR, 0, (LPARAM)clr);
4332     }
4333
4334     BOOL GetUnicodeFormat() const
4335     {
4336         ATLASSERT(::IsWindow(m_hWnd));
4337         return (BOOL)::SendMessage(m_hWnd, TVM_GETUNICODEFORMAT, 0, 0L);
4338     }
4339
4340     BOOL SetUnicodeFormat(BOOL bUnicode = TRUE)
4341     {
4342         ATLASSERT(::IsWindow(m_hWnd));
4343         return (BOOL)::SendMessage(m_hWnd, TVM_SETUNICODEFORMAT, bUnicode, 0L);
4344     }
4345 #endif // (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
4346
4347 #if (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
4348     COLORREF GetLineColor() const
4349     {
4350         ATLASSERT(::IsWindow(m_hWnd));
4351         return (COLORREF)::SendMessage(m_hWnd, TVM_GETLINECOLOR, 0, 0L);
4352     }
4353
4354     COLORREF SetLineColor(COLORREF clrNew /*= CLR_DEFAULT*/)
4355     {
4356         ATLASSERT(::IsWindow(m_hWnd));
4357         return (COLORREF)::SendMessage(m_hWnd, TVM_SETLINECOLOR, 0, (LPARAM)clrNew);
4358     }
4359 #endif // (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
4360
4361 #if (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
4362     BOOL GetItem(LPTVITEMEX pItem) const
4363     {
4364         ATLASSERT(::IsWindow(m_hWnd));
4365         return (BOOL)::SendMessage(m_hWnd, TVM_GETITEM, 0, (LPARAM)pItem);
4366     }
4367
4368     BOOL SetItem(LPTVITEMEX pItem)
4369     {
4370         ATLASSERT(::IsWindow(m_hWnd));
4371         return (BOOL)::SendMessage(m_hWnd, TVM_SETITEM, 0, (LPARAM)pItem);
4372     }
4373 #endif // (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
4374
4375     DWORD GetExtendedStyle() const
4376     {
4377 #ifndef TVM_GETEXTENDEDSTYLE
4378         const UINT TVM_GETEXTENDEDSTYLE = (TV_FIRST + 45);
4379 #endif
4380         ATLASSERT(::IsWindow(m_hWnd));
4381         return (DWORD)::SendMessage(m_hWnd, TVM_GETEXTENDEDSTYLE, 0, 0L);
4382     }
4383
4384     DWORD SetExtendedStyle(DWORD dwStyle, DWORD dwMask)
4385     {
4386 #ifndef TVM_SETEXTENDEDSTYLE
4387         const UINT TVM_SETEXTENDEDSTYLE = (TV_FIRST + 44);
4388 #endif
4389         ATLASSERT(::IsWindow(m_hWnd));
4390         return (DWORD)::SendMessage(m_hWnd, TVM_SETEXTENDEDSTYLE, dwMask, dwStyle);
4391     }
4392
4393 #if (_WIN32_WINNT >= 0x0600)
4394     BOOL SetAutoScrollInfo(UINT uPixPerSec, UINT uUpdateTime)
4395     {
4396         ATLASSERT(::IsWindow(m_hWnd));
4397         return (BOOL)::SendMessage(m_hWnd, TVM_SETAUTOSCROLLINFO, (WPARAM)uPixPerSec, (LPARAM)uUpdateTime);
4398     }
4399
4400     DWORD GetSelectedCount() const
4401     {
4402         ATLASSERT(::IsWindow(m_hWnd));
4403         return (DWORD)::SendMessage(m_hWnd, TVM_GETSELECTEDCOUNT, 0, 0L);
4404     }
4405
4406     BOOL GetItemPartRect(HTREEITEM hItem, TVITEMPART partID, LPRECT lpRect) const
4407     {
4408         ATLASSERT(::IsWindow(m_hWnd));
4409         TVGETITEMPARTRECTINFO gipri = { hItem, lpRect, partID };
4410         return (BOOL)::SendMessage(m_hWnd, TVM_GETITEMPARTRECT, 0, (LPARAM)&gipri);
4411     }
4412 #endif // (_WIN32_WINNT >= 0x0600)
4413
4414 // Operations
4415     HTREEITEM InsertItem(LPTVINSERTSTRUCT lpInsertStruct)
4416     {
4417         ATLASSERT(::IsWindow(m_hWnd));
4418         return (HTREEITEM)::SendMessage(m_hWnd, TVM_INSERTITEM, 0, (LPARAM)lpInsertStruct);
4419     }
4420
4421     HTREEITEM InsertItem(LPCTSTR lpszItem, int nImage,
4422         int nSelectedImage, HTREEITEM hParent, HTREEITEM hInsertAfter)
4423     {
4424         ATLASSERT(::IsWindow(m_hWnd));
4425         return InsertItem(TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE, lpszItem, nImage, nSelectedImage, 0, 0, 0, hParent, hInsertAfter);
4426     }
4427
4428     HTREEITEM InsertItem(LPCTSTR lpszItem, HTREEITEM hParent, HTREEITEM hInsertAfter)
4429     {
4430         ATLASSERT(::IsWindow(m_hWnd));
4431         return InsertItem(TVIF_TEXT, lpszItem, 0, 0, 0, 0, 0, hParent, hInsertAfter);
4432     }
4433
4434     HTREEITEM InsertItem(UINT nMask, LPCTSTR lpszItem, int nImage,
4435         int nSelectedImage, UINT nState, UINT nStateMask, LPARAM lParam,
4436         HTREEITEM hParent, HTREEITEM hInsertAfter)
4437     {
4438         ATLASSERT(::IsWindow(m_hWnd));
4439         TVINSERTSTRUCT tvis = { 0 };
4440         tvis.hParent = hParent;
4441         tvis.hInsertAfter = hInsertAfter;
4442         tvis.item.mask = nMask;
4443         tvis.item.pszText = (LPTSTR) lpszItem;
4444         tvis.item.iImage = nImage;
4445         tvis.item.iSelectedImage = nSelectedImage;
4446         tvis.item.state = nState;
4447         tvis.item.stateMask = nStateMask;
4448         tvis.item.lParam = lParam;
4449         return (HTREEITEM)::SendMessage(m_hWnd, TVM_INSERTITEM, 0, (LPARAM)&tvis);
4450     }
4451
4452     BOOL DeleteItem(HTREEITEM hItem)
4453     {
4454         ATLASSERT(::IsWindow(m_hWnd));
4455         return (BOOL)::SendMessage(m_hWnd, TVM_DELETEITEM, 0, (LPARAM)hItem);
4456     }
4457
4458     BOOL DeleteAllItems()
4459     {
4460         ATLASSERT(::IsWindow(m_hWnd));
4461         return (BOOL)::SendMessage(m_hWnd, TVM_DELETEITEM, 0, (LPARAM)TVI_ROOT);
4462     }
4463
4464     BOOL Expand(HTREEITEM hItem, UINT nCode = TVE_EXPAND)
4465     {
4466         ATLASSERT(::IsWindow(m_hWnd));
4467         return (BOOL)::SendMessage(m_hWnd, TVM_EXPAND, nCode, (LPARAM)hItem);
4468     }
4469
4470     HTREEITEM GetNextItem(HTREEITEM hItem, UINT nCode) const
4471     {
4472         ATLASSERT(::IsWindow(m_hWnd));
4473         return (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, nCode, (LPARAM)hItem);
4474     }
4475
4476     HTREEITEM GetChildItem(HTREEITEM hItem) const
4477     {
4478         ATLASSERT(::IsWindow(m_hWnd));
4479         return (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_CHILD, (LPARAM)hItem);
4480     }
4481
4482     HTREEITEM GetNextSiblingItem(HTREEITEM hItem) const
4483     {
4484         ATLASSERT(::IsWindow(m_hWnd));
4485         return (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_NEXT, (LPARAM)hItem);
4486     }
4487
4488     HTREEITEM GetPrevSiblingItem(HTREEITEM hItem) const
4489     {
4490         ATLASSERT(::IsWindow(m_hWnd));
4491         return (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_PREVIOUS, (LPARAM)hItem);
4492     }
4493
4494     HTREEITEM GetParentItem(HTREEITEM hItem) const
4495     {
4496         ATLASSERT(::IsWindow(m_hWnd));
4497         return (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_PARENT, (LPARAM)hItem);
4498     }
4499
4500     HTREEITEM GetFirstVisibleItem() const
4501     {
4502         ATLASSERT(::IsWindow(m_hWnd));
4503         return (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_FIRSTVISIBLE, 0L);
4504     }
4505
4506     HTREEITEM GetNextVisibleItem(HTREEITEM hItem) const
4507     {
4508         ATLASSERT(::IsWindow(m_hWnd));
4509         return (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_NEXTVISIBLE, (LPARAM)hItem);
4510     }
4511
4512     HTREEITEM GetPrevVisibleItem(HTREEITEM hItem) const
4513     {
4514         ATLASSERT(::IsWindow(m_hWnd));
4515         return (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_PREVIOUSVISIBLE, (LPARAM)hItem);
4516     }
4517
4518     HTREEITEM GetSelectedItem() const
4519     {
4520         ATLASSERT(::IsWindow(m_hWnd));
4521         return (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_CARET, 0L);
4522     }
4523
4524     HTREEITEM GetDropHilightItem() const
4525     {
4526         ATLASSERT(::IsWindow(m_hWnd));
4527         return (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_DROPHILITE, 0L);
4528     }
4529
4530     HTREEITEM GetRootItem() const
4531     {
4532         ATLASSERT(::IsWindow(m_hWnd));
4533         return (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_ROOT, 0L);
4534     }
4535
4536 #if !defined(_WIN32_WCE) && (_WIN32_IE >= 0x0400)
4537     HTREEITEM GetLastVisibleItem() const
4538     {
4539         ATLASSERT(::IsWindow(m_hWnd));
4540         return (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_LASTVISIBLE, 0L);
4541     }
4542 #endif // !defined(_WIN32_WCE) && (_WIN32_IE >= 0x0400)
4543
4544 #if (_WIN32_IE >= 0x0600)
4545     HTREEITEM GetNextSelectedItem() const
4546     {
4547         ATLASSERT(::IsWindow(m_hWnd));
4548         return (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_NEXTSELECTED, 0L);
4549     }
4550 #endif // (_WIN32_IE >= 0x0600)
4551
4552     BOOL Select(HTREEITEM hItem, UINT nCode)
4553     {
4554         ATLASSERT(::IsWindow(m_hWnd));
4555         return (BOOL)::SendMessage(m_hWnd, TVM_SELECTITEM, nCode, (LPARAM)hItem);
4556     }
4557
4558     BOOL SelectItem(HTREEITEM hItem)
4559     {
4560         ATLASSERT(::IsWindow(m_hWnd));
4561         return (BOOL)::SendMessage(m_hWnd, TVM_SELECTITEM, TVGN_CARET, (LPARAM)hItem);
4562     }
4563
4564     BOOL SelectDropTarget(HTREEITEM hItem)
4565     {
4566         ATLASSERT(::IsWindow(m_hWnd));
4567         return (BOOL)::SendMessage(m_hWnd, TVM_SELECTITEM, TVGN_DROPHILITE, (LPARAM)hItem);
4568     }
4569
4570     BOOL SelectSetFirstVisible(HTREEITEM hItem)
4571     {
4572         ATLASSERT(::IsWindow(m_hWnd));
4573         return (BOOL)::SendMessage(m_hWnd, TVM_SELECTITEM, TVGN_FIRSTVISIBLE, (LPARAM)hItem);
4574     }
4575
4576     CEdit EditLabel(HTREEITEM hItem)
4577     {
4578         ATLASSERT(::IsWindow(m_hWnd));
4579         return CEdit((HWND)::SendMessage(m_hWnd, TVM_EDITLABEL, 0, (LPARAM)hItem));
4580     }
4581
4582     BOOL EndEditLabelNow(BOOL bCancel)
4583     {
4584         ATLASSERT(::IsWindow(m_hWnd));
4585         return (BOOL)::SendMessage(m_hWnd, TVM_ENDEDITLABELNOW, bCancel, 0L);
4586     }
4587
4588     HTREEITEM HitTest(TVHITTESTINFO* pHitTestInfo) const
4589     {
4590         ATLASSERT(::IsWindow(m_hWnd));
4591         return (HTREEITEM)::SendMessage(m_hWnd, TVM_HITTEST, 0, (LPARAM)pHitTestInfo);
4592     }
4593
4594     HTREEITEM HitTest(POINT pt, UINT* pFlags) const
4595     {
4596         ATLASSERT(::IsWindow(m_hWnd));
4597         TVHITTESTINFO hti = { 0 };
4598         hti.pt = pt;
4599         HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_HITTEST, 0, (LPARAM)&hti);
4600         if (pFlags != NULL)
4601             *pFlags = hti.flags;
4602         return hTreeItem;
4603     }
4604
4605     BOOL SortChildren(HTREEITEM hItem, BOOL bRecurse = FALSE)
4606     {
4607         ATLASSERT(::IsWindow(m_hWnd));
4608         return (BOOL)::SendMessage(m_hWnd, TVM_SORTCHILDREN, (WPARAM)bRecurse, (LPARAM)hItem);
4609     }
4610
4611     BOOL EnsureVisible(HTREEITEM hItem)
4612     {
4613         ATLASSERT(::IsWindow(m_hWnd));
4614         return (BOOL)::SendMessage(m_hWnd, TVM_ENSUREVISIBLE, 0, (LPARAM)hItem);
4615     }
4616
4617     BOOL SortChildrenCB(LPTVSORTCB pSort, BOOL bRecurse = FALSE)
4618     {
4619         ATLASSERT(::IsWindow(m_hWnd));
4620         return (BOOL)::SendMessage(m_hWnd, TVM_SORTCHILDRENCB, (WPARAM)bRecurse, (LPARAM)pSort);
4621     }
4622
4623     CImageList RemoveImageList(int nImageList)
4624     {
4625         ATLASSERT(::IsWindow(m_hWnd));
4626         return CImageList((HIMAGELIST)::SendMessage(m_hWnd, TVM_SETIMAGELIST, (WPARAM)nImageList, NULL));
4627     }
4628
4629     CImageList CreateDragImage(HTREEITEM hItem)
4630     {
4631         ATLASSERT(::IsWindow(m_hWnd));
4632         return CImageList((HIMAGELIST)::SendMessage(m_hWnd, TVM_CREATEDRAGIMAGE, 0, (LPARAM)hItem));
4633     }
4634
4635 #if (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
4636     BOOL SetInsertMark(HTREEITEM hTreeItem, BOOL bAfter)
4637     {
4638         ATLASSERT(::IsWindow(m_hWnd));
4639         return (BOOL)::SendMessage(m_hWnd, TVM_SETINSERTMARK, bAfter, (LPARAM)hTreeItem);
4640     }
4641
4642     BOOL RemoveInsertMark()
4643     {
4644         ATLASSERT(::IsWindow(m_hWnd));
4645         return (BOOL)::SendMessage(m_hWnd, TVM_SETINSERTMARK, 0, 0L);
4646     }
4647 #endif // (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
4648
4649 #if (_WIN32_WINNT >= 0x0501)
4650     HTREEITEM MapAccIDToHTREEITEM(UINT uID) const
4651     {
4652         ATLASSERT(::IsWindow(m_hWnd));
4653         return (HTREEITEM)::SendMessage(m_hWnd, TVM_MAPACCIDTOHTREEITEM, uID, 0L);
4654     }
4655
4656     UINT MapHTREEITEMToAccID(HTREEITEM hTreeItem) const
4657     {
4658         ATLASSERT(::IsWindow(m_hWnd));
4659         return (UINT)::SendMessage(m_hWnd, TVM_MAPHTREEITEMTOACCID, (WPARAM)hTreeItem, 0L);
4660     }
4661 #endif // (_WIN32_WINNT >= 0x0501)
4662
4663 #if (_WIN32_WINNT >= 0x0600)
4664     void ShowInfoTip(HTREEITEM hItem)
4665     {
4666         ATLASSERT(::IsWindow(m_hWnd));
4667         ::SendMessage(m_hWnd, TVM_SHOWINFOTIP, 0, (LPARAM)hItem);
4668     }
4669 #endif // (_WIN32_WINNT >= 0x0600)
4670 };
4671
4672 typedef CTreeViewCtrlT<ATL::CWindow>   CTreeViewCtrl;
4673
4674
4675 ///////////////////////////////////////////////////////////////////////////////
4676 // CTreeViewCtrlEx
4677
4678 // forward declaration
4679 template <class TBase> class CTreeViewCtrlExT;
4680
4681 // Note: TBase here is for CTreeViewCtrlExT, and not for CTreeItemT itself
4682 template <class TBase>
4683 class CTreeItemT
4684 {
4685 public:
4686     HTREEITEM m_hTreeItem;
4687     CTreeViewCtrlExT<TBase>* m_pTreeView;
4688
4689 // Construction
4690     CTreeItemT(HTREEITEM hTreeItem = NULL, CTreeViewCtrlExT<TBase>* pTreeView = NULL) : m_hTreeItem(hTreeItem), m_pTreeView(pTreeView)
4691     { }
4692
4693     CTreeItemT(const CTreeItemT<TBase>& posSrc)
4694     {
4695         *this = posSrc;
4696     }
4697
4698     operator HTREEITEM() { return m_hTreeItem; }
4699
4700     CTreeItemT<TBase>& operator =(const CTreeItemT<TBase>& itemSrc)
4701     {
4702         m_hTreeItem = itemSrc.m_hTreeItem;
4703         m_pTreeView = itemSrc.m_pTreeView;
4704         return *this;
4705     }
4706
4707 // Attributes
4708     CTreeViewCtrlExT<TBase>* GetTreeView() const { return m_pTreeView; }
4709
4710     BOOL operator !() const { return m_hTreeItem == NULL; }
4711
4712     BOOL IsNull() const { return m_hTreeItem == NULL; }
4713
4714     BOOL GetRect(LPRECT lpRect, BOOL bTextOnly) const;
4715     BOOL GetText(LPTSTR lpstrText, int nLen) const;
4716 #ifndef _ATL_NO_COM
4717     BOOL GetText(BSTR& bstrText) const;
4718 #endif // !_ATL_NO_COM
4719 #if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
4720     BOOL GetText(_CSTRING_NS::CString& strText) const;
4721 #endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
4722     BOOL SetText(LPCTSTR lpszItem);
4723     BOOL GetImage(int& nImage, int& nSelectedImage) const;
4724     BOOL SetImage(int nImage, int nSelectedImage);
4725     UINT GetState(UINT nStateMask) const;
4726     BOOL SetState(UINT nState, UINT nStateMask);
4727     DWORD_PTR GetData() const;
4728     BOOL SetData(DWORD_PTR dwData);
4729     BOOL SetItem(UINT nMask, LPCTSTR lpszItem, int nImage, int nSelectedImage, UINT nState, UINT nStateMask, LPARAM lParam);
4730
4731 // Operations
4732     CTreeItemT<TBase> InsertAfter(LPCTSTR lpstrItem, HTREEITEM hItemAfter, int nImageIndex)
4733     {
4734         return _Insert(lpstrItem, nImageIndex, hItemAfter);
4735     }
4736
4737     CTreeItemT<TBase> AddHead(LPCTSTR lpstrItem, int nImageIndex)
4738     {
4739         return _Insert(lpstrItem, nImageIndex, TVI_FIRST);
4740     }
4741
4742     CTreeItemT<TBase> AddTail(LPCTSTR lpstrItem, int nImageIndex)
4743     {
4744         return _Insert(lpstrItem, nImageIndex, TVI_LAST);
4745     }
4746
4747     CTreeItemT<TBase> GetChild() const;
4748     CTreeItemT<TBase> GetNext(UINT nCode) const;
4749     CTreeItemT<TBase> GetNextSibling() const;
4750     CTreeItemT<TBase> GetPrevSibling() const;
4751     CTreeItemT<TBase> GetParent() const;
4752     CTreeItemT<TBase> GetFirstVisible() const;
4753     CTreeItemT<TBase> GetNextVisible() const;
4754     CTreeItemT<TBase> GetPrevVisible() const;
4755     CTreeItemT<TBase> GetSelected() const;
4756     CTreeItemT<TBase> GetDropHilight() const;
4757     CTreeItemT<TBase> GetRoot() const;
4758 #if !defined(_WIN32_WCE) && (_WIN32_IE >= 0x0400)
4759     CTreeItemT<TBase> GetLastVisible() const;
4760 #endif // !defined(_WIN32_WCE) && (_WIN32_IE >= 0x0400)
4761 #if (_WIN32_IE >= 0x0600)
4762     CTreeItemT<TBase> GetNextSelected() const;
4763 #endif // (_WIN32_IE >= 0x0600)
4764     BOOL HasChildren() const;
4765     BOOL Delete();
4766     BOOL Expand(UINT nCode = TVE_EXPAND);
4767     BOOL Select(UINT nCode);
4768     BOOL Select();
4769     BOOL SelectDropTarget();
4770     BOOL SelectSetFirstVisible();
4771     HWND EditLabel();
4772     HIMAGELIST CreateDragImage();
4773     BOOL SortChildren(BOOL bRecurse = FALSE);
4774     BOOL EnsureVisible();
4775     CTreeItemT<TBase> _Insert(LPCTSTR lpstrItem, int nImageIndex, HTREEITEM hItemAfter);
4776     int GetImageIndex() const;
4777 #if (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
4778     BOOL SetInsertMark(BOOL bAfter);
4779 #endif // (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
4780 #if (_WIN32_WINNT >= 0x0501)
4781     UINT MapHTREEITEMToAccID() const;
4782 #endif // (_WIN32_WINNT >= 0x0501)
4783 #if (_WIN32_WINNT >= 0x0600)
4784     void ShowInfoTip();
4785     BOOL GetPartRect(TVITEMPART partID, LPRECT lpRect) const;
4786 #endif // (_WIN32_WINNT >= 0x0600)
4787 };
4788
4789 typedef CTreeItemT<ATL::CWindow>   CTreeItem;
4790
4791
4792 template <class TBase>
4793 class CTreeViewCtrlExT : public CTreeViewCtrlT< TBase >
4794 {
4795 public:
4796 // Constructors
4797     CTreeViewCtrlExT(HWND hWnd = NULL) : CTreeViewCtrlT< TBase >(hWnd)
4798     { }
4799
4800     CTreeViewCtrlExT< TBase >& operator =(HWND hWnd)
4801     {
4802         m_hWnd = hWnd;
4803         return *this;
4804     }
4805
4806 // Operations (overides that return CTreeItem)
4807     CTreeItemT<TBase> InsertItem(LPTVINSERTSTRUCT lpInsertStruct)
4808     {
4809         ATLASSERT(::IsWindow(m_hWnd));
4810         HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_INSERTITEM, 0, (LPARAM)lpInsertStruct);
4811         return CTreeItemT<TBase>(hTreeItem, this);
4812     }
4813
4814     CTreeItemT<TBase> InsertItem(LPCTSTR lpszItem, int nImage,
4815         int nSelectedImage, HTREEITEM hParent, HTREEITEM hInsertAfter)
4816     {
4817         ATLASSERT(::IsWindow(m_hWnd));
4818         return InsertItem(TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE, lpszItem, nImage, nSelectedImage, 0, 0, 0, hParent, hInsertAfter);
4819     }
4820
4821     CTreeItemT<TBase> InsertItem(LPCTSTR lpszItem, HTREEITEM hParent, HTREEITEM hInsertAfter)
4822     {
4823         ATLASSERT(::IsWindow(m_hWnd));
4824         return InsertItem(TVIF_TEXT, lpszItem, 0, 0, 0, 0, 0, hParent, hInsertAfter);
4825     }
4826
4827     CTreeItemT<TBase> GetNextItem(HTREEITEM hItem, UINT nCode) const
4828     {
4829         ATLASSERT(::IsWindow(m_hWnd));
4830         HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, nCode, (LPARAM)hItem);
4831         return CTreeItemT<TBase>(hTreeItem, (CTreeViewCtrlExT<TBase>*)this);
4832     }
4833
4834     CTreeItemT<TBase> GetChildItem(HTREEITEM hItem) const
4835     {
4836         ATLASSERT(::IsWindow(m_hWnd));
4837         HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_CHILD, (LPARAM)hItem);
4838         return CTreeItemT<TBase>(hTreeItem, (CTreeViewCtrlExT<TBase>*)this);
4839     }
4840
4841     CTreeItemT<TBase> GetNextSiblingItem(HTREEITEM hItem) const
4842     {
4843         ATLASSERT(::IsWindow(m_hWnd));
4844         HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_NEXT, (LPARAM)hItem);
4845         return CTreeItemT<TBase>(hTreeItem, (CTreeViewCtrlExT<TBase>*)this);
4846     }
4847
4848     CTreeItemT<TBase> GetPrevSiblingItem(HTREEITEM hItem) const
4849     {
4850         ATLASSERT(::IsWindow(m_hWnd));
4851         HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_PREVIOUS, (LPARAM)hItem);
4852         return CTreeItemT<TBase>(hTreeItem, (CTreeViewCtrlExT<TBase>*)this);
4853     }
4854
4855     CTreeItemT<TBase> GetParentItem(HTREEITEM hItem) const
4856     {
4857         ATLASSERT(::IsWindow(m_hWnd));
4858         HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_PARENT, (LPARAM)hItem);
4859         return CTreeItemT<TBase>(hTreeItem, (CTreeViewCtrlExT<TBase>*)this);
4860     }
4861
4862     CTreeItemT<TBase> GetFirstVisibleItem() const
4863     {
4864         ATLASSERT(::IsWindow(m_hWnd));
4865         HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_FIRSTVISIBLE, 0L);
4866         return CTreeItemT<TBase>(hTreeItem, (CTreeViewCtrlExT<TBase>*)this);
4867     }
4868
4869     CTreeItemT<TBase> GetNextVisibleItem(HTREEITEM hItem) const
4870     {
4871         ATLASSERT(::IsWindow(m_hWnd));
4872         HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_NEXTVISIBLE, (LPARAM)hItem);
4873         return CTreeItemT<TBase>(hTreeItem, (CTreeViewCtrlExT<TBase>*)this);
4874     }
4875
4876     CTreeItemT<TBase> GetPrevVisibleItem(HTREEITEM hItem) const
4877     {
4878         ATLASSERT(::IsWindow(m_hWnd));
4879         HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_PREVIOUSVISIBLE, (LPARAM)hItem);
4880         return CTreeItemT<TBase>(hTreeItem, (CTreeViewCtrlExT<TBase>*)this);
4881     }
4882
4883     CTreeItemT<TBase> GetSelectedItem() const
4884     {
4885         ATLASSERT(::IsWindow(m_hWnd));
4886         HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_CARET, 0L);
4887         return CTreeItemT<TBase>(hTreeItem, (CTreeViewCtrlExT<TBase>*)this);
4888     }
4889
4890     CTreeItemT<TBase> GetDropHilightItem() const
4891     {
4892         ATLASSERT(::IsWindow(m_hWnd));
4893         HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_DROPHILITE, 0L);
4894         return CTreeItemT<TBase>(hTreeItem, (CTreeViewCtrlExT<TBase>*)this);
4895     }
4896
4897     CTreeItemT<TBase> GetRootItem() const
4898     {
4899         ATLASSERT(::IsWindow(m_hWnd));
4900         HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_ROOT, 0L);
4901         return CTreeItemT<TBase>(hTreeItem, (CTreeViewCtrlExT<TBase>*)this);
4902     }
4903
4904 #if !defined(_WIN32_WCE) && (_WIN32_IE >= 0x0400)
4905     CTreeItemT<TBase> GetLastVisibleItem() const
4906     {
4907         ATLASSERT(::IsWindow(m_hWnd));
4908         HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_LASTVISIBLE, 0L);
4909         return CTreeItemT<TBase>(hTreeItem, (CTreeViewCtrlExT<TBase>*)this);
4910     }
4911 #endif // !defined(_WIN32_WCE) && (_WIN32_IE >= 0x0400)
4912
4913 #if (_WIN32_IE >= 0x0600)
4914     CTreeItemT<TBase> GetNextSelectedItem() const
4915     {
4916         ATLASSERT(::IsWindow(m_hWnd));
4917         HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_GETNEXTITEM, TVGN_NEXTSELECTED, 0L);
4918         return CTreeItemT<TBase>(hTreeItem, (CTreeViewCtrlExT<TBase>*)this);
4919     }
4920 #endif // (_WIN32_IE >= 0x0600)
4921
4922     CTreeItemT<TBase> HitTest(TVHITTESTINFO* pHitTestInfo) const
4923     {
4924         ATLASSERT(::IsWindow(m_hWnd));
4925         HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_HITTEST, 0, (LPARAM)pHitTestInfo);
4926         return CTreeItemT<TBase>(hTreeItem, (CTreeViewCtrlExT<TBase>*)this);
4927     }
4928
4929     CTreeItemT<TBase> InsertItem(UINT nMask, LPCTSTR lpszItem, int nImage,
4930         int nSelectedImage, UINT nState, UINT nStateMask, LPARAM lParam,
4931         HTREEITEM hParent, HTREEITEM hInsertAfter)
4932     {
4933         ATLASSERT(::IsWindow(m_hWnd));
4934         TVINSERTSTRUCT tvis = { 0 };
4935         tvis.hParent = hParent;
4936         tvis.hInsertAfter = hInsertAfter;
4937         tvis.item.mask = nMask;
4938         tvis.item.pszText = (LPTSTR) lpszItem;
4939         tvis.item.iImage = nImage;
4940         tvis.item.iSelectedImage = nSelectedImage;
4941         tvis.item.state = nState;
4942         tvis.item.stateMask = nStateMask;
4943         tvis.item.lParam = lParam;
4944         HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_INSERTITEM, 0, (LPARAM)&tvis);
4945         return CTreeItemT<TBase>(hTreeItem, this);
4946     }
4947
4948     CTreeItemT<TBase> HitTest(POINT pt, UINT* pFlags) const
4949     {
4950         ATLASSERT(::IsWindow(m_hWnd));
4951         TVHITTESTINFO hti = { 0 };
4952         hti.pt = pt;
4953         HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_HITTEST, 0, (LPARAM)&hti);
4954         if (pFlags != NULL)
4955             *pFlags = hti.flags;
4956         return CTreeItemT<TBase>(hTreeItem, (CTreeViewCtrlExT<TBase>*)this);
4957     }
4958
4959 #if (_WIN32_WINNT >= 0x0501)
4960     CTreeItemT<TBase> MapAccIDToHTREEITEM(UINT uID) const
4961     {
4962         ATLASSERT(::IsWindow(m_hWnd));
4963         HTREEITEM hTreeItem = (HTREEITEM)::SendMessage(m_hWnd, TVM_MAPACCIDTOHTREEITEM, uID, 0L);
4964         return CTreeItemT<TBase>(hTreeItem, (CTreeViewCtrlExT<TBase>*)this);
4965     }
4966 #endif // (_WIN32_WINNT >= 0x0501)
4967 };
4968
4969 typedef CTreeViewCtrlExT<ATL::CWindow>   CTreeViewCtrlEx;
4970
4971
4972 // CTreeItem inline methods
4973 template <class TBase>
4974 inline BOOL CTreeItemT<TBase>::GetRect(LPRECT lpRect, BOOL bTextOnly) const
4975 {
4976     ATLASSERT(m_pTreeView != NULL);
4977     return m_pTreeView->GetItemRect(m_hTreeItem,lpRect,bTextOnly);
4978 }
4979
4980 template <class TBase>
4981 inline CTreeItemT<TBase> CTreeItemT<TBase>::GetNext(UINT nCode) const
4982 {
4983     ATLASSERT(m_pTreeView != NULL);
4984     return m_pTreeView->GetNextItem(m_hTreeItem,nCode);
4985 }
4986
4987 template <class TBase>
4988 inline CTreeItemT<TBase> CTreeItemT<TBase>::GetChild() const
4989 {
4990     ATLASSERT(m_pTreeView != NULL);
4991     return m_pTreeView->GetChildItem(m_hTreeItem);
4992 }
4993
4994 template <class TBase>
4995 inline CTreeItemT<TBase> CTreeItemT<TBase>::GetNextSibling() const
4996 {
4997     ATLASSERT(m_pTreeView != NULL);
4998     return m_pTreeView->GetNextSiblingItem(m_hTreeItem);
4999 }
5000
5001 template <class TBase>
5002 inline CTreeItemT<TBase> CTreeItemT<TBase>::GetPrevSibling() const
5003 {
5004     ATLASSERT(m_pTreeView != NULL);
5005     return m_pTreeView->GetPrevSiblingItem(m_hTreeItem);
5006 }
5007
5008 template <class TBase>
5009 inline CTreeItemT<TBase> CTreeItemT<TBase>::GetParent() const
5010 {
5011     ATLASSERT(m_pTreeView != NULL);
5012     return m_pTreeView->GetParentItem(m_hTreeItem);
5013 }
5014
5015 template <class TBase>
5016 inline CTreeItemT<TBase> CTreeItemT<TBase>::GetFirstVisible() const
5017 {
5018     ATLASSERT(m_pTreeView != NULL);
5019     return m_pTreeView->GetFirstVisibleItem();
5020 }
5021
5022 template <class TBase>
5023 inline CTreeItemT<TBase> CTreeItemT<TBase>::GetNextVisible() const
5024 {
5025     ATLASSERT(m_pTreeView != NULL);
5026     return m_pTreeView->GetNextVisibleItem(m_hTreeItem);
5027 }
5028
5029 template <class TBase>
5030 inline CTreeItemT<TBase> CTreeItemT<TBase>::GetPrevVisible() const
5031 {
5032     ATLASSERT(m_pTreeView != NULL);
5033     return m_pTreeView->GetPrevVisibleItem(m_hTreeItem);
5034 }
5035
5036 template <class TBase>
5037 inline CTreeItemT<TBase> CTreeItemT<TBase>::GetSelected() const
5038 {
5039     ATLASSERT(m_pTreeView != NULL);
5040     return m_pTreeView->GetSelectedItem();
5041 }
5042
5043 template <class TBase>
5044 inline CTreeItemT<TBase> CTreeItemT<TBase>::GetDropHilight() const
5045 {
5046     ATLASSERT(m_pTreeView != NULL);
5047     return m_pTreeView->GetDropHilightItem();
5048 }
5049
5050 template <class TBase>
5051 inline CTreeItemT<TBase> CTreeItemT<TBase>::GetRoot() const
5052 {
5053     ATLASSERT(m_pTreeView != NULL);
5054     return m_pTreeView->GetRootItem();
5055 }
5056
5057 #if !defined(_WIN32_WCE) && (_WIN32_IE >= 0x0400)
5058 template <class TBase>
5059 inline CTreeItemT<TBase> CTreeItemT<TBase>::GetLastVisible() const
5060 {
5061     ATLASSERT(m_pTreeView != NULL);
5062     return m_pTreeView->GetLastVisibleItem();
5063 }
5064 #endif // !defined(_WIN32_WCE) && (_WIN32_IE >= 0x0400)
5065
5066 #if (_WIN32_IE >= 0x0600)
5067 template <class TBase>
5068 inline CTreeItemT<TBase> CTreeItemT<TBase>::GetNextSelected() const
5069 {
5070     ATLASSERT(m_pTreeView != NULL);
5071     return m_pTreeView->GetNextSelectedItem();
5072 }
5073 #endif // (_WIN32_IE >= 0x0600)
5074
5075 template <class TBase>
5076 inline BOOL CTreeItemT<TBase>::GetText(LPTSTR lpstrText, int nLen) const
5077 {
5078     ATLASSERT(m_pTreeView != NULL);
5079     return m_pTreeView->GetItemText(m_hTreeItem, lpstrText, nLen);
5080 }
5081
5082 #ifndef _ATL_NO_COM
5083 #ifdef _OLEAUTO_H_
5084 template <class TBase>
5085 inline BOOL CTreeItemT<TBase>::GetText(BSTR& bstrText) const
5086 {
5087     ATLASSERT(m_pTreeView != NULL);
5088     return m_pTreeView->GetItemText(m_hTreeItem, bstrText);
5089 }
5090 #endif // _OLEAUTO_H_
5091 #endif // !_ATL_NO_COM
5092
5093 #if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
5094 template <class TBase>
5095 inline BOOL CTreeItemT<TBase>::GetText(_CSTRING_NS::CString& strText) const
5096 {
5097     ATLASSERT(m_pTreeView != NULL);
5098     return m_pTreeView->GetItemText(m_hTreeItem, strText);
5099 }
5100 #endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
5101
5102 template <class TBase>
5103 inline BOOL CTreeItemT<TBase>::GetImage(int& nImage, int& nSelectedImage) const
5104 {
5105     ATLASSERT(m_pTreeView != NULL);
5106     return m_pTreeView->GetItemImage(m_hTreeItem,nImage,nSelectedImage);
5107 }
5108
5109 template <class TBase>
5110 inline UINT CTreeItemT<TBase>::GetState(UINT nStateMask) const
5111 {
5112     ATLASSERT(m_pTreeView != NULL);
5113     return m_pTreeView->GetItemState(m_hTreeItem,nStateMask);
5114 }
5115
5116 template <class TBase>
5117 inline DWORD_PTR CTreeItemT<TBase>::GetData() const
5118 {
5119     ATLASSERT(m_pTreeView != NULL);
5120     return m_pTreeView->GetItemData(m_hTreeItem);
5121 }
5122
5123 template <class TBase>
5124 inline BOOL CTreeItemT<TBase>::SetItem(UINT nMask, LPCTSTR lpszItem, int nImage,
5125         int nSelectedImage, UINT nState, UINT nStateMask, LPARAM lParam)
5126 {
5127     ATLASSERT(m_pTreeView != NULL);
5128     return m_pTreeView->SetItem(m_hTreeItem, nMask, lpszItem, nImage, nSelectedImage, nState, nStateMask, lParam);
5129 }
5130
5131 template <class TBase>
5132 inline BOOL CTreeItemT<TBase>::SetText(LPCTSTR lpszItem)
5133 {
5134     ATLASSERT(m_pTreeView != NULL);
5135     return m_pTreeView->SetItemText(m_hTreeItem,lpszItem);
5136 }
5137
5138 template <class TBase>
5139 inline BOOL CTreeItemT<TBase>::SetImage(int nImage, int nSelectedImage)
5140 {
5141     ATLASSERT(m_pTreeView != NULL);
5142     return m_pTreeView->SetItemImage(m_hTreeItem,nImage,nSelectedImage);
5143 }
5144
5145 template <class TBase>
5146 inline BOOL CTreeItemT<TBase>::SetState(UINT nState, UINT nStateMask)
5147 {
5148     ATLASSERT(m_pTreeView != NULL);
5149     return m_pTreeView->SetItemState(m_hTreeItem,nState,nStateMask);
5150 }
5151
5152 template <class TBase>
5153 inline BOOL CTreeItemT<TBase>::SetData(DWORD_PTR dwData)
5154 {
5155     ATLASSERT(m_pTreeView != NULL);
5156     return m_pTreeView->SetItemData(m_hTreeItem,dwData);
5157 }
5158
5159 template <class TBase>
5160 inline BOOL CTreeItemT<TBase>::HasChildren() const
5161 {
5162     ATLASSERT(m_pTreeView != NULL);
5163     return m_pTreeView->ItemHasChildren(m_hTreeItem);
5164 }
5165
5166 template <class TBase>
5167 inline BOOL CTreeItemT<TBase>::Delete()
5168 {
5169     ATLASSERT(m_pTreeView != NULL);
5170     return m_pTreeView->DeleteItem(m_hTreeItem);
5171 }
5172
5173 template <class TBase>
5174 inline BOOL CTreeItemT<TBase>::Expand(UINT nCode /*= TVE_EXPAND*/)
5175 {
5176     ATLASSERT(m_pTreeView != NULL);
5177     return m_pTreeView->Expand(m_hTreeItem,nCode);
5178 }
5179
5180 template <class TBase>
5181 inline BOOL CTreeItemT<TBase>::Select(UINT nCode)
5182 {
5183     ATLASSERT(m_pTreeView != NULL);
5184     return m_pTreeView->Select(m_hTreeItem,nCode);
5185 }
5186
5187 template <class TBase>
5188 inline BOOL CTreeItemT<TBase>::Select()
5189 {
5190     ATLASSERT(m_pTreeView != NULL);
5191     return m_pTreeView->SelectItem(m_hTreeItem);
5192 }
5193
5194 template <class TBase>
5195 inline BOOL CTreeItemT<TBase>::SelectDropTarget()
5196 {
5197     ATLASSERT(m_pTreeView != NULL);
5198     return m_pTreeView->SelectDropTarget(m_hTreeItem);
5199 }
5200
5201 template <class TBase>
5202 inline BOOL CTreeItemT<TBase>::SelectSetFirstVisible()
5203 {
5204     ATLASSERT(m_pTreeView != NULL);
5205     return m_pTreeView->SelectSetFirstVisible(m_hTreeItem);
5206 }
5207
5208 template <class TBase>
5209 inline HWND CTreeItemT<TBase>::EditLabel()
5210 {
5211     ATLASSERT(m_pTreeView != NULL);
5212     return m_pTreeView->EditLabel(m_hTreeItem);
5213 }
5214
5215 template <class TBase>
5216 inline HIMAGELIST CTreeItemT<TBase>::CreateDragImage()
5217 {
5218     ATLASSERT(m_pTreeView != NULL);
5219     return m_pTreeView->CreateDragImage(m_hTreeItem);
5220 }
5221
5222 template <class TBase>
5223 inline BOOL CTreeItemT<TBase>::SortChildren(BOOL bRecurse /*= FALSE*/)
5224 {
5225     ATLASSERT(m_pTreeView != NULL);
5226     return m_pTreeView->SortChildren(m_hTreeItem, bRecurse);
5227 }
5228
5229 template <class TBase>
5230 inline BOOL CTreeItemT<TBase>::EnsureVisible()
5231 {
5232     ATLASSERT(m_pTreeView != NULL);
5233     return m_pTreeView->EnsureVisible(m_hTreeItem);
5234 }
5235
5236 template <class TBase>
5237 inline CTreeItemT<TBase> CTreeItemT<TBase>::_Insert(LPCTSTR lpstrItem, int nImageIndex, HTREEITEM hItemAfter)
5238 {
5239     ATLASSERT(m_pTreeView != NULL);
5240     TVINSERTSTRUCT ins = { 0 };
5241     ins.hParent = m_hTreeItem;
5242     ins.hInsertAfter = hItemAfter;
5243     ins.item.mask = TVIF_TEXT;
5244     ins.item.pszText = (LPTSTR)lpstrItem;
5245     if(nImageIndex != -1)
5246     {
5247         ins.item.mask |= TVIF_IMAGE | TVIF_SELECTEDIMAGE;
5248         ins.item.iImage = nImageIndex;
5249         ins.item.iSelectedImage = nImageIndex;
5250     }
5251     return CTreeItemT<TBase>(m_pTreeView->InsertItem(&ins), m_pTreeView);
5252 }
5253
5254 template <class TBase>
5255 inline int CTreeItemT<TBase>::GetImageIndex() const
5256 {
5257     ATLASSERT(m_pTreeView != NULL);
5258     TVITEM item = { 0 };
5259     item.mask = TVIF_HANDLE | TVIF_IMAGE;
5260     item.hItem = m_hTreeItem;
5261     m_pTreeView->GetItem(&item);
5262     return item.iImage;
5263 }
5264
5265 #if (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
5266 template <class TBase>
5267 inline BOOL CTreeItemT<TBase>::SetInsertMark(BOOL bAfter)
5268 {
5269     ATLASSERT(m_pTreeView != NULL);
5270     return m_pTreeView->SetInsertMark(m_hTreeItem, bAfter);
5271 }
5272 #endif // (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
5273
5274 #if (_WIN32_WINNT >= 0x0501)
5275 template <class TBase>
5276 inline UINT CTreeItemT<TBase>::MapHTREEITEMToAccID() const
5277 {
5278     ATLASSERT(m_pTreeView != NULL);
5279     return m_pTreeView->MapHTREEITEMToAccID(m_hTreeItem);
5280 }
5281 #endif // (_WIN32_WINNT >= 0x0501)
5282
5283 #if (_WIN32_WINNT >= 0x0600)
5284 template <class TBase>
5285 inline void CTreeItemT<TBase>::ShowInfoTip()
5286 {
5287     ATLASSERT(m_pTreeView != NULL);
5288     m_pTreeView->ShowInfoTip(m_hTreeItem);
5289 }
5290
5291 template <class TBase>
5292 inline BOOL CTreeItemT<TBase>::GetPartRect(TVITEMPART partID, LPRECT lpRect) const
5293 {
5294     ATLASSERT(m_pTreeView != NULL);
5295     return m_pTreeView->GetItemPartRect(m_hTreeItem, partID, lpRect);
5296 }
5297 #endif // (_WIN32_WINNT >= 0x0600)
5298
5299
5300 ///////////////////////////////////////////////////////////////////////////////
5301 // CToolBarCtrl
5302
5303 template <class TBase>
5304 class CToolBarCtrlT : public TBase
5305 {
5306 public:
5307 // Construction
5308     CToolBarCtrlT(HWND hWnd = NULL) : TBase(hWnd)
5309     { }
5310
5311     CToolBarCtrlT< TBase >& operator =(HWND hWnd)
5312     {
5313         m_hWnd = hWnd;
5314         return *this;
5315     }
5316
5317     HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
5318             DWORD dwStyle = 0, DWORD dwExStyle = 0,
5319             ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
5320     {
5321         return TBase::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);
5322     }
5323
5324 // Attributes
5325     static LPCTSTR GetWndClassName()
5326     {
5327         return TOOLBARCLASSNAME;
5328     }
5329
5330     BOOL IsButtonEnabled(int nID) const
5331     {
5332         ATLASSERT(::IsWindow(m_hWnd));
5333         return (BOOL)::SendMessage(m_hWnd, TB_ISBUTTONENABLED, nID, 0L);
5334     }
5335
5336     BOOL IsButtonChecked(int nID) const
5337     {
5338         ATLASSERT(::IsWindow(m_hWnd));
5339         return (BOOL)::SendMessage(m_hWnd, TB_ISBUTTONCHECKED, nID, 0L);
5340     }
5341
5342     BOOL IsButtonPressed(int nID) const
5343     {
5344         ATLASSERT(::IsWindow(m_hWnd));
5345         return (BOOL)::SendMessage(m_hWnd, TB_ISBUTTONPRESSED, nID, 0L);
5346     }
5347
5348     BOOL IsButtonHidden(int nID) const
5349     {
5350         ATLASSERT(::IsWindow(m_hWnd));
5351         return(BOOL) ::SendMessage(m_hWnd, TB_ISBUTTONHIDDEN, nID, 0L);
5352     }
5353
5354     BOOL IsButtonIndeterminate(int nID) const
5355     {
5356         ATLASSERT(::IsWindow(m_hWnd));
5357         return (BOOL)::SendMessage(m_hWnd, TB_ISBUTTONINDETERMINATE, nID, 0L);
5358     }
5359
5360     int GetState(int nID) const
5361     {
5362         ATLASSERT(::IsWindow(m_hWnd));
5363         return (int)::SendMessage(m_hWnd, TB_GETSTATE, nID, 0L);
5364     }
5365
5366     BOOL SetState(int nID, UINT nState)
5367     {
5368         ATLASSERT(::IsWindow(m_hWnd));
5369         return (BOOL)::SendMessage(m_hWnd, TB_SETSTATE, nID, MAKELPARAM(nState, 0));
5370     }
5371
5372     BOOL GetButton(int nIndex, LPTBBUTTON lpButton) const
5373     {
5374         ATLASSERT(::IsWindow(m_hWnd));
5375         return (BOOL)::SendMessage(m_hWnd, TB_GETBUTTON, nIndex, (LPARAM)lpButton);
5376     }
5377
5378     int GetButtonCount() const
5379     {
5380         ATLASSERT(::IsWindow(m_hWnd));
5381         return (int)::SendMessage(m_hWnd, TB_BUTTONCOUNT, 0, 0L);
5382     }
5383
5384     BOOL GetItemRect(int nIndex, LPRECT lpRect) const
5385     {
5386         ATLASSERT(::IsWindow(m_hWnd));
5387         return (BOOL)::SendMessage(m_hWnd, TB_GETITEMRECT, nIndex, (LPARAM)lpRect);
5388     }
5389
5390     void SetButtonStructSize(int nSize = sizeof(TBBUTTON))
5391     {
5392         ATLASSERT(::IsWindow(m_hWnd));
5393         ::SendMessage(m_hWnd, TB_BUTTONSTRUCTSIZE, nSize, 0L);
5394     }
5395
5396     BOOL SetButtonSize(SIZE size)
5397     {
5398         ATLASSERT(::IsWindow(m_hWnd));
5399         return (BOOL)::SendMessage(m_hWnd, TB_SETBUTTONSIZE, 0, MAKELPARAM(size.cx, size.cy));
5400     }
5401
5402     BOOL SetButtonSize(int cx, int cy)
5403     {
5404         ATLASSERT(::IsWindow(m_hWnd));
5405         return (BOOL)::SendMessage(m_hWnd, TB_SETBUTTONSIZE, 0, MAKELPARAM(cx, cy));
5406     }
5407
5408     BOOL SetBitmapSize(SIZE size)
5409     {
5410         ATLASSERT(::IsWindow(m_hWnd));
5411         return (BOOL)::SendMessage(m_hWnd, TB_SETBITMAPSIZE, 0, MAKELPARAM(size.cx, size.cy));
5412     }
5413
5414     BOOL SetBitmapSize(int cx, int cy)
5415     {
5416         ATLASSERT(::IsWindow(m_hWnd));
5417         return (BOOL)::SendMessage(m_hWnd, TB_SETBITMAPSIZE, 0, MAKELPARAM(cx, cy));
5418     }
5419
5420 #ifndef _WIN32_WCE
5421     CToolTipCtrl GetToolTips() const
5422     {
5423         ATLASSERT(::IsWindow(m_hWnd));
5424         return CToolTipCtrl((HWND)::SendMessage(m_hWnd, TB_GETTOOLTIPS, 0, 0L));
5425     }
5426
5427     void SetToolTips(HWND hWndToolTip)
5428     {
5429         ATLASSERT(::IsWindow(m_hWnd));
5430         ::SendMessage(m_hWnd, TB_SETTOOLTIPS, (WPARAM)hWndToolTip, 0L);
5431     }
5432 #endif // !_WIN32_WCE
5433
5434     void SetNotifyWnd(HWND hWnd)
5435     {
5436         ATLASSERT(::IsWindow(m_hWnd));
5437         ::SendMessage(m_hWnd, TB_SETPARENT, (WPARAM)hWnd, 0L);
5438     }
5439
5440     int GetRows() const
5441     {
5442         ATLASSERT(::IsWindow(m_hWnd));
5443         return (int)::SendMessage(m_hWnd, TB_GETROWS, 0, 0L);
5444     }
5445
5446     void SetRows(int nRows, BOOL bLarger, LPRECT lpRect)
5447     {
5448         ATLASSERT(::IsWindow(m_hWnd));
5449         ::SendMessage(m_hWnd, TB_SETROWS, MAKELPARAM(nRows, bLarger), (LPARAM)lpRect);
5450     }
5451
5452     BOOL SetCmdID(int nIndex, UINT nID)
5453     {
5454         ATLASSERT(::IsWindow(m_hWnd));
5455         return (BOOL)::SendMessage(m_hWnd, TB_SETCMDID, nIndex, nID);
5456     }
5457
5458     DWORD GetBitmapFlags() const
5459     {
5460         ATLASSERT(::IsWindow(m_hWnd));
5461         return (DWORD)::SendMessage(m_hWnd, TB_GETBITMAPFLAGS, 0, 0L);
5462     }
5463
5464     int GetBitmap(int nID) const
5465     {
5466         ATLASSERT(::IsWindow(m_hWnd));
5467         return (int)::SendMessage(m_hWnd, TB_GETBITMAP, nID, 0L);
5468     }
5469
5470     int GetButtonText(int nID, LPTSTR lpstrText) const
5471     {
5472         ATLASSERT(::IsWindow(m_hWnd));
5473         return (int)::SendMessage(m_hWnd, TB_GETBUTTONTEXT, nID, (LPARAM)lpstrText);
5474     }
5475
5476     // nIndex - IE5 or higher only
5477     CImageList GetImageList(int nIndex = 0) const
5478     {
5479         ATLASSERT(::IsWindow(m_hWnd));
5480         return CImageList((HIMAGELIST)::SendMessage(m_hWnd, TB_GETIMAGELIST, nIndex, 0L));
5481     }
5482
5483     // nIndex - IE5 or higher only
5484     CImageList SetImageList(HIMAGELIST hImageList, int nIndex = 0)
5485     {
5486         ATLASSERT(::IsWindow(m_hWnd));
5487         return CImageList((HIMAGELIST)::SendMessage(m_hWnd, TB_SETIMAGELIST, nIndex, (LPARAM)hImageList));
5488     }
5489
5490     // nIndex - IE5 or higher only
5491     CImageList GetDisabledImageList(int nIndex = 0) const
5492     {
5493         ATLASSERT(::IsWindow(m_hWnd));
5494         return CImageList((HIMAGELIST)::SendMessage(m_hWnd, TB_GETDISABLEDIMAGELIST, nIndex, 0L));
5495     }
5496
5497     // nIndex - IE5 or higher only
5498     CImageList SetDisabledImageList(HIMAGELIST hImageList, int nIndex = 0)
5499     {
5500         ATLASSERT(::IsWindow(m_hWnd));
5501         return CImageList((HIMAGELIST)::SendMessage(m_hWnd, TB_SETDISABLEDIMAGELIST, nIndex, (LPARAM)hImageList));
5502     }
5503
5504 #ifndef _WIN32_WCE
5505     // nIndex - IE5 or higher only
5506     CImageList GetHotImageList(int nIndex = 0) const
5507     {
5508         ATLASSERT(::IsWindow(m_hWnd));
5509         return CImageList((HIMAGELIST)::SendMessage(m_hWnd, TB_GETHOTIMAGELIST, nIndex, 0L));
5510     }
5511
5512     // nIndex - IE5 or higher only
5513     CImageList SetHotImageList(HIMAGELIST hImageList, int nIndex = 0)
5514     {
5515         ATLASSERT(::IsWindow(m_hWnd));
5516         return CImageList((HIMAGELIST)::SendMessage(m_hWnd, TB_SETHOTIMAGELIST, nIndex, (LPARAM)hImageList));
5517     }
5518 #endif // !_WIN32_WCE
5519
5520     DWORD GetStyle() const
5521     {
5522         ATLASSERT(::IsWindow(m_hWnd));
5523         return (DWORD)::SendMessage(m_hWnd, TB_GETSTYLE, 0, 0L);
5524     }
5525
5526     void SetStyle(DWORD dwStyle)
5527     {
5528         ATLASSERT(::IsWindow(m_hWnd));
5529         ::SendMessage(m_hWnd, TB_SETSTYLE, 0, dwStyle);
5530     }
5531
5532     DWORD GetButtonSize() const
5533     {
5534         ATLASSERT(::IsWindow(m_hWnd));
5535         return (DWORD)::SendMessage(m_hWnd, TB_GETBUTTONSIZE, 0, 0L);
5536     }
5537
5538     void GetButtonSize(SIZE& size) const
5539     {
5540         ATLASSERT(::IsWindow(m_hWnd));
5541         DWORD dwRet = (DWORD)::SendMessage(m_hWnd, TB_GETBUTTONSIZE, 0, 0L);
5542         size.cx = LOWORD(dwRet);
5543         size.cy = HIWORD(dwRet);
5544     }
5545
5546     BOOL GetRect(int nID, LPRECT lpRect) const
5547     {
5548         ATLASSERT(::IsWindow(m_hWnd));
5549         return (BOOL)::SendMessage(m_hWnd, TB_GETRECT, nID, (LPARAM)lpRect);
5550     }
5551
5552     int GetTextRows() const
5553     {
5554         ATLASSERT(::IsWindow(m_hWnd));
5555         return (int)::SendMessage(m_hWnd, TB_GETTEXTROWS, 0, 0L);
5556     }
5557
5558     BOOL SetButtonWidth(int cxMin, int cxMax)
5559     {
5560         ATLASSERT(::IsWindow(m_hWnd));
5561         return (BOOL)::SendMessage(m_hWnd, TB_SETBUTTONWIDTH, 0, MAKELPARAM(cxMin, cxMax));
5562     }
5563
5564     BOOL SetIndent(int nIndent)
5565     {
5566         ATLASSERT(::IsWindow(m_hWnd));
5567         return (BOOL)::SendMessage(m_hWnd, TB_SETINDENT, nIndent, 0L);
5568     }
5569
5570     BOOL SetMaxTextRows(int nMaxTextRows)
5571     {
5572         ATLASSERT(::IsWindow(m_hWnd));
5573         return (BOOL)::SendMessage(m_hWnd, TB_SETMAXTEXTROWS, nMaxTextRows, 0L);
5574     }
5575
5576 #if (_WIN32_IE >= 0x0400)
5577 #ifndef _WIN32_WCE
5578     BOOL GetAnchorHighlight() const
5579     {
5580         ATLASSERT(::IsWindow(m_hWnd));
5581         return (BOOL)::SendMessage(m_hWnd, TB_GETANCHORHIGHLIGHT, 0, 0L);
5582     }
5583
5584     BOOL SetAnchorHighlight(BOOL bEnable = TRUE)
5585     {
5586         ATLASSERT(::IsWindow(m_hWnd));
5587         return (BOOL)::SendMessage(m_hWnd, TB_SETANCHORHIGHLIGHT, bEnable, 0L);
5588     }
5589 #endif // !_WIN32_WCE
5590
5591     int GetButtonInfo(int nID, LPTBBUTTONINFO lptbbi) const
5592     {
5593         ATLASSERT(::IsWindow(m_hWnd));
5594         return (int)::SendMessage(m_hWnd, TB_GETBUTTONINFO, nID, (LPARAM)lptbbi);
5595     }
5596
5597     BOOL SetButtonInfo(int nID, LPTBBUTTONINFO lptbbi)
5598     {
5599         ATLASSERT(::IsWindow(m_hWnd));
5600         return (BOOL)::SendMessage(m_hWnd, TB_SETBUTTONINFO, nID, (LPARAM)lptbbi);
5601     }
5602
5603     BOOL SetButtonInfo(int nID, DWORD dwMask, BYTE Style, BYTE State, LPCTSTR lpszItem,
5604                        int iImage, WORD cx, int iCommand, DWORD_PTR lParam)
5605     {
5606         ATLASSERT(::IsWindow(m_hWnd));
5607         TBBUTTONINFO tbbi = { 0 };
5608         tbbi.cbSize = sizeof(TBBUTTONINFO);
5609         tbbi.dwMask = dwMask;
5610         tbbi.idCommand = iCommand;
5611         tbbi.iImage = iImage;
5612         tbbi.fsState = State;
5613         tbbi.fsStyle = Style;
5614         tbbi.cx = cx;
5615         tbbi.pszText = (LPTSTR) lpszItem;
5616         tbbi.lParam = lParam;
5617         return (BOOL)::SendMessage(m_hWnd, TB_SETBUTTONINFO, nID, (LPARAM)&tbbi);
5618     }
5619
5620 #ifndef _WIN32_WCE
5621     int GetHotItem() const
5622     {
5623         ATLASSERT(::IsWindow(m_hWnd));
5624         return (int)::SendMessage(m_hWnd, TB_GETHOTITEM, 0, 0L);
5625     }
5626
5627     int SetHotItem(int nItem)
5628     {
5629         ATLASSERT(::IsWindow(m_hWnd));
5630         return (int)::SendMessage(m_hWnd, TB_SETHOTITEM, nItem, 0L);
5631     }
5632 #endif // !_WIN32_WCE
5633
5634     BOOL IsButtonHighlighted(int nButtonID) const
5635     {
5636         ATLASSERT(::IsWindow(m_hWnd));
5637         return (BOOL)::SendMessage(m_hWnd, TB_ISBUTTONHIGHLIGHTED, nButtonID, 0L);
5638     }
5639
5640     DWORD SetDrawTextFlags(DWORD dwMask, DWORD dwFlags)
5641     {
5642         ATLASSERT(::IsWindow(m_hWnd));
5643         return (DWORD)::SendMessage(m_hWnd, TB_SETDRAWTEXTFLAGS, dwMask, dwFlags);
5644     }
5645
5646 #ifndef _WIN32_WCE
5647     BOOL GetColorScheme(LPCOLORSCHEME lpcs) const
5648     {
5649         ATLASSERT(::IsWindow(m_hWnd));
5650         return (BOOL)::SendMessage(m_hWnd, TB_GETCOLORSCHEME, 0, (LPARAM)lpcs);
5651     }
5652
5653     void SetColorScheme(LPCOLORSCHEME lpcs)
5654     {
5655         ATLASSERT(::IsWindow(m_hWnd));
5656         ::SendMessage(m_hWnd, TB_SETCOLORSCHEME, 0, (LPARAM)lpcs);
5657     }
5658
5659     DWORD GetExtendedStyle() const
5660     {
5661         ATLASSERT(::IsWindow(m_hWnd));
5662         return (DWORD)::SendMessage(m_hWnd, TB_GETEXTENDEDSTYLE, 0, 0L);
5663     }
5664
5665     DWORD SetExtendedStyle(DWORD dwStyle)
5666     {
5667         ATLASSERT(::IsWindow(m_hWnd));
5668         return (DWORD)::SendMessage(m_hWnd, TB_SETEXTENDEDSTYLE, 0, dwStyle);
5669     }
5670
5671     void GetInsertMark(LPTBINSERTMARK lptbim) const
5672     {
5673         ATLASSERT(::IsWindow(m_hWnd));
5674         ::SendMessage(m_hWnd, TB_GETINSERTMARK, 0, (LPARAM)lptbim);
5675     }
5676
5677     void SetInsertMark(LPTBINSERTMARK lptbim)
5678     {
5679         ATLASSERT(::IsWindow(m_hWnd));
5680         ::SendMessage(m_hWnd, TB_SETINSERTMARK, 0, (LPARAM)lptbim);
5681     }
5682
5683     COLORREF GetInsertMarkColor() const
5684     {
5685         ATLASSERT(::IsWindow(m_hWnd));
5686         return (COLORREF)::SendMessage(m_hWnd, TB_GETINSERTMARKCOLOR, 0, 0L);
5687     }
5688
5689     COLORREF SetInsertMarkColor(COLORREF clr)
5690     {
5691         ATLASSERT(::IsWindow(m_hWnd));
5692         return (COLORREF)::SendMessage(m_hWnd, TB_SETINSERTMARKCOLOR, 0, (LPARAM)clr);
5693     }
5694
5695     BOOL GetMaxSize(LPSIZE lpSize) const
5696     {
5697         ATLASSERT(::IsWindow(m_hWnd));
5698         return (BOOL)::SendMessage(m_hWnd, TB_GETMAXSIZE, 0, (LPARAM)lpSize);
5699     }
5700
5701     void GetPadding(LPSIZE lpSizePadding) const
5702     {
5703         ATLASSERT(::IsWindow(m_hWnd));
5704         ATLASSERT(lpSizePadding != NULL);
5705         DWORD dwRet = (DWORD)::SendMessage(m_hWnd, TB_GETPADDING, 0, 0L);
5706         lpSizePadding->cx = GET_X_LPARAM(dwRet);
5707         lpSizePadding->cy = GET_Y_LPARAM(dwRet);
5708     }
5709
5710     void SetPadding(int cx, int cy, LPSIZE lpSizePadding = NULL)
5711     {
5712         ATLASSERT(::IsWindow(m_hWnd));
5713         DWORD dwRet = (DWORD)::SendMessage(m_hWnd, TB_SETPADDING, 0, MAKELPARAM(cx, cy));
5714         if(lpSizePadding != NULL)
5715         {
5716             lpSizePadding->cx = GET_X_LPARAM(dwRet);
5717             lpSizePadding->cy = GET_Y_LPARAM(dwRet);
5718         }
5719     }
5720
5721     BOOL GetUnicodeFormat() const
5722     {
5723         ATLASSERT(::IsWindow(m_hWnd));
5724         return (BOOL)::SendMessage(m_hWnd, TB_GETUNICODEFORMAT, 0, 0L);
5725     }
5726
5727     BOOL SetUnicodeFormat(BOOL bUnicode = TRUE)
5728     {
5729         ATLASSERT(::IsWindow(m_hWnd));
5730         return (BOOL)::SendMessage(m_hWnd, TB_SETUNICODEFORMAT, bUnicode, 0L);
5731     }
5732 #endif // !_WIN32_WCE
5733 #endif // (_WIN32_IE >= 0x0400)
5734
5735 #if (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
5736     int GetString(int nString, LPTSTR lpstrString, int cchMaxLen) const
5737     {
5738         ATLASSERT(::IsWindow(m_hWnd));
5739         return (int)::SendMessage(m_hWnd, TB_GETSTRING, MAKEWPARAM(cchMaxLen, nString), (LPARAM)lpstrString);
5740     }
5741
5742     int GetStringBSTR(int nString, BSTR& bstrString) const
5743     {
5744         USES_CONVERSION;
5745         ATLASSERT(::IsWindow(m_hWnd));
5746         ATLASSERT(bstrString == NULL);
5747         int nLength = (int)(short)LOWORD(::SendMessage(m_hWnd, TB_GETSTRING, MAKEWPARAM(0, nString), NULL));
5748         if(nLength != -1)
5749         {
5750             CTempBuffer<TCHAR, _WTL_STACK_ALLOC_THRESHOLD> buff;
5751             LPTSTR lpstrText = buff.Allocate(nLength + 1);
5752             if(lpstrText != NULL)
5753             {
5754                 nLength = (int)::SendMessage(m_hWnd, TB_GETSTRING, MAKEWPARAM(nLength + 1, nString), (LPARAM)lpstrText);
5755                 if(nLength != -1)
5756                     bstrString = ::SysAllocString(T2OLE(lpstrText));
5757             }
5758             else
5759             {
5760                 nLength = -1;
5761             }
5762         }
5763
5764         return nLength;
5765     }
5766
5767 #if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
5768     int GetString(int nString, _CSTRING_NS::CString& str) const
5769     {
5770         ATLASSERT(::IsWindow(m_hWnd));
5771         int nLength = (int)(short)LOWORD(::SendMessage(m_hWnd, TB_GETSTRING, MAKEWPARAM(0, nString), NULL));
5772         if(nLength != -1)
5773         {
5774             LPTSTR lpstr = str.GetBufferSetLength(nLength + 1);
5775             if(lpstr != NULL)
5776                 nLength = (int)::SendMessage(m_hWnd, TB_GETSTRING, MAKEWPARAM(nLength + 1, nString), (LPARAM)lpstr);
5777             else
5778                 nLength = -1;
5779             str.ReleaseBuffer();
5780         }
5781         return nLength;
5782     }
5783 #endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
5784 #endif // (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
5785
5786 #if (_WIN32_WINNT >= 0x0501)
5787     void GetMetrics(LPTBMETRICS lptbm) const
5788     {
5789         ATLASSERT(::IsWindow(m_hWnd));
5790         ::SendMessage(m_hWnd, TB_GETMETRICS, 0, (LPARAM)lptbm);
5791     }
5792
5793     void SetMetrics(LPTBMETRICS lptbm)
5794     {
5795         ATLASSERT(::IsWindow(m_hWnd));
5796         ::SendMessage(m_hWnd, TB_SETMETRICS, 0, (LPARAM)lptbm);
5797     }
5798
5799     void SetWindowTheme(LPCWSTR lpstrTheme)
5800     {
5801         ATLASSERT(::IsWindow(m_hWnd));
5802         ::SendMessage(m_hWnd, TB_SETWINDOWTHEME, 0, (LPARAM)lpstrTheme);
5803     }
5804 #endif // (_WIN32_WINNT >= 0x0501)
5805
5806 #if (_WIN32_WINNT >= 0x0600)
5807     CImageList GetPressedImageList(int nIndex = 0) const
5808     {
5809         ATLASSERT(::IsWindow(m_hWnd));
5810         return CImageList((HIMAGELIST)::SendMessage(m_hWnd, TB_GETPRESSEDIMAGELIST, nIndex, 0L));
5811     }
5812
5813     CImageList SetPressedImageList(HIMAGELIST hImageList, int nIndex = 0)
5814     {
5815         ATLASSERT(::IsWindow(m_hWnd));
5816         return CImageList((HIMAGELIST)::SendMessage(m_hWnd, TB_SETPRESSEDIMAGELIST, nIndex, (LPARAM)hImageList));
5817     }
5818
5819     void GetItemDropDownRect(int nIndex, LPRECT lpRect) const
5820     {
5821 #ifndef TB_GETITEMDROPDOWNRECT
5822         const int TB_GETITEMDROPDOWNRECT = WM_USER + 103;
5823 #endif
5824         ATLASSERT(::IsWindow(m_hWnd));
5825         BOOL bRet = (BOOL)::SendMessage(m_hWnd, TB_GETITEMDROPDOWNRECT, nIndex, (LPARAM)lpRect);
5826         bRet;   // avoid level 4 warning
5827         ATLASSERT(bRet != FALSE);
5828     }
5829 #endif // (_WIN32_WINNT >= 0x0600)
5830
5831 // Operations
5832     BOOL EnableButton(int nID, BOOL bEnable = TRUE)
5833     {
5834         ATLASSERT(::IsWindow(m_hWnd));
5835         return (BOOL)::SendMessage(m_hWnd, TB_ENABLEBUTTON, nID, MAKELPARAM(bEnable, 0));
5836     }
5837
5838     BOOL CheckButton(int nID, BOOL bCheck = TRUE)
5839     {
5840         ATLASSERT(::IsWindow(m_hWnd));
5841         return (BOOL)::SendMessage(m_hWnd, TB_CHECKBUTTON, nID, MAKELPARAM(bCheck, 0));
5842     }
5843
5844     BOOL PressButton(int nID, BOOL bPress = TRUE)
5845     {
5846         ATLASSERT(::IsWindow(m_hWnd));
5847         return (BOOL)::SendMessage(m_hWnd, TB_PRESSBUTTON, nID, MAKELPARAM(bPress, 0));
5848     }
5849
5850     BOOL HideButton(int nID, BOOL bHide = TRUE)
5851     {
5852         ATLASSERT(::IsWindow(m_hWnd));
5853         return (BOOL)::SendMessage(m_hWnd, TB_HIDEBUTTON, nID, MAKELPARAM(bHide, 0));
5854     }
5855
5856     BOOL Indeterminate(int nID, BOOL bIndeterminate = TRUE)
5857     {
5858         ATLASSERT(::IsWindow(m_hWnd));
5859         return (BOOL)::SendMessage(m_hWnd, TB_INDETERMINATE, nID, MAKELPARAM(bIndeterminate, 0));
5860     }
5861
5862     int AddBitmap(int nNumButtons, UINT nBitmapID)
5863     {
5864         ATLASSERT(::IsWindow(m_hWnd));
5865         TBADDBITMAP tbab = { 0 };
5866         tbab.hInst = ModuleHelper::GetResourceInstance();
5867         ATLASSERT(tbab.hInst != NULL);
5868         tbab.nID = nBitmapID;
5869         return (int)::SendMessage(m_hWnd, TB_ADDBITMAP, (WPARAM)nNumButtons, (LPARAM)&tbab);
5870     }
5871
5872     int AddBitmap(int nNumButtons, HBITMAP hBitmap)
5873     {
5874         ATLASSERT(::IsWindow(m_hWnd));
5875         TBADDBITMAP tbab = { 0 };
5876         tbab.hInst = NULL;
5877         tbab.nID = (UINT_PTR)hBitmap;
5878         return (int)::SendMessage(m_hWnd, TB_ADDBITMAP, (WPARAM)nNumButtons, (LPARAM)&tbab);
5879     }
5880
5881     BOOL AddButtons(int nNumButtons, LPTBBUTTON lpButtons)
5882     {
5883         ATLASSERT(::IsWindow(m_hWnd));
5884         return (BOOL)::SendMessage(m_hWnd, TB_ADDBUTTONS, nNumButtons, (LPARAM)lpButtons);
5885     }
5886
5887     BOOL InsertButton(int nIndex, LPTBBUTTON lpButton)
5888     {
5889         ATLASSERT(::IsWindow(m_hWnd));
5890         return (BOOL)::SendMessage(m_hWnd, TB_INSERTBUTTON, nIndex, (LPARAM)lpButton);
5891     }
5892
5893     BOOL InsertButton(int nIndex, int iCommand, BYTE Style, BYTE State, int iBitmap,
5894                       INT_PTR iString, DWORD_PTR lParam)
5895     {
5896         ATLASSERT(::IsWindow(m_hWnd));
5897         TBBUTTON tbb = { 0 };
5898         tbb.fsStyle = Style;
5899         tbb.fsState = State;
5900         tbb.idCommand = iCommand;
5901         tbb.iBitmap = iBitmap;
5902         tbb.iString = iString;
5903         tbb.dwData = lParam;
5904         return (BOOL)::SendMessage(m_hWnd, TB_INSERTBUTTON, nIndex, (LPARAM)&tbb);
5905     }
5906
5907     BOOL InsertButton(int nIndex, int iCommand, BYTE Style, BYTE State, int iBitmap,
5908                       LPCTSTR lpszItem, DWORD_PTR lParam)
5909     {
5910         return InsertButton(nIndex, iCommand, Style, State, iBitmap, (INT_PTR)lpszItem, lParam);
5911     }
5912
5913     BOOL AddButton(LPTBBUTTON lpButton)
5914     {
5915         return InsertButton(-1, lpButton);
5916     }
5917
5918     BOOL AddButton(int iCommand, BYTE Style, BYTE State, int iBitmap, INT_PTR iString, DWORD_PTR lParam)
5919     {
5920         return InsertButton(-1, iCommand, Style, State, iBitmap, iString, lParam);
5921     }
5922
5923     BOOL AddButton(int iCommand, BYTE Style, BYTE State, int iBitmap, LPCTSTR lpszItem, DWORD_PTR lParam)
5924     {
5925         return InsertButton(-1, iCommand, Style, State, iBitmap, lpszItem, lParam);
5926     }
5927
5928     BOOL DeleteButton(int nIndex)
5929     {
5930         ATLASSERT(::IsWindow(m_hWnd));
5931         return (BOOL)::SendMessage(m_hWnd, TB_DELETEBUTTON, nIndex, 0L);
5932     }
5933
5934     BOOL InsertSeparator(int nIndex, int cxWidth = 8)
5935     {
5936         return InsertButton(nIndex, 0, BTNS_SEP, 0, cxWidth, (INT_PTR)0, 0);
5937     }
5938
5939     BOOL AddSeparator(int cxWidth = 8)
5940     {
5941         return AddButton(0, BTNS_SEP, 0, cxWidth, (INT_PTR)0, 0);
5942     }
5943
5944     int CommandToIndex(UINT nID) const
5945     {
5946         ATLASSERT(::IsWindow(m_hWnd));
5947         return (int)::SendMessage(m_hWnd, TB_COMMANDTOINDEX, nID, 0L);
5948     }
5949
5950 #ifndef _WIN32_WCE
5951     void SaveState(HKEY hKeyRoot, LPCTSTR lpszSubKey, LPCTSTR lpszValueName)
5952     {
5953         ATLASSERT(::IsWindow(m_hWnd));
5954         TBSAVEPARAMS tbs = { 0 };
5955         tbs.hkr = hKeyRoot;
5956         tbs.pszSubKey = lpszSubKey;
5957         tbs.pszValueName = lpszValueName;
5958         ::SendMessage(m_hWnd, TB_SAVERESTORE, (WPARAM)TRUE, (LPARAM)&tbs);
5959     }
5960
5961     void RestoreState(HKEY hKeyRoot, LPCTSTR lpszSubKey, LPCTSTR lpszValueName)
5962     {
5963         ATLASSERT(::IsWindow(m_hWnd));
5964         TBSAVEPARAMS tbs = { 0 };
5965         tbs.hkr = hKeyRoot;
5966         tbs.pszSubKey = lpszSubKey;
5967         tbs.pszValueName = lpszValueName;
5968         ::SendMessage(m_hWnd, TB_SAVERESTORE, (WPARAM)FALSE, (LPARAM)&tbs);
5969     }
5970
5971     void Customize()
5972     {
5973         ATLASSERT(::IsWindow(m_hWnd));
5974         ::SendMessage(m_hWnd, TB_CUSTOMIZE, 0, 0L);
5975     }
5976 #endif // !_WIN32_WCE
5977
5978     int AddString(UINT nStringID)
5979     {
5980         ATLASSERT(::IsWindow(m_hWnd));
5981         return (int)::SendMessage(m_hWnd, TB_ADDSTRING, (WPARAM)ModuleHelper::GetResourceInstance(), (LPARAM)nStringID);
5982     }
5983
5984     int AddStrings(LPCTSTR lpszStrings)
5985     {
5986         ATLASSERT(::IsWindow(m_hWnd));
5987         return (int)::SendMessage(m_hWnd, TB_ADDSTRING, 0, (LPARAM)lpszStrings);
5988     }
5989
5990     void AutoSize()
5991     {
5992         ATLASSERT(::IsWindow(m_hWnd));
5993         ::SendMessage(m_hWnd, TB_AUTOSIZE, 0, 0L);
5994     }
5995
5996     BOOL ChangeBitmap(int nID, int nBitmap)
5997     {
5998         ATLASSERT(::IsWindow(m_hWnd));
5999         return (BOOL)::SendMessage(m_hWnd, TB_CHANGEBITMAP, nID, MAKELPARAM(nBitmap, 0));
6000     }
6001
6002     int LoadImages(int nBitmapID)
6003     {
6004         ATLASSERT(::IsWindow(m_hWnd));
6005         return (int)::SendMessage(m_hWnd, TB_LOADIMAGES, nBitmapID, (LPARAM)ModuleHelper::GetResourceInstance());
6006     }
6007
6008     int LoadStdImages(int nBitmapID)
6009     {
6010         ATLASSERT(::IsWindow(m_hWnd));
6011         return (int)::SendMessage(m_hWnd, TB_LOADIMAGES, nBitmapID, (LPARAM)HINST_COMMCTRL);
6012     }
6013
6014     BOOL ReplaceBitmap(LPTBREPLACEBITMAP ptbrb)
6015     {
6016         ATLASSERT(::IsWindow(m_hWnd));
6017         return (BOOL)::SendMessage(m_hWnd, TB_REPLACEBITMAP, 0, (LPARAM)ptbrb);
6018     }
6019
6020 #if (_WIN32_IE >= 0x0400)
6021     int HitTest(LPPOINT lpPoint) const
6022     {
6023         ATLASSERT(::IsWindow(m_hWnd));
6024         return (int)::SendMessage(m_hWnd, TB_HITTEST, 0, (LPARAM)lpPoint);
6025     }
6026
6027 #ifndef _WIN32_WCE
6028     BOOL InsertMarkHitTest(LPPOINT lpPoint, LPTBINSERTMARK lptbim) const
6029     {
6030         ATLASSERT(::IsWindow(m_hWnd));
6031         return (BOOL)::SendMessage(m_hWnd, TB_INSERTMARKHITTEST, (WPARAM)lpPoint, (LPARAM)lptbim);
6032     }
6033
6034     BOOL InsertMarkHitTest(int x, int y, LPTBINSERTMARK lptbim) const
6035     {
6036         ATLASSERT(::IsWindow(m_hWnd));
6037         POINT pt = { x, y };
6038         return (BOOL)::SendMessage(m_hWnd, TB_INSERTMARKHITTEST, (WPARAM)&pt, (LPARAM)lptbim);
6039     }
6040
6041     BOOL MapAccelerator(TCHAR chAccel, int& nID) const
6042     {
6043         ATLASSERT(::IsWindow(m_hWnd));
6044         return (BOOL)::SendMessage(m_hWnd, TB_MAPACCELERATOR, (WPARAM)chAccel, (LPARAM)&nID);
6045     }
6046
6047     BOOL MarkButton(int nID, BOOL bHighlight = TRUE)
6048     {
6049         ATLASSERT(::IsWindow(m_hWnd));
6050         return (BOOL)::SendMessage(m_hWnd, TB_MARKBUTTON, nID, MAKELPARAM(bHighlight, 0));
6051     }
6052
6053     BOOL MoveButton(int nOldPos, int nNewPos)
6054     {
6055         ATLASSERT(::IsWindow(m_hWnd));
6056         return (BOOL)::SendMessage(m_hWnd, TB_MOVEBUTTON, nOldPos, nNewPos);
6057     }
6058
6059     HRESULT GetObject(REFIID iid, LPVOID* ppvObject)
6060     {
6061         ATLASSERT(::IsWindow(m_hWnd));
6062         return (HRESULT)::SendMessage(m_hWnd, TB_GETOBJECT, (WPARAM)&iid, (LPARAM)ppvObject);
6063     }
6064 #endif // !_WIN32_WCE
6065 #endif // (_WIN32_IE >= 0x0400)
6066 };
6067
6068 typedef CToolBarCtrlT<ATL::CWindow>   CToolBarCtrl;
6069
6070
6071 ///////////////////////////////////////////////////////////////////////////////
6072 // CStatusBarCtrl
6073
6074 template <class TBase>
6075 class CStatusBarCtrlT : public TBase
6076 {
6077 public:
6078 // Constructors
6079     CStatusBarCtrlT(HWND hWnd = NULL) : TBase(hWnd)
6080     { }
6081
6082     CStatusBarCtrlT< TBase >& operator =(HWND hWnd)
6083     {
6084         m_hWnd = hWnd;
6085         return *this;
6086     }
6087
6088     HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
6089             DWORD dwStyle = 0, DWORD dwExStyle = 0,
6090             ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
6091     {
6092         return TBase::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);
6093     }
6094
6095 // Methods
6096     static LPCTSTR GetWndClassName()
6097     {
6098         return STATUSCLASSNAME;
6099     }
6100
6101     int GetParts(int nParts, int* pParts) const
6102     {
6103         ATLASSERT(::IsWindow(m_hWnd));
6104         return (int)::SendMessage(m_hWnd, SB_GETPARTS, nParts, (LPARAM)pParts);
6105     }
6106
6107     BOOL SetParts(int nParts, int* pWidths)
6108     {
6109         ATLASSERT(::IsWindow(m_hWnd));
6110         return (BOOL)::SendMessage(m_hWnd, SB_SETPARTS, nParts, (LPARAM)pWidths);
6111     }
6112
6113     int GetTextLength(int nPane, int* pType = NULL) const
6114     {
6115         ATLASSERT(::IsWindow(m_hWnd));
6116         ATLASSERT(nPane < 256);
6117         DWORD dwRet = (DWORD)::SendMessage(m_hWnd, SB_GETTEXTLENGTH, (WPARAM)nPane, 0L);
6118         if (pType != NULL)
6119             *pType = (int)(short)HIWORD(dwRet);
6120         return (int)(short)LOWORD(dwRet);
6121     }
6122
6123     int GetText(int nPane, LPTSTR lpszText, int* pType = NULL) const
6124     {
6125         ATLASSERT(::IsWindow(m_hWnd));
6126         ATLASSERT(nPane < 256);
6127         DWORD dwRet = (DWORD)::SendMessage(m_hWnd, SB_GETTEXT, (WPARAM)nPane, (LPARAM)lpszText);
6128         if(pType != NULL)
6129             *pType = (int)(short)HIWORD(dwRet);
6130         return (int)(short)LOWORD(dwRet);
6131     }
6132
6133 #ifndef _ATL_NO_COM
6134     BOOL GetTextBSTR(int nPane, BSTR& bstrText, int* pType = NULL) const
6135     {
6136         USES_CONVERSION;
6137         ATLASSERT(::IsWindow(m_hWnd));
6138         ATLASSERT(nPane < 256);
6139         ATLASSERT(bstrText == NULL);
6140         int nLength = (int)(short)LOWORD(::SendMessage(m_hWnd, SB_GETTEXTLENGTH, (WPARAM)nPane, 0L));
6141         if(nLength == 0)
6142             return FALSE;
6143
6144         CTempBuffer<TCHAR, _WTL_STACK_ALLOC_THRESHOLD> buff;
6145         LPTSTR lpstrText = buff.Allocate(nLength + 1);
6146         if(lpstrText == NULL)
6147             return FALSE;
6148
6149         if(!GetText(nPane, lpstrText, pType))
6150             return FALSE;
6151
6152         bstrText = ::SysAllocString(T2OLE(lpstrText));
6153         return (bstrText != NULL) ? TRUE : FALSE;
6154     }
6155 #endif // !_ATL_NO_COM
6156
6157 #if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
6158     int GetText(int nPane, _CSTRING_NS::CString& strText, int* pType = NULL) const
6159     {
6160         ATLASSERT(::IsWindow(m_hWnd));
6161         ATLASSERT(nPane < 256);
6162         int nLength = (int)(short)LOWORD(::SendMessage(m_hWnd, SB_GETTEXTLENGTH, (WPARAM)nPane, 0L));
6163         if(nLength == 0)
6164             return 0;
6165
6166         LPTSTR lpstr = strText.GetBufferSetLength(nLength);
6167         if(lpstr == NULL)
6168             return 0;
6169         return GetText(nPane, lpstr, pType);
6170     }
6171 #endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
6172
6173     BOOL SetText(int nPane, LPCTSTR lpszText, int nType = 0)
6174     {
6175         ATLASSERT(::IsWindow(m_hWnd));
6176         ATLASSERT(nPane < 256);
6177         return (BOOL)::SendMessage(m_hWnd, SB_SETTEXT, (nPane | nType), (LPARAM)lpszText);
6178     }
6179
6180     BOOL GetRect(int nPane, LPRECT lpRect) const
6181     {
6182         ATLASSERT(::IsWindow(m_hWnd));
6183         ATLASSERT(nPane < 256);
6184         return (BOOL)::SendMessage(m_hWnd, SB_GETRECT, nPane, (LPARAM)lpRect);
6185     }
6186
6187     BOOL GetBorders(int* pBorders) const
6188     {
6189         ATLASSERT(::IsWindow(m_hWnd));
6190         return (BOOL)::SendMessage(m_hWnd, SB_GETBORDERS, 0, (LPARAM)pBorders);
6191     }
6192
6193     BOOL GetBorders(int& nHorz, int& nVert, int& nSpacing) const
6194     {
6195         ATLASSERT(::IsWindow(m_hWnd));
6196         int borders[3] = { 0, 0, 0 };
6197         BOOL bResult = (BOOL)::SendMessage(m_hWnd, SB_GETBORDERS, 0, (LPARAM)&borders);
6198         if(bResult)
6199         {
6200             nHorz = borders[0];
6201             nVert = borders[1];
6202             nSpacing = borders[2];
6203         }
6204         return bResult;
6205     }
6206
6207     void SetMinHeight(int nMin)
6208     {
6209         ATLASSERT(::IsWindow(m_hWnd));
6210         ::SendMessage(m_hWnd, SB_SETMINHEIGHT, nMin, 0L);
6211     }
6212
6213     BOOL SetSimple(BOOL bSimple = TRUE)
6214     {
6215         ATLASSERT(::IsWindow(m_hWnd));
6216         return (BOOL)::SendMessage(m_hWnd, SB_SIMPLE, bSimple, 0L);
6217     }
6218
6219     BOOL IsSimple() const
6220     {
6221         ATLASSERT(::IsWindow(m_hWnd));
6222         return (BOOL)::SendMessage(m_hWnd, SB_ISSIMPLE, 0, 0L);
6223     }
6224
6225 #if (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
6226     BOOL GetUnicodeFormat() const
6227     {
6228         ATLASSERT(::IsWindow(m_hWnd));
6229         return (BOOL)::SendMessage(m_hWnd, SB_GETUNICODEFORMAT, 0, 0L);
6230     }
6231
6232     BOOL SetUnicodeFormat(BOOL bUnicode = TRUE)
6233     {
6234         ATLASSERT(::IsWindow(m_hWnd));
6235         return (BOOL)::SendMessage(m_hWnd, SB_SETUNICODEFORMAT, bUnicode, 0L);
6236     }
6237
6238     void GetTipText(int nPane, LPTSTR lpstrText, int nSize) const
6239     {
6240         ATLASSERT(::IsWindow(m_hWnd));
6241         ATLASSERT(nPane < 256);
6242         ::SendMessage(m_hWnd, SB_GETTIPTEXT, MAKEWPARAM(nPane, nSize), (LPARAM)lpstrText);
6243     }
6244
6245     void SetTipText(int nPane, LPCTSTR lpstrText)
6246     {
6247         ATLASSERT(::IsWindow(m_hWnd));
6248         ATLASSERT(nPane < 256);
6249         ::SendMessage(m_hWnd, SB_SETTIPTEXT, nPane, (LPARAM)lpstrText);
6250     }
6251 #endif // (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
6252
6253 #if ((_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)) || (defined(_WIN32_WCE) && (_WIN32_WCE >= 0x0500))
6254     COLORREF SetBkColor(COLORREF clrBk)
6255     {
6256         ATLASSERT(::IsWindow(m_hWnd));
6257         return (COLORREF)::SendMessage(m_hWnd, SB_SETBKCOLOR, 0, (LPARAM)clrBk);
6258     }
6259
6260     HICON GetIcon(int nPane) const
6261     {
6262         ATLASSERT(::IsWindow(m_hWnd));
6263         ATLASSERT(nPane < 256);
6264         return (HICON)::SendMessage(m_hWnd, SB_GETICON, nPane, 0L);
6265     }
6266
6267     BOOL SetIcon(int nPane, HICON hIcon)
6268     {
6269         ATLASSERT(::IsWindow(m_hWnd));
6270         ATLASSERT(nPane < 256);
6271         return (BOOL)::SendMessage(m_hWnd, SB_SETICON, nPane, (LPARAM)hIcon);
6272     }
6273 #endif // ((_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)) || (defined(_WIN32_WCE) && (_WIN32_WCE >= 0x0500))
6274 };
6275
6276 typedef CStatusBarCtrlT<ATL::CWindow>   CStatusBarCtrl;
6277
6278
6279 ///////////////////////////////////////////////////////////////////////////////
6280 // CTabCtrl
6281
6282 template <class TBase>
6283 class CTabCtrlT : public TBase
6284 {
6285 public:
6286 // Constructors
6287     CTabCtrlT(HWND hWnd = NULL) : TBase(hWnd)
6288     { }
6289
6290     CTabCtrlT< TBase >& operator =(HWND hWnd)
6291     {
6292         m_hWnd = hWnd;
6293         return *this;
6294     }
6295
6296     HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
6297             DWORD dwStyle = 0, DWORD dwExStyle = 0,
6298             ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
6299     {
6300         return TBase::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);
6301     }
6302
6303 // Attributes
6304     static LPCTSTR GetWndClassName()
6305     {
6306         return WC_TABCONTROL;
6307     }
6308
6309     CImageList GetImageList() const
6310     {
6311         ATLASSERT(::IsWindow(m_hWnd));
6312         return CImageList((HIMAGELIST)::SendMessage(m_hWnd, TCM_GETIMAGELIST, 0, 0L));
6313     }
6314
6315     CImageList SetImageList(HIMAGELIST hImageList)
6316     {
6317         ATLASSERT(::IsWindow(m_hWnd));
6318         return CImageList((HIMAGELIST)::SendMessage(m_hWnd, TCM_SETIMAGELIST, 0, (LPARAM)hImageList));
6319     }
6320
6321     int GetItemCount() const
6322     {
6323         ATLASSERT(::IsWindow(m_hWnd));
6324         return (int)::SendMessage(m_hWnd, TCM_GETITEMCOUNT, 0, 0L);
6325     }
6326
6327     BOOL GetItem(int nItem, LPTCITEM pTabCtrlItem) const
6328     {
6329         ATLASSERT(::IsWindow(m_hWnd));
6330         return (BOOL)::SendMessage(m_hWnd, TCM_GETITEM, nItem, (LPARAM)pTabCtrlItem);
6331     }
6332
6333     BOOL SetItem(int nItem, LPTCITEM pTabCtrlItem)
6334     {
6335         ATLASSERT(::IsWindow(m_hWnd));
6336         return (BOOL)::SendMessage(m_hWnd, TCM_SETITEM, nItem, (LPARAM)pTabCtrlItem);
6337     }
6338
6339     int SetItem(int nItem, UINT mask, LPCTSTR lpszItem, DWORD dwState, DWORD dwStateMask, int iImage, LPARAM lParam)
6340     {
6341         ATLASSERT(::IsWindow(m_hWnd));
6342         TCITEM tci = { 0 };
6343         tci.mask = mask;
6344         tci.pszText = (LPTSTR) lpszItem;
6345         tci.dwState = dwState;
6346         tci.dwStateMask = dwStateMask;
6347         tci.iImage = iImage;
6348         tci.lParam = lParam;
6349         return (int)::SendMessage(m_hWnd, TCM_SETITEM, nItem, (LPARAM)&tci);
6350     }
6351
6352     BOOL GetItemRect(int nItem, LPRECT lpRect) const
6353     {
6354         ATLASSERT(::IsWindow(m_hWnd));
6355         return (BOOL)::SendMessage(m_hWnd, TCM_GETITEMRECT, nItem, (LPARAM)lpRect);
6356     }
6357
6358     int GetCurSel() const
6359     {
6360         ATLASSERT(::IsWindow(m_hWnd));
6361         return (int)::SendMessage(m_hWnd, TCM_GETCURSEL, 0, 0L);
6362     }
6363
6364     int SetCurSel(int nItem)
6365     {
6366         ATLASSERT(::IsWindow(m_hWnd));
6367         return (int)::SendMessage(m_hWnd, TCM_SETCURSEL, nItem, 0L);
6368     }
6369
6370     SIZE SetItemSize(SIZE size)
6371     {
6372         ATLASSERT(::IsWindow(m_hWnd));
6373         DWORD dwSize = (DWORD)::SendMessage(m_hWnd, TCM_SETITEMSIZE, 0, MAKELPARAM(size.cx, size.cy));
6374         SIZE sizeRet = { GET_X_LPARAM(dwSize), GET_Y_LPARAM(dwSize) };
6375         return sizeRet;
6376     }
6377
6378     void SetItemSize(int cx, int cy)
6379     {
6380         ATLASSERT(::IsWindow(m_hWnd));
6381         ::SendMessage(m_hWnd, TCM_SETITEMSIZE, 0, MAKELPARAM(cx, cy));
6382     }
6383
6384     void SetPadding(SIZE size)
6385     {
6386         ATLASSERT(::IsWindow(m_hWnd));
6387         ::SendMessage(m_hWnd, TCM_SETPADDING, 0, MAKELPARAM(size.cx, size.cy));
6388     }
6389
6390     int GetRowCount() const
6391     {
6392         ATLASSERT(::IsWindow(m_hWnd));
6393         return (int)::SendMessage(m_hWnd, TCM_GETROWCOUNT, 0, 0L);
6394     }
6395
6396 #ifndef _WIN32_WCE
6397     CToolTipCtrl GetToolTips() const
6398     {
6399         ATLASSERT(::IsWindow(m_hWnd));
6400         return CToolTipCtrl((HWND)::SendMessage(m_hWnd, TCM_GETTOOLTIPS, 0, 0L));
6401     }
6402
6403     // this method is deprecated, please use GetToolTips
6404     CToolTipCtrl GetTooltips() const { return GetToolTips(); }
6405
6406     void SetToolTips(HWND hWndToolTip)
6407     {
6408         ATLASSERT(::IsWindow(m_hWnd));
6409         ::SendMessage(m_hWnd, TCM_SETTOOLTIPS, (WPARAM)hWndToolTip, 0L);
6410     }
6411
6412     // this method is deprecated, please use SetToolTips
6413     void SetTooltips(HWND hWndToolTip) { SetToolTips(hWndToolTip); }
6414
6415 #endif // !_WIN32_WCE
6416
6417     int GetCurFocus() const
6418     {
6419         ATLASSERT(::IsWindow(m_hWnd));
6420         return (int)::SendMessage(m_hWnd, TCM_GETCURFOCUS, 0, 0L);
6421     }
6422
6423     void SetCurFocus(int nItem)
6424     {
6425         ATLASSERT(::IsWindow(m_hWnd));
6426         ::SendMessage(m_hWnd, TCM_SETCURFOCUS, nItem, 0L);
6427     }
6428
6429     BOOL SetItemExtra(int cbExtra)
6430     {
6431         ATLASSERT(::IsWindow(m_hWnd));
6432         ATLASSERT(GetItemCount() == 0);   // must be empty
6433         return (BOOL)::SendMessage(m_hWnd, TCM_SETITEMEXTRA, cbExtra, 0L);
6434     }
6435
6436     int SetMinTabWidth(int nWidth = -1)
6437     {
6438         ATLASSERT(::IsWindow(m_hWnd));
6439         return (int)::SendMessage(m_hWnd, TCM_SETMINTABWIDTH, 0, nWidth);
6440     }
6441
6442 #if (_WIN32_IE >= 0x0400)
6443     DWORD GetExtendedStyle() const
6444     {
6445         ATLASSERT(::IsWindow(m_hWnd));
6446         return (DWORD)::SendMessage(m_hWnd, TCM_GETEXTENDEDSTYLE, 0, 0L);
6447     }
6448
6449     DWORD SetExtendedStyle(DWORD dwExMask, DWORD dwExStyle)
6450     {
6451         ATLASSERT(::IsWindow(m_hWnd));
6452         return (DWORD)::SendMessage(m_hWnd, TCM_SETEXTENDEDSTYLE, dwExMask, dwExStyle);
6453     }
6454
6455 #ifndef _WIN32_WCE
6456     BOOL GetUnicodeFormat() const
6457     {
6458         ATLASSERT(::IsWindow(m_hWnd));
6459         return (BOOL)::SendMessage(m_hWnd, TCM_GETUNICODEFORMAT, 0, 0L);
6460     }
6461
6462     BOOL SetUnicodeFormat(BOOL bUnicode = TRUE)
6463     {
6464         ATLASSERT(::IsWindow(m_hWnd));
6465         return (BOOL)::SendMessage(m_hWnd, TCM_SETUNICODEFORMAT, bUnicode, 0L);
6466     }
6467 #endif // !_WIN32_WCE
6468 #endif // (_WIN32_IE >= 0x0400)
6469
6470 // Operations
6471     int InsertItem(int nItem, LPTCITEM pTabCtrlItem)
6472     {
6473         ATLASSERT(::IsWindow(m_hWnd));
6474         return (int)::SendMessage(m_hWnd, TCM_INSERTITEM, nItem, (LPARAM)pTabCtrlItem);
6475     }
6476
6477     int InsertItem(int nItem, UINT mask, LPCTSTR lpszItem, int iImage, LPARAM lParam)
6478     {
6479         ATLASSERT(::IsWindow(m_hWnd));
6480         TCITEM tci = { 0 };
6481         tci.mask = mask;
6482         tci.pszText = (LPTSTR) lpszItem;
6483         tci.iImage = iImage;
6484         tci.lParam = lParam;
6485         return (int)::SendMessage(m_hWnd, TCM_INSERTITEM, nItem, (LPARAM)&tci);
6486     }
6487
6488     int InsertItem(int nItem, LPCTSTR lpszItem)
6489     {
6490         ATLASSERT(::IsWindow(m_hWnd));
6491         TCITEM tci = { 0 };
6492         tci.mask = TCIF_TEXT;
6493         tci.pszText = (LPTSTR) lpszItem;
6494         return (int)::SendMessage(m_hWnd, TCM_INSERTITEM, nItem, (LPARAM)&tci);
6495     }
6496
6497     int AddItem(LPTCITEM pTabCtrlItem)
6498     {
6499         return InsertItem(GetItemCount(), pTabCtrlItem);
6500     }
6501
6502     int AddItem(UINT mask, LPCTSTR lpszItem, int iImage, LPARAM lParam)
6503     {
6504         return InsertItem(GetItemCount(), mask, lpszItem, iImage, lParam);
6505     }
6506
6507     int AddItem(LPCTSTR lpszItem)
6508     {
6509         return InsertItem(GetItemCount(), lpszItem);
6510     }
6511
6512     BOOL DeleteItem(int nItem)
6513     {
6514         ATLASSERT(::IsWindow(m_hWnd));
6515         return (BOOL)::SendMessage(m_hWnd, TCM_DELETEITEM, nItem, 0L);
6516     }
6517
6518     BOOL DeleteAllItems()
6519     {
6520         ATLASSERT(::IsWindow(m_hWnd));
6521         return (BOOL)::SendMessage(m_hWnd, TCM_DELETEALLITEMS, 0, 0L);
6522     }
6523
6524     void AdjustRect(BOOL bLarger, LPRECT lpRect)
6525     {
6526         ATLASSERT(::IsWindow(m_hWnd));
6527         ::SendMessage(m_hWnd, TCM_ADJUSTRECT, bLarger, (LPARAM)lpRect);
6528     }
6529
6530     void RemoveImage(int nImage)
6531     {
6532         ATLASSERT(::IsWindow(m_hWnd));
6533         ::SendMessage(m_hWnd, TCM_REMOVEIMAGE, nImage, 0L);
6534     }
6535
6536     int HitTest(TC_HITTESTINFO* pHitTestInfo) const
6537     {
6538         ATLASSERT(::IsWindow(m_hWnd));
6539         return (int)::SendMessage(m_hWnd, TCM_HITTEST, 0, (LPARAM)pHitTestInfo);
6540     }
6541
6542     void DeselectAll(BOOL bExcludeFocus = TRUE)
6543     {
6544         ATLASSERT(::IsWindow(m_hWnd));
6545         ::SendMessage(m_hWnd, TCM_DESELECTALL, bExcludeFocus, 0L);
6546     }
6547
6548 #if (_WIN32_IE >= 0x0400)
6549     BOOL HighlightItem(int nIndex, BOOL bHighlight = TRUE)
6550     {
6551         ATLASSERT(::IsWindow(m_hWnd));
6552         return (BOOL)::SendMessage(m_hWnd, TCM_HIGHLIGHTITEM, nIndex, MAKELPARAM(bHighlight, 0));
6553     }
6554 #endif // (_WIN32_IE >= 0x0400)
6555 };
6556
6557 typedef CTabCtrlT<ATL::CWindow>   CTabCtrl;
6558
6559
6560 ///////////////////////////////////////////////////////////////////////////////
6561 // CTrackBarCtrl
6562
6563 template <class TBase>
6564 class CTrackBarCtrlT : public TBase
6565 {
6566 public:
6567 // Constructors
6568     CTrackBarCtrlT(HWND hWnd = NULL) : TBase(hWnd)
6569     { }
6570
6571     CTrackBarCtrlT< TBase >& operator =(HWND hWnd)
6572     {
6573         m_hWnd = hWnd;
6574         return *this;
6575     }
6576
6577     HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
6578             DWORD dwStyle = 0, DWORD dwExStyle = 0,
6579             ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
6580     {
6581         return TBase::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);
6582     }
6583
6584 // Attributes
6585     static LPCTSTR GetWndClassName()
6586     {
6587         return TRACKBAR_CLASS;
6588     }
6589
6590     int GetLineSize() const
6591     {
6592         ATLASSERT(::IsWindow(m_hWnd));
6593         return (int)::SendMessage(m_hWnd, TBM_GETLINESIZE, 0, 0L);
6594     }
6595
6596     int SetLineSize(int nSize)
6597     {
6598         ATLASSERT(::IsWindow(m_hWnd));
6599         return (int)::SendMessage(m_hWnd, TBM_SETLINESIZE, 0, nSize);
6600     }
6601
6602     int GetPageSize() const
6603     {
6604         ATLASSERT(::IsWindow(m_hWnd));
6605         return (int)::SendMessage(m_hWnd, TBM_GETPAGESIZE, 0, 0L);
6606     }
6607
6608     int SetPageSize(int nSize)
6609     {
6610         ATLASSERT(::IsWindow(m_hWnd));
6611         return (int)::SendMessage(m_hWnd, TBM_SETPAGESIZE, 0, nSize);
6612     }
6613
6614     int GetRangeMin() const
6615     {
6616         ATLASSERT(::IsWindow(m_hWnd));
6617         return (int)::SendMessage(m_hWnd, TBM_GETRANGEMIN, 0, 0L);
6618     }
6619
6620     void SetRangeMin(int nMin, BOOL bRedraw = FALSE)
6621     {
6622         ATLASSERT(::IsWindow(m_hWnd));
6623         ::SendMessage(m_hWnd, TBM_SETRANGEMIN, bRedraw, nMin);
6624     }
6625
6626     int GetRangeMax() const
6627     {
6628         ATLASSERT(::IsWindow(m_hWnd));
6629         return (int)::SendMessage(m_hWnd, TBM_GETRANGEMAX, 0, 0L);
6630     }
6631
6632     void SetRangeMax(int nMax, BOOL bRedraw = FALSE)
6633     {
6634         ATLASSERT(::IsWindow(m_hWnd));
6635         ::SendMessage(m_hWnd, TBM_SETRANGEMAX, bRedraw, nMax);
6636     }
6637
6638     void GetRange(int& nMin, int& nMax) const
6639     {
6640         nMin = GetRangeMin();
6641         nMax = GetRangeMax();
6642     }
6643
6644     void SetRange(int nMin, int nMax, BOOL bRedraw = TRUE)
6645     {
6646         ATLASSERT(::IsWindow(m_hWnd));
6647         ::SendMessage(m_hWnd, TBM_SETRANGE, bRedraw, MAKELPARAM(nMin, nMax));
6648     }
6649
6650     int GetSelStart() const
6651     {
6652         ATLASSERT(::IsWindow(m_hWnd));
6653         return (int)::SendMessage(m_hWnd, TBM_GETSELSTART, 0, 0L);
6654     }
6655
6656     void SetSelStart(int nMin, BOOL bRedraw = FALSE)
6657     {
6658         ATLASSERT(::IsWindow(m_hWnd));
6659         ::SendMessage(m_hWnd, TBM_SETSELSTART, bRedraw, (LPARAM)nMin);
6660     }
6661
6662     int GetSelEnd() const
6663     {
6664         ATLASSERT(::IsWindow(m_hWnd));
6665         return (int)::SendMessage(m_hWnd, TBM_GETSELEND, 0, 0L);
6666     }
6667
6668     void SetSelEnd(int nMax, BOOL bRedraw = FALSE)
6669     {
6670         ATLASSERT(::IsWindow(m_hWnd));
6671         ::SendMessage(m_hWnd, TBM_SETSELEND, bRedraw, (LPARAM)nMax);
6672     }
6673
6674     void GetSelection(int& nMin, int& nMax) const
6675     {
6676         nMin = GetSelStart();
6677         nMax = GetSelEnd();
6678     }
6679
6680     void SetSelection(int nMin, int nMax, BOOL bRedraw = TRUE)
6681     {
6682         SetSelStart(nMin, FALSE);
6683         SetSelEnd(nMax, bRedraw);
6684     }
6685
6686     void GetChannelRect(LPRECT lprc) const
6687     {
6688         ATLASSERT(::IsWindow(m_hWnd));
6689         ::SendMessage(m_hWnd, TBM_GETCHANNELRECT, 0, (LPARAM)lprc);
6690     }
6691
6692     void GetThumbRect(LPRECT lprc) const
6693     {
6694         ATLASSERT(::IsWindow(m_hWnd));
6695         ::SendMessage(m_hWnd, TBM_GETTHUMBRECT, 0, (LPARAM)lprc);
6696     }
6697
6698     int GetPos() const
6699     {
6700         ATLASSERT(::IsWindow(m_hWnd));
6701         return (int)::SendMessage(m_hWnd, TBM_GETPOS, 0, 0L);
6702     }
6703
6704     void SetPos(int nPos)
6705     {
6706         ATLASSERT(::IsWindow(m_hWnd));
6707         ::SendMessage(m_hWnd, TBM_SETPOS, TRUE, nPos);
6708     }
6709
6710     UINT GetNumTics() const
6711     {
6712         ATLASSERT(::IsWindow(m_hWnd));
6713         return (UINT)::SendMessage(m_hWnd, TBM_GETNUMTICS, 0, 0L);
6714     }
6715
6716     DWORD* GetTicArray() const
6717     {
6718         ATLASSERT(::IsWindow(m_hWnd));
6719         return (DWORD*)::SendMessage(m_hWnd, TBM_GETPTICS, 0, 0L);
6720     }
6721
6722     int GetTic(int nTic) const
6723     {
6724         ATLASSERT(::IsWindow(m_hWnd));
6725         return (int)::SendMessage(m_hWnd, TBM_GETTIC, nTic, 0L);
6726     }
6727
6728     BOOL SetTic(int nTic)
6729     {
6730         ATLASSERT(::IsWindow(m_hWnd));
6731         return (BOOL)::SendMessage(m_hWnd, TBM_SETTIC, 0, nTic);
6732     }
6733
6734     int GetTicPos(int nTic) const
6735     {
6736         ATLASSERT(::IsWindow(m_hWnd));
6737         return (int)::SendMessage(m_hWnd, TBM_GETTICPOS, nTic, 0L);
6738     }
6739
6740     void SetTicFreq(int nFreq)
6741     {
6742         ATLASSERT(::IsWindow(m_hWnd));
6743         ::SendMessage(m_hWnd, TBM_SETTICFREQ, nFreq, 0L);
6744     }
6745
6746     int GetThumbLength() const
6747     {
6748         ATLASSERT(::IsWindow(m_hWnd));
6749         return (int)::SendMessage(m_hWnd, TBM_GETTHUMBLENGTH, 0, 0L);
6750     }
6751
6752     void SetThumbLength(int nLength)
6753     {
6754         ATLASSERT(::IsWindow(m_hWnd));
6755         ::SendMessage(m_hWnd, TBM_SETTHUMBLENGTH, nLength, 0L);
6756     }
6757
6758     void SetSel(int nStart, int nEnd, BOOL bRedraw = TRUE)
6759     {
6760         ATLASSERT(::IsWindow(m_hWnd));
6761         ATLASSERT((GetStyle() & TBS_ENABLESELRANGE) != 0);
6762         ::SendMessage(m_hWnd, TBM_SETSEL, bRedraw, MAKELPARAM(nStart, nEnd));
6763     }
6764
6765     ATL::CWindow GetBuddy(BOOL bLeft = TRUE) const
6766     {
6767         ATLASSERT(::IsWindow(m_hWnd));
6768         return ATL::CWindow((HWND)::SendMessage(m_hWnd, TBM_GETBUDDY, bLeft, 0L));
6769     }
6770
6771     ATL::CWindow SetBuddy(HWND hWndBuddy, BOOL bLeft = TRUE)
6772     {
6773         ATLASSERT(::IsWindow(m_hWnd));
6774         return ATL::CWindow((HWND)::SendMessage(m_hWnd, TBM_SETBUDDY, bLeft, (LPARAM)hWndBuddy));
6775     }
6776
6777 #ifndef _WIN32_WCE
6778     CToolTipCtrl GetToolTips() const
6779     {
6780         ATLASSERT(::IsWindow(m_hWnd));
6781         return CToolTipCtrl((HWND)::SendMessage(m_hWnd, TBM_GETTOOLTIPS, 0, 0L));
6782     }
6783
6784     void SetToolTips(HWND hWndTT)
6785     {
6786         ATLASSERT(::IsWindow(m_hWnd));
6787         ::SendMessage(m_hWnd, TBM_SETTOOLTIPS, (WPARAM)hWndTT, 0L);
6788     }
6789
6790     int SetTipSide(int nSide)
6791     {
6792         ATLASSERT(::IsWindow(m_hWnd));
6793         return (int)::SendMessage(m_hWnd, TBM_SETTIPSIDE, nSide, 0L);
6794     }
6795 #endif // !_WIN32_WCE
6796
6797 #if (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
6798     BOOL GetUnicodeFormat() const
6799     {
6800         ATLASSERT(::IsWindow(m_hWnd));
6801         return (BOOL)::SendMessage(m_hWnd, TBM_GETUNICODEFORMAT, 0, 0L);
6802     }
6803
6804     BOOL SetUnicodeFormat(BOOL bUnicode = TRUE)
6805     {
6806         ATLASSERT(::IsWindow(m_hWnd));
6807         return (BOOL)::SendMessage(m_hWnd, TBM_SETUNICODEFORMAT, bUnicode, 0L);
6808     }
6809 #endif // (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
6810
6811 // Operations
6812     void ClearSel(BOOL bRedraw = FALSE)
6813     {
6814         ATLASSERT(::IsWindow(m_hWnd));
6815         ::SendMessage(m_hWnd, TBM_CLEARSEL, bRedraw, 0L);
6816     }
6817
6818     void VerifyPos()
6819     {
6820         ATLASSERT(::IsWindow(m_hWnd));
6821         ::SendMessage(m_hWnd, TBM_SETPOS, FALSE, 0L);
6822     }
6823
6824     void ClearTics(BOOL bRedraw = FALSE)
6825     {
6826         ATLASSERT(::IsWindow(m_hWnd));
6827         ::SendMessage(m_hWnd, TBM_CLEARTICS, bRedraw, 0L);
6828     }
6829 };
6830
6831 typedef CTrackBarCtrlT<ATL::CWindow>   CTrackBarCtrl;
6832
6833
6834 ///////////////////////////////////////////////////////////////////////////////
6835 // CUpDownCtrl
6836
6837 template <class TBase>
6838 class CUpDownCtrlT : public TBase
6839 {
6840 public:
6841 // Constructors
6842     CUpDownCtrlT(HWND hWnd = NULL) : TBase(hWnd)
6843     { }
6844
6845     CUpDownCtrlT< TBase >& operator =(HWND hWnd)
6846     {
6847         m_hWnd = hWnd;
6848         return *this;
6849     }
6850
6851     HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
6852             DWORD dwStyle = 0, DWORD dwExStyle = 0,
6853             ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
6854     {
6855         return TBase::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);
6856     }
6857
6858 // Attributes
6859     static LPCTSTR GetWndClassName()
6860     {
6861         return UPDOWN_CLASS;
6862     }
6863
6864     UINT GetAccel(int nAccel, UDACCEL* pAccel) const
6865     {
6866         ATLASSERT(::IsWindow(m_hWnd));
6867         return (UINT)LOWORD(::SendMessage(m_hWnd, UDM_GETACCEL, nAccel, (LPARAM)pAccel));
6868     }
6869
6870     BOOL SetAccel(int nAccel, UDACCEL* pAccel)
6871     {
6872         ATLASSERT(::IsWindow(m_hWnd));
6873         return (BOOL)LOWORD(::SendMessage(m_hWnd, UDM_SETACCEL, nAccel, (LPARAM)pAccel));
6874     }
6875
6876     UINT GetBase() const
6877     {
6878         ATLASSERT(::IsWindow(m_hWnd));
6879         return (UINT)LOWORD(::SendMessage(m_hWnd, UDM_GETBASE, 0, 0L));
6880     }
6881
6882     int SetBase(int nBase)
6883     {
6884         ATLASSERT(::IsWindow(m_hWnd));
6885         return (int)::SendMessage(m_hWnd, UDM_SETBASE, nBase, 0L);
6886     }
6887
6888     ATL::CWindow GetBuddy() const
6889     {
6890         ATLASSERT(::IsWindow(m_hWnd));
6891         return ATL::CWindow((HWND)::SendMessage(m_hWnd, UDM_GETBUDDY, 0, 0L));
6892     }
6893
6894     ATL::CWindow SetBuddy(HWND hWndBuddy)
6895     {
6896         ATLASSERT(::IsWindow(m_hWnd));
6897         return ATL::CWindow((HWND)::SendMessage(m_hWnd, UDM_SETBUDDY, (WPARAM)hWndBuddy, 0L));
6898     }
6899
6900     int GetPos(LPBOOL lpbError = NULL) const
6901     {
6902         ATLASSERT(::IsWindow(m_hWnd));
6903         DWORD dwRet = (DWORD)::SendMessage(m_hWnd, UDM_GETPOS, 0, 0L);
6904         // Note: Seems that Windows always sets error to TRUE if
6905         // UDS_SETBUDDYINT style is not used
6906         if(lpbError != NULL)
6907             *lpbError = (HIWORD(dwRet) != 0) ? TRUE : FALSE;
6908         return (int)(short)LOWORD(dwRet);
6909     }
6910
6911     int SetPos(int nPos)
6912     {
6913         ATLASSERT(::IsWindow(m_hWnd));
6914         return (int)(short)LOWORD(::SendMessage(m_hWnd, UDM_SETPOS, 0, MAKELPARAM(nPos, 0)));
6915     }
6916
6917     DWORD GetRange() const
6918     {
6919         ATLASSERT(::IsWindow(m_hWnd));
6920         return (DWORD)::SendMessage(m_hWnd, UDM_GETRANGE, 0, 0L);
6921     }
6922
6923     void GetRange(int& nLower, int& nUpper) const
6924     {
6925         ATLASSERT(::IsWindow(m_hWnd));
6926         DWORD dwRet = (DWORD)::SendMessage(m_hWnd, UDM_GETRANGE, 0, 0L);
6927         nLower = (int)(short)HIWORD(dwRet);
6928         nUpper = (int)(short)LOWORD(dwRet);
6929     }
6930
6931     void SetRange(int nLower, int nUpper)
6932     {
6933         ATLASSERT(::IsWindow(m_hWnd));
6934         ::SendMessage(m_hWnd, UDM_SETRANGE, 0, MAKELPARAM(nUpper, nLower));
6935     }
6936
6937 #if (_WIN32_IE >= 0x0400)
6938     void SetRange32(int nLower, int nUpper)
6939     {
6940         ATLASSERT(::IsWindow(m_hWnd));
6941         ::SendMessage(m_hWnd, UDM_SETRANGE32, nLower, nUpper);
6942     }
6943
6944     void GetRange32(int& nLower, int& nUpper) const
6945     {
6946         ATLASSERT(::IsWindow(m_hWnd));
6947         ::SendMessage(m_hWnd, UDM_GETRANGE32, (WPARAM)&nLower, (LPARAM)&nUpper);
6948     }
6949
6950 #ifndef _WIN32_WCE
6951     BOOL GetUnicodeFormat() const
6952     {
6953         ATLASSERT(::IsWindow(m_hWnd));
6954         return (BOOL)::SendMessage(m_hWnd, UDM_GETUNICODEFORMAT, 0, 0L);
6955     }
6956
6957     BOOL SetUnicodeFormat(BOOL bUnicode = TRUE)
6958     {
6959         ATLASSERT(::IsWindow(m_hWnd));
6960         return (BOOL)::SendMessage(m_hWnd, UDM_SETUNICODEFORMAT, bUnicode, 0L);
6961     }
6962 #endif // !_WIN32_WCE
6963 #endif // (_WIN32_IE >= 0x0400)
6964
6965 #if (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
6966     int GetPos32(LPBOOL lpbError = NULL) const
6967     {
6968         ATLASSERT(::IsWindow(m_hWnd));
6969         // Note: Seems that Windows always sets error to TRUE if
6970         // UDS_SETBUDDYINT style is not used
6971         return (int)::SendMessage(m_hWnd, UDM_GETPOS32, 0, (LPARAM)lpbError);
6972     }
6973
6974     int SetPos32(int nPos)
6975     {
6976         ATLASSERT(::IsWindow(m_hWnd));
6977         return (int)::SendMessage(m_hWnd, UDM_SETPOS32, 0, (LPARAM)nPos);
6978     }
6979 #endif // (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
6980 };
6981
6982 typedef CUpDownCtrlT<ATL::CWindow>   CUpDownCtrl;
6983
6984
6985 ///////////////////////////////////////////////////////////////////////////////
6986 // CProgressBarCtrl
6987
6988 template <class TBase>
6989 class CProgressBarCtrlT : public TBase
6990 {
6991 public:
6992 // Constructors
6993     CProgressBarCtrlT(HWND hWnd = NULL) : TBase(hWnd)
6994     { }
6995
6996     CProgressBarCtrlT< TBase >& operator =(HWND hWnd)
6997     {
6998         m_hWnd = hWnd;
6999         return *this;
7000     }
7001
7002     HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
7003             DWORD dwStyle = 0, DWORD dwExStyle = 0,
7004             ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
7005     {
7006         return TBase::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);
7007     }
7008
7009 // Attributes
7010     static LPCTSTR GetWndClassName()
7011     {
7012         return PROGRESS_CLASS;
7013     }
7014
7015     DWORD SetRange(int nLower, int nUpper)
7016     {
7017         ATLASSERT(::IsWindow(m_hWnd));
7018         return (DWORD)::SendMessage(m_hWnd, PBM_SETRANGE, 0, MAKELPARAM(nLower, nUpper));
7019     }
7020
7021     int SetPos(int nPos)
7022     {
7023         ATLASSERT(::IsWindow(m_hWnd));
7024         return (int)(short)LOWORD(::SendMessage(m_hWnd, PBM_SETPOS, nPos, 0L));
7025     }
7026
7027     int OffsetPos(int nPos)
7028     {
7029         ATLASSERT(::IsWindow(m_hWnd));
7030         return (int)(short)LOWORD(::SendMessage(m_hWnd, PBM_DELTAPOS, nPos, 0L));
7031     }
7032
7033     int SetStep(int nStep)
7034     {
7035         ATLASSERT(::IsWindow(m_hWnd));
7036         return (int)(short)LOWORD(::SendMessage(m_hWnd, PBM_SETSTEP, nStep, 0L));
7037     }
7038
7039     UINT GetPos() const
7040     {
7041         ATLASSERT(::IsWindow(m_hWnd));
7042         return (UINT)::SendMessage(m_hWnd, PBM_GETPOS, 0, 0L);
7043     }
7044
7045     void GetRange(PPBRANGE pPBRange) const
7046     {
7047         ATLASSERT(::IsWindow(m_hWnd));
7048         ATLASSERT(pPBRange != NULL);
7049         ::SendMessage(m_hWnd, PBM_GETRANGE, TRUE, (LPARAM)pPBRange);
7050     }
7051
7052     void GetRange(int& nLower, int& nUpper) const
7053     {
7054         ATLASSERT(::IsWindow(m_hWnd));
7055         PBRANGE range = { 0 };
7056         ::SendMessage(m_hWnd, PBM_GETRANGE, TRUE, (LPARAM)&range);
7057         nLower = range.iLow;
7058         nUpper = range.iHigh;
7059     }
7060
7061     int GetRangeLimit(BOOL bLowLimit) const
7062     {
7063         ATLASSERT(::IsWindow(m_hWnd));
7064         return (int)::SendMessage(m_hWnd, PBM_GETRANGE, bLowLimit, (LPARAM)NULL);
7065     }
7066
7067     DWORD SetRange32(int nMin, int nMax)
7068     {
7069         ATLASSERT(::IsWindow(m_hWnd));
7070         return (DWORD)::SendMessage(m_hWnd, PBM_SETRANGE32, nMin, nMax);
7071     }
7072
7073 #if (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
7074     COLORREF SetBarColor(COLORREF clr)
7075     {
7076         ATLASSERT(::IsWindow(m_hWnd));
7077         return (COLORREF)::SendMessage(m_hWnd, PBM_SETBARCOLOR, 0, (LPARAM)clr);
7078     }
7079
7080     COLORREF SetBkColor(COLORREF clr)
7081     {
7082         ATLASSERT(::IsWindow(m_hWnd));
7083         return (COLORREF)::SendMessage(m_hWnd, PBM_SETBKCOLOR, 0, (LPARAM)clr);
7084     }
7085 #endif // (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
7086
7087 #if (_WIN32_WINNT >= 0x0501) && defined(PBM_SETMARQUEE)
7088     BOOL SetMarquee(BOOL bMarquee, UINT uUpdateTime = 0U)
7089     {
7090         ATLASSERT(::IsWindow(m_hWnd));
7091         return (BOOL)::SendMessage(m_hWnd, PBM_SETMARQUEE, (WPARAM)bMarquee, (LPARAM)uUpdateTime);
7092     }
7093 #endif // (_WIN32_WINNT >= 0x0501) && defined(PBM_SETMARQUEE)
7094
7095 #if (_WIN32_WINNT >= 0x0600)
7096     int GetStep() const
7097     {
7098         ATLASSERT(::IsWindow(m_hWnd));
7099         return (int)::SendMessage(m_hWnd, PBM_GETSTEP, 0, 0L);
7100     }
7101
7102     COLORREF GetBkColor() const
7103     {
7104         ATLASSERT(::IsWindow(m_hWnd));
7105         return (COLORREF)::SendMessage(m_hWnd, PBM_GETBKCOLOR, 0, 0L);
7106     }
7107
7108     COLORREF GetBarColor() const
7109     {
7110         ATLASSERT(::IsWindow(m_hWnd));
7111         return (COLORREF)::SendMessage(m_hWnd, PBM_GETBARCOLOR, 0, 0L);
7112     }
7113
7114     int GetState() const
7115     {
7116         ATLASSERT(::IsWindow(m_hWnd));
7117         return (int)::SendMessage(m_hWnd, PBM_GETSTATE, 0, 0L);
7118     }
7119
7120     int SetState(int nState)
7121     {
7122         ATLASSERT(::IsWindow(m_hWnd));
7123         return (int)::SendMessage(m_hWnd, PBM_SETSTATE, nState, 0L);
7124     }
7125 #endif // (_WIN32_WINNT >= 0x0600)
7126
7127 // Operations
7128     int StepIt()
7129     {
7130         ATLASSERT(::IsWindow(m_hWnd));
7131         return (int)(short)LOWORD(::SendMessage(m_hWnd, PBM_STEPIT, 0, 0L));
7132     }
7133 };
7134
7135 typedef CProgressBarCtrlT<ATL::CWindow>   CProgressBarCtrl;
7136
7137
7138 ///////////////////////////////////////////////////////////////////////////////
7139 // CHotKeyCtrl
7140
7141 #ifndef _WIN32_WCE
7142
7143 template <class TBase>
7144 class CHotKeyCtrlT : public TBase
7145 {
7146 public:
7147 // Constructors
7148     CHotKeyCtrlT(HWND hWnd = NULL) : TBase(hWnd)
7149     { }
7150
7151     CHotKeyCtrlT< TBase >& operator =(HWND hWnd)
7152     {
7153         m_hWnd = hWnd;
7154         return *this;
7155     }
7156
7157     HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
7158             DWORD dwStyle = 0, DWORD dwExStyle = 0,
7159             ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
7160     {
7161         return TBase::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);
7162     }
7163
7164 // Attributes
7165     static LPCTSTR GetWndClassName()
7166     {
7167         return HOTKEY_CLASS;
7168     }
7169
7170     DWORD GetHotKey() const
7171     {
7172         ATLASSERT(::IsWindow(m_hWnd));
7173         return (DWORD)::SendMessage(m_hWnd, HKM_GETHOTKEY, 0, 0L);
7174     }
7175
7176     void GetHotKey(WORD &wVirtualKeyCode, WORD &wModifiers) const
7177     {
7178         ATLASSERT(::IsWindow(m_hWnd));
7179         DWORD dw = (DWORD)::SendMessage(m_hWnd, HKM_GETHOTKEY, 0, 0L);
7180         wVirtualKeyCode = LOBYTE(LOWORD(dw));
7181         wModifiers = HIBYTE(LOWORD(dw));
7182     }
7183
7184     void SetHotKey(WORD wVirtualKeyCode, WORD wModifiers)
7185     {
7186         ATLASSERT(::IsWindow(m_hWnd));
7187         ::SendMessage(m_hWnd, HKM_SETHOTKEY, MAKEWORD(wVirtualKeyCode, wModifiers), 0L);
7188     }
7189
7190     void SetRules(WORD wInvalidComb, WORD wModifiers)
7191     {
7192         ATLASSERT(::IsWindow(m_hWnd));
7193         ::SendMessage(m_hWnd, HKM_SETRULES, wInvalidComb, MAKELPARAM(wModifiers, 0));
7194     }
7195 };
7196
7197 typedef CHotKeyCtrlT<ATL::CWindow>   CHotKeyCtrl;
7198
7199 #endif // !_WIN32_WCE
7200
7201
7202 ///////////////////////////////////////////////////////////////////////////////
7203 // CAnimateCtrl
7204
7205 #ifndef _WIN32_WCE
7206
7207 template <class TBase>
7208 class CAnimateCtrlT : public TBase
7209 {
7210 public:
7211 // Constructors
7212     CAnimateCtrlT(HWND hWnd = NULL) : TBase(hWnd)
7213     { }
7214
7215     CAnimateCtrlT< TBase >& operator =(HWND hWnd)
7216     {
7217         m_hWnd = hWnd;
7218         return *this;
7219     }
7220
7221     HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
7222             DWORD dwStyle = 0, DWORD dwExStyle = 0,
7223             ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
7224     {
7225         return TBase::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);
7226     }
7227
7228 // Attributes
7229     static LPCTSTR GetWndClassName()
7230     {
7231         return ANIMATE_CLASS;
7232     }
7233
7234 // Operations
7235     BOOL Open(ATL::_U_STRINGorID FileName)
7236     {
7237         ATLASSERT(::IsWindow(m_hWnd));
7238         return (BOOL)::SendMessage(m_hWnd, ACM_OPEN, 0, (LPARAM)FileName.m_lpstr);
7239     }
7240
7241     BOOL Play(UINT nFrom, UINT nTo, UINT nRep)
7242     {
7243         ATLASSERT(::IsWindow(m_hWnd));
7244         return (BOOL)::SendMessage(m_hWnd, ACM_PLAY, nRep, MAKELPARAM(nFrom, nTo));
7245     }
7246
7247     BOOL Stop()
7248     {
7249         ATLASSERT(::IsWindow(m_hWnd));
7250         return (BOOL)::SendMessage(m_hWnd, ACM_STOP, 0, 0L);
7251     }
7252
7253     BOOL Close()
7254     {
7255         ATLASSERT(::IsWindow(m_hWnd));
7256         return (BOOL)::SendMessage(m_hWnd, ACM_OPEN, 0, 0L);
7257     }
7258
7259     BOOL Seek(UINT nTo)
7260     {
7261         ATLASSERT(::IsWindow(m_hWnd));
7262         return (BOOL)::SendMessage(m_hWnd, ACM_PLAY, 0, MAKELPARAM(nTo, nTo));
7263     }
7264
7265     // Vista only
7266     BOOL IsPlaying() const
7267     {
7268 #ifndef ACM_ISPLAYING
7269         const UINT ACM_ISPLAYING = (WM_USER+104);
7270 #endif
7271         ATLASSERT(::IsWindow(m_hWnd));
7272         return (BOOL)::SendMessage(m_hWnd, ACM_ISPLAYING, 0, 0L);
7273     }
7274 };
7275
7276 typedef CAnimateCtrlT<ATL::CWindow>   CAnimateCtrl;
7277
7278 #endif // !_WIN32_WCE
7279
7280
7281 ///////////////////////////////////////////////////////////////////////////////
7282 // CRichEditCtrl
7283
7284 #ifndef _WIN32_WCE
7285
7286 #if defined(_UNICODE) && (_RICHEDIT_VER == 0x0100)
7287   #undef RICHEDIT_CLASS
7288   #define RICHEDIT_CLASS    L"RICHEDIT"
7289 #endif
7290
7291 #if !defined(_UNICODE) && (_RICHEDIT_VER >= 0x0500)
7292   #undef MSFTEDIT_CLASS
7293   #define MSFTEDIT_CLASS    "RICHEDIT50W"
7294 #endif
7295
7296 template <class TBase>
7297 class CRichEditCtrlT : public TBase
7298 {
7299 public:
7300 // Constructors
7301     CRichEditCtrlT(HWND hWnd = NULL) : TBase(hWnd)
7302     { }
7303
7304     CRichEditCtrlT< TBase >& operator =(HWND hWnd)
7305     {
7306         m_hWnd = hWnd;
7307         return *this;
7308     }
7309
7310     HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
7311             DWORD dwStyle = 0, DWORD dwExStyle = 0,
7312             ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
7313     {
7314         return TBase::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);
7315     }
7316
7317 // Attributes
7318     static LPCTSTR GetWndClassName()
7319     {
7320 #if (_RICHEDIT_VER >= 0x0500)
7321         return MSFTEDIT_CLASS;
7322 #else
7323         return RICHEDIT_CLASS;
7324 #endif
7325     }
7326
7327     static LPCTSTR GetLibraryName()
7328     {
7329 #if (_RICHEDIT_VER >= 0x0500)
7330         return _T("MSFTEDIT.DLL");
7331 #elif (_RICHEDIT_VER >= 0x0200)
7332         return _T("RICHED20.DLL");
7333 #else
7334         return _T("RICHED32.DLL");
7335 #endif
7336     }
7337
7338     int GetLineCount() const
7339     {
7340         ATLASSERT(::IsWindow(m_hWnd));
7341         return (int)::SendMessage(m_hWnd, EM_GETLINECOUNT, 0, 0L);
7342     }
7343
7344     BOOL GetModify() const
7345     {
7346         ATLASSERT(::IsWindow(m_hWnd));
7347         return (BOOL)::SendMessage(m_hWnd, EM_GETMODIFY, 0, 0L);
7348     }
7349
7350     void SetModify(BOOL bModified = TRUE)
7351     {
7352         ATLASSERT(::IsWindow(m_hWnd));
7353         ::SendMessage(m_hWnd, EM_SETMODIFY, bModified, 0L);
7354     }
7355
7356     void GetRect(LPRECT lpRect) const
7357     {
7358         ATLASSERT(::IsWindow(m_hWnd));
7359         ::SendMessage(m_hWnd, EM_GETRECT, 0, (LPARAM)lpRect);
7360     }
7361
7362     DWORD GetOptions() const
7363     {
7364         ATLASSERT(::IsWindow(m_hWnd));
7365         return (DWORD)::SendMessage(m_hWnd, EM_GETOPTIONS, 0, 0L);
7366     }
7367
7368     DWORD SetOptions(WORD wOperation, DWORD dwOptions)
7369     {
7370         ATLASSERT(::IsWindow(m_hWnd));
7371         return (DWORD)::SendMessage(m_hWnd, EM_SETOPTIONS, wOperation, dwOptions);
7372     }
7373
7374     // NOTE: first word in lpszBuffer must contain the size of the buffer!
7375     int GetLine(int nIndex, LPTSTR lpszBuffer) const
7376     {
7377         ATLASSERT(::IsWindow(m_hWnd));
7378         return (int)::SendMessage(m_hWnd, EM_GETLINE, nIndex, (LPARAM)lpszBuffer);
7379     }
7380
7381     int GetLine(int nIndex, LPTSTR lpszBuffer, int nMaxLength) const
7382     {
7383         ATLASSERT(::IsWindow(m_hWnd));
7384         *(LPWORD)lpszBuffer = (WORD)nMaxLength;
7385         return (int)::SendMessage(m_hWnd, EM_GETLINE, nIndex, (LPARAM)lpszBuffer);
7386     }
7387
7388     BOOL CanUndo() const
7389     {
7390         ATLASSERT(::IsWindow(m_hWnd));
7391         return (BOOL)::SendMessage(m_hWnd, EM_CANUNDO, 0, 0L);
7392     }
7393
7394     BOOL CanPaste(UINT nFormat = 0) const
7395     {
7396         ATLASSERT(::IsWindow(m_hWnd));
7397         return (BOOL)::SendMessage(m_hWnd, EM_CANPASTE, nFormat, 0L);
7398     }
7399
7400     void GetSel(LONG& nStartChar, LONG& nEndChar) const
7401     {
7402         ATLASSERT(::IsWindow(m_hWnd));
7403         CHARRANGE cr = { 0, 0 };
7404         ::SendMessage(m_hWnd, EM_EXGETSEL, 0, (LPARAM)&cr);
7405         nStartChar = cr.cpMin;
7406         nEndChar = cr.cpMax;
7407     }
7408
7409     void GetSel(CHARRANGE &cr) const
7410     {
7411         ATLASSERT(::IsWindow(m_hWnd));
7412         ::SendMessage(m_hWnd, EM_EXGETSEL, 0, (LPARAM)&cr);
7413     }
7414
7415     int SetSel(LONG nStartChar, LONG nEndChar)
7416     {
7417         ATLASSERT(::IsWindow(m_hWnd));
7418         CHARRANGE cr = { nStartChar, nEndChar };
7419         return (int)::SendMessage(m_hWnd, EM_EXSETSEL, 0, (LPARAM)&cr);
7420     }
7421
7422     int SetSel(CHARRANGE &cr)
7423     {
7424         ATLASSERT(::IsWindow(m_hWnd));
7425         return (int)::SendMessage(m_hWnd, EM_EXSETSEL, 0, (LPARAM)&cr);
7426     }
7427
7428     int SetSelAll()
7429     {
7430         return SetSel(0, -1);
7431     }
7432
7433     int SetSelNone()
7434     {
7435         return SetSel(-1, 0);
7436     }
7437
7438     DWORD GetDefaultCharFormat(CHARFORMAT& cf) const
7439     {
7440         ATLASSERT(::IsWindow(m_hWnd));
7441         cf.cbSize = sizeof(CHARFORMAT);
7442         return (DWORD)::SendMessage(m_hWnd, EM_GETCHARFORMAT, 0, (LPARAM)&cf);
7443     }
7444
7445     DWORD GetSelectionCharFormat(CHARFORMAT& cf) const
7446     {
7447         ATLASSERT(::IsWindow(m_hWnd));
7448         cf.cbSize = sizeof(CHARFORMAT);
7449         return (DWORD)::SendMessage(m_hWnd, EM_GETCHARFORMAT, 1, (LPARAM)&cf);
7450     }
7451
7452     DWORD GetEventMask() const
7453     {
7454         ATLASSERT(::IsWindow(m_hWnd));
7455         return (DWORD)::SendMessage(m_hWnd, EM_GETEVENTMASK, 0, 0L);
7456     }
7457
7458     LONG GetLimitText() const
7459     {
7460         ATLASSERT(::IsWindow(m_hWnd));
7461         return (LONG)::SendMessage(m_hWnd, EM_GETLIMITTEXT, 0, 0L);
7462     }
7463
7464     DWORD GetParaFormat(PARAFORMAT& pf) const
7465     {
7466         ATLASSERT(::IsWindow(m_hWnd));
7467         pf.cbSize = sizeof(PARAFORMAT);
7468         return (DWORD)::SendMessage(m_hWnd, EM_GETPARAFORMAT, 0, (LPARAM)&pf);
7469     }
7470
7471 #if (_RICHEDIT_VER >= 0x0200)
7472     LONG GetSelText(LPTSTR lpstrBuff) const
7473     {
7474         ATLASSERT(::IsWindow(m_hWnd));
7475         return (LONG)::SendMessage(m_hWnd, EM_GETSELTEXT, 0, (LPARAM)lpstrBuff);
7476     }
7477 #else // !(_RICHEDIT_VER >= 0x0200)
7478     // RichEdit 1.0 EM_GETSELTEXT is ANSI only
7479     LONG GetSelText(LPSTR lpstrBuff) const
7480     {
7481         ATLASSERT(::IsWindow(m_hWnd));
7482         return (LONG)::SendMessage(m_hWnd, EM_GETSELTEXT, 0, (LPARAM)lpstrBuff);
7483     }
7484 #endif // !(_RICHEDIT_VER >= 0x0200)
7485
7486 #ifndef _ATL_NO_COM
7487     BOOL GetSelTextBSTR(BSTR& bstrText) const
7488     {
7489         USES_CONVERSION;
7490         ATLASSERT(::IsWindow(m_hWnd));
7491         ATLASSERT(bstrText == NULL);
7492
7493         CHARRANGE cr = { 0, 0 };
7494         ::SendMessage(m_hWnd, EM_EXGETSEL, 0, (LPARAM)&cr);
7495
7496 #if (_RICHEDIT_VER >= 0x0200)
7497         CTempBuffer<TCHAR, _WTL_STACK_ALLOC_THRESHOLD> buff;
7498         LPTSTR lpstrText = buff.Allocate(cr.cpMax - cr.cpMin + 1);
7499         if(lpstrText == NULL)
7500             return FALSE;
7501         if(::SendMessage(m_hWnd, EM_GETSELTEXT, 0, (LPARAM)lpstrText) == 0)
7502             return FALSE;
7503
7504         bstrText = ::SysAllocString(T2W(lpstrText));
7505 #else // !(_RICHEDIT_VER >= 0x0200)
7506         CTempBuffer<char, _WTL_STACK_ALLOC_THRESHOLD> buff;
7507         LPSTR lpstrText = buff.Allocate(cr.cpMax - cr.cpMin + 1);
7508         if(lpstrText == NULL)
7509             return FALSE;
7510         if(::SendMessage(m_hWnd, EM_GETSELTEXT, 0, (LPARAM)lpstrText) == 0)
7511             return FALSE;
7512
7513         bstrText = ::SysAllocString(A2W(lpstrText));
7514 #endif // !(_RICHEDIT_VER >= 0x0200)
7515
7516         return (bstrText != NULL) ? TRUE : FALSE;
7517     }
7518 #endif // !_ATL_NO_COM
7519
7520 #if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
7521     LONG GetSelText(_CSTRING_NS::CString& strText) const
7522     {
7523         ATLASSERT(::IsWindow(m_hWnd));
7524
7525         CHARRANGE cr = { 0, 0 };
7526         ::SendMessage(m_hWnd, EM_EXGETSEL, 0, (LPARAM)&cr);
7527
7528 #if (_RICHEDIT_VER >= 0x0200)
7529         LONG lLen = 0;
7530         LPTSTR lpstrText = strText.GetBufferSetLength(cr.cpMax - cr.cpMin);
7531         if(lpstrText != NULL)
7532         {
7533             lLen = (LONG)::SendMessage(m_hWnd, EM_GETSELTEXT, 0, (LPARAM)lpstrText);
7534             strText.ReleaseBuffer();
7535         }
7536 #else // !(_RICHEDIT_VER >= 0x0200)
7537         CTempBuffer<char, _WTL_STACK_ALLOC_THRESHOLD> buff;
7538         LPSTR lpstrText = buff.Allocate(cr.cpMax - cr.cpMin + 1);
7539         if(lpstrText == NULL)
7540             return 0;
7541         LONG lLen = (LONG)::SendMessage(m_hWnd, EM_GETSELTEXT, 0, (LPARAM)lpstrText);
7542         if(lLen == 0)
7543             return 0;
7544
7545         USES_CONVERSION;
7546         strText = A2T(lpstrText);
7547 #endif // !(_RICHEDIT_VER >= 0x0200)
7548
7549         return lLen;
7550     }
7551 #endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
7552
7553     WORD GetSelectionType() const
7554     {
7555         ATLASSERT(::IsWindow(m_hWnd));
7556         return (WORD)::SendMessage(m_hWnd, EM_SELECTIONTYPE, 0, 0L);
7557     }
7558
7559     COLORREF SetBackgroundColor(COLORREF cr)
7560     {
7561         ATLASSERT(::IsWindow(m_hWnd));
7562         return (COLORREF)::SendMessage(m_hWnd, EM_SETBKGNDCOLOR, 0, cr);
7563     }
7564
7565     COLORREF SetBackgroundColor()   // sets to system background
7566     {
7567         ATLASSERT(::IsWindow(m_hWnd));
7568         return (COLORREF)::SendMessage(m_hWnd, EM_SETBKGNDCOLOR, 1, 0);
7569     }
7570
7571     BOOL SetCharFormat(CHARFORMAT& cf, WORD wFlags)
7572     {
7573         ATLASSERT(::IsWindow(m_hWnd));
7574         cf.cbSize = sizeof(CHARFORMAT);
7575         return (BOOL)::SendMessage(m_hWnd, EM_SETCHARFORMAT, (WPARAM)wFlags, (LPARAM)&cf);
7576     }
7577
7578     BOOL SetDefaultCharFormat(CHARFORMAT& cf)
7579     {
7580         ATLASSERT(::IsWindow(m_hWnd));
7581         cf.cbSize = sizeof(CHARFORMAT);
7582         return (BOOL)::SendMessage(m_hWnd, EM_SETCHARFORMAT, 0, (LPARAM)&cf);
7583     }
7584
7585     BOOL SetSelectionCharFormat(CHARFORMAT& cf)
7586     {
7587         ATLASSERT(::IsWindow(m_hWnd));
7588         cf.cbSize = sizeof(CHARFORMAT);
7589         return (BOOL)::SendMessage(m_hWnd, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&cf);
7590     }
7591
7592     BOOL SetWordCharFormat(CHARFORMAT& cf)
7593     {
7594         ATLASSERT(::IsWindow(m_hWnd));
7595         cf.cbSize = sizeof(CHARFORMAT);
7596         return (BOOL)::SendMessage(m_hWnd, EM_SETCHARFORMAT, SCF_SELECTION | SCF_WORD, (LPARAM)&cf);
7597     }
7598
7599     DWORD SetEventMask(DWORD dwEventMask)
7600     {
7601         ATLASSERT(::IsWindow(m_hWnd));
7602         return (DWORD)::SendMessage(m_hWnd, EM_SETEVENTMASK, 0, dwEventMask);
7603     }
7604
7605     BOOL SetParaFormat(PARAFORMAT& pf)
7606     {
7607         ATLASSERT(::IsWindow(m_hWnd));
7608         pf.cbSize = sizeof(PARAFORMAT);
7609         return (BOOL)::SendMessage(m_hWnd, EM_SETPARAFORMAT, 0, (LPARAM)&pf);
7610     }
7611
7612     BOOL SetTargetDevice(HDC hDC, int cxLineWidth)
7613     {
7614         ATLASSERT(::IsWindow(m_hWnd));
7615         return (BOOL)::SendMessage(m_hWnd, EM_SETTARGETDEVICE, (WPARAM)hDC, cxLineWidth);
7616     }
7617
7618     int GetTextLength() const
7619     {
7620         ATLASSERT(::IsWindow(m_hWnd));
7621         return (int)::SendMessage(m_hWnd, WM_GETTEXTLENGTH, 0, 0L);
7622     }
7623
7624     BOOL SetReadOnly(BOOL bReadOnly = TRUE)
7625     {
7626         ATLASSERT(::IsWindow(m_hWnd));
7627         return (BOOL)::SendMessage(m_hWnd, EM_SETREADONLY, bReadOnly, 0L);
7628     }
7629
7630     int GetFirstVisibleLine() const
7631     {
7632         ATLASSERT(::IsWindow(m_hWnd));
7633         return (int)::SendMessage(m_hWnd, EM_GETFIRSTVISIBLELINE, 0, 0L);
7634     }
7635
7636     int GetTextRange(TEXTRANGE* pTextRange) const
7637     {
7638         ATLASSERT(::IsWindow(m_hWnd));
7639         return (int)::SendMessage(m_hWnd, EM_GETTEXTRANGE, 0, (LPARAM)pTextRange);
7640     }
7641
7642 #if (_RICHEDIT_VER < 0x0200)
7643     EDITWORDBREAKPROCEX GetWordBreakProcEx() const
7644     {
7645         ATLASSERT(::IsWindow(m_hWnd));
7646         return (EDITWORDBREAKPROCEX)::SendMessage(m_hWnd, EM_GETWORDBREAKPROCEX, 0, 0L);
7647     }
7648
7649     EDITWORDBREAKPROCEX SetWordBreakProcEx(EDITWORDBREAKPROCEX pfnEditWordBreakProcEx)
7650     {
7651         ATLASSERT(::IsWindow(m_hWnd));
7652         return (EDITWORDBREAKPROCEX)::SendMessage(m_hWnd, EM_SETWORDBREAKPROCEX, 0, (LPARAM)pfnEditWordBreakProcEx);
7653     }
7654 #endif // (_RICHEDIT_VER < 0x0200)
7655
7656 #if (_RICHEDIT_VER >= 0x0200)
7657     int GetTextRange(LONG nStartChar, LONG nEndChar, LPTSTR lpstrText) const
7658     {
7659         ATLASSERT(::IsWindow(m_hWnd));
7660         TEXTRANGE tr = { 0 };
7661         tr.chrg.cpMin = nStartChar;
7662         tr.chrg.cpMax = nEndChar;
7663         tr.lpstrText = lpstrText;
7664         return (int)::SendMessage(m_hWnd, EM_GETTEXTRANGE, 0, (LPARAM)&tr);
7665     }
7666 #else // !(_RICHEDIT_VER >= 0x0200)
7667     int GetTextRange(LONG nStartChar, LONG nEndChar, LPSTR lpstrText) const
7668     {
7669         ATLASSERT(::IsWindow(m_hWnd));
7670         TEXTRANGE tr = { 0 };
7671         tr.chrg.cpMin = nStartChar;
7672         tr.chrg.cpMax = nEndChar;
7673         tr.lpstrText = lpstrText;
7674         return (int)::SendMessage(m_hWnd, EM_GETTEXTRANGE, 0, (LPARAM)&tr);
7675     }
7676 #endif // !(_RICHEDIT_VER >= 0x0200)
7677
7678 #if (_RICHEDIT_VER >= 0x0200)
7679     DWORD GetDefaultCharFormat(CHARFORMAT2& cf) const
7680     {
7681         ATLASSERT(::IsWindow(m_hWnd));
7682         cf.cbSize = sizeof(CHARFORMAT2);
7683         return (DWORD)::SendMessage(m_hWnd, EM_GETCHARFORMAT, 0, (LPARAM)&cf);
7684     }
7685
7686     BOOL SetCharFormat(CHARFORMAT2& cf, WORD wFlags)
7687     {
7688         ATLASSERT(::IsWindow(m_hWnd));
7689         cf.cbSize = sizeof(CHARFORMAT2);
7690         return (BOOL)::SendMessage(m_hWnd, EM_SETCHARFORMAT, (WPARAM)wFlags, (LPARAM)&cf);
7691     }
7692
7693     BOOL SetDefaultCharFormat(CHARFORMAT2& cf)
7694     {
7695         ATLASSERT(::IsWindow(m_hWnd));
7696         cf.cbSize = sizeof(CHARFORMAT2);
7697         return (BOOL)::SendMessage(m_hWnd, EM_SETCHARFORMAT, 0, (LPARAM)&cf);
7698     }
7699
7700     DWORD GetSelectionCharFormat(CHARFORMAT2& cf) const
7701     {
7702         ATLASSERT(::IsWindow(m_hWnd));
7703         cf.cbSize = sizeof(CHARFORMAT2);
7704         return (DWORD)::SendMessage(m_hWnd, EM_GETCHARFORMAT, 1, (LPARAM)&cf);
7705     }
7706
7707     BOOL SetSelectionCharFormat(CHARFORMAT2& cf)
7708     {
7709         ATLASSERT(::IsWindow(m_hWnd));
7710         cf.cbSize = sizeof(CHARFORMAT2);
7711         return (BOOL)::SendMessage(m_hWnd, EM_SETCHARFORMAT, SCF_SELECTION, (LPARAM)&cf);
7712     }
7713
7714     BOOL SetWordCharFormat(CHARFORMAT2& cf)
7715     {
7716         ATLASSERT(::IsWindow(m_hWnd));
7717         cf.cbSize = sizeof(CHARFORMAT2);
7718         return (BOOL)::SendMessage(m_hWnd, EM_SETCHARFORMAT, SCF_SELECTION | SCF_WORD, (LPARAM)&cf);
7719     }
7720
7721     DWORD GetParaFormat(PARAFORMAT2& pf) const
7722     {
7723         ATLASSERT(::IsWindow(m_hWnd));
7724         pf.cbSize = sizeof(PARAFORMAT2);
7725         return (DWORD)::SendMessage(m_hWnd, EM_GETPARAFORMAT, 0, (LPARAM)&pf);
7726     }
7727
7728     BOOL SetParaFormat(PARAFORMAT2& pf)
7729     {
7730         ATLASSERT(::IsWindow(m_hWnd));
7731         pf.cbSize = sizeof(PARAFORMAT2);
7732         return (BOOL)::SendMessage(m_hWnd, EM_SETPARAFORMAT, 0, (LPARAM)&pf);
7733     }
7734
7735     TEXTMODE GetTextMode() const
7736     {
7737         ATLASSERT(::IsWindow(m_hWnd));
7738         return (TEXTMODE)::SendMessage(m_hWnd, EM_GETTEXTMODE, 0, 0L);
7739     }
7740
7741     BOOL SetTextMode(TEXTMODE enumTextMode)
7742     {
7743         ATLASSERT(::IsWindow(m_hWnd));
7744         return !(BOOL)::SendMessage(m_hWnd, EM_SETTEXTMODE, enumTextMode, 0L);
7745     }
7746
7747     UNDONAMEID GetUndoName() const
7748     {
7749         ATLASSERT(::IsWindow(m_hWnd));
7750         return (UNDONAMEID)::SendMessage(m_hWnd, EM_GETUNDONAME, 0, 0L);
7751     }
7752
7753     UNDONAMEID GetRedoName() const
7754     {
7755         ATLASSERT(::IsWindow(m_hWnd));
7756         return (UNDONAMEID)::SendMessage(m_hWnd, EM_GETREDONAME, 0, 0L);
7757     }
7758
7759     BOOL CanRedo() const
7760     {
7761         ATLASSERT(::IsWindow(m_hWnd));
7762         return (BOOL)::SendMessage(m_hWnd, EM_CANREDO, 0, 0L);
7763     }
7764
7765     BOOL GetAutoURLDetect() const
7766     {
7767         ATLASSERT(::IsWindow(m_hWnd));
7768         return (BOOL)::SendMessage(m_hWnd, EM_GETAUTOURLDETECT, 0, 0L);
7769     }
7770
7771     BOOL SetAutoURLDetect(BOOL bAutoDetect = TRUE)
7772     {
7773         ATLASSERT(::IsWindow(m_hWnd));
7774         return !(BOOL)::SendMessage(m_hWnd, EM_AUTOURLDETECT, bAutoDetect, 0L);
7775     }
7776
7777     // this method is deprecated, please use SetAutoURLDetect
7778     BOOL EnableAutoURLDetect(BOOL bEnable = TRUE) { return SetAutoURLDetect(bEnable); }
7779
7780     UINT SetUndoLimit(UINT uUndoLimit)
7781     {
7782         ATLASSERT(::IsWindow(m_hWnd));
7783         return (UINT)::SendMessage(m_hWnd, EM_SETUNDOLIMIT, uUndoLimit, 0L);
7784     }
7785
7786     void SetPalette(HPALETTE hPalette)
7787     {
7788         ATLASSERT(::IsWindow(m_hWnd));
7789         ::SendMessage(m_hWnd, EM_SETPALETTE, (WPARAM)hPalette, 0L);
7790     }
7791
7792     int GetTextEx(GETTEXTEX* pGetTextEx, LPTSTR lpstrText) const
7793     {
7794         ATLASSERT(::IsWindow(m_hWnd));
7795         return (int)::SendMessage(m_hWnd, EM_GETTEXTEX, (WPARAM)pGetTextEx, (LPARAM)lpstrText);
7796     }
7797
7798     int GetTextEx(LPTSTR lpstrText, int nTextLen, DWORD dwFlags = GT_DEFAULT, UINT uCodePage = CP_ACP, LPCSTR lpDefaultChar = NULL, LPBOOL lpUsedDefChar = NULL) const
7799     {
7800         ATLASSERT(::IsWindow(m_hWnd));
7801         GETTEXTEX gte = { 0 };
7802         gte.cb = nTextLen * sizeof(TCHAR);
7803         gte.codepage = uCodePage;
7804         gte.flags = dwFlags;
7805         gte.lpDefaultChar = lpDefaultChar;
7806         gte.lpUsedDefChar = lpUsedDefChar;
7807         return (int)::SendMessage(m_hWnd, EM_GETTEXTEX, (WPARAM)&gte, (LPARAM)lpstrText);
7808     }
7809
7810     int GetTextLengthEx(GETTEXTLENGTHEX* pGetTextLengthEx) const
7811     {
7812         ATLASSERT(::IsWindow(m_hWnd));
7813         return (int)::SendMessage(m_hWnd, EM_GETTEXTLENGTHEX, (WPARAM)pGetTextLengthEx, 0L);
7814     }
7815
7816     int GetTextLengthEx(DWORD dwFlags = GTL_DEFAULT, UINT uCodePage = CP_ACP) const
7817     {
7818         ATLASSERT(::IsWindow(m_hWnd));
7819         GETTEXTLENGTHEX gtle = { 0 };
7820         gtle.codepage = uCodePage;
7821         gtle.flags = dwFlags;
7822         return (int)::SendMessage(m_hWnd, EM_GETTEXTLENGTHEX, (WPARAM)&gtle, 0L);
7823     }
7824
7825     EDITWORDBREAKPROC GetWordBreakProc() const
7826     {
7827         ATLASSERT(::IsWindow(m_hWnd));
7828         return (EDITWORDBREAKPROC)::SendMessage(m_hWnd, EM_GETWORDBREAKPROC, 0, 0L);
7829     }
7830
7831     void SetWordBreakProc(EDITWORDBREAKPROC ewbprc)
7832     {
7833         ATLASSERT(::IsWindow(m_hWnd));
7834         ::SendMessage(m_hWnd, EM_SETWORDBREAKPROC, 0, (LPARAM)ewbprc);
7835     }
7836 #endif // (_RICHEDIT_VER >= 0x0200)
7837
7838 #if (_RICHEDIT_VER >= 0x0300)
7839     int SetTextEx(SETTEXTEX* pSetTextEx, LPCTSTR lpstrText)
7840     {
7841         ATLASSERT(::IsWindow(m_hWnd));
7842         return (int)::SendMessage(m_hWnd, EM_SETTEXTEX, (WPARAM)pSetTextEx, (LPARAM)lpstrText);
7843     }
7844
7845     int SetTextEx(LPCTSTR lpstrText, DWORD dwFlags = ST_DEFAULT, UINT uCodePage = CP_ACP)
7846     {
7847         ATLASSERT(::IsWindow(m_hWnd));
7848         SETTEXTEX ste = { 0 };
7849         ste.flags = dwFlags;
7850         ste.codepage = uCodePage;
7851         return (int)::SendMessage(m_hWnd, EM_SETTEXTEX, (WPARAM)&ste, (LPARAM)lpstrText);
7852     }
7853
7854     int GetEditStyle() const
7855     {
7856         ATLASSERT(::IsWindow(m_hWnd));
7857         return (int)::SendMessage(m_hWnd, EM_GETEDITSTYLE, 0, 0L);
7858     }
7859
7860     int SetEditStyle(int nStyle, int nMask = -1)
7861     {
7862         ATLASSERT(::IsWindow(m_hWnd));
7863         if(nMask == -1)
7864             nMask = nStyle;   // set everything specified
7865         return (int)::SendMessage(m_hWnd, EM_SETEDITSTYLE, nStyle, nMask);
7866     }
7867
7868     BOOL SetFontSize(int nFontSizeDelta)
7869     {
7870         ATLASSERT(::IsWindow(m_hWnd));
7871         ATLASSERT(nFontSizeDelta >= -1637 && nFontSizeDelta <= 1638);
7872         return (BOOL)::SendMessage(m_hWnd, EM_SETFONTSIZE, nFontSizeDelta, 0L);
7873     }
7874
7875     void GetScrollPos(LPPOINT lpPoint) const
7876     {
7877         ATLASSERT(::IsWindow(m_hWnd));
7878         ATLASSERT(lpPoint != NULL);
7879         ::SendMessage(m_hWnd, EM_GETSCROLLPOS, 0, (LPARAM)lpPoint);
7880     }
7881
7882     void SetScrollPos(LPPOINT lpPoint)
7883     {
7884         ATLASSERT(::IsWindow(m_hWnd));
7885         ATLASSERT(lpPoint != NULL);
7886         ::SendMessage(m_hWnd, EM_SETSCROLLPOS, 0, (LPARAM)lpPoint);
7887     }
7888
7889     BOOL GetZoom(int& nNum, int& nDen) const
7890     {
7891         ATLASSERT(::IsWindow(m_hWnd));
7892         return (BOOL)::SendMessage(m_hWnd, EM_GETZOOM, (WPARAM)&nNum, (LPARAM)&nDen);
7893     }
7894
7895     BOOL SetZoom(int nNum, int nDen)
7896     {
7897         ATLASSERT(::IsWindow(m_hWnd));
7898         ATLASSERT(nNum >= 0 && nNum <= 64);
7899         ATLASSERT(nDen >= 0 && nDen <= 64);
7900         return (BOOL)::SendMessage(m_hWnd, EM_SETZOOM, nNum, nDen);
7901     }
7902
7903     BOOL SetZoomOff()
7904     {
7905         ATLASSERT(::IsWindow(m_hWnd));
7906         return (BOOL)::SendMessage(m_hWnd, EM_SETZOOM, 0, 0L);
7907     }
7908
7909     void SetMargins(UINT nLeft, UINT nRight, WORD wFlags = EC_LEFTMARGIN | EC_RIGHTMARGIN)
7910     {
7911         ATLASSERT(::IsWindow(m_hWnd));
7912         ::SendMessage(m_hWnd, EM_SETMARGINS, wFlags, MAKELONG(nLeft, nRight));
7913     }
7914 #endif // (_RICHEDIT_VER >= 0x0300)
7915
7916 // Operations
7917     void LimitText(LONG nChars = 0)
7918     {
7919         ATLASSERT(::IsWindow(m_hWnd));
7920         ::SendMessage(m_hWnd, EM_EXLIMITTEXT, 0, nChars);
7921     }
7922
7923     int LineFromChar(LONG nIndex) const
7924     {
7925         ATLASSERT(::IsWindow(m_hWnd));
7926         return (int)::SendMessage(m_hWnd, EM_EXLINEFROMCHAR, 0, nIndex);
7927     }
7928
7929     POINT PosFromChar(LONG nChar) const
7930     {
7931         ATLASSERT(::IsWindow(m_hWnd));
7932         POINT point = { 0, 0 };
7933         ::SendMessage(m_hWnd, EM_POSFROMCHAR, (WPARAM)&point, nChar);
7934         return point;
7935     }
7936
7937     int CharFromPos(POINT pt) const
7938     {
7939         ATLASSERT(::IsWindow(m_hWnd));
7940         POINTL ptl = { pt.x, pt.y };
7941         return (int)::SendMessage(m_hWnd, EM_CHARFROMPOS, 0, (LPARAM)&ptl);
7942     }
7943
7944     void EmptyUndoBuffer()
7945     {
7946         ATLASSERT(::IsWindow(m_hWnd));
7947         ::SendMessage(m_hWnd, EM_EMPTYUNDOBUFFER, 0, 0L);
7948     }
7949
7950     int LineIndex(int nLine = -1) const
7951     {
7952         ATLASSERT(::IsWindow(m_hWnd));
7953         return (int)::SendMessage(m_hWnd, EM_LINEINDEX, nLine, 0L);
7954     }
7955
7956     int LineLength(int nLine = -1) const
7957     {
7958         ATLASSERT(::IsWindow(m_hWnd));
7959         return (int)::SendMessage(m_hWnd, EM_LINELENGTH, nLine, 0L);
7960     }
7961
7962     BOOL LineScroll(int nLines)
7963     {
7964         ATLASSERT(::IsWindow(m_hWnd));
7965         return (BOOL)::SendMessage(m_hWnd, EM_LINESCROLL, 0, nLines);
7966     }
7967
7968     void ReplaceSel(LPCTSTR lpszNewText, BOOL bCanUndo = FALSE)
7969     {
7970         ATLASSERT(::IsWindow(m_hWnd));
7971         ::SendMessage(m_hWnd, EM_REPLACESEL, (WPARAM) bCanUndo, (LPARAM)lpszNewText);
7972     }
7973
7974     void SetRect(LPCRECT lpRect)
7975     {
7976         ATLASSERT(::IsWindow(m_hWnd));
7977         ::SendMessage(m_hWnd, EM_SETRECT, 0, (LPARAM)lpRect);
7978     }
7979
7980     BOOL DisplayBand(LPRECT pDisplayRect)
7981     {
7982         ATLASSERT(::IsWindow(m_hWnd));
7983         return (BOOL)::SendMessage(m_hWnd, EM_DISPLAYBAND, 0, (LPARAM)pDisplayRect);
7984     }
7985
7986     LONG FindText(DWORD dwFlags, FINDTEXT& ft) const
7987     {
7988         ATLASSERT(::IsWindow(m_hWnd));
7989 #if (_RICHEDIT_VER >= 0x0200) && defined(_UNICODE)
7990         return (LONG)::SendMessage(m_hWnd, EM_FINDTEXTW, dwFlags, (LPARAM)&ft);
7991 #else
7992         return (LONG)::SendMessage(m_hWnd, EM_FINDTEXT, dwFlags, (LPARAM)&ft);
7993 #endif
7994     }
7995
7996     LONG FindText(DWORD dwFlags, FINDTEXTEX& ft) const
7997     {
7998         ATLASSERT(::IsWindow(m_hWnd));
7999 #if (_RICHEDIT_VER >= 0x0200) && defined(_UNICODE)
8000         return (LONG)::SendMessage(m_hWnd, EM_FINDTEXTEXW, dwFlags, (LPARAM)&ft);
8001 #else
8002         return (LONG)::SendMessage(m_hWnd, EM_FINDTEXTEX, dwFlags, (LPARAM)&ft);
8003 #endif
8004     }
8005
8006     LONG FormatRange(FORMATRANGE& fr, BOOL bDisplay = TRUE)
8007     {
8008         ATLASSERT(::IsWindow(m_hWnd));
8009         return (LONG)::SendMessage(m_hWnd, EM_FORMATRANGE, bDisplay, (LPARAM)&fr);
8010     }
8011
8012     LONG FormatRange(FORMATRANGE* pFormatRange, BOOL bDisplay = TRUE)
8013     {
8014         ATLASSERT(::IsWindow(m_hWnd));
8015         return (LONG)::SendMessage(m_hWnd, EM_FORMATRANGE, bDisplay, (LPARAM)pFormatRange);
8016     }
8017
8018     void HideSelection(BOOL bHide = TRUE, BOOL bChangeStyle = FALSE)
8019     {
8020         ATLASSERT(::IsWindow(m_hWnd));
8021         ::SendMessage(m_hWnd, EM_HIDESELECTION, bHide, bChangeStyle);
8022     }
8023
8024     void PasteSpecial(UINT uClipFormat, DWORD dwAspect = 0, HMETAFILE hMF = 0)
8025     {
8026         ATLASSERT(::IsWindow(m_hWnd));
8027         REPASTESPECIAL reps = { dwAspect, (DWORD_PTR)hMF };
8028         ::SendMessage(m_hWnd, EM_PASTESPECIAL, uClipFormat, (LPARAM)&reps);
8029     }
8030
8031     void RequestResize()
8032     {
8033         ATLASSERT(::IsWindow(m_hWnd));
8034         ::SendMessage(m_hWnd, EM_REQUESTRESIZE, 0, 0L);
8035     }
8036
8037     LONG StreamIn(UINT uFormat, EDITSTREAM& es)
8038     {
8039         ATLASSERT(::IsWindow(m_hWnd));
8040         return (LONG)::SendMessage(m_hWnd, EM_STREAMIN, uFormat, (LPARAM)&es);
8041     }
8042
8043     LONG StreamOut(UINT uFormat, EDITSTREAM& es)
8044     {
8045         ATLASSERT(::IsWindow(m_hWnd));
8046         return (LONG)::SendMessage(m_hWnd, EM_STREAMOUT, uFormat, (LPARAM)&es);
8047     }
8048
8049     DWORD FindWordBreak(int nCode, LONG nStartChar)
8050     {
8051         ATLASSERT(::IsWindow(m_hWnd));
8052         return (DWORD)::SendMessage(m_hWnd, EM_FINDWORDBREAK, nCode, nStartChar);
8053     }
8054
8055     // Additional operations
8056     void ScrollCaret()
8057     {
8058         ATLASSERT(::IsWindow(m_hWnd));
8059         ::SendMessage(m_hWnd, EM_SCROLLCARET, 0, 0L);
8060     }
8061
8062     int InsertText(long nInsertAfterChar, LPCTSTR lpstrText, BOOL bCanUndo = FALSE)
8063     {
8064         int nRet = SetSel(nInsertAfterChar, nInsertAfterChar);
8065         ReplaceSel(lpstrText, bCanUndo);
8066         return nRet;
8067     }
8068
8069     int AppendText(LPCTSTR lpstrText, BOOL bCanUndo = FALSE)
8070     {
8071         return InsertText(GetWindowTextLength(), lpstrText, bCanUndo);
8072     }
8073
8074     // Clipboard operations
8075     BOOL Undo()
8076     {
8077         ATLASSERT(::IsWindow(m_hWnd));
8078         return (BOOL)::SendMessage(m_hWnd, EM_UNDO, 0, 0L);
8079     }
8080
8081     void Clear()
8082     {
8083         ATLASSERT(::IsWindow(m_hWnd));
8084         ::SendMessage(m_hWnd, WM_CLEAR, 0, 0L);
8085     }
8086
8087     void Copy()
8088     {
8089         ATLASSERT(::IsWindow(m_hWnd));
8090         ::SendMessage(m_hWnd, WM_COPY, 0, 0L);
8091     }
8092
8093     void Cut()
8094     {
8095         ATLASSERT(::IsWindow(m_hWnd));
8096         ::SendMessage(m_hWnd, WM_CUT, 0, 0L);
8097     }
8098
8099     void Paste()
8100     {
8101         ATLASSERT(::IsWindow(m_hWnd));
8102         ::SendMessage(m_hWnd, WM_PASTE, 0, 0L);
8103     }
8104
8105     // OLE support
8106     IRichEditOle* GetOleInterface() const
8107     {
8108         ATLASSERT(::IsWindow(m_hWnd));
8109         IRichEditOle *pRichEditOle = NULL;
8110         ::SendMessage(m_hWnd, EM_GETOLEINTERFACE, 0, (LPARAM)&pRichEditOle);
8111         return pRichEditOle;
8112     }
8113
8114     BOOL SetOleCallback(IRichEditOleCallback* pCallback)
8115     {
8116         ATLASSERT(::IsWindow(m_hWnd));
8117         return (BOOL)::SendMessage(m_hWnd, EM_SETOLECALLBACK, 0, (LPARAM)pCallback);
8118     }
8119
8120 #if (_RICHEDIT_VER >= 0x0200)
8121     BOOL Redo()
8122     {
8123         ATLASSERT(::IsWindow(m_hWnd));
8124         return (BOOL)::SendMessage(m_hWnd, EM_REDO, 0, 0L);
8125     }
8126
8127     void StopGroupTyping()
8128     {
8129         ATLASSERT(::IsWindow(m_hWnd));
8130         ::SendMessage(m_hWnd, EM_STOPGROUPTYPING, 0, 0L);
8131     }
8132
8133     void ShowScrollBar(int nBarType, BOOL bVisible = TRUE)
8134     {
8135         ATLASSERT(::IsWindow(m_hWnd));
8136         ::SendMessage(m_hWnd, EM_SHOWSCROLLBAR, nBarType, bVisible);
8137     }
8138 #endif // (_RICHEDIT_VER >= 0x0200)
8139
8140 #if (_RICHEDIT_VER >= 0x0300)
8141     BOOL SetTabStops(int nTabStops, LPINT rgTabStops)
8142     {
8143         ATLASSERT(::IsWindow(m_hWnd));
8144         return (BOOL)::SendMessage(m_hWnd, EM_SETTABSTOPS, nTabStops, (LPARAM)rgTabStops);
8145     }
8146
8147     BOOL SetTabStops()
8148     {
8149         ATLASSERT(::IsWindow(m_hWnd));
8150         return (BOOL)::SendMessage(m_hWnd, EM_SETTABSTOPS, 0, 0L);
8151     }
8152
8153     BOOL SetTabStops(const int& cxEachStop)    // takes an 'int'
8154     {
8155         ATLASSERT(::IsWindow(m_hWnd));
8156         return (BOOL)::SendMessage(m_hWnd, EM_SETTABSTOPS, 1, (LPARAM)(LPINT)&cxEachStop);
8157     }
8158 #endif // (_RICHEDIT_VER >= 0x0300)
8159
8160 #if (_RICHEDIT_VER >= 0x0800)
8161     AutoCorrectProc GetAutoCorrectProc() const
8162     {
8163         ATLASSERT(::IsWindow(m_hWnd));
8164         return (AutoCorrectProc)::SendMessage(m_hWnd, EM_GETAUTOCORRECTPROC, 0, 0L);
8165     }
8166
8167     BOOL SetAutoCorrectProc(AutoCorrectProc pfn)
8168     {
8169         ATLASSERT(::IsWindow(m_hWnd));
8170         return (BOOL)::SendMessage(m_hWnd, EM_SETAUTOCORRECTPROC, (WPARAM)pfn, 0L);
8171     }
8172
8173     BOOL CallAutoCorrectProc(WCHAR ch)
8174     {
8175         ATLASSERT(::IsWindow(m_hWnd));
8176         return (BOOL)::SendMessage(m_hWnd, EM_CALLAUTOCORRECTPROC, (WPARAM)ch, 0L);
8177     }
8178
8179     DWORD GetEditStyleEx() const
8180     {
8181         ATLASSERT(::IsWindow(m_hWnd));
8182         return (DWORD)::SendMessage(m_hWnd, EM_GETEDITSTYLEEX, 0, 0L);
8183     }
8184
8185     DWORD SetEditStyleEx(DWORD dwStyleEx, DWORD dwMask)
8186     {
8187         ATLASSERT(::IsWindow(m_hWnd));
8188         return (DWORD)::SendMessage(m_hWnd, EM_SETEDITSTYLEEX, dwStyleEx, dwMask);
8189     }
8190
8191     DWORD GetStoryType(int nStoryIndex) const
8192     {
8193         ATLASSERT(::IsWindow(m_hWnd));
8194         return (DWORD)::SendMessage(m_hWnd, EM_GETSTORYTYPE, nStoryIndex, 0L);
8195     }
8196
8197     DWORD SetStoryType(int nStoryIndex, DWORD dwStoryType)
8198     {
8199         ATLASSERT(::IsWindow(m_hWnd));
8200         return (DWORD)::SendMessage(m_hWnd, EM_SETSTORYTYPE, nStoryIndex, dwStoryType);
8201     }
8202
8203     DWORD GetEllipsisMode() const
8204     {
8205         ATLASSERT(::IsWindow(m_hWnd));
8206
8207         DWORD dwMode = 0;
8208         BOOL bRet = (BOOL)::SendMessage(m_hWnd, EM_GETELLIPSISMODE, 0, (LPARAM)&dwMode);
8209         bRet;   // avoid level 4 warning
8210         ATLASSERT(bRet != FALSE);
8211
8212         return dwMode;
8213     }
8214
8215     BOOL SetEllipsisMode(DWORD dwEllipsisMode)
8216     {
8217         ATLASSERT(::IsWindow(m_hWnd));
8218         return (BOOL)::SendMessage(m_hWnd, EM_SETELLIPSISMODE, 0, dwEllipsisMode);
8219     }
8220
8221     BOOL GetEllipsisState() const
8222     {
8223         ATLASSERT(::IsWindow(m_hWnd));
8224         return (BOOL)::SendMessage(m_hWnd, EM_GETELLIPSISSTATE, 0, 0L);
8225     }
8226
8227     BOOL GetTouchOptions(int nTouchOptions) const
8228     {
8229         ATLASSERT(::IsWindow(m_hWnd));
8230         return (BOOL)::SendMessage(m_hWnd, EM_GETTOUCHOPTIONS, nTouchOptions, 0L);
8231     }
8232
8233     void SetTouchOptions(int nTouchOptions, BOOL bEnable)
8234     {
8235         ATLASSERT(::IsWindow(m_hWnd));
8236         ::SendMessage(m_hWnd, EM_SETTOUCHOPTIONS, nTouchOptions, bEnable);
8237     }
8238
8239     HRESULT InsertTable(TABLEROWPARMS* pRowParams, TABLECELLPARMS* pCellParams)
8240     {
8241         ATLASSERT(::IsWindow(m_hWnd));
8242         return (HRESULT)::SendMessage(m_hWnd, EM_INSERTTABLE, (WPARAM)pRowParams, (LPARAM)pCellParams);
8243     }
8244
8245     HRESULT GetTableParams(TABLEROWPARMS* pRowParams, TABLECELLPARMS* pCellParams) const
8246     {
8247         ATLASSERT(::IsWindow(m_hWnd));
8248         return (HRESULT)::SendMessage(m_hWnd, EM_GETTABLEPARMS, (WPARAM)pRowParams, (LPARAM)pCellParams);
8249     }
8250
8251     HRESULT SetTableParams(TABLEROWPARMS* pRowParams, TABLECELLPARMS* pCellParams)
8252     {
8253         ATLASSERT(::IsWindow(m_hWnd));
8254         return (HRESULT)::SendMessage(m_hWnd, EM_SETTABLEPARMS, (WPARAM)pRowParams, (LPARAM)pCellParams);
8255     }
8256
8257     HRESULT InsertImage(RICHEDIT_IMAGE_PARAMETERS* pParams)
8258     {
8259         ATLASSERT(::IsWindow(m_hWnd));
8260         return (HRESULT)::SendMessage(m_hWnd, EM_INSERTIMAGE, 0, (LPARAM)pParams);
8261     }
8262
8263     BOOL SetUiaName(LPCTSTR lpstrName)
8264     {
8265         ATLASSERT(::IsWindow(m_hWnd));
8266         return (BOOL)::SendMessage(m_hWnd, EM_SETUIANAME, 0, (LPARAM)lpstrName);
8267     }
8268 #endif // (_RICHEDIT_VER >= 0x0800)
8269 };
8270
8271 typedef CRichEditCtrlT<ATL::CWindow>   CRichEditCtrl;
8272
8273 #endif // !_WIN32_WCE
8274
8275
8276 ///////////////////////////////////////////////////////////////////////////////
8277 // CRichEditCommands - message handlers for standard EDIT commands
8278
8279 #ifndef _WIN32_WCE
8280
8281 // Chain to CRichEditCommands message map. Your class must also derive from CRichEditCtrl.
8282 // Example:
8283 // class CMyRichEdit : public CWindowImpl<CMyRichEdit, CRichEditCtrl>,
8284 //                     public CRichEditCommands<CMyRichEdit>
8285 // {
8286 // public:
8287 //      BEGIN_MSG_MAP(CMyRichEdit)
8288 //              // your handlers...
8289 //              CHAIN_MSG_MAP_ALT(CRichEditCommands<CMyRichEdit>, 1)
8290 //      END_MSG_MAP()
8291 //      // other stuff...
8292 // };
8293
8294 template <class T>
8295 class CRichEditCommands : public CEditCommands< T >
8296 {
8297 public:
8298     BEGIN_MSG_MAP(CRichEditCommands< T >)
8299     ALT_MSG_MAP(1)
8300         COMMAND_ID_HANDLER(ID_EDIT_CLEAR, CEditCommands< T >::OnEditClear)
8301         COMMAND_ID_HANDLER(ID_EDIT_CLEAR_ALL, CEditCommands< T >::OnEditClearAll)
8302         COMMAND_ID_HANDLER(ID_EDIT_COPY, CEditCommands< T >::OnEditCopy)
8303         COMMAND_ID_HANDLER(ID_EDIT_CUT, CEditCommands< T >::OnEditCut)
8304         COMMAND_ID_HANDLER(ID_EDIT_PASTE, CEditCommands< T >::OnEditPaste)
8305         COMMAND_ID_HANDLER(ID_EDIT_SELECT_ALL, CEditCommands< T >::OnEditSelectAll)
8306         COMMAND_ID_HANDLER(ID_EDIT_UNDO, CEditCommands< T >::OnEditUndo)
8307 #if (_RICHEDIT_VER >= 0x0200)
8308         COMMAND_ID_HANDLER(ID_EDIT_REDO, OnEditRedo)
8309 #endif // (_RICHEDIT_VER >= 0x0200)
8310     END_MSG_MAP()
8311
8312 #if (_RICHEDIT_VER >= 0x0200)
8313     LRESULT OnEditRedo(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
8314     {
8315         T* pT = static_cast<T*>(this);
8316         pT->Redo();
8317         return 0;
8318     }
8319 #endif // (_RICHEDIT_VER >= 0x0200)
8320
8321 // State (update UI) helpers
8322     BOOL CanCut() const
8323     { return HasSelection(); }
8324
8325     BOOL CanCopy() const
8326     { return HasSelection(); }
8327
8328     BOOL CanClear() const
8329     { return HasSelection(); }
8330
8331 // Implementation
8332     BOOL HasSelection() const
8333     {
8334         const T* pT = static_cast<const T*>(this);
8335         return (pT->GetSelectionType() != SEL_EMPTY);
8336     }
8337 };
8338
8339 #endif // _WIN32_WCE
8340
8341
8342 ///////////////////////////////////////////////////////////////////////////////
8343 // CDragListBox
8344
8345 #ifndef _WIN32_WCE
8346
8347 template <class TBase>
8348 class CDragListBoxT : public CListBoxT< TBase >
8349 {
8350 public:
8351 // Constructors
8352     CDragListBoxT(HWND hWnd = NULL) : CListBoxT< TBase >(hWnd)
8353     { }
8354
8355     CDragListBoxT< TBase >& operator =(HWND hWnd)
8356     {
8357         m_hWnd = hWnd;
8358         return *this;
8359     }
8360
8361     HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
8362             DWORD dwStyle = 0, DWORD dwExStyle = 0,
8363             ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
8364     {
8365         HWND hWnd = TBase::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);
8366         if(hWnd != NULL)
8367             MakeDragList();
8368         return hWnd;
8369     }
8370
8371 // Operations
8372     BOOL MakeDragList()
8373     {
8374         ATLASSERT(::IsWindow(m_hWnd));
8375         ATLASSERT((GetStyle() & (LBS_MULTIPLESEL | LBS_EXTENDEDSEL)) == 0);
8376         return ::MakeDragList(m_hWnd);
8377     }
8378
8379     int LBItemFromPt(POINT pt, BOOL bAutoScroll = TRUE)
8380     {
8381         ATLASSERT(::IsWindow(m_hWnd));
8382         return ::LBItemFromPt(m_hWnd, pt, bAutoScroll);
8383     }
8384
8385     void DrawInsert(int nItem)
8386     {
8387         ATLASSERT(::IsWindow(m_hWnd));
8388         ::DrawInsert(GetParent(), m_hWnd, nItem);
8389     }
8390
8391     static UINT GetDragListMessage()
8392     {
8393         static UINT uDragListMessage = 0;
8394         if(uDragListMessage == 0)
8395         {
8396             CStaticDataInitCriticalSectionLock lock;
8397             if(FAILED(lock.Lock()))
8398             {
8399                 ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to lock critical section in CDragListBox::GetDragListMessage.\n"));
8400                 ATLASSERT(FALSE);
8401                 return 0;
8402             }
8403
8404             if(uDragListMessage == 0)
8405                 uDragListMessage = ::RegisterWindowMessage(DRAGLISTMSGSTRING);
8406
8407             lock.Unlock();
8408         }
8409         ATLASSERT(uDragListMessage != 0);
8410         return uDragListMessage;
8411     }
8412 };
8413
8414 typedef CDragListBoxT<ATL::CWindow>   CDragListBox;
8415
8416 template <class T>
8417 class CDragListNotifyImpl
8418 {
8419 public:
8420     BEGIN_MSG_MAP(CDragListNotifyImpl< T >)
8421         MESSAGE_HANDLER(CDragListBox::GetDragListMessage(), OnDragListNotify)
8422     END_MSG_MAP()
8423
8424     LRESULT OnDragListNotify(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
8425     {
8426         uMsg;   // avoid level 4 warning
8427         ATLASSERT(uMsg == CDragListBox::GetDragListMessage());
8428         T* pT = static_cast<T*>(this);
8429         LPDRAGLISTINFO lpDragListInfo = (LPDRAGLISTINFO)lParam;
8430         LRESULT lRet = 0;
8431         switch(lpDragListInfo->uNotification)
8432         {
8433         case DL_BEGINDRAG:
8434             lRet = (LPARAM)pT->OnBeginDrag((int)wParam, lpDragListInfo->hWnd, lpDragListInfo->ptCursor);
8435             break;
8436         case DL_CANCELDRAG:
8437             pT->OnCancelDrag((int)wParam, lpDragListInfo->hWnd, lpDragListInfo->ptCursor);
8438             break;
8439         case DL_DRAGGING:
8440             lRet = (LPARAM)pT->OnDragging((int)wParam, lpDragListInfo->hWnd, lpDragListInfo->ptCursor);
8441             break;
8442         case DL_DROPPED:
8443             pT->OnDropped((int)wParam, lpDragListInfo->hWnd, lpDragListInfo->ptCursor);
8444             break;
8445         default:
8446             ATLTRACE2(atlTraceUI, 0, _T("Unknown DragListBox notification\n"));
8447             bHandled = FALSE;   // don't handle it
8448             break;
8449         }
8450         return lRet;
8451     }
8452
8453 // Overrideables
8454     BOOL OnBeginDrag(int /*nCtlID*/, HWND /*hWndDragList*/, POINT /*ptCursor*/)
8455     {
8456         return TRUE;   // allow dragging
8457     }
8458
8459     void OnCancelDrag(int /*nCtlID*/, HWND /*hWndDragList*/, POINT /*ptCursor*/)
8460     {
8461         // nothing to do
8462     }
8463
8464     int OnDragging(int /*nCtlID*/, HWND /*hWndDragList*/, POINT /*ptCursor*/)
8465     {
8466         return 0;   // don't change cursor
8467     }
8468
8469     void OnDropped(int /*nCtlID*/, HWND /*hWndDragList*/, POINT /*ptCursor*/)
8470     {
8471         // nothing to do
8472     }
8473 };
8474
8475 #endif // _WIN32_WCE
8476
8477
8478 ///////////////////////////////////////////////////////////////////////////////
8479 // CReBarCtrl
8480
8481 template <class TBase>
8482 class CReBarCtrlT : public TBase
8483 {
8484 public:
8485 // Constructors
8486     CReBarCtrlT(HWND hWnd = NULL) : TBase(hWnd)
8487     { }
8488
8489     CReBarCtrlT< TBase >& operator =(HWND hWnd)
8490     {
8491         m_hWnd = hWnd;
8492         return *this;
8493     }
8494
8495     HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
8496             DWORD dwStyle = 0, DWORD dwExStyle = 0,
8497             ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
8498     {
8499         return TBase::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);
8500     }
8501
8502 // Attributes
8503     static LPCTSTR GetWndClassName()
8504     {
8505         return REBARCLASSNAME;
8506     }
8507
8508     UINT GetBandCount() const
8509     {
8510         ATLASSERT(::IsWindow(m_hWnd));
8511         return (UINT)::SendMessage(m_hWnd, RB_GETBANDCOUNT, 0, 0L);
8512     }
8513
8514     BOOL GetBandInfo(int nBand, LPREBARBANDINFO lprbbi) const
8515     {
8516         ATLASSERT(::IsWindow(m_hWnd));
8517         return (BOOL)::SendMessage(m_hWnd, RB_GETBANDINFO, nBand, (LPARAM)lprbbi);
8518     }
8519
8520     BOOL SetBandInfo(int nBand, LPREBARBANDINFO lprbbi)
8521     {
8522         ATLASSERT(::IsWindow(m_hWnd));
8523         return (BOOL)::SendMessage(m_hWnd, RB_SETBANDINFO, nBand, (LPARAM)lprbbi);
8524     }
8525
8526     BOOL GetBarInfo(LPREBARINFO lprbi) const
8527     {
8528         ATLASSERT(::IsWindow(m_hWnd));
8529         return (BOOL)::SendMessage(m_hWnd, RB_GETBARINFO, 0, (LPARAM)lprbi);
8530     }
8531
8532     BOOL SetBarInfo(LPREBARINFO lprbi)
8533     {
8534         ATLASSERT(::IsWindow(m_hWnd));
8535         return (BOOL)::SendMessage(m_hWnd, RB_SETBARINFO, 0, (LPARAM)lprbi);
8536     }
8537
8538     CImageList GetImageList() const
8539     {
8540         ATLASSERT(::IsWindow(m_hWnd));
8541         REBARINFO rbi = { 0 };
8542         rbi.cbSize = sizeof(REBARINFO);
8543         rbi.fMask = RBIM_IMAGELIST;
8544         BOOL bRet = (BOOL)::SendMessage(m_hWnd, RB_GETBARINFO, 0, (LPARAM)&rbi);
8545         return CImageList((bRet != FALSE) ? rbi.himl : NULL);
8546     }
8547
8548     BOOL SetImageList(HIMAGELIST hImageList)
8549     {
8550         ATLASSERT(::IsWindow(m_hWnd));
8551         REBARINFO rbi = { 0 };
8552         rbi.cbSize = sizeof(REBARINFO);
8553         rbi.fMask = RBIM_IMAGELIST;
8554         rbi.himl = hImageList;
8555         return (BOOL)::SendMessage(m_hWnd, RB_SETBARINFO, 0, (LPARAM)&rbi);
8556     }
8557
8558     UINT GetRowCount() const
8559     {
8560         ATLASSERT(::IsWindow(m_hWnd));
8561         return (UINT)::SendMessage(m_hWnd, RB_GETROWCOUNT, 0, 0L);
8562     }
8563
8564     UINT GetRowHeight(int nBand) const
8565     {
8566         ATLASSERT(::IsWindow(m_hWnd));
8567         return (UINT)::SendMessage(m_hWnd, RB_GETROWHEIGHT, nBand, 0L);
8568     }
8569
8570 #if (_WIN32_IE >= 0x0400)
8571     COLORREF GetTextColor() const
8572     {
8573         ATLASSERT(::IsWindow(m_hWnd));
8574         return (COLORREF)::SendMessage(m_hWnd, RB_GETTEXTCOLOR, 0, 0L);
8575     }
8576
8577     COLORREF SetTextColor(COLORREF clr)
8578     {
8579         ATLASSERT(::IsWindow(m_hWnd));
8580         return (COLORREF)::SendMessage(m_hWnd, RB_SETTEXTCOLOR, 0, (LPARAM)clr);
8581     }
8582
8583     COLORREF GetBkColor() const
8584     {
8585         ATLASSERT(::IsWindow(m_hWnd));
8586         return (COLORREF)::SendMessage(m_hWnd, RB_GETBKCOLOR, 0, 0L);
8587     }
8588
8589     COLORREF SetBkColor(COLORREF clr)
8590     {
8591         ATLASSERT(::IsWindow(m_hWnd));
8592         return (COLORREF)::SendMessage(m_hWnd, RB_SETBKCOLOR, 0, (LPARAM)clr);
8593     }
8594
8595     UINT GetBarHeight() const
8596     {
8597         ATLASSERT(::IsWindow(m_hWnd));
8598         return (UINT)::SendMessage(m_hWnd, RB_GETBARHEIGHT, 0, 0L);
8599     }
8600
8601     BOOL GetRect(int nBand, LPRECT lpRect) const
8602     {
8603         ATLASSERT(::IsWindow(m_hWnd));
8604         return (BOOL)::SendMessage(m_hWnd, RB_GETRECT, nBand, (LPARAM)lpRect);
8605     }
8606
8607 #ifndef _WIN32_WCE
8608     CToolTipCtrl GetToolTips() const
8609     {
8610         ATLASSERT(::IsWindow(m_hWnd));
8611         return CToolTipCtrl((HWND)::SendMessage(m_hWnd, RB_GETTOOLTIPS, 0, 0L));
8612     }
8613
8614     void SetToolTips(HWND hwndToolTip)
8615     {
8616         ATLASSERT(::IsWindow(m_hWnd));
8617         ::SendMessage(m_hWnd, RB_SETTOOLTIPS, (WPARAM)hwndToolTip, 0L);
8618     }
8619 #endif // !_WIN32_WCE
8620
8621     void GetBandBorders(int nBand, LPRECT lpRect) const
8622     {
8623         ATLASSERT(::IsWindow(m_hWnd));
8624         ATLASSERT(lpRect != NULL);
8625         ::SendMessage(m_hWnd, RB_GETBANDBORDERS, nBand, (LPARAM)lpRect);
8626     }
8627
8628 #ifndef _WIN32_WCE
8629     BOOL GetColorScheme(LPCOLORSCHEME lpColorScheme) const
8630     {
8631         ATLASSERT(::IsWindow(m_hWnd));
8632         ATLASSERT(lpColorScheme != NULL);
8633         return (BOOL)::SendMessage(m_hWnd, RB_GETCOLORSCHEME, 0, (LPARAM)lpColorScheme);
8634     }
8635
8636     void SetColorScheme(LPCOLORSCHEME lpColorScheme)
8637     {
8638         ATLASSERT(::IsWindow(m_hWnd));
8639         ATLASSERT(lpColorScheme != NULL);
8640         ::SendMessage(m_hWnd, RB_SETCOLORSCHEME, 0, (LPARAM)lpColorScheme);
8641     }
8642
8643     HPALETTE GetPalette() const
8644     {
8645         ATLASSERT(::IsWindow(m_hWnd));
8646         return (HPALETTE)::SendMessage(m_hWnd, RB_GETPALETTE, 0, 0L);
8647     }
8648
8649     HPALETTE SetPalette(HPALETTE hPalette)
8650     {
8651         ATLASSERT(::IsWindow(m_hWnd));
8652         return (HPALETTE)::SendMessage(m_hWnd, RB_SETPALETTE, 0, (LPARAM)hPalette);
8653     }
8654
8655     BOOL GetUnicodeFormat() const
8656     {
8657         ATLASSERT(::IsWindow(m_hWnd));
8658         return (BOOL)::SendMessage(m_hWnd, RB_GETUNICODEFORMAT, 0, 0L);
8659     }
8660
8661     BOOL SetUnicodeFormat(BOOL bUnicode = TRUE)
8662     {
8663         ATLASSERT(::IsWindow(m_hWnd));
8664         return (BOOL)::SendMessage(m_hWnd, RB_SETUNICODEFORMAT, bUnicode, 0L);
8665     }
8666 #endif // !_WIN32_WCE
8667 #endif // (_WIN32_IE >= 0x0400)
8668
8669 #if (_WIN32_WINNT >= 0x0501)
8670     // requires uxtheme.h to be included to use MARGINS struct
8671 #ifndef _UXTHEME_H_
8672     typedef struct _MARGINS*   PMARGINS;
8673 #endif // !_UXTHEME_H_
8674     void GetBandMargins(PMARGINS pMargins) const
8675     {
8676         ATLASSERT(::IsWindow(m_hWnd));
8677         ::SendMessage(m_hWnd, RB_GETBANDMARGINS, 0, (LPARAM)pMargins);
8678     }
8679
8680     void SetWindowTheme(LPCWSTR lpstrTheme)
8681     {
8682         ATLASSERT(::IsWindow(m_hWnd));
8683         ::SendMessage(m_hWnd, RB_SETWINDOWTHEME, 0, (LPARAM)lpstrTheme);
8684     }
8685 #endif // (_WIN32_WINNT >= 0x0501)
8686
8687 #if (_WIN32_IE >= 0x0600)
8688     DWORD GetExtendedStyle() const
8689     {
8690         ATLASSERT(::IsWindow(m_hWnd));
8691         return (DWORD)::SendMessage(m_hWnd, RB_GETEXTENDEDSTYLE, 0, 0L);
8692     }
8693
8694     DWORD SetExtendedStyle(DWORD dwStyle, DWORD dwMask)
8695     {
8696         ATLASSERT(::IsWindow(m_hWnd));
8697         return (DWORD)::SendMessage(m_hWnd, RB_SETEXTENDEDSTYLE, dwMask, dwStyle);
8698     }
8699 #endif // (_WIN32_IE >= 0x0600)
8700
8701 // Operations
8702     BOOL InsertBand(int nBand, LPREBARBANDINFO lprbbi)
8703     {
8704         ATLASSERT(::IsWindow(m_hWnd));
8705         return (BOOL)::SendMessage(m_hWnd, RB_INSERTBAND, nBand, (LPARAM)lprbbi);
8706     }
8707
8708     BOOL AddBand(LPREBARBANDINFO lprbbi)
8709     {
8710         return InsertBand(-1, lprbbi);
8711     }
8712
8713     BOOL DeleteBand(int nBand)
8714     {
8715         ATLASSERT(::IsWindow(m_hWnd));
8716         return (BOOL)::SendMessage(m_hWnd, RB_DELETEBAND, nBand, 0L);
8717     }
8718
8719     ATL::CWindow SetNotifyWnd(HWND hWnd)
8720     {
8721         ATLASSERT(::IsWindow(m_hWnd));
8722         return ATL::CWindow((HWND)::SendMessage(m_hWnd, RB_SETPARENT, (WPARAM)hWnd, 0L));
8723     }
8724
8725 #if (_WIN32_IE >= 0x0400)
8726     void BeginDrag(int nBand, DWORD dwPos)
8727     {
8728         ATLASSERT(::IsWindow(m_hWnd));
8729         ::SendMessage(m_hWnd, RB_BEGINDRAG, nBand, dwPos);
8730     }
8731
8732     void BeginDrag(int nBand, int xPos, int yPos)
8733     {
8734         ATLASSERT(::IsWindow(m_hWnd));
8735         ::SendMessage(m_hWnd, RB_BEGINDRAG, nBand, MAKELPARAM(xPos, yPos));
8736     }
8737
8738     void EndDrag()
8739     {
8740         ATLASSERT(::IsWindow(m_hWnd));
8741         ::SendMessage(m_hWnd, RB_ENDDRAG, 0, 0L);
8742     }
8743
8744     void DragMove(DWORD dwPos)
8745     {
8746         ATLASSERT(::IsWindow(m_hWnd));
8747         ::SendMessage(m_hWnd, RB_DRAGMOVE, 0, dwPos);
8748     }
8749
8750     void DragMove(int xPos, int yPos)
8751     {
8752         ATLASSERT(::IsWindow(m_hWnd));
8753         ::SendMessage(m_hWnd, RB_DRAGMOVE, 0, MAKELPARAM(xPos, yPos));
8754     }
8755
8756 #ifndef _WIN32_WCE
8757     void GetDropTarget(IDropTarget** ppDropTarget) const
8758     {
8759         ATLASSERT(::IsWindow(m_hWnd));
8760         ::SendMessage(m_hWnd, RB_GETDROPTARGET, 0, (LPARAM)ppDropTarget);
8761     }
8762 #endif // !_WIN32_WCE
8763
8764     void MaximizeBand(int nBand, BOOL bIdeal = FALSE)
8765     {
8766         ATLASSERT(::IsWindow(m_hWnd));
8767         ::SendMessage(m_hWnd, RB_MAXIMIZEBAND, nBand, bIdeal);
8768     }
8769
8770     void MinimizeBand(int nBand)
8771     {
8772         ATLASSERT(::IsWindow(m_hWnd));
8773         ::SendMessage(m_hWnd, RB_MINIMIZEBAND, nBand, 0L);
8774     }
8775
8776     BOOL SizeToRect(LPRECT lpRect)
8777     {
8778         ATLASSERT(::IsWindow(m_hWnd));
8779         return (BOOL)::SendMessage(m_hWnd, RB_SIZETORECT, 0, (LPARAM)lpRect);
8780     }
8781
8782     int IdToIndex(UINT uBandID) const
8783     {
8784         ATLASSERT(::IsWindow(m_hWnd));
8785         return (int)::SendMessage(m_hWnd, RB_IDTOINDEX, uBandID, 0L);
8786     }
8787
8788     int HitTest(LPRBHITTESTINFO lprbht) const
8789     {
8790         ATLASSERT(::IsWindow(m_hWnd));
8791         return (int)::SendMessage(m_hWnd, RB_HITTEST, 0, (LPARAM)lprbht);
8792     }
8793
8794     BOOL ShowBand(int nBand, BOOL bShow)
8795     {
8796         ATLASSERT(::IsWindow(m_hWnd));
8797         return (BOOL)::SendMessage(m_hWnd, RB_SHOWBAND, nBand, bShow);
8798     }
8799
8800 #ifndef _WIN32_WCE
8801     BOOL MoveBand(int nBand, int nNewPos)
8802     {
8803         ATLASSERT(::IsWindow(m_hWnd));
8804         ATLASSERT(nNewPos >= 0 && nNewPos <= ((int)GetBandCount() - 1));
8805         return (BOOL)::SendMessage(m_hWnd, RB_MOVEBAND, nBand, nNewPos);
8806     }
8807 #endif // !_WIN32_WCE
8808 #endif // (_WIN32_IE >= 0x0400)
8809
8810 #if (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
8811     void PushChevron(int nBand, LPARAM lAppValue)
8812     {
8813         ATLASSERT(::IsWindow(m_hWnd));
8814         ::SendMessage(m_hWnd, RB_PUSHCHEVRON, nBand, lAppValue);
8815     }
8816 #endif // (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
8817
8818 // Extra operations
8819 #if (_WIN32_IE >= 0x0400)
8820     void LockBands(bool bLock)
8821     {
8822         int nBandCount = GetBandCount();
8823         for(int i =0; i < nBandCount; i++)
8824         {
8825             REBARBANDINFO rbbi = { RunTimeHelper::SizeOf_REBARBANDINFO() };
8826             rbbi.fMask = RBBIM_STYLE;
8827             BOOL bRet = GetBandInfo(i, &rbbi);
8828             ATLASSERT(bRet);
8829
8830             if((rbbi.fStyle & RBBS_GRIPPERALWAYS) == 0)
8831             {
8832                 rbbi.fStyle |= RBBS_GRIPPERALWAYS;
8833                 bRet = SetBandInfo(i, &rbbi);
8834                 ATLASSERT(bRet);
8835                 rbbi.fStyle &= ~RBBS_GRIPPERALWAYS;
8836             }
8837
8838             if(bLock)
8839                 rbbi.fStyle |= RBBS_NOGRIPPER;
8840             else
8841                 rbbi.fStyle &= ~RBBS_NOGRIPPER;
8842
8843             bRet = SetBandInfo(i, &rbbi);
8844             ATLASSERT(bRet);
8845         }
8846     }
8847 #endif // (_WIN32_IE >= 0x0400)
8848
8849 #if (_WIN32_WINNT >= 0x0600)
8850     BOOL SetBandWidth(int nBand, int cxWidth)
8851     {
8852         ATLASSERT(::IsWindow(m_hWnd));
8853         return (BOOL)::SendMessage(m_hWnd, RB_SETBANDWIDTH, nBand, cxWidth);
8854     }
8855 #endif // (_WIN32_WINNT >= 0x0600)
8856 };
8857
8858 typedef CReBarCtrlT<ATL::CWindow>   CReBarCtrl;
8859
8860
8861 ///////////////////////////////////////////////////////////////////////////////
8862 // CComboBoxEx
8863
8864 #ifndef _WIN32_WCE
8865
8866 template <class TBase>
8867 class CComboBoxExT : public CComboBoxT< TBase >
8868 {
8869 public:
8870 // Constructors
8871     CComboBoxExT(HWND hWnd = NULL) : CComboBoxT< TBase >(hWnd)
8872     { }
8873
8874     CComboBoxExT< TBase >& operator =(HWND hWnd)
8875     {
8876         m_hWnd = hWnd;
8877         return *this;
8878     }
8879
8880     HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
8881             DWORD dwStyle = 0, DWORD dwExStyle = 0,
8882             ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
8883     {
8884         return TBase::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);
8885     }
8886
8887 // Attributes
8888     static LPCTSTR GetWndClassName()
8889     {
8890         return WC_COMBOBOXEX;
8891     }
8892
8893     CImageList GetImageList() const
8894     {
8895         ATLASSERT(::IsWindow(m_hWnd));
8896         return CImageList((HIMAGELIST)::SendMessage(m_hWnd, CBEM_GETIMAGELIST, 0, 0L));
8897     }
8898
8899     CImageList SetImageList(HIMAGELIST hImageList)
8900     {
8901         ATLASSERT(::IsWindow(m_hWnd));
8902         return CImageList((HIMAGELIST)::SendMessage(m_hWnd, CBEM_SETIMAGELIST, 0, (LPARAM)hImageList));
8903     }
8904
8905 #if (_WIN32_IE >= 0x0400)
8906     DWORD GetExtendedStyle() const
8907     {
8908         ATLASSERT(::IsWindow(m_hWnd));
8909         return (DWORD)::SendMessage(m_hWnd, CBEM_GETEXTENDEDSTYLE, 0, 0L);
8910     }
8911
8912     DWORD SetExtendedStyle(DWORD dwExMask, DWORD dwExStyle)
8913     {
8914         ATLASSERT(::IsWindow(m_hWnd));
8915         return (DWORD)::SendMessage(m_hWnd, CBEM_SETEXTENDEDSTYLE, dwExMask, dwExStyle);
8916     }
8917
8918     BOOL GetUnicodeFormat() const
8919     {
8920         ATLASSERT(::IsWindow(m_hWnd));
8921         return (BOOL)::SendMessage(m_hWnd, CBEM_GETUNICODEFORMAT, 0, 0L);
8922     }
8923
8924     BOOL SetUnicodeFormat(BOOL bUnicode = TRUE)
8925     {
8926         ATLASSERT(::IsWindow(m_hWnd));
8927         return (BOOL)::SendMessage(m_hWnd, CBEM_SETUNICODEFORMAT, bUnicode, 0L);
8928     }
8929 #endif // (_WIN32_IE >= 0x0400)
8930
8931 #if (_WIN32_WINNT >= 0x0501)
8932     void SetWindowTheme(LPCWSTR lpstrTheme)
8933     {
8934         ATLASSERT(::IsWindow(m_hWnd));
8935         ::SendMessage(m_hWnd, CBEM_SETWINDOWTHEME, 0, (LPARAM)lpstrTheme);
8936     }
8937 #endif // (_WIN32_WINNT >= 0x0501)
8938
8939 // Operations
8940     int InsertItem(const COMBOBOXEXITEM* lpcCBItem)
8941     {
8942         ATLASSERT(::IsWindow(m_hWnd));
8943         return (int)::SendMessage(m_hWnd, CBEM_INSERTITEM, 0, (LPARAM)lpcCBItem);
8944     }
8945
8946     int InsertItem(UINT nMask, int nIndex, LPCTSTR lpszItem, int nImage, int nSelImage,
8947                    int iIndent, int iOverlay, LPARAM lParam)
8948     {
8949         ATLASSERT(::IsWindow(m_hWnd));
8950         COMBOBOXEXITEM cbex = { 0 };
8951         cbex.mask = nMask;
8952         cbex.iItem = nIndex;
8953         cbex.pszText = (LPTSTR) lpszItem;
8954         cbex.iImage = nImage;
8955         cbex.iSelectedImage = nSelImage;
8956         cbex.iIndent = iIndent;
8957         cbex.iOverlay = iOverlay;
8958         cbex.lParam = lParam;
8959         return (int)::SendMessage(m_hWnd, CBEM_INSERTITEM, 0, (LPARAM)&cbex);
8960     }
8961
8962     int InsertItem(int nIndex, LPCTSTR lpszItem, int nImage, int nSelImage, int iIndent, LPARAM lParam = 0)
8963     {
8964         ATLASSERT(::IsWindow(m_hWnd));
8965         COMBOBOXEXITEM cbex = { 0 };
8966         cbex.mask = CBEIF_TEXT | CBEIF_IMAGE | CBEIF_SELECTEDIMAGE | CBEIF_INDENT | CBEIF_LPARAM;
8967         cbex.iItem = nIndex;
8968         cbex.pszText = (LPTSTR) lpszItem;
8969         cbex.iImage = nImage;
8970         cbex.iSelectedImage = nSelImage;
8971         cbex.iIndent = iIndent;
8972         cbex.lParam = lParam;
8973         return (int)::SendMessage(m_hWnd, CBEM_INSERTITEM, 0, (LPARAM)&cbex);
8974     }
8975
8976     int AddItem(UINT nMask, LPCTSTR lpszItem, int nImage, int nSelImage, int iIndent, int iOverlay, LPARAM lParam)
8977     {
8978         return InsertItem(nMask, -1, lpszItem, nImage, nSelImage, iIndent, iOverlay, lParam);
8979     }
8980
8981     int AddItem(LPCTSTR lpszItem, int nImage, int nSelImage, int iIndent, LPARAM lParam = 0)
8982     {
8983         return InsertItem(-1, lpszItem, nImage, nSelImage, iIndent, lParam);
8984     }
8985
8986     int DeleteItem(int nIndex)
8987     {
8988         ATLASSERT(::IsWindow(m_hWnd));
8989         return (int)::SendMessage(m_hWnd, CBEM_DELETEITEM, nIndex, 0L);
8990     }
8991
8992     BOOL GetItem(PCOMBOBOXEXITEM pCBItem) const
8993     {
8994         ATLASSERT(::IsWindow(m_hWnd));
8995         return (BOOL)::SendMessage(m_hWnd, CBEM_GETITEM, 0, (LPARAM)pCBItem);
8996     }
8997
8998     BOOL SetItem(const COMBOBOXEXITEM* lpcCBItem)
8999     {
9000         ATLASSERT(::IsWindow(m_hWnd));
9001         return (BOOL)::SendMessage(m_hWnd, CBEM_SETITEM, 0, (LPARAM)lpcCBItem);
9002     }
9003
9004     int SetItem(int nIndex, UINT nMask, LPCTSTR lpszItem, int nImage, int nSelImage,
9005                 int iIndent, int iOverlay, LPARAM lParam)
9006     {
9007         ATLASSERT(::IsWindow(m_hWnd));
9008         COMBOBOXEXITEM cbex = { 0 };
9009         cbex.mask = nMask;
9010         cbex.iItem = nIndex;
9011         cbex.pszText = (LPTSTR) lpszItem;
9012         cbex.iImage = nImage;
9013         cbex.iSelectedImage = nSelImage;
9014         cbex.iIndent = iIndent;
9015         cbex.iOverlay = iOverlay;
9016         cbex.lParam = lParam;
9017         return (int)::SendMessage(m_hWnd, CBEM_SETITEM, 0, (LPARAM)&cbex);
9018     }
9019
9020     BOOL GetItemText(int nIndex, LPTSTR lpszItem, int nLen) const
9021     {
9022         ATLASSERT(::IsWindow(m_hWnd));
9023         ATLASSERT(lpszItem != NULL);
9024
9025         COMBOBOXEXITEM cbex = { 0 };
9026         cbex.mask = CBEIF_TEXT;
9027         cbex.iItem = nIndex;
9028         cbex.pszText = lpszItem;
9029         cbex.cchTextMax = nLen;
9030
9031         return (BOOL)::SendMessage(m_hWnd, CBEM_GETITEM, 0, (LPARAM)&cbex);
9032     }
9033
9034 #ifndef _ATL_NO_COM
9035     BOOL GetItemText(int nIndex, BSTR& bstrText) const
9036     {
9037         USES_CONVERSION;
9038         ATLASSERT(::IsWindow(m_hWnd));
9039         ATLASSERT(bstrText == NULL);
9040
9041         COMBOBOXEXITEM cbex = { 0 };
9042         cbex.mask = CBEIF_TEXT;
9043         cbex.iItem = nIndex;
9044
9045         LPTSTR lpstrText = NULL;
9046         BOOL bRet = FALSE;
9047         for(int nLen = 256; ; nLen *= 2)
9048         {
9049             ATLTRY(lpstrText = new TCHAR[nLen]);
9050             if(lpstrText == NULL)
9051                 break;
9052             lpstrText[0] = NULL;
9053             cbex.pszText = lpstrText;
9054             cbex.cchTextMax = nLen;
9055             bRet = (BOOL)::SendMessage(m_hWnd, CBEM_GETITEM, 0, (LPARAM)&cbex);
9056             if(!bRet || (lstrlen(cbex.pszText) < nLen - 1))
9057                 break;
9058             delete [] lpstrText;
9059             lpstrText = NULL;
9060         }
9061
9062         if(lpstrText != NULL)
9063         {
9064             if(bRet)
9065                 bstrText = ::SysAllocString(T2OLE(lpstrText));
9066             delete [] lpstrText;
9067         }
9068
9069         return (bstrText != NULL) ? TRUE : FALSE;
9070     }
9071 #endif // !_ATL_NO_COM
9072
9073 #if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
9074     BOOL GetItemText(int nIndex, _CSTRING_NS::CString& strText) const
9075     {
9076         ATLASSERT(::IsWindow(m_hWnd));
9077
9078         COMBOBOXEXITEM cbex = { 0 };
9079         cbex.mask = CBEIF_TEXT;
9080         cbex.iItem = nIndex;
9081
9082         strText.Empty();
9083         BOOL bRet = FALSE;
9084         for(int nLen = 256; ; nLen *= 2)
9085         {
9086             cbex.pszText = strText.GetBufferSetLength(nLen);
9087             if(cbex.pszText == NULL)
9088             {
9089                 bRet = FALSE;
9090                 break;
9091             }
9092             cbex.cchTextMax = nLen;
9093             bRet = (BOOL)::SendMessage(m_hWnd, CBEM_GETITEM, 0, (LPARAM)&cbex);
9094             if(!bRet || (lstrlen(cbex.pszText) < nLen - 1))
9095                 break;
9096         }
9097         strText.ReleaseBuffer();
9098         return bRet;
9099     }
9100 #endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
9101
9102     BOOL SetItemText(int nIndex, LPCTSTR lpszItem)
9103     {
9104         ATLASSERT(::IsWindow(m_hWnd));
9105         return SetItem(nIndex, CBEIF_TEXT, lpszItem, 0, 0, 0, 0, 0);
9106     }
9107
9108     CComboBox GetComboCtrl() const
9109     {
9110         ATLASSERT(::IsWindow(m_hWnd));
9111         return CComboBox((HWND)::SendMessage(m_hWnd, CBEM_GETCOMBOCONTROL, 0, 0L));
9112     }
9113
9114     CEdit GetEditCtrl() const
9115     {
9116         ATLASSERT(::IsWindow(m_hWnd));
9117         return CEdit((HWND)::SendMessage(m_hWnd, CBEM_GETEDITCONTROL, 0, 0L));
9118     }
9119
9120     BOOL HasEditChanged() const
9121     {
9122         ATLASSERT(::IsWindow(m_hWnd));
9123         return (BOOL)::SendMessage(m_hWnd, CBEM_HASEDITCHANGED, 0, 0L);
9124     }
9125
9126 // Non-functional
9127     int AddString(LPCTSTR /*lpszItem*/)
9128     {
9129         ATLASSERT(FALSE);  // Not available in CComboBoxEx; use InsertItem
9130         return 0;
9131     }
9132
9133     int InsertString(int /*nIndex*/, LPCTSTR /*lpszString*/)
9134     {
9135         ATLASSERT(FALSE);  // Not available in CComboBoxEx; use InsertItem
9136         return 0;
9137     }
9138
9139     int Dir(UINT /*attr*/, LPCTSTR /*lpszWildCard*/)
9140     {
9141         ATLASSERT(FALSE);  // Not available in CComboBoxEx
9142         return 0;
9143     }
9144
9145     int FindString(int /*nStartAfter*/, LPCTSTR /*lpszString*/) const
9146     {
9147         ATLASSERT(FALSE);  // Not available in CComboBoxEx; try FindStringExact
9148         return 0;
9149     }
9150 };
9151
9152 typedef CComboBoxExT<ATL::CWindow>   CComboBoxEx;
9153
9154 #endif // !_WIN32_WCE
9155
9156
9157 ///////////////////////////////////////////////////////////////////////////////
9158 // CMonthCalendarCtrl
9159
9160 template <class TBase>
9161 class CMonthCalendarCtrlT : public TBase
9162 {
9163 public:
9164 // Constructors
9165     CMonthCalendarCtrlT(HWND hWnd = NULL) : TBase(hWnd)
9166     { }
9167
9168     CMonthCalendarCtrlT< TBase >& operator =(HWND hWnd)
9169     {
9170         m_hWnd = hWnd;
9171         return *this;
9172     }
9173
9174     HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
9175             DWORD dwStyle = 0, DWORD dwExStyle = 0,
9176             ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
9177     {
9178         return TBase::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);
9179     }
9180
9181 // Attributes
9182     static LPCTSTR GetWndClassName()
9183     {
9184         return MONTHCAL_CLASS;
9185     }
9186
9187     COLORREF GetColor(int nColorType) const
9188     {
9189         ATLASSERT(::IsWindow(m_hWnd));
9190         return (COLORREF)::SendMessage(m_hWnd, MCM_GETCOLOR, nColorType, 0L);
9191     }
9192
9193     COLORREF SetColor(int nColorType, COLORREF clr)
9194     {
9195         ATLASSERT(::IsWindow(m_hWnd));
9196         return (COLORREF)::SendMessage(m_hWnd, MCM_SETCOLOR, nColorType, clr);
9197     }
9198
9199     BOOL GetCurSel(LPSYSTEMTIME lpSysTime) const
9200     {
9201         ATLASSERT(::IsWindow(m_hWnd));
9202         return (BOOL)::SendMessage(m_hWnd, MCM_GETCURSEL, 0, (LPARAM)lpSysTime);
9203     }
9204
9205     BOOL SetCurSel(LPSYSTEMTIME lpSysTime)
9206     {
9207         ATLASSERT(::IsWindow(m_hWnd));
9208         return (BOOL)::SendMessage(m_hWnd, MCM_SETCURSEL, 0, (LPARAM)lpSysTime);
9209     }
9210
9211     int GetFirstDayOfWeek(BOOL* pbLocaleVal = NULL) const
9212     {
9213         ATLASSERT(::IsWindow(m_hWnd));
9214         DWORD dwRet = (DWORD)::SendMessage(m_hWnd, MCM_GETFIRSTDAYOFWEEK, 0, 0L);
9215         if(pbLocaleVal != NULL)
9216             *pbLocaleVal = (BOOL)HIWORD(dwRet);
9217         return (int)(short)LOWORD(dwRet);
9218     }
9219
9220     int SetFirstDayOfWeek(int nDay, BOOL* pbLocaleVal = NULL)
9221     {
9222         ATLASSERT(::IsWindow(m_hWnd));
9223         DWORD dwRet = (DWORD)::SendMessage(m_hWnd, MCM_SETFIRSTDAYOFWEEK, 0, nDay);
9224         if(pbLocaleVal != NULL)
9225             *pbLocaleVal = (BOOL)HIWORD(dwRet);
9226         return (int)(short)LOWORD(dwRet);
9227     }
9228
9229     int GetMaxSelCount() const
9230     {
9231         ATLASSERT(::IsWindow(m_hWnd));
9232         return (int)::SendMessage(m_hWnd, MCM_GETMAXSELCOUNT, 0, 0L);
9233     }
9234
9235     BOOL SetMaxSelCount(int nMax)
9236     {
9237         ATLASSERT(::IsWindow(m_hWnd));
9238         return (BOOL)::SendMessage(m_hWnd, MCM_SETMAXSELCOUNT, nMax, 0L);
9239     }
9240
9241     int GetMonthDelta() const
9242     {
9243         ATLASSERT(::IsWindow(m_hWnd));
9244         return (int)::SendMessage(m_hWnd, MCM_GETMONTHDELTA, 0, 0L);
9245     }
9246
9247     int SetMonthDelta(int nDelta)
9248     {
9249         ATLASSERT(::IsWindow(m_hWnd));
9250         return (int)::SendMessage(m_hWnd, MCM_SETMONTHDELTA, nDelta, 0L);
9251     }
9252
9253     DWORD GetRange(LPSYSTEMTIME lprgSysTimeArray) const
9254     {
9255         ATLASSERT(::IsWindow(m_hWnd));
9256         return (DWORD)::SendMessage(m_hWnd, MCM_GETRANGE, 0, (LPARAM)lprgSysTimeArray);
9257     }
9258
9259     BOOL SetRange(DWORD dwFlags, LPSYSTEMTIME lprgSysTimeArray)
9260     {
9261         ATLASSERT(::IsWindow(m_hWnd));
9262         return (BOOL)::SendMessage(m_hWnd, MCM_SETRANGE, dwFlags, (LPARAM)lprgSysTimeArray);
9263     }
9264
9265     BOOL GetSelRange(LPSYSTEMTIME lprgSysTimeArray) const
9266     {
9267         ATLASSERT(::IsWindow(m_hWnd));
9268         return (BOOL)::SendMessage(m_hWnd, MCM_GETSELRANGE, 0, (LPARAM)lprgSysTimeArray);
9269     }
9270
9271     BOOL SetSelRange(LPSYSTEMTIME lprgSysTimeArray)
9272     {
9273         ATLASSERT(::IsWindow(m_hWnd));
9274         return (BOOL)::SendMessage(m_hWnd, MCM_SETSELRANGE, 0, (LPARAM)lprgSysTimeArray);
9275     }
9276
9277     BOOL GetToday(LPSYSTEMTIME lpSysTime) const
9278     {
9279         ATLASSERT(::IsWindow(m_hWnd));
9280         return (BOOL)::SendMessage(m_hWnd, MCM_GETTODAY, 0, (LPARAM)lpSysTime);
9281     }
9282
9283     void SetToday(LPSYSTEMTIME lpSysTime)
9284     {
9285         ATLASSERT(::IsWindow(m_hWnd));
9286         ::SendMessage(m_hWnd, MCM_SETTODAY, 0, (LPARAM)lpSysTime);
9287     }
9288
9289     BOOL GetMinReqRect(LPRECT lpRectInfo) const
9290     {
9291         ATLASSERT(::IsWindow(m_hWnd));
9292         return (BOOL)::SendMessage(m_hWnd, MCM_GETMINREQRECT, 0, (LPARAM)lpRectInfo);
9293     }
9294
9295     int GetMaxTodayWidth() const
9296     {
9297         ATLASSERT(::IsWindow(m_hWnd));
9298         return (int)::SendMessage(m_hWnd, MCM_GETMAXTODAYWIDTH, 0, 0L);
9299     }
9300
9301 #if (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
9302     BOOL GetUnicodeFormat() const
9303     {
9304         ATLASSERT(::IsWindow(m_hWnd));
9305         return (BOOL)::SendMessage(m_hWnd, MCM_GETUNICODEFORMAT, 0, 0L);
9306     }
9307
9308     BOOL SetUnicodeFormat(BOOL bUnicode = TRUE)
9309     {
9310         ATLASSERT(::IsWindow(m_hWnd));
9311         return (BOOL)::SendMessage(m_hWnd, MCM_SETUNICODEFORMAT, bUnicode, 0L);
9312     }
9313 #endif // (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
9314
9315 #if defined(NTDDI_VERSION) && (NTDDI_VERSION >= NTDDI_LONGHORN)
9316     DWORD GetCurrentView() const
9317     {
9318         ATLASSERT(::IsWindow(m_hWnd));
9319         return (DWORD)::SendMessage(m_hWnd, MCM_GETCURRENTVIEW, 0, 0L);
9320     }
9321
9322     BOOL SetCurrentView(DWORD dwView)
9323     {
9324         ATLASSERT(::IsWindow(m_hWnd));
9325         return (BOOL)::SendMessage(m_hWnd, MCM_SETCURRENTVIEW, 0, dwView);
9326     }
9327
9328     DWORD GetCalendarCount() const
9329     {
9330         ATLASSERT(::IsWindow(m_hWnd));
9331         return (DWORD)::SendMessage(m_hWnd, MCM_GETCALENDARCOUNT, 0, 0L);
9332     }
9333
9334     BOOL GetCalendarGridInfo(PMCGRIDINFO pGridInfo) const
9335     {
9336         ATLASSERT(::IsWindow(m_hWnd));
9337         return (BOOL)::SendMessage(m_hWnd, MCM_GETCALENDARGRIDINFO, 0, (LPARAM)pGridInfo);
9338     }
9339
9340     CALID GetCALID() const
9341     {
9342         ATLASSERT(::IsWindow(m_hWnd));
9343         return (CALID)::SendMessage(m_hWnd, MCM_GETCALID, 0, 0L);
9344     }
9345
9346     void SetCALID(CALID calid)
9347     {
9348         ATLASSERT(::IsWindow(m_hWnd));
9349         ::SendMessage(m_hWnd, MCM_SETCALID, (LPARAM)calid, 0L);
9350     }
9351
9352     int GetCalendarBorder() const
9353     {
9354         ATLASSERT(::IsWindow(m_hWnd));
9355         return (int)::SendMessage(m_hWnd, MCM_GETCALENDARBORDER, 0, 0L);
9356     }
9357
9358     void SetCalendarBorder(int cxyBorder, BOOL bSet = TRUE)
9359     {
9360         ATLASSERT(::IsWindow(m_hWnd));
9361         ::SendMessage(m_hWnd, MCM_SETCALENDARBORDER, (WPARAM)bSet, (LPARAM)cxyBorder);
9362     }
9363 #endif // defined(NTDDI_VERSION) && (NTDDI_VERSION >= NTDDI_LONGHORN)
9364
9365 // Operations
9366     int GetMonthRange(DWORD dwFlags, LPSYSTEMTIME lprgSysTimeArray) const
9367     {
9368         ATLASSERT(::IsWindow(m_hWnd));
9369         return (int)::SendMessage(m_hWnd, MCM_GETMONTHRANGE, dwFlags, (LPARAM)lprgSysTimeArray);
9370     }
9371
9372     BOOL SetDayState(int nMonths, LPMONTHDAYSTATE lpDayStateArray)
9373     {
9374         ATLASSERT(::IsWindow(m_hWnd));
9375         return (BOOL)::SendMessage(m_hWnd, MCM_SETDAYSTATE, nMonths, (LPARAM)lpDayStateArray);
9376     }
9377
9378     DWORD HitTest(PMCHITTESTINFO pMCHitTest) const
9379     {
9380         ATLASSERT(::IsWindow(m_hWnd));
9381         return (DWORD)::SendMessage(m_hWnd, MCM_HITTEST, 0, (LPARAM)pMCHitTest);
9382     }
9383
9384 #if defined(NTDDI_VERSION) && (NTDDI_VERSION >= NTDDI_LONGHORN)
9385     void SizeRectToMin(LPRECT lpRect)
9386     {
9387         ATLASSERT(::IsWindow(m_hWnd));
9388         ::SendMessage(m_hWnd, MCM_SIZERECTTOMIN, 0, (LPARAM)lpRect);
9389     }
9390 #endif // defined(NTDDI_VERSION) && (NTDDI_VERSION >= NTDDI_LONGHORN)
9391 };
9392
9393 typedef CMonthCalendarCtrlT<ATL::CWindow>   CMonthCalendarCtrl;
9394
9395
9396 ///////////////////////////////////////////////////////////////////////////////
9397 // CDateTimePickerCtrl
9398
9399 template <class TBase>
9400 class CDateTimePickerCtrlT : public TBase
9401 {
9402 public:
9403 // Constructors
9404     CDateTimePickerCtrlT(HWND hWnd = NULL) : TBase(hWnd)
9405     { }
9406
9407     CDateTimePickerCtrlT< TBase >& operator =(HWND hWnd)
9408     {
9409         m_hWnd = hWnd;
9410         return *this;
9411     }
9412
9413     HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
9414             DWORD dwStyle = 0, DWORD dwExStyle = 0,
9415             ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
9416     {
9417         return TBase::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);
9418     }
9419
9420 // Operations
9421     static LPCTSTR GetWndClassName()
9422     {
9423         return DATETIMEPICK_CLASS;
9424     }
9425
9426     BOOL SetFormat(LPCTSTR lpszFormat)
9427     {
9428         ATLASSERT(::IsWindow(m_hWnd));
9429         return (BOOL)::SendMessage(m_hWnd, DTM_SETFORMAT, 0, (LPARAM)lpszFormat);
9430     }
9431
9432     COLORREF GetMonthCalColor(int nColorType) const
9433     {
9434         ATLASSERT(::IsWindow(m_hWnd));
9435         return (COLORREF)::SendMessage(m_hWnd, DTM_GETMCCOLOR, nColorType, 0L);
9436     }
9437
9438     COLORREF SetMonthCalColor(int nColorType, COLORREF clr)
9439     {
9440         ATLASSERT(::IsWindow(m_hWnd));
9441         return (COLORREF)::SendMessage(m_hWnd, DTM_SETMCCOLOR, nColorType, clr);
9442     }
9443
9444     DWORD GetRange(LPSYSTEMTIME lpSysTimeArray) const
9445     {
9446         ATLASSERT(::IsWindow(m_hWnd));
9447         return (DWORD)::SendMessage(m_hWnd, DTM_GETRANGE, 0, (LPARAM)lpSysTimeArray);
9448     }
9449
9450     BOOL SetRange(DWORD dwFlags, LPSYSTEMTIME lpSysTimeArray)
9451     {
9452         ATLASSERT(::IsWindow(m_hWnd));
9453         return (BOOL)::SendMessage(m_hWnd, DTM_SETRANGE, dwFlags, (LPARAM)lpSysTimeArray);
9454     }
9455
9456     DWORD GetSystemTime(LPSYSTEMTIME lpSysTime) const
9457     {
9458         ATLASSERT(::IsWindow(m_hWnd));
9459         return (DWORD)::SendMessage(m_hWnd, DTM_GETSYSTEMTIME, 0, (LPARAM)lpSysTime);
9460     }
9461
9462     BOOL SetSystemTime(DWORD dwFlags, LPSYSTEMTIME lpSysTime)
9463     {
9464         ATLASSERT(::IsWindow(m_hWnd));
9465         return (BOOL)::SendMessage(m_hWnd, DTM_SETSYSTEMTIME, dwFlags, (LPARAM)lpSysTime);
9466     }
9467
9468     CMonthCalendarCtrl GetMonthCal() const
9469     {
9470         ATLASSERT(::IsWindow(m_hWnd));
9471         return CMonthCalendarCtrl((HWND)::SendMessage(m_hWnd, DTM_GETMONTHCAL, 0, 0L));
9472     }
9473
9474 #if (_WIN32_IE >= 0x0400)
9475     CFontHandle GetMonthCalFont() const
9476     {
9477         ATLASSERT(::IsWindow(m_hWnd));
9478         return CFontHandle((HFONT)::SendMessage(m_hWnd, DTM_GETMCFONT, 0, 0L));
9479     }
9480
9481     void SetMonthCalFont(HFONT hFont, BOOL bRedraw = TRUE)
9482     {
9483         ATLASSERT(::IsWindow(m_hWnd));
9484         ::SendMessage(m_hWnd, DTM_SETMCFONT, (WPARAM)hFont, MAKELPARAM(bRedraw, 0));
9485     }
9486 #endif // (_WIN32_IE >= 0x0400)
9487
9488 #if defined(NTDDI_VERSION) && (NTDDI_VERSION >= NTDDI_LONGHORN)
9489     DWORD GetMonthCalStyle() const
9490     {
9491         ATLASSERT(::IsWindow(m_hWnd));
9492         return (DWORD)::SendMessage(m_hWnd, DTM_GETMCSTYLE, 0, 0L);
9493     }
9494
9495     DWORD SetMonthCalStyle(DWORD dwStyle)
9496     {
9497         ATLASSERT(::IsWindow(m_hWnd));
9498         return (DWORD)::SendMessage(m_hWnd, DTM_SETMCSTYLE, 0, (LPARAM)dwStyle);
9499     }
9500
9501     void GetDateTimePickerInfo(LPDATETIMEPICKERINFO lpPickerInfo) const
9502     {
9503         ATLASSERT(::IsWindow(m_hWnd));
9504         ::SendMessage(m_hWnd, DTM_GETDATETIMEPICKERINFO, 0, (LPARAM)lpPickerInfo);
9505     }
9506
9507     BOOL GetIdealSize(LPSIZE lpSize) const
9508     {
9509         ATLASSERT(::IsWindow(m_hWnd));
9510         return (BOOL)::SendMessage(m_hWnd, DTM_GETIDEALSIZE, 0, (LPARAM)lpSize);
9511     }
9512
9513     void CloseMonthCal()
9514     {
9515         ATLASSERT(::IsWindow(m_hWnd));
9516         ::SendMessage(m_hWnd, DTM_CLOSEMONTHCAL, 0, 0L);
9517     }
9518 #endif // defined(NTDDI_VERSION) && (NTDDI_VERSION >= NTDDI_LONGHORN)
9519 };
9520
9521 typedef CDateTimePickerCtrlT<ATL::CWindow>   CDateTimePickerCtrl;
9522
9523
9524 ///////////////////////////////////////////////////////////////////////////////
9525 // CFlatScrollBarImpl - support for flat scroll bars
9526
9527 #if (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
9528
9529 template <class T>
9530 class CFlatScrollBarImpl
9531 {
9532 public:
9533 // Initialization
9534     BOOL FlatSB_Initialize()
9535     {
9536         T* pT = static_cast<T*>(this);
9537         ATLASSERT(::IsWindow(pT->m_hWnd));
9538         return ::InitializeFlatSB(pT->m_hWnd);
9539     }
9540
9541     HRESULT FlatSB_Uninitialize()
9542     {
9543         T* pT = static_cast<T*>(this);
9544         ATLASSERT(::IsWindow(pT->m_hWnd));
9545         return ::UninitializeFlatSB(pT->m_hWnd);
9546     }
9547
9548 // Flat scroll bar properties
9549     BOOL FlatSB_GetScrollProp(UINT uIndex, LPINT lpnValue) const
9550     {
9551         const T* pT = static_cast<const T*>(this);
9552         ATLASSERT(::IsWindow(pT->m_hWnd));
9553         return ::FlatSB_GetScrollProp(pT->m_hWnd, uIndex, lpnValue);
9554     }
9555
9556     BOOL FlatSB_SetScrollProp(UINT uIndex, int nValue, BOOL bRedraw = TRUE)
9557     {
9558         T* pT = static_cast<T*>(this);
9559         ATLASSERT(::IsWindow(pT->m_hWnd));
9560         return ::FlatSB_SetScrollProp(pT->m_hWnd, uIndex, nValue, bRedraw);
9561     }
9562
9563 // Attributes
9564     int FlatSB_GetScrollPos(int nBar) const
9565     {
9566         const T* pT = static_cast<const T*>(this);
9567         ATLASSERT(::IsWindow(pT->m_hWnd));
9568         return ::FlatSB_GetScrollPos(pT->m_hWnd, nBar);
9569     }
9570
9571     int FlatSB_SetScrollPos(int nBar, int nPos, BOOL bRedraw = TRUE)
9572     {
9573         T* pT = static_cast<T*>(this);
9574         ATLASSERT(::IsWindow(pT->m_hWnd));
9575         return ::FlatSB_SetScrollPos(pT->m_hWnd, nBar, nPos, bRedraw);
9576     }
9577
9578     BOOL FlatSB_GetScrollRange(int nBar, LPINT lpMinPos, LPINT lpMaxPos) const
9579     {
9580         const T* pT = static_cast<const T*>(this);
9581         ATLASSERT(::IsWindow(pT->m_hWnd));
9582         return ::FlatSB_GetScrollRange(pT->m_hWnd, nBar, lpMinPos, lpMaxPos);
9583     }
9584
9585     BOOL FlatSB_SetScrollRange(int nBar, int nMinPos, int nMaxPos, BOOL bRedraw = TRUE)
9586     {
9587         T* pT = static_cast<T*>(this);
9588         ATLASSERT(::IsWindow(pT->m_hWnd));
9589         return ::FlatSB_SetScrollRange(pT->m_hWnd, nBar, nMinPos, nMaxPos, bRedraw);
9590     }
9591
9592     BOOL FlatSB_GetScrollInfo(int nBar, LPSCROLLINFO lpScrollInfo) const
9593     {
9594         const T* pT = static_cast<const T*>(this);
9595         ATLASSERT(::IsWindow(pT->m_hWnd));
9596         return ::FlatSB_GetScrollInfo(pT->m_hWnd, nBar, lpScrollInfo);
9597     }
9598
9599     int FlatSB_SetScrollInfo(int nBar, LPSCROLLINFO lpScrollInfo, BOOL bRedraw = TRUE)
9600     {
9601         T* pT = static_cast<T*>(this);
9602         ATLASSERT(::IsWindow(pT->m_hWnd));
9603         return ::FlatSB_SetScrollInfo(pT->m_hWnd, nBar, lpScrollInfo, bRedraw);
9604     }
9605
9606 // Operations
9607     BOOL FlatSB_ShowScrollBar(UINT nBar, BOOL bShow = TRUE)
9608     {
9609         T* pT = static_cast<T*>(this);
9610         ATLASSERT(::IsWindow(pT->m_hWnd));
9611         return ::FlatSB_ShowScrollBar(pT->m_hWnd, nBar, bShow);
9612     }
9613
9614     BOOL FlatSB_EnableScrollBar(UINT uSBFlags, UINT uArrowFlags = ESB_ENABLE_BOTH)
9615     {
9616         T* pT = static_cast<T*>(this);
9617         ATLASSERT(::IsWindow(pT->m_hWnd));
9618         return ::FlatSB_EnableScrollBar(pT->m_hWnd, uSBFlags, uArrowFlags);
9619     }
9620 };
9621
9622 template <class TBase>
9623 class CFlatScrollBarT : public TBase, public CFlatScrollBarImpl<CFlatScrollBarT< TBase > >
9624 {
9625 public:
9626     CFlatScrollBarT(HWND hWnd = NULL) : TBase(hWnd)
9627     { }
9628
9629     CFlatScrollBarT< TBase >& operator =(HWND hWnd)
9630     {
9631         m_hWnd = hWnd;
9632         return *this;
9633     }
9634 };
9635
9636 typedef CFlatScrollBarT<ATL::CWindow>   CFlatScrollBar;
9637
9638 #endif // (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
9639
9640
9641 ///////////////////////////////////////////////////////////////////////////////
9642 // CIPAddressCtrl
9643
9644 #if (_WIN32_IE >= 0x0400)
9645
9646 template <class TBase>
9647 class CIPAddressCtrlT : public TBase
9648 {
9649 public:
9650 // Constructors
9651     CIPAddressCtrlT(HWND hWnd = NULL) : TBase(hWnd)
9652     { }
9653
9654     CIPAddressCtrlT< TBase >& operator =(HWND hWnd)
9655     {
9656         m_hWnd = hWnd;
9657         return *this;
9658     }
9659
9660     HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
9661             DWORD dwStyle = 0, DWORD dwExStyle = 0,
9662             ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
9663     {
9664         return TBase::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);
9665     }
9666
9667 // Atteributes
9668     static LPCTSTR GetWndClassName()
9669     {
9670         return WC_IPADDRESS;
9671     }
9672
9673     BOOL IsBlank() const
9674     {
9675         ATLASSERT(::IsWindow(m_hWnd));
9676         return (BOOL)::SendMessage(m_hWnd, IPM_ISBLANK, 0, 0L);
9677     }
9678
9679     int GetAddress(LPDWORD lpdwAddress) const
9680     {
9681         ATLASSERT(::IsWindow(m_hWnd));
9682         return (int)::SendMessage(m_hWnd, IPM_GETADDRESS, 0, (LPARAM)lpdwAddress);
9683     }
9684
9685     void SetAddress(DWORD dwAddress)
9686     {
9687         ATLASSERT(::IsWindow(m_hWnd));
9688         ::SendMessage(m_hWnd, IPM_SETADDRESS, 0, dwAddress);
9689     }
9690
9691     void ClearAddress()
9692     {
9693         ATLASSERT(::IsWindow(m_hWnd));
9694         ::SendMessage(m_hWnd, IPM_CLEARADDRESS, 0, 0L);
9695     }
9696
9697     void SetRange(int nField, WORD wRange)
9698     {
9699         ATLASSERT(::IsWindow(m_hWnd));
9700         ::SendMessage(m_hWnd, IPM_SETRANGE, nField, wRange);
9701     }
9702
9703     void SetRange(int nField, BYTE nMin, BYTE nMax)
9704     {
9705         ATLASSERT(::IsWindow(m_hWnd));
9706         ::SendMessage(m_hWnd, IPM_SETRANGE, nField, MAKEIPRANGE(nMin, nMax));
9707     }
9708
9709     void SetFocus(int nField)
9710     {
9711         ATLASSERT(::IsWindow(m_hWnd));
9712         ::SendMessage(m_hWnd, IPM_SETFOCUS, nField, 0L);
9713     }
9714 };
9715
9716 typedef CIPAddressCtrlT<ATL::CWindow>   CIPAddressCtrl;
9717
9718 #endif // (_WIN32_IE >= 0x0400)
9719
9720
9721 ///////////////////////////////////////////////////////////////////////////////
9722 // CPagerCtrl
9723
9724 #if (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
9725
9726 template <class TBase>
9727 class CPagerCtrlT : public TBase
9728 {
9729 public:
9730 // Constructors
9731     CPagerCtrlT(HWND hWnd = NULL) : TBase(hWnd)
9732     { }
9733
9734     CPagerCtrlT< TBase >& operator =(HWND hWnd)
9735     {
9736         m_hWnd = hWnd;
9737         return *this;
9738     }
9739
9740     HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
9741             DWORD dwStyle = 0, DWORD dwExStyle = 0,
9742             ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
9743     {
9744         return TBase::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);
9745     }
9746
9747 // Attributes
9748     static LPCTSTR GetWndClassName()
9749     {
9750         return WC_PAGESCROLLER;
9751     }
9752
9753     int GetButtonSize() const
9754     {
9755         ATLASSERT(::IsWindow(m_hWnd));
9756         return (int)::SendMessage(m_hWnd, PGM_GETBUTTONSIZE, 0, 0L);
9757     }
9758
9759     int SetButtonSize(int nButtonSize)
9760     {
9761         ATLASSERT(::IsWindow(m_hWnd));
9762         return (int)::SendMessage(m_hWnd, PGM_SETBUTTONSIZE, 0, nButtonSize);
9763     }
9764
9765     DWORD GetButtonState(int nButton) const
9766     {
9767         ATLASSERT(::IsWindow(m_hWnd));
9768         ATLASSERT(nButton == PGB_TOPORLEFT || nButton == PGB_BOTTOMORRIGHT);
9769         return (DWORD)::SendMessage(m_hWnd, PGM_GETBUTTONSTATE, 0, nButton);
9770     }
9771
9772     COLORREF GetBkColor() const
9773     {
9774         ATLASSERT(::IsWindow(m_hWnd));
9775         return (COLORREF)::SendMessage(m_hWnd, PGM_GETBKCOLOR, 0, 0L);
9776     }
9777
9778     COLORREF SetBkColor(COLORREF clrBk)
9779     {
9780         ATLASSERT(::IsWindow(m_hWnd));
9781         return (COLORREF)::SendMessage(m_hWnd, PGM_SETBKCOLOR, 0, (LPARAM)clrBk);
9782     }
9783
9784     int GetBorder() const
9785     {
9786         ATLASSERT(::IsWindow(m_hWnd));
9787         return (int)::SendMessage(m_hWnd, PGM_GETBORDER, 0, 0L);
9788     }
9789
9790     int SetBorder(int nBorderSize)
9791     {
9792         ATLASSERT(::IsWindow(m_hWnd));
9793         return (int)::SendMessage(m_hWnd, PGM_SETBORDER, 0, nBorderSize);
9794     }
9795
9796     int GetPos() const
9797     {
9798         ATLASSERT(::IsWindow(m_hWnd));
9799         return (int)::SendMessage(m_hWnd, PGM_GETPOS, 0, 0L);
9800     }
9801
9802     int SetPos(int nPos)
9803     {
9804         ATLASSERT(::IsWindow(m_hWnd));
9805         return (int)::SendMessage(m_hWnd, PGM_SETPOS, 0, nPos);
9806     }
9807
9808 // Operations
9809     void SetChild(HWND hWndChild)
9810     {
9811         ATLASSERT(::IsWindow(m_hWnd));
9812         ::SendMessage(m_hWnd, PGM_SETCHILD, 0, (LPARAM)hWndChild);
9813     }
9814
9815     void ForwardMouse(BOOL bForward = TRUE)
9816     {
9817         ATLASSERT(::IsWindow(m_hWnd));
9818         ::SendMessage(m_hWnd, PGM_FORWARDMOUSE, bForward, 0L);
9819     }
9820
9821     void RecalcSize()
9822     {
9823         ATLASSERT(::IsWindow(m_hWnd));
9824         ::SendMessage(m_hWnd, PGM_RECALCSIZE, 0, 0L);
9825     }
9826
9827     void GetDropTarget(IDropTarget** ppDropTarget)
9828     {
9829         ATLASSERT(::IsWindow(m_hWnd));
9830         ATLASSERT(ppDropTarget != NULL);
9831         ::SendMessage(m_hWnd, PGM_GETDROPTARGET, 0, (LPARAM)ppDropTarget);
9832     }
9833 };
9834
9835 typedef CPagerCtrlT<ATL::CWindow>   CPagerCtrl;
9836
9837 #endif // (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
9838
9839
9840 ///////////////////////////////////////////////////////////////////////////////
9841 // CLinkCtrl - Windows SYSLINK control
9842
9843 #if (_WIN32_WINNT >= 0x0501) && !defined(_WIN32_WCE)
9844
9845 template <class TBase>
9846 class CLinkCtrlT : public TBase
9847 {
9848 public:
9849 // Constructors
9850     CLinkCtrlT(HWND hWnd = NULL) : TBase(hWnd)
9851     { }
9852
9853     CLinkCtrlT< TBase >& operator =(HWND hWnd)
9854     {
9855         m_hWnd = hWnd;
9856         return *this;
9857     }
9858
9859     HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
9860             DWORD dwStyle = 0, DWORD dwExStyle = 0,
9861             ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
9862     {
9863         return TBase::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);
9864     }
9865
9866 // Attributes
9867     static LPCTSTR GetWndClassName()
9868     {
9869 #ifdef _UNICODE
9870         return WC_LINK;
9871 #else // !_UNICODE
9872         return "SysLink";
9873 #endif // !_UNICODE
9874     }
9875
9876     int GetIdealHeight(int cxMaxWidth = 0) const
9877     {
9878         ATLASSERT(::IsWindow(m_hWnd));
9879         return (int)::SendMessage(m_hWnd, LM_GETIDEALHEIGHT, cxMaxWidth, 0L);
9880     }
9881
9882     BOOL GetItem(PLITEM pLItem) const
9883     {
9884         ATLASSERT(::IsWindow(m_hWnd));
9885         return (BOOL)::SendMessage(m_hWnd, LM_GETITEM, 0, (LPARAM)pLItem);
9886     }
9887
9888     BOOL SetItem(PLITEM pLItem)
9889     {
9890         ATLASSERT(::IsWindow(m_hWnd));
9891         return (BOOL)::SendMessage(m_hWnd, LM_SETITEM, 0, (LPARAM)pLItem);
9892     }
9893
9894     // Vista only
9895     int GetIdealSize(SIZE& size, int cxMaxWidth = 0) const
9896     {
9897 #ifndef LM_GETIDEALSIZE
9898         const UINT LM_GETIDEALSIZE = LM_GETIDEALHEIGHT;
9899 #endif
9900         ATLASSERT(::IsWindow(m_hWnd));
9901         return (int)::SendMessage(m_hWnd, LM_GETIDEALSIZE, cxMaxWidth, (LPARAM)&size);
9902     }
9903
9904 // Operations
9905     BOOL HitTest(PLHITTESTINFO pLHitTestInfo) const
9906     {
9907         ATLASSERT(::IsWindow(m_hWnd));
9908         return (BOOL)::SendMessage(m_hWnd, LM_HITTEST, 0, (LPARAM)pLHitTestInfo);
9909     }
9910 };
9911
9912 typedef CLinkCtrlT<ATL::CWindow>   CLinkCtrl;
9913
9914 #endif // (_WIN32_WINNT >= 0x0501) && !defined(_WIN32_WCE)
9915
9916
9917 ///////////////////////////////////////////////////////////////////////////////
9918 // CCustomDraw - MI class for custom-draw support
9919
9920 template <class T>
9921 class CCustomDraw
9922 {
9923 public:
9924 #if (_ATL_VER < 0x0700)
9925     BOOL m_bHandledCD;
9926
9927     BOOL IsMsgHandled() const
9928     {
9929         return m_bHandledCD;
9930     }
9931
9932     void SetMsgHandled(BOOL bHandled)
9933     {
9934         m_bHandledCD = bHandled;
9935     }
9936 #endif // !(_ATL_VER < 0x0700)
9937
9938 // Message map and handlers
9939     BEGIN_MSG_MAP(CCustomDraw< T >)
9940         NOTIFY_CODE_HANDLER(NM_CUSTOMDRAW, OnCustomDraw)
9941     ALT_MSG_MAP(1)
9942         REFLECTED_NOTIFY_CODE_HANDLER(NM_CUSTOMDRAW, OnCustomDraw)
9943     END_MSG_MAP()
9944
9945 // message handler
9946     LRESULT OnCustomDraw(int idCtrl, LPNMHDR pnmh, BOOL& bHandled)
9947     {
9948         T* pT = static_cast<T*>(this);
9949         pT->SetMsgHandled(TRUE);
9950         LPNMCUSTOMDRAW lpNMCustomDraw = (LPNMCUSTOMDRAW)pnmh;
9951         DWORD dwRet = 0;
9952         switch(lpNMCustomDraw->dwDrawStage)
9953         {
9954         case CDDS_PREPAINT:
9955             dwRet = pT->OnPrePaint(idCtrl, lpNMCustomDraw);
9956             break;
9957         case CDDS_POSTPAINT:
9958             dwRet = pT->OnPostPaint(idCtrl, lpNMCustomDraw);
9959             break;
9960         case CDDS_PREERASE:
9961             dwRet = pT->OnPreErase(idCtrl, lpNMCustomDraw);
9962             break;
9963         case CDDS_POSTERASE:
9964             dwRet = pT->OnPostErase(idCtrl, lpNMCustomDraw);
9965             break;
9966         case CDDS_ITEMPREPAINT:
9967             dwRet = pT->OnItemPrePaint(idCtrl, lpNMCustomDraw);
9968             break;
9969         case CDDS_ITEMPOSTPAINT:
9970             dwRet = pT->OnItemPostPaint(idCtrl, lpNMCustomDraw);
9971             break;
9972         case CDDS_ITEMPREERASE:
9973             dwRet = pT->OnItemPreErase(idCtrl, lpNMCustomDraw);
9974             break;
9975         case CDDS_ITEMPOSTERASE:
9976             dwRet = pT->OnItemPostErase(idCtrl, lpNMCustomDraw);
9977             break;
9978 #if (_WIN32_IE >= 0x0400)
9979         case (CDDS_ITEMPREPAINT | CDDS_SUBITEM):
9980             dwRet = pT->OnSubItemPrePaint(idCtrl, lpNMCustomDraw);
9981             break;
9982 #endif // (_WIN32_IE >= 0x0400)
9983         default:
9984             pT->SetMsgHandled(FALSE);
9985             break;
9986         }
9987         bHandled = pT->IsMsgHandled();
9988         return dwRet;
9989     }
9990
9991 // Overrideables
9992     DWORD OnPrePaint(int /*idCtrl*/, LPNMCUSTOMDRAW /*lpNMCustomDraw*/)
9993     {
9994         return CDRF_DODEFAULT;
9995     }
9996
9997     DWORD OnPostPaint(int /*idCtrl*/, LPNMCUSTOMDRAW /*lpNMCustomDraw*/)
9998     {
9999         return CDRF_DODEFAULT;
10000     }
10001
10002     DWORD OnPreErase(int /*idCtrl*/, LPNMCUSTOMDRAW /*lpNMCustomDraw*/)
10003     {
10004         return CDRF_DODEFAULT;
10005     }
10006
10007     DWORD OnPostErase(int /*idCtrl*/, LPNMCUSTOMDRAW /*lpNMCustomDraw*/)
10008     {
10009         return CDRF_DODEFAULT;
10010     }
10011
10012     DWORD OnItemPrePaint(int /*idCtrl*/, LPNMCUSTOMDRAW /*lpNMCustomDraw*/)
10013     {
10014         return CDRF_DODEFAULT;
10015     }
10016
10017     DWORD OnItemPostPaint(int /*idCtrl*/, LPNMCUSTOMDRAW /*lpNMCustomDraw*/)
10018     {
10019         return CDRF_DODEFAULT;
10020     }
10021
10022     DWORD OnItemPreErase(int /*idCtrl*/, LPNMCUSTOMDRAW /*lpNMCustomDraw*/)
10023     {
10024         return CDRF_DODEFAULT;
10025     }
10026
10027     DWORD OnItemPostErase(int /*idCtrl*/, LPNMCUSTOMDRAW /*lpNMCustomDraw*/)
10028     {
10029         return CDRF_DODEFAULT;
10030     }
10031
10032 #if (_WIN32_IE >= 0x0400)
10033     DWORD OnSubItemPrePaint(int /*idCtrl*/, LPNMCUSTOMDRAW /*lpNMCustomDraw*/)
10034     {
10035         return CDRF_DODEFAULT;
10036     }
10037 #endif // (_WIN32_IE >= 0x0400)
10038 };
10039
10040
10041 // --- Windows CE common controls ---
10042
10043 #ifdef _WIN32_WCE
10044
10045 ///////////////////////////////////////////////////////////////////////////////
10046 // CCECommandBarCtrl
10047
10048 template <class TBase>
10049 class CCECommandBarCtrlT : public TBase
10050 {
10051 public:
10052 // Constructors
10053     CCECommandBarCtrlT(HWND hWnd = NULL) : TBase(hWnd) { }
10054
10055     CCECommandBarCtrlT< TBase >& operator=(HWND hWnd)
10056     {
10057         m_hWnd = hWnd;
10058         return *this;
10059     }
10060
10061 // Attributes
10062     BOOL IsVisible() const
10063     {
10064         return IsWindowVisible();
10065     }
10066
10067     int GetHeight() const
10068     {
10069         ATLASSERT(::IsWindow(m_hWnd));
10070         return ::CommandBar_Height(m_hWnd);
10071     }
10072
10073     HMENU GetMenu(WORD wButton) const
10074     {
10075         ATLASSERT(::IsWindow(m_hWnd));
10076         return ::CommandBar_GetMenu(m_hWnd, wButton);
10077     }
10078
10079 // Operations
10080     HWND Create(HWND hWndParent, int nCmdBarID)
10081     {
10082         m_hWnd = ::CommandBar_Create(ModuleHelper::GetModuleInstance(), hWndParent, nCmdBarID);
10083         ATLASSERT(::IsWindow(m_hWnd));
10084         return m_hWnd;
10085     }
10086
10087     void Destroy()
10088     {
10089         DestroyWindow();
10090     }
10091
10092     BOOL Show(BOOL bShow = TRUE)
10093     {
10094         ATLASSERT(::IsWindow(m_hWnd));
10095         return ::CommandBar_Show(m_hWnd, bShow);
10096     }
10097
10098     BOOL DrawMenuBar(WORD wButton)
10099     {
10100         ATLASSERT(::IsWindow(m_hWnd));
10101         return ::CommandBar_DrawMenuBar(m_hWnd, wButton);
10102     }
10103
10104     BOOL AddAdornments(DWORD dwFlags = 0)
10105     {
10106         ATLASSERT(::IsWindow(m_hWnd));
10107         return ::CommandBar_AddAdornments(m_hWnd, dwFlags, 0);
10108     }
10109
10110     int AddBitmap(int nBitmapID, int nNumImages)
10111     {
10112         ATLASSERT(::IsWindow(m_hWnd));
10113         return ::CommandBar_AddBitmap(m_hWnd, ModuleHelper::GetResourceInstance(), nBitmapID, nNumImages, 16, 16);
10114     }
10115
10116     BOOL AddButtons(UINT uNumButtons, LPTBBUTTON lpButtons)
10117     {
10118         ATLASSERT(::IsWindow(m_hWnd));
10119         return CommandBar_AddButtons(m_hWnd, uNumButtons, lpButtons);
10120     }
10121
10122     BOOL AddToolTips(UINT uNumToolTips, LPTSTR lpToolTips)
10123     {
10124         ATLASSERT(::IsWindow(m_hWnd));
10125         return CommandBar_AddToolTips(m_hWnd, uNumToolTips, lpToolTips);
10126     }
10127
10128     BOOL InsertButton(int nButton, LPTBBUTTON lpButton)
10129     {
10130         ATLASSERT(::IsWindow(m_hWnd));
10131         return CommandBar_InsertButton(m_hWnd, nButton, lpButton);
10132     }
10133
10134     HWND InsertComboBox(int nWidth, UINT dwStyle, WORD wComboBoxID, WORD wButton)
10135     {
10136         ATLASSERT(::IsWindow(m_hWnd));
10137         return ::CommandBar_InsertComboBox(m_hWnd, ModuleHelper::GetModuleInstance(), nWidth, dwStyle, wComboBoxID, wButton);
10138     }
10139
10140     BOOL InsertMenubar(WORD wMenuID, WORD wButton)
10141     {
10142         ATLASSERT(::IsWindow(m_hWnd));
10143         return ::CommandBar_InsertMenubar(m_hWnd, ModuleHelper::GetResourceInstance(), wMenuID, wButton);
10144     }
10145
10146     BOOL InsertMenubarEx(ATL::_U_STRINGorID menu, WORD wButton)
10147     {
10148         ATLASSERT(::IsWindow(m_hWnd));
10149         return ::CommandBar_InsertMenubarEx(m_hWnd, ModuleHelper::GetResourceInstance(), (LPTSTR)menu.m_lpstr, wButton);
10150     }
10151
10152     BOOL IsCommandBarMessage(LPMSG lpMsg)
10153     {
10154         ATLASSERT(::IsWindow(m_hWnd));
10155         return ::IsCommandBarMessage(m_hWnd, lpMsg);
10156     }
10157 };
10158
10159 #if defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__) // PPC MenuBar
10160     typedef CCECommandBarCtrlT<CToolBarCtrl>    CMenuBarCtrl;
10161 #else
10162     typedef CCECommandBarCtrlT<CToolBarCtrl>    CCECommandBarCtrl;
10163 #endif // defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__)
10164
10165 ///////////////////////////////////////////////////////////////////////////////
10166 // CCECommandBandsCtrl
10167
10168 template <class TBase>
10169 class CCECommandBandsCtrlT : public TBase
10170 {
10171 public:
10172 // Constructors
10173     CCECommandBandsCtrlT(HWND hWnd = NULL) : TBase(hWnd) { }
10174
10175     CCECommandBandsCtrlT< TBase >& operator=(HWND hWnd)
10176     {
10177         m_hWnd = hWnd;
10178         return *this;
10179     }
10180
10181 // Attributes
10182     BOOL IsVisible() const
10183     {
10184         return IsWindowVisible();
10185     }
10186
10187 #if (_WIN32_IE >= 0x0400)
10188     UINT GetHeight() const
10189     {
10190         ATLASSERT(::IsWindow(m_hWnd));
10191         return CommandBands_Height(m_hWnd);
10192     }
10193 #endif // (_WIN32_IE >= 0x0400)
10194
10195     HWND GetCommandBar(UINT uBand) const
10196     {
10197         ATLASSERT(::IsWindow(m_hWnd));
10198         return ::CommandBands_GetCommandBar(m_hWnd, uBand);
10199     }
10200
10201     BOOL GetRestoreInformation(UINT uBand, LPCOMMANDBANDSRESTOREINFO pcbr) const
10202     {
10203         ATLASSERT(::IsWindow(m_hWnd));
10204         return ::CommandBands_GetRestoreInformation(m_hWnd, uBand, pcbr);
10205     }
10206
10207 // Operations
10208     HWND Create(HWND hWndParent, UINT wID, DWORD dwStyles, HIMAGELIST hImageList = NULL)
10209     {
10210         m_hWnd = ::CommandBands_Create(ModuleHelper::GetModuleInstance(), hWndParent, wID, dwStyles, hImageList);
10211         ATLASSERT(::IsWindow(m_hWnd));
10212         return m_hWnd;
10213     }
10214
10215     BOOL AddAdornments(DWORD dwFlags = 0, LPREBARBANDINFO prbbi = NULL)
10216     {
10217         ATLASSERT(::IsWindow(m_hWnd));
10218         return ::CommandBands_AddAdornments(m_hWnd, ModuleHelper::GetModuleInstance(), dwFlags, prbbi);
10219     }
10220
10221     BOOL AddBands(UINT uBandCount, LPREBARBANDINFO prbbi)
10222     {
10223         ATLASSERT(::IsWindow(m_hWnd));
10224         return ::CommandBands_AddBands(m_hWnd, ModuleHelper::GetModuleInstance(), uBandCount, prbbi);
10225     }
10226
10227     BOOL Show(BOOL bShow = TRUE)
10228     {
10229         ATLASSERT(::IsWindow(m_hWnd));
10230         return ::CommandBands_Show(m_hWnd, bShow);
10231     }
10232 };
10233
10234 typedef CCECommandBandsCtrlT<ATL::CWindow>  CCECommandBandsCtrl;
10235
10236 #endif // _WIN32_WCE
10237
10238 }; // namespace WTL
10239
10240 #endif // __ATLCTRLS_H__