git.sesse.net Git - casparcg/blob - WTL80/include/atluser.h

   1 // Windows Template Library - WTL version 8.0\r
   2 // Copyright (C) Microsoft Corporation. All rights reserved.\r
   3 //\r
   4 // This file is a part of the Windows Template Library.\r
   5 // The use and distribution terms for this software are covered by the\r
   6 // Common Public License 1.0 (http://opensource.org/osi3.0/licenses/cpl1.0.php)\r
   7 // which can be found in the file CPL.TXT at the root of this distribution.\r
   8 // By using this software in any fashion, you are agreeing to be bound by\r
   9 // the terms of this license. You must not remove this notice, or\r
  10 // any other, from this software.\r
  11 \r
  12 #ifndef __ATLUSER_H__\r
  13 #define __ATLUSER_H__\r
  14 \r
  15 #pragma once\r
  16 \r
  17 #ifndef __cplusplus\r
  18         #error ATL requires C++ compilation (use a .cpp suffix)\r
  19 #endif\r
  20 \r
  21 #ifndef __ATLAPP_H__\r
  22         #error atluser.h requires atlapp.h to be included first\r
  23 #endif\r
  24 \r
  25 \r
  26 ///////////////////////////////////////////////////////////////////////////////\r
  27 // Classes in this file:\r
  28 //\r
  29 // CMenuItemInfo\r
  30 // CMenuT<t_bManaged>\r
  31 // CAcceleratorT<t_bManaged>\r
  32 // CIconT<t_bManaged>\r
  33 // CCursorT<t_bManaged>\r
  34 // CResource\r
  35 //\r
  36 // Global functions:\r
  37 //   AtlMessageBox()\r
  38 \r
  39 \r
  40 namespace WTL\r
  41 {\r
  42 \r
  43 ///////////////////////////////////////////////////////////////////////////////\r
  44 // AtlMessageBox - accepts both memory and resource based strings\r
  45 \r
  46 inline int AtlMessageBox(HWND hWndOwner, ATL::_U_STRINGorID message, ATL::_U_STRINGorID title = (LPCTSTR)NULL, UINT uType = MB_OK | MB_ICONINFORMATION)\r
  47 {\r
  48         ATLASSERT(hWndOwner == NULL || ::IsWindow(hWndOwner));\r
  49 \r
  50         LPTSTR lpstrMessage = NULL;\r
  51         if(IS_INTRESOURCE(message.m_lpstr))\r
  52         {\r
  53                 for(int nLen = 256; ; nLen *= 2)\r
  54                 {\r
  55                         ATLTRY(lpstrMessage = new TCHAR[nLen]);\r
  56                         if(lpstrMessage == NULL)\r
  57                         {\r
  58                                 ATLASSERT(FALSE);\r
  59                                 return 0;\r
  60                         }\r
  61                         int nRes = ::LoadString(ModuleHelper::GetResourceInstance(), LOWORD(message.m_lpstr), lpstrMessage, nLen);\r
  62                         if(nRes < nLen - 1)\r
  63                                 break;\r
  64                         delete [] lpstrMessage;\r
  65                         lpstrMessage = NULL;\r
  66                 }\r
  67 \r
  68                 message.m_lpstr = lpstrMessage;\r
  69         }\r
  70 \r
  71         LPTSTR lpstrTitle = NULL;\r
  72         if(IS_INTRESOURCE(title.m_lpstr) && LOWORD(title.m_lpstr) != 0)\r
  73         {\r
  74                 for(int nLen = 256; ; nLen *= 2)\r
  75                 {\r
  76                         ATLTRY(lpstrTitle = new TCHAR[nLen]);\r
  77                         if(lpstrTitle == NULL)\r
  78                         {\r
  79                                 ATLASSERT(FALSE);\r
  80                                 return 0;\r
  81                         }\r
  82                         int nRes = ::LoadString(ModuleHelper::GetResourceInstance(), LOWORD(title.m_lpstr), lpstrTitle, nLen);\r
  83                         if(nRes < nLen - 1)\r
  84                                 break;\r
  85                         delete [] lpstrTitle;\r
  86                         lpstrTitle = NULL;\r
  87                 }\r
  88 \r
  89                 title.m_lpstr = lpstrTitle;\r
  90         }\r
  91 \r
  92         int nRet = ::MessageBox(hWndOwner, message.m_lpstr, title.m_lpstr, uType);\r
  93 \r
  94         delete [] lpstrMessage;\r
  95         delete [] lpstrTitle;\r
  96 \r
  97         return nRet;\r
  98 }\r
  99 \r
 100 \r
 101 ///////////////////////////////////////////////////////////////////////////////\r
 102 // CMenu\r
 103 \r
 104 #if (WINVER >= 0x0500)\r
 105   #ifndef MII_SIZEOF_STRUCT\r
 106     #define MII_SIZEOF_STRUCT(structname, member)  (((int)((LPBYTE)(&((structname*)0)->member) - ((LPBYTE)((structname*)0)))) + sizeof(((structname*)0)->member))\r
 107   #endif\r
 108   #define MENUITEMINFO_SIZE_VERSION_400A  MII_SIZEOF_STRUCT(MENUITEMINFOA, cch)\r
 109   #define MENUITEMINFO_SIZE_VERSION_400W  MII_SIZEOF_STRUCT(MENUITEMINFOW, cch)\r
 110   #ifdef UNICODE\r
 111     #define MENUITEMINFO_SIZE_VERSION_400  MENUITEMINFO_SIZE_VERSION_400W\r
 112   #else\r
 113     #define MENUITEMINFO_SIZE_VERSION_400  MENUITEMINFO_SIZE_VERSION_400A\r
 114   #endif // !UNICODE\r
 115 #endif // (WINVER >= 0x0500)\r
 116 \r
 117 class CMenuItemInfo : public MENUITEMINFO\r
 118 {\r
 119 public:\r
 120         CMenuItemInfo()\r
 121         {\r
 122                 memset(this, 0, sizeof(MENUITEMINFO));\r
 123                 cbSize = sizeof(MENUITEMINFO);\r
 124 #if (WINVER >= 0x0500)\r
 125                 // adjust struct size if running on older version of Windows\r
 126                 if(AtlIsOldWindows())\r
 127                 {\r
 128                         ATLASSERT(cbSize > MENUITEMINFO_SIZE_VERSION_400);   // must be\r
 129                         cbSize = MENUITEMINFO_SIZE_VERSION_400;\r
 130                 }\r
 131 #endif // (WINVER >= 0x0500)\r
 132         }\r
 133 };\r
 134 \r
 135 \r
 136 // forward declarations\r
 137 template <bool t_bManaged> class CMenuT;\r
 138 typedef CMenuT<false>   CMenuHandle;\r
 139 typedef CMenuT<true>    CMenu;\r
 140 \r
 141 \r
 142 template <bool t_bManaged>\r
 143 class CMenuT\r
 144 {\r
 145 public:\r
 146 // Data members\r
 147         HMENU m_hMenu;\r
 148 \r
 149 // Constructor/destructor/operators\r
 150         CMenuT(HMENU hMenu = NULL) : m_hMenu(hMenu)\r
 151         { }\r
 152 \r
 153         ~CMenuT()\r
 154         {\r
 155                 if(t_bManaged && m_hMenu != NULL)\r
 156                         DestroyMenu();\r
 157         }\r
 158 \r
 159         CMenuT<t_bManaged>& operator =(HMENU hMenu)\r
 160         {\r
 161                 Attach(hMenu);\r
 162                 return *this;\r
 163         }\r
 164 \r
 165         void Attach(HMENU hMenuNew)\r
 166         {\r
 167                 ATLASSERT(::IsMenu(hMenuNew));\r
 168                 if(t_bManaged && m_hMenu != NULL && m_hMenu != hMenuNew)\r
 169                         ::DestroyMenu(m_hMenu);\r
 170                 m_hMenu = hMenuNew;\r
 171         }\r
 172 \r
 173         HMENU Detach()\r
 174         {\r
 175                 HMENU hMenu = m_hMenu;\r
 176                 m_hMenu = NULL;\r
 177                 return hMenu;\r
 178         }\r
 179 \r
 180         operator HMENU() const { return m_hMenu; }\r
 181 \r
 182         bool IsNull() const { return (m_hMenu == NULL); }\r
 183 \r
 184         BOOL IsMenu() const\r
 185         {\r
 186                 return ::IsMenu(m_hMenu);\r
 187         }\r
 188 \r
 189 // Create/destroy methods\r
 190         BOOL CreateMenu()\r
 191         {\r
 192                 ATLASSERT(m_hMenu == NULL);\r
 193                 m_hMenu = ::CreateMenu();\r
 194                 return (m_hMenu != NULL) ? TRUE : FALSE;\r
 195         }\r
 196 \r
 197         BOOL CreatePopupMenu()\r
 198         {\r
 199                 ATLASSERT(m_hMenu == NULL);\r
 200                 m_hMenu = ::CreatePopupMenu();\r
 201                 return (m_hMenu != NULL) ? TRUE : FALSE;\r
 202         }\r
 203 \r
 204         BOOL LoadMenu(ATL::_U_STRINGorID menu)\r
 205         {\r
 206                 ATLASSERT(m_hMenu == NULL);\r
 207                 m_hMenu = ::LoadMenu(ModuleHelper::GetResourceInstance(), menu.m_lpstr);\r
 208                 return (m_hMenu != NULL) ? TRUE : FALSE;\r
 209         }\r
 210 \r
 211 #ifndef _WIN32_WCE\r
 212         BOOL LoadMenuIndirect(const void* lpMenuTemplate)\r
 213         {\r
 214                 ATLASSERT(m_hMenu == NULL);\r
 215                 m_hMenu = ::LoadMenuIndirect(lpMenuTemplate);\r
 216                 return (m_hMenu != NULL) ? TRUE : FALSE;\r
 217         }\r
 218 #endif // !_WIN32_WCE\r
 219 \r
 220         BOOL DestroyMenu()\r
 221         {\r
 222                 if (m_hMenu == NULL)\r
 223                         return FALSE;\r
 224                 BOOL bRet = ::DestroyMenu(m_hMenu);\r
 225                 if(bRet)\r
 226                         m_hMenu = NULL;\r
 227                 return bRet;\r
 228         }\r
 229 \r
 230 // Menu Operations\r
 231         BOOL DeleteMenu(UINT nPosition, UINT nFlags)\r
 232         {\r
 233                 ATLASSERT(::IsMenu(m_hMenu));\r
 234                 return ::DeleteMenu(m_hMenu, nPosition, nFlags);\r
 235         }\r
 236 \r
 237         BOOL TrackPopupMenu(UINT nFlags, int x, int y, HWND hWnd, LPCRECT lpRect = NULL)\r
 238         {\r
 239                 ATLASSERT(::IsMenu(m_hMenu));\r
 240 #ifndef _WIN32_WCE\r
 241 #if (WINVER >= 0x0500)\r
 242                 x = _FixTrackMenuPopupX(x, y);\r
 243 #endif // !(WINVER >= 0x0500)\r
 244                 return ::TrackPopupMenu(m_hMenu, nFlags, x, y, 0, hWnd, lpRect);\r
 245 #else // CE specific\r
 246                 lpRect;\r
 247                 return ::TrackPopupMenuEx(m_hMenu, nFlags, x, y, hWnd, NULL);\r
 248 #endif // _WIN32_WCE\r
 249         }\r
 250 \r
 251         BOOL TrackPopupMenuEx(UINT uFlags, int x, int y, HWND hWnd, LPTPMPARAMS lptpm = NULL)\r
 252         {\r
 253                 ATLASSERT(::IsMenu(m_hMenu));\r
 254 #if (WINVER >= 0x0500) && !defined(_WIN32_WCE)\r
 255                 x = _FixTrackMenuPopupX(x, y);\r
 256 #endif // (WINVER >= 0x0500) && !defined(_WIN32_WCE)\r
 257                 return ::TrackPopupMenuEx(m_hMenu, uFlags, x, y, hWnd, lptpm);\r
 258         }\r
 259 \r
 260 #if (WINVER >= 0x0500) && !defined(_WIN32_WCE)\r
 261         // helper that fixes popup menu X position when it's off-screen\r
 262         static int _FixTrackMenuPopupX(int x, int y)\r
 263         {\r
 264                 POINT pt = { x, y };\r
 265                 HMONITOR hMonitor = ::MonitorFromPoint(pt, MONITOR_DEFAULTTONULL);\r
 266                 if(hMonitor == NULL)\r
 267                 {\r
 268                         HMONITOR hMonitorNear = ::MonitorFromPoint(pt, MONITOR_DEFAULTTONEAREST);\r
 269                         if(hMonitorNear != NULL)\r
 270                         {\r
 271                                 MONITORINFO mi = { 0 };\r
 272                                 mi.cbSize = sizeof(MONITORINFO);\r
 273                                 if(::GetMonitorInfo(hMonitorNear, &mi) != FALSE)\r
 274                                 {\r
 275                                         if(x < mi.rcWork.left)\r
 276                                                 x = mi.rcWork.left;\r
 277                                         else if(x > mi.rcWork.right)\r
 278                                                 x = mi.rcWork.right;\r
 279                                 }\r
 280                         }\r
 281                 }\r
 282 \r
 283                 return x;\r
 284         }\r
 285 \r
 286         BOOL GetMenuInfo(LPMENUINFO lpMenuInfo) const\r
 287         {\r
 288                 ATLASSERT(::IsMenu(m_hMenu));\r
 289                 return ::GetMenuInfo(m_hMenu, lpMenuInfo);\r
 290         }\r
 291 \r
 292         BOOL SetMenuInfo(LPCMENUINFO lpMenuInfo)\r
 293         {\r
 294                 ATLASSERT(::IsMenu(m_hMenu));\r
 295                 return ::SetMenuInfo(m_hMenu, lpMenuInfo);\r
 296         }\r
 297 #endif // (WINVER >= 0x0500) && !defined(_WIN32_WCE)\r
 298 \r
 299 // Menu Item Operations\r
 300         BOOL AppendMenu(UINT nFlags, UINT_PTR nIDNewItem = 0, LPCTSTR lpszNewItem = NULL)\r
 301         {\r
 302                 ATLASSERT(::IsMenu(m_hMenu));\r
 303                 return ::AppendMenu(m_hMenu, nFlags, nIDNewItem, lpszNewItem);\r
 304         }\r
 305 \r
 306         BOOL AppendMenu(UINT nFlags, HMENU hSubMenu, LPCTSTR lpszNewItem)\r
 307         {\r
 308                 ATLASSERT(::IsMenu(m_hMenu));\r
 309                 ATLASSERT(::IsMenu(hSubMenu));\r
 310                 return ::AppendMenu(m_hMenu, nFlags | MF_POPUP, (UINT_PTR)hSubMenu, lpszNewItem);\r
 311         }\r
 312 \r
 313 #ifndef _WIN32_WCE\r
 314         BOOL AppendMenu(UINT nFlags, UINT_PTR nIDNewItem, HBITMAP hBmp)\r
 315         {\r
 316                 ATLASSERT(::IsMenu(m_hMenu));\r
 317                 return ::AppendMenu(m_hMenu, nFlags | MF_BITMAP, nIDNewItem, (LPCTSTR)hBmp);\r
 318         }\r
 319 \r
 320         BOOL AppendMenu(UINT nFlags, HMENU hSubMenu, HBITMAP hBmp)\r
 321         {\r
 322                 ATLASSERT(::IsMenu(m_hMenu));\r
 323                 ATLASSERT(::IsMenu(hSubMenu));\r
 324                 return ::AppendMenu(m_hMenu, nFlags | (MF_BITMAP | MF_POPUP), (UINT_PTR)hSubMenu, (LPCTSTR)hBmp);\r
 325         }\r
 326 #endif // !_WIN32_WCE\r
 327 \r
 328         UINT CheckMenuItem(UINT nIDCheckItem, UINT nCheck)\r
 329         {\r
 330                 ATLASSERT(::IsMenu(m_hMenu));\r
 331                 return (UINT)::CheckMenuItem(m_hMenu, nIDCheckItem, nCheck);\r
 332         }\r
 333 \r
 334         UINT EnableMenuItem(UINT nIDEnableItem, UINT nEnable)\r
 335         {\r
 336                 ATLASSERT(::IsMenu(m_hMenu));\r
 337                 return ::EnableMenuItem(m_hMenu, nIDEnableItem, nEnable);\r
 338         }\r
 339 \r
 340 #ifndef _WIN32_WCE\r
 341         BOOL HiliteMenuItem(HWND hWnd, UINT uIDHiliteItem, UINT uHilite)\r
 342         {\r
 343                 ATLASSERT(::IsMenu(m_hMenu));\r
 344                 return ::HiliteMenuItem(hWnd, m_hMenu, uIDHiliteItem, uHilite);\r
 345         }\r
 346 \r
 347         int GetMenuItemCount() const\r
 348         {\r
 349                 ATLASSERT(::IsMenu(m_hMenu));\r
 350                 return ::GetMenuItemCount(m_hMenu);\r
 351         }\r
 352 \r
 353         UINT GetMenuItemID(int nPos) const\r
 354         {\r
 355                 ATLASSERT(::IsMenu(m_hMenu));\r
 356                 return ::GetMenuItemID(m_hMenu, nPos);\r
 357         }\r
 358 \r
 359         UINT GetMenuState(UINT nID, UINT nFlags) const\r
 360         {\r
 361                 ATLASSERT(::IsMenu(m_hMenu));\r
 362                 return ::GetMenuState(m_hMenu, nID, nFlags);\r
 363         }\r
 364 \r
 365         int GetMenuString(UINT nIDItem, LPTSTR lpString, int nMaxCount, UINT nFlags) const\r
 366         {\r
 367                 ATLASSERT(::IsMenu(m_hMenu));\r
 368                 return ::GetMenuString(m_hMenu, nIDItem, lpString, nMaxCount, nFlags);\r
 369         }\r
 370 \r
 371         int GetMenuStringLen(UINT nIDItem, UINT nFlags) const\r
 372         {\r
 373                 ATLASSERT(::IsMenu(m_hMenu));\r
 374                 return ::GetMenuString(m_hMenu, nIDItem, NULL, 0, nFlags);\r
 375         }\r
 376 \r
 377 #ifndef _ATL_NO_COM\r
 378         BOOL GetMenuString(UINT nIDItem, BSTR& bstrText, UINT nFlags) const\r
 379         {\r
 380                 USES_CONVERSION;\r
 381                 ATLASSERT(::IsMenu(m_hMenu));\r
 382                 ATLASSERT(bstrText == NULL);\r
 383 \r
 384                 int nLen = GetMenuStringLen(nIDItem, nFlags);\r
 385                 if(nLen == 0)\r
 386                 {\r
 387                         bstrText = ::SysAllocString(OLESTR(""));\r
 388                         return (bstrText != NULL) ? TRUE : FALSE;\r
 389                 }\r
 390 \r
 391                 nLen++;   // increment to include terminating NULL char\r
 392                 CTempBuffer<TCHAR, _WTL_STACK_ALLOC_THRESHOLD> buff;\r
 393                 LPTSTR lpszText = buff.Allocate(nLen);\r
 394                 if(lpszText == NULL)\r
 395                         return FALSE;\r
 396 \r
 397                 if(!GetMenuString(nIDItem, lpszText, nLen, nFlags))\r
 398                         return FALSE;\r
 399 \r
 400                 bstrText = ::SysAllocString(T2OLE(lpszText));\r
 401                 return (bstrText != NULL) ? TRUE : FALSE;\r
 402         }\r
 403 #endif // !_ATL_NO_COM\r
 404 #endif // !_WIN32_WCE\r
 405 \r
 406 #if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)\r
 407         int GetMenuString(UINT nIDItem, _CSTRING_NS::CString& strText, UINT nFlags) const\r
 408         {\r
 409                 ATLASSERT(::IsMenu(m_hMenu));\r
 410 \r
 411                 int nLen = GetMenuStringLen(nIDItem, nFlags);\r
 412                 if(nLen == 0)\r
 413                         return 0;\r
 414 \r
 415                 nLen++;   // increment to include terminating NULL char\r
 416                 LPTSTR lpstr = strText.GetBufferSetLength(nLen);\r
 417                 if(lpstr == NULL)\r
 418                         return 0;\r
 419                 int nRet = GetMenuString(nIDItem, lpstr, nLen, nFlags);\r
 420                 strText.ReleaseBuffer();\r
 421                 return nRet;\r
 422         }\r
 423 #endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)\r
 424 \r
 425         CMenuHandle GetSubMenu(int nPos) const\r
 426         {\r
 427                 ATLASSERT(::IsMenu(m_hMenu));\r
 428                 return CMenuHandle(::GetSubMenu(m_hMenu, nPos));\r
 429         }\r
 430 \r
 431         BOOL InsertMenu(UINT nPosition, UINT nFlags, UINT_PTR nIDNewItem = 0, LPCTSTR lpszNewItem = NULL)\r
 432         {\r
 433                 ATLASSERT(::IsMenu(m_hMenu));\r
 434                 return ::InsertMenu(m_hMenu, nPosition, nFlags, nIDNewItem, lpszNewItem);\r
 435         }\r
 436 \r
 437         BOOL InsertMenu(UINT nPosition, UINT nFlags, HMENU hSubMenu, LPCTSTR lpszNewItem)\r
 438         {\r
 439                 ATLASSERT(::IsMenu(m_hMenu));\r
 440                 ATLASSERT(::IsMenu(hSubMenu));\r
 441                 return ::InsertMenu(m_hMenu, nPosition, nFlags | MF_POPUP, (UINT_PTR)hSubMenu, lpszNewItem);\r
 442         }\r
 443 \r
 444 #ifndef _WIN32_WCE\r
 445         BOOL InsertMenu(UINT nPosition, UINT nFlags, UINT_PTR nIDNewItem, HBITMAP hBmp)\r
 446         {\r
 447                 ATLASSERT(::IsMenu(m_hMenu));\r
 448                 return ::InsertMenu(m_hMenu, nPosition, nFlags | MF_BITMAP, nIDNewItem, (LPCTSTR)hBmp);\r
 449         }\r
 450 \r
 451         BOOL InsertMenu(UINT nPosition, UINT nFlags, HMENU hSubMenu, HBITMAP hBmp)\r
 452         {\r
 453                 ATLASSERT(::IsMenu(m_hMenu));\r
 454                 ATLASSERT(::IsMenu(hSubMenu));\r
 455                 return ::InsertMenu(m_hMenu, nPosition, nFlags | (MF_BITMAP | MF_POPUP), (UINT_PTR)hSubMenu, (LPCTSTR)hBmp);\r
 456         }\r
 457 \r
 458         BOOL ModifyMenu(UINT nPosition, UINT nFlags, UINT_PTR nIDNewItem = 0, LPCTSTR lpszNewItem = NULL)\r
 459         {\r
 460                 ATLASSERT(::IsMenu(m_hMenu));\r
 461                 return ::ModifyMenu(m_hMenu, nPosition, nFlags, nIDNewItem, lpszNewItem);\r
 462         }\r
 463 \r
 464         BOOL ModifyMenu(UINT nPosition, UINT nFlags, HMENU hSubMenu, LPCTSTR lpszNewItem)\r
 465         {\r
 466                 ATLASSERT(::IsMenu(m_hMenu));\r
 467                 ATLASSERT(::IsMenu(hSubMenu));\r
 468                 return ::ModifyMenu(m_hMenu, nPosition, nFlags | MF_POPUP, (UINT_PTR)hSubMenu, lpszNewItem);\r
 469         }\r
 470 \r
 471         BOOL ModifyMenu(UINT nPosition, UINT nFlags, UINT_PTR nIDNewItem, HBITMAP hBmp)\r
 472         {\r
 473                 ATLASSERT(::IsMenu(m_hMenu));\r
 474                 return ::ModifyMenu(m_hMenu, nPosition, nFlags | MF_BITMAP, nIDNewItem, (LPCTSTR)hBmp);\r
 475         }\r
 476 \r
 477         BOOL ModifyMenu(UINT nPosition, UINT nFlags, HMENU hSubMenu, HBITMAP hBmp)\r
 478         {\r
 479                 ATLASSERT(::IsMenu(m_hMenu));\r
 480                 ATLASSERT(::IsMenu(hSubMenu));\r
 481                 return ::ModifyMenu(m_hMenu, nPosition, nFlags | (MF_BITMAP | MF_POPUP), (UINT_PTR)hSubMenu, (LPCTSTR)hBmp);\r
 482         }\r
 483 #endif // !_WIN32_WCE\r
 484 \r
 485         BOOL RemoveMenu(UINT nPosition, UINT nFlags)\r
 486         {\r
 487                 ATLASSERT(::IsMenu(m_hMenu));\r
 488                 return ::RemoveMenu(m_hMenu, nPosition, nFlags);\r
 489         }\r
 490 \r
 491 #ifndef _WIN32_WCE\r
 492         BOOL SetMenuItemBitmaps(UINT nPosition, UINT nFlags, HBITMAP hBmpUnchecked, HBITMAP hBmpChecked)\r
 493         {\r
 494                 ATLASSERT(::IsMenu(m_hMenu));\r
 495                 return ::SetMenuItemBitmaps(m_hMenu, nPosition, nFlags, hBmpUnchecked, hBmpChecked);\r
 496         }\r
 497 #endif // !_WIN32_WCE\r
 498 \r
 499         BOOL CheckMenuRadioItem(UINT nIDFirst, UINT nIDLast, UINT nIDItem, UINT nFlags)\r
 500         {\r
 501                 ATLASSERT(::IsMenu(m_hMenu));\r
 502                 return ::CheckMenuRadioItem(m_hMenu, nIDFirst, nIDLast, nIDItem, nFlags);\r
 503         }\r
 504 \r
 505         BOOL GetMenuItemInfo(UINT uItem, BOOL bByPosition, LPMENUITEMINFO lpmii) const\r
 506         {\r
 507                 ATLASSERT(::IsMenu(m_hMenu));\r
 508                 return (BOOL)::GetMenuItemInfo(m_hMenu, uItem, bByPosition, lpmii);\r
 509         }\r
 510 \r
 511         BOOL SetMenuItemInfo(UINT uItem, BOOL bByPosition, LPMENUITEMINFO lpmii)\r
 512         {\r
 513                 ATLASSERT(::IsMenu(m_hMenu));\r
 514                 return (BOOL)::SetMenuItemInfo(m_hMenu, uItem, bByPosition, lpmii);\r
 515         }\r
 516 \r
 517 #ifndef _WIN32_WCE\r
 518         BOOL InsertMenuItem(UINT uItem, BOOL bByPosition, LPMENUITEMINFO lpmii)\r
 519         {\r
 520                 ATLASSERT(::IsMenu(m_hMenu));\r
 521                 return (BOOL)::InsertMenuItem(m_hMenu, uItem, bByPosition, lpmii);\r
 522         }\r
 523 \r
 524         UINT GetMenuDefaultItem(BOOL bByPosition = FALSE, UINT uFlags = 0U) const\r
 525         {\r
 526                 ATLASSERT(::IsMenu(m_hMenu));\r
 527                 return ::GetMenuDefaultItem(m_hMenu, (UINT)bByPosition, uFlags);\r
 528         }\r
 529 \r
 530         BOOL SetMenuDefaultItem(UINT uItem = (UINT)-1,  BOOL bByPosition = FALSE)\r
 531         {\r
 532                 ATLASSERT(::IsMenu(m_hMenu));\r
 533                 return ::SetMenuDefaultItem(m_hMenu, uItem, (UINT)bByPosition);\r
 534         }\r
 535 \r
 536         BOOL GetMenuItemRect(HWND hWnd, UINT uItem, LPRECT lprcItem) const\r
 537         {\r
 538                 ATLASSERT(::IsMenu(m_hMenu));\r
 539                 return ::GetMenuItemRect(hWnd, m_hMenu, uItem, lprcItem);\r
 540         }\r
 541 \r
 542         int MenuItemFromPoint(HWND hWnd, POINT point) const\r
 543         {\r
 544                 ATLASSERT(::IsMenu(m_hMenu));\r
 545                 return ::MenuItemFromPoint(hWnd, m_hMenu, point);\r
 546         }\r
 547 \r
 548 // Context Help Functions\r
 549         BOOL SetMenuContextHelpId(DWORD dwContextHelpId)\r
 550         {\r
 551                 ATLASSERT(::IsMenu(m_hMenu));\r
 552                 return ::SetMenuContextHelpId(m_hMenu, dwContextHelpId);\r
 553         }\r
 554 \r
 555         DWORD GetMenuContextHelpId() const\r
 556         {\r
 557                 ATLASSERT(::IsMenu(m_hMenu));\r
 558                 return ::GetMenuContextHelpId(m_hMenu);\r
 559         }\r
 560 #endif // !_WIN32_WCE\r
 561 };\r
 562 \r
 563 \r
 564 ///////////////////////////////////////////////////////////////////////////////\r
 565 // CAccelerator\r
 566 \r
 567 template <bool t_bManaged>\r
 568 class CAcceleratorT\r
 569 {\r
 570 public:\r
 571         HACCEL m_hAccel;\r
 572 \r
 573 // Constructor/destructor/operators\r
 574         CAcceleratorT(HACCEL hAccel = NULL) : m_hAccel(hAccel)\r
 575         { }\r
 576 \r
 577         ~CAcceleratorT()\r
 578         {\r
 579                 if(t_bManaged && m_hAccel != NULL)\r
 580                         ::DestroyAcceleratorTable(m_hAccel);\r
 581         }\r
 582 \r
 583         CAcceleratorT<t_bManaged>& operator =(HACCEL hAccel)\r
 584         {\r
 585                 Attach(hAccel);\r
 586                 return *this;\r
 587         }\r
 588 \r
 589         void Attach(HACCEL hAccel)\r
 590         {\r
 591                 if(t_bManaged && m_hAccel != NULL)\r
 592                         ::DestroyAcceleratorTable(m_hAccel);\r
 593                 m_hAccel = hAccel;\r
 594         }\r
 595 \r
 596         HACCEL Detach()\r
 597         {\r
 598                 HACCEL hAccel = m_hAccel;\r
 599                 m_hAccel = NULL;\r
 600                 return hAccel;\r
 601         }\r
 602 \r
 603         operator HACCEL() const { return m_hAccel; }\r
 604 \r
 605         bool IsNull() const { return m_hAccel == NULL; }\r
 606 \r
 607 // Create/destroy methods\r
 608         HACCEL LoadAccelerators(ATL::_U_STRINGorID accel)\r
 609         {\r
 610                 ATLASSERT(m_hAccel == NULL);\r
 611                 m_hAccel = ::LoadAccelerators(ModuleHelper::GetResourceInstance(), accel.m_lpstr);\r
 612                 return m_hAccel;\r
 613         }\r
 614 \r
 615         HACCEL CreateAcceleratorTable(LPACCEL pAccel, int cEntries)\r
 616         {\r
 617                 ATLASSERT(m_hAccel == NULL);\r
 618                 ATLASSERT(pAccel != NULL);\r
 619                 m_hAccel = ::CreateAcceleratorTable(pAccel, cEntries);\r
 620                 return m_hAccel;\r
 621         }\r
 622 \r
 623         void DestroyObject()\r
 624         {\r
 625                 if(m_hAccel != NULL)\r
 626                 {\r
 627                         ::DestroyAcceleratorTable(m_hAccel);\r
 628                         m_hAccel = NULL;\r
 629                 }\r
 630         }\r
 631 \r
 632 // Operations\r
 633 #ifndef _WIN32_WCE\r
 634         int CopyAcceleratorTable(LPACCEL lpAccelDst, int cEntries)\r
 635         {\r
 636                 ATLASSERT(m_hAccel != NULL);\r
 637                 ATLASSERT(lpAccelDst != NULL);\r
 638                 return ::CopyAcceleratorTable(m_hAccel, lpAccelDst, cEntries);\r
 639         }\r
 640 \r
 641         int GetEntriesCount() const\r
 642         {\r
 643                 ATLASSERT(m_hAccel != NULL);\r
 644                 return ::CopyAcceleratorTable(m_hAccel, NULL, 0);\r
 645         }\r
 646 #endif // !_WIN32_WCE\r
 647 \r
 648         BOOL TranslateAccelerator(HWND hWnd, LPMSG pMsg)\r
 649         {\r
 650                 ATLASSERT(m_hAccel != NULL);\r
 651                 ATLASSERT(::IsWindow(hWnd));\r
 652                 ATLASSERT(pMsg != NULL);\r
 653                 return ::TranslateAccelerator(hWnd, m_hAccel, pMsg);\r
 654         }\r
 655 };\r
 656 \r
 657 typedef CAcceleratorT<false>   CAcceleratorHandle;\r
 658 typedef CAcceleratorT<true>    CAccelerator;\r
 659 \r
 660 \r
 661 ///////////////////////////////////////////////////////////////////////////////\r
 662 // CIcon\r
 663 \r
 664 template <bool t_bManaged>\r
 665 class CIconT\r
 666 {\r
 667 public:\r
 668         HICON m_hIcon;\r
 669 \r
 670 // Constructor/destructor/operators\r
 671         CIconT(HICON hIcon = NULL) : m_hIcon(hIcon)\r
 672         { }\r
 673 \r
 674         ~CIconT()\r
 675         {\r
 676                 if(t_bManaged && m_hIcon != NULL)\r
 677                         ::DestroyIcon(m_hIcon);\r
 678         }\r
 679 \r
 680         CIconT<t_bManaged>& operator =(HICON hIcon)\r
 681         {\r
 682                 Attach(hIcon);\r
 683                 return *this;\r
 684         }\r
 685 \r
 686         void Attach(HICON hIcon)\r
 687         {\r
 688                 if(t_bManaged && m_hIcon != NULL)\r
 689                         ::DestroyIcon(m_hIcon);\r
 690                 m_hIcon = hIcon;\r
 691         }\r
 692 \r
 693         HICON Detach()\r
 694         {\r
 695                 HICON hIcon = m_hIcon;\r
 696                 m_hIcon = NULL;\r
 697                 return hIcon;\r
 698         }\r
 699 \r
 700         operator HICON() const { return m_hIcon; }\r
 701 \r
 702         bool IsNull() const { return m_hIcon == NULL; }\r
 703 \r
 704 // Create/destroy methods\r
 705         HICON LoadIcon(ATL::_U_STRINGorID icon)\r
 706         {\r
 707                 ATLASSERT(m_hIcon == NULL);\r
 708                 m_hIcon = ::LoadIcon(ModuleHelper::GetResourceInstance(), icon.m_lpstr);\r
 709                 return m_hIcon;\r
 710         }\r
 711 \r
 712         HICON LoadIcon(ATL::_U_STRINGorID icon, int cxDesired, int cyDesired, UINT fuLoad = 0)\r
 713         {\r
 714                 ATLASSERT(m_hIcon == NULL);\r
 715                 m_hIcon = (HICON) ::LoadImage(ModuleHelper::GetResourceInstance(), icon.m_lpstr, IMAGE_ICON, cxDesired, cyDesired, fuLoad);\r
 716                 return m_hIcon;\r
 717         }\r
 718 \r
 719 #ifndef _WIN32_WCE\r
 720         HICON LoadOEMIcon(LPCTSTR lpstrIconName)\r
 721         {\r
 722                 ATLASSERT(m_hIcon == NULL);\r
 723                 ATLASSERT(IsOEMIcon(lpstrIconName));\r
 724                 m_hIcon = ::LoadIcon(NULL, lpstrIconName);\r
 725                 return m_hIcon;\r
 726         }\r
 727 \r
 728         HICON CreateIcon(int nWidth, int nHeight, BYTE cPlanes, BYTE cBitsPixel, CONST BYTE* lpbANDbits, CONST BYTE *lpbXORbits)\r
 729         {\r
 730                 ATLASSERT(m_hIcon == NULL);\r
 731                 ATLASSERT(lpbANDbits != NULL);\r
 732                 ATLASSERT(lpbXORbits != NULL);\r
 733                 m_hIcon = ::CreateIcon(ModuleHelper::GetResourceInstance(), nWidth, nHeight, cPlanes, cBitsPixel, lpbANDbits, lpbXORbits);\r
 734                 return m_hIcon;\r
 735         }\r
 736 \r
 737         HICON CreateIconFromResource(PBYTE pBits, DWORD dwResSize, DWORD dwVersion = 0x00030000)\r
 738         {\r
 739                 ATLASSERT(m_hIcon == NULL);\r
 740                 ATLASSERT(pBits != NULL);\r
 741                 m_hIcon = ::CreateIconFromResource(pBits, dwResSize, TRUE, dwVersion);\r
 742                 return m_hIcon;\r
 743         }\r
 744 \r
 745         HICON CreateIconFromResourceEx(PBYTE pbBits, DWORD cbBits, DWORD dwVersion = 0x00030000, int cxDesired = 0, int cyDesired = 0, UINT uFlags = LR_DEFAULTCOLOR)\r
 746         {\r
 747                 ATLASSERT(m_hIcon == NULL);\r
 748                 ATLASSERT(pbBits != NULL);\r
 749                 ATLASSERT(cbBits > 0);\r
 750                 m_hIcon = ::CreateIconFromResourceEx(pbBits, cbBits, TRUE, dwVersion, cxDesired, cyDesired, uFlags);\r
 751                 return m_hIcon;\r
 752         }\r
 753 #endif // !_WIN32_WCE\r
 754 \r
 755         HICON CreateIconIndirect(PICONINFO pIconInfo)\r
 756         {\r
 757                 ATLASSERT(m_hIcon == NULL);\r
 758                 ATLASSERT(pIconInfo != NULL);\r
 759                 m_hIcon = ::CreateIconIndirect(pIconInfo);\r
 760                 return m_hIcon;\r
 761         }\r
 762 \r
 763 #ifndef _WIN32_WCE\r
 764         HICON ExtractIcon(LPCTSTR lpszExeFileName, UINT nIconIndex)\r
 765         {\r
 766                 ATLASSERT(m_hIcon == NULL);\r
 767                 ATLASSERT(lpszExeFileName != NULL);\r
 768                 m_hIcon = ::ExtractIcon(ModuleHelper::GetModuleInstance(), lpszExeFileName, nIconIndex);\r
 769                 return m_hIcon;\r
 770         }\r
 771 \r
 772         HICON ExtractAssociatedIcon(HINSTANCE hInst, LPTSTR lpIconPath, LPWORD lpiIcon)\r
 773         {\r
 774                 ATLASSERT(m_hIcon == NULL);\r
 775                 ATLASSERT(lpIconPath != NULL);\r
 776                 ATLASSERT(lpiIcon != NULL);\r
 777                 m_hIcon = ::ExtractAssociatedIcon(hInst, lpIconPath, lpiIcon);\r
 778                 return m_hIcon;\r
 779         }\r
 780 #endif // !_WIN32_WCE\r
 781 \r
 782         BOOL DestroyIcon()\r
 783         {\r
 784                 ATLASSERT(m_hIcon != NULL);\r
 785                 BOOL bRet = ::DestroyIcon(m_hIcon);\r
 786                 if(bRet != FALSE)\r
 787                         m_hIcon = NULL;\r
 788                 return bRet;\r
 789         }\r
 790 \r
 791 // Operations\r
 792 #ifndef _WIN32_WCE\r
 793         HICON CopyIcon()\r
 794         {\r
 795                 ATLASSERT(m_hIcon != NULL);\r
 796                 return ::CopyIcon(m_hIcon);\r
 797         }\r
 798 \r
 799         HICON DuplicateIcon()\r
 800         {\r
 801                 ATLASSERT(m_hIcon != NULL);\r
 802                 return ::DuplicateIcon(NULL, m_hIcon);\r
 803         }\r
 804 #endif // !_WIN32_WCE\r
 805 \r
 806         BOOL DrawIcon(HDC hDC, int x, int y)\r
 807         {\r
 808                 ATLASSERT(m_hIcon != NULL);\r
 809 #ifndef _WIN32_WCE\r
 810                 return ::DrawIcon(hDC, x, y, m_hIcon);\r
 811 #else // CE specific\r
 812                 return ::DrawIconEx(hDC, x, y, m_hIcon, 0, 0, 0, NULL, DI_NORMAL);\r
 813 #endif // _WIN32_WCE\r
 814         }\r
 815 \r
 816         BOOL DrawIcon(HDC hDC, POINT pt)\r
 817         {\r
 818                 ATLASSERT(m_hIcon != NULL);\r
 819 #ifndef _WIN32_WCE\r
 820                 return ::DrawIcon(hDC, pt.x, pt.y, m_hIcon);\r
 821 #else // CE specific\r
 822                 return ::DrawIconEx(hDC, pt.x, pt.y, m_hIcon, 0, 0, 0, NULL, DI_NORMAL);\r
 823 #endif // _WIN32_WCE\r
 824         }\r
 825 \r
 826         BOOL DrawIconEx(HDC hDC, int x, int y, int cxWidth, int cyWidth, UINT uStepIfAniCur = 0, HBRUSH hbrFlickerFreeDraw = NULL, UINT uFlags = DI_NORMAL)\r
 827         {\r
 828                 ATLASSERT(m_hIcon != NULL);\r
 829                 return ::DrawIconEx(hDC, x, y, m_hIcon, cxWidth, cyWidth, uStepIfAniCur, hbrFlickerFreeDraw, uFlags);\r
 830         }\r
 831 \r
 832         BOOL DrawIconEx(HDC hDC, POINT pt, SIZE size, UINT uStepIfAniCur = 0, HBRUSH hbrFlickerFreeDraw = NULL, UINT uFlags = DI_NORMAL)\r
 833         {\r
 834                 ATLASSERT(m_hIcon != NULL);\r
 835                 return ::DrawIconEx(hDC, pt.x, pt.y, m_hIcon, size.cx, size.cy, uStepIfAniCur, hbrFlickerFreeDraw, uFlags);\r
 836         }\r
 837 \r
 838 #ifndef _WIN32_WCE\r
 839         BOOL GetIconInfo(PICONINFO pIconInfo) const\r
 840         {\r
 841                 ATLASSERT(m_hIcon != NULL);\r
 842                 ATLASSERT(pIconInfo != NULL);\r
 843                 return ::GetIconInfo(m_hIcon, pIconInfo);\r
 844         }\r
 845 \r
 846 #if (_WIN32_WINNT >= 0x0600)\r
 847         BOOL GetIconInfoEx(PICONINFOEX pIconInfo) const\r
 848         {\r
 849                 ATLASSERT(m_hIcon != NULL);\r
 850                 ATLASSERT(pIconInfo != NULL);\r
 851                 return ::GetIconInfoEx(m_hIcon, pIconInfo);\r
 852         }\r
 853 #endif // (_WIN32_WINNT >= 0x0600)\r
 854 \r
 855 #if defined(NTDDI_VERSION) && (NTDDI_VERSION >= NTDDI_LONGHORN)\r
 856         HRESULT LoadIconMetric(ATL::_U_STRINGorID icon, int lims)\r
 857         {\r
 858                 ATLASSERT(m_hIcon == NULL);\r
 859                 USES_CONVERSION;\r
 860                 return ::LoadIconMetric(ModuleHelper::GetResourceInstance(), T2CW(icon.m_lpstr), lims, &m_hIcon);\r
 861         }\r
 862 \r
 863         HRESULT LoadIconWithScaleDown(ATL::_U_STRINGorID icon, int cx, int cy)\r
 864         {\r
 865                 ATLASSERT(m_hIcon == NULL);\r
 866                 USES_CONVERSION;\r
 867                 return ::LoadIconWithScaleDown(ModuleHelper::GetResourceInstance(), T2CW(icon.m_lpstr), cx, cy, &m_hIcon);\r
 868         }\r
 869 \r
 870         HRESULT LoadOEMIconMetric(LPCTSTR lpstrIconName, int lims)\r
 871         {\r
 872                 ATLASSERT(m_hIcon == NULL);\r
 873                 ATLASSERT(IsOEMIcon(lpstrIconName));\r
 874                 return ::LoadIconMetric(NULL, (LPCWSTR)lpstrIconName, lims, &m_hIcon);\r
 875         }\r
 876 \r
 877         HRESULT LoadOEMIconWithScaleDown(LPCTSTR lpstrIconName, int cx, int cy)\r
 878         {\r
 879                 ATLASSERT(m_hIcon == NULL);\r
 880                 ATLASSERT(IsOEMIcon(lpstrIconName));\r
 881                 USES_CONVERSION;\r
 882                 return ::LoadIconWithScaleDown(NULL, (LPCWSTR)lpstrIconName, cx, cy, &m_hIcon);\r
 883         }\r
 884 #endif // defined(NTDDI_VERSION) && (NTDDI_VERSION >= NTDDI_LONGHORN)\r
 885 #endif // !_WIN32_WCE\r
 886 \r
 887         // Helper\r
 888 #ifndef _WIN32_WCE\r
 889         static bool IsOEMIcon(LPCTSTR lpstrIconName)\r
 890         {\r
 891 #if (WINVER >= 0x0600)\r
 892                 return (lpstrIconName == IDI_APPLICATION || lpstrIconName == IDI_ASTERISK || lpstrIconName == IDI_EXCLAMATION ||\r
 893                           lpstrIconName == IDI_HAND || lpstrIconName == IDI_QUESTION || lpstrIconName == IDI_WINLOGO ||\r
 894                           lpstrIconName == IDI_SHIELD);\r
 895 #else // !(WINVER >= 0x0600)\r
 896                 return (lpstrIconName == IDI_APPLICATION || lpstrIconName == IDI_ASTERISK || lpstrIconName == IDI_EXCLAMATION ||\r
 897                           lpstrIconName == IDI_HAND || lpstrIconName == IDI_QUESTION || lpstrIconName == IDI_WINLOGO);\r
 898 #endif // !(WINVER >= 0x0600)\r
 899         }\r
 900 #endif // !_WIN32_WCE\r
 901 };\r
 902 \r
 903 typedef CIconT<false>   CIconHandle;\r
 904 typedef CIconT<true>    CIcon;\r
 905 \r
 906 \r
 907 ///////////////////////////////////////////////////////////////////////////////\r
 908 // CCursor\r
 909 \r
 910 // protect template member from a winuser.h macro\r
 911 #ifdef CopyCursor\r
 912   #undef CopyCursor\r
 913 #endif\r
 914 \r
 915 template <bool t_bManaged>\r
 916 class CCursorT\r
 917 {\r
 918 public:\r
 919         HCURSOR m_hCursor;\r
 920 \r
 921 // Constructor/destructor/operators\r
 922         CCursorT(HCURSOR hCursor = NULL) : m_hCursor(hCursor)\r
 923         { }\r
 924 \r
 925         ~CCursorT()\r
 926         {\r
 927                 if(t_bManaged && m_hCursor != NULL)\r
 928                         DestroyCursor();\r
 929         }\r
 930 \r
 931         CCursorT<t_bManaged>& operator =(HCURSOR hCursor)\r
 932         {\r
 933                 Attach(hCursor);\r
 934                 return *this;\r
 935         }\r
 936 \r
 937         void Attach(HCURSOR hCursor)\r
 938         {\r
 939                 if(t_bManaged && m_hCursor != NULL)\r
 940                         DestroyCursor();\r
 941                 m_hCursor = hCursor;\r
 942         }\r
 943 \r
 944         HCURSOR Detach()\r
 945         {\r
 946                 HCURSOR hCursor = m_hCursor;\r
 947                 m_hCursor = NULL;\r
 948                 return hCursor;\r
 949         }\r
 950 \r
 951         operator HCURSOR() const { return m_hCursor; }\r
 952 \r
 953         bool IsNull() const { return m_hCursor == NULL; }\r
 954 \r
 955 // Create/destroy methods\r
 956         HCURSOR LoadCursor(ATL::_U_STRINGorID cursor)\r
 957         {\r
 958                 ATLASSERT(m_hCursor == NULL);\r
 959                 m_hCursor = ::LoadCursor(ModuleHelper::GetResourceInstance(), cursor.m_lpstr);\r
 960                 return m_hCursor;\r
 961         }\r
 962 \r
 963         HCURSOR LoadSysCursor(LPCTSTR lpstrCursorName)\r
 964         {\r
 965                 ATLASSERT(m_hCursor == NULL);\r
 966 #if (WINVER >= 0x0500)\r
 967                 ATLASSERT(lpstrCursorName == IDC_ARROW || lpstrCursorName == IDC_IBEAM || lpstrCursorName == IDC_WAIT ||\r
 968                         lpstrCursorName == IDC_CROSS || lpstrCursorName == IDC_UPARROW || lpstrCursorName == IDC_SIZE ||\r
 969                         lpstrCursorName == IDC_ICON || lpstrCursorName == IDC_SIZENWSE || lpstrCursorName == IDC_SIZENESW ||\r
 970                         lpstrCursorName == IDC_SIZEWE || lpstrCursorName == IDC_SIZENS || lpstrCursorName == IDC_SIZEALL ||\r
 971                         lpstrCursorName == IDC_NO || lpstrCursorName == IDC_APPSTARTING || lpstrCursorName == IDC_HELP ||\r
 972                         lpstrCursorName == IDC_HAND);\r
 973 #else // !(WINVER >= 0x0500)\r
 974                 ATLASSERT(lpstrCursorName == IDC_ARROW || lpstrCursorName == IDC_IBEAM || lpstrCursorName == IDC_WAIT ||\r
 975                         lpstrCursorName == IDC_CROSS || lpstrCursorName == IDC_UPARROW || lpstrCursorName == IDC_SIZE ||\r
 976                         lpstrCursorName == IDC_ICON || lpstrCursorName == IDC_SIZENWSE || lpstrCursorName == IDC_SIZENESW ||\r
 977                         lpstrCursorName == IDC_SIZEWE || lpstrCursorName == IDC_SIZENS || lpstrCursorName == IDC_SIZEALL ||\r
 978                         lpstrCursorName == IDC_NO || lpstrCursorName == IDC_APPSTARTING || lpstrCursorName == IDC_HELP);\r
 979 #endif // !(WINVER >= 0x0500)\r
 980                 m_hCursor = ::LoadCursor(NULL, lpstrCursorName);\r
 981                 return m_hCursor;\r
 982         }\r
 983 \r
 984         // deprecated\r
 985         HCURSOR LoadOEMCursor(LPCTSTR lpstrCursorName)\r
 986         {\r
 987                 return LoadSysCursor(lpstrCursorName);\r
 988         }\r
 989 \r
 990         HCURSOR LoadCursor(ATL::_U_STRINGorID cursor, int cxDesired, int cyDesired, UINT fuLoad = 0)\r
 991         {\r
 992                 ATLASSERT(m_hCursor == NULL);\r
 993                 m_hCursor = (HCURSOR) ::LoadImage(ModuleHelper::GetResourceInstance(), cursor.m_lpstr, IMAGE_CURSOR, cxDesired, cyDesired, fuLoad);\r
 994                 return m_hCursor;\r
 995         }\r
 996 \r
 997 #ifndef _WIN32_WCE\r
 998         HCURSOR LoadCursorFromFile(LPCTSTR pstrFilename)\r
 999         {\r
1000                 ATLASSERT(m_hCursor == NULL);\r
1001                 ATLASSERT(pstrFilename != NULL);\r
1002                 m_hCursor = ::LoadCursorFromFile(pstrFilename);\r
1003                 return m_hCursor;\r
1004         }\r
1005 #endif // !_WIN32_WCE\r
1006 \r
1007 #if !defined(_WIN32_WCE) || ((_WIN32_WCE >= 0x400) && !(defined(WIN32_PLATFORM_PSPC) || defined(WIN32_PLATFORM_WFSP)))\r
1008         HCURSOR CreateCursor(int xHotSpot, int yHotSpot, int nWidth, int nHeight, CONST VOID *pvANDPlane, CONST VOID *pvXORPlane)\r
1009         {\r
1010                 ATLASSERT(m_hCursor == NULL);\r
1011                 m_hCursor = ::CreateCursor(ModuleHelper::GetResourceInstance(), xHotSpot, yHotSpot, nWidth, nHeight, pvANDPlane, pvXORPlane);\r
1012                 return m_hCursor;\r
1013         }\r
1014 #endif // !defined(_WIN32_WCE) || ((_WIN32_WCE >= 0x400) && !(defined(WIN32_PLATFORM_PSPC) || defined(WIN32_PLATFORM_WFSP)))\r
1015 \r
1016 #ifndef _WIN32_WCE\r
1017         HCURSOR CreateCursorFromResource(PBYTE pBits, DWORD dwResSize, DWORD dwVersion = 0x00030000)\r
1018         {\r
1019                 ATLASSERT(m_hCursor == NULL);\r
1020                 ATLASSERT(pBits != NULL);\r
1021                 m_hCursor = (HCURSOR)::CreateIconFromResource(pBits, dwResSize, FALSE, dwVersion);\r
1022                 return m_hCursor;\r
1023         }\r
1024 \r
1025         HCURSOR CreateCursorFromResourceEx(PBYTE pbBits, DWORD cbBits, DWORD dwVersion = 0x00030000, int cxDesired = 0, int cyDesired = 0, UINT uFlags = LR_DEFAULTCOLOR)\r
1026         {\r
1027                 ATLASSERT(m_hCursor == NULL);\r
1028                 ATLASSERT(pbBits != NULL);\r
1029                 ATLASSERT(cbBits > 0);\r
1030                 m_hCursor = (HCURSOR)::CreateIconFromResourceEx(pbBits, cbBits, FALSE, dwVersion, cxDesired, cyDesired, uFlags);\r
1031                 return m_hCursor;\r
1032         }\r
1033 #endif // !_WIN32_WCE\r
1034 \r
1035         BOOL DestroyCursor()\r
1036         {\r
1037                 ATLASSERT(m_hCursor != NULL);\r
1038 #if !defined(_WIN32_WCE) || ((_WIN32_WCE >= 0x400) && !(defined(WIN32_PLATFORM_PSPC) || defined(WIN32_PLATFORM_WFSP)))\r
1039                 BOOL bRet = ::DestroyCursor(m_hCursor);\r
1040                 if(bRet != FALSE)\r
1041                         m_hCursor = NULL;\r
1042                 return bRet;\r
1043 #else // !(!defined(_WIN32_WCE) || ((_WIN32_WCE >= 0x400) && !(defined(WIN32_PLATFORM_PSPC) || defined(WIN32_PLATFORM_WFSP))))\r
1044                 ATLTRACE2(atlTraceUI, 0, _T("Warning: This version of Windows CE does not have ::DestroyCursor()\n"));\r
1045                 return FALSE;\r
1046 #endif // !(!defined(_WIN32_WCE) || ((_WIN32_WCE >= 0x400) && !(defined(WIN32_PLATFORM_PSPC) || defined(WIN32_PLATFORM_WFSP))))\r
1047         }\r
1048 \r
1049 // Operations\r
1050 #ifndef _WIN32_WCE\r
1051         HCURSOR CopyCursor()\r
1052         {\r
1053                 ATLASSERT(m_hCursor != NULL);\r
1054                 return (HCURSOR)::CopyIcon((HICON)m_hCursor);\r
1055         }\r
1056 #endif // !_WIN32_WCE\r
1057 \r
1058 #if (WINVER >= 0x0500) && !defined(_WIN32_WCE)\r
1059         BOOL GetCursorInfo(LPCURSORINFO pCursorInfo)\r
1060         {\r
1061                 ATLASSERT(m_hCursor != NULL);\r
1062                 ATLASSERT(pCursorInfo != NULL);\r
1063                 return ::GetCursorInfo(pCursorInfo);\r
1064         }\r
1065 #endif // (WINVER >= 0x0500) && !defined(_WIN32_WCE)\r
1066 };\r
1067 \r
1068 typedef CCursorT<false>   CCursorHandle;\r
1069 typedef CCursorT<true>    CCursor;\r
1070 \r
1071 \r
1072 ///////////////////////////////////////////////////////////////////////////////\r
1073 // CResource - Wraps a generic Windows resource.\r
1074 //             Use it with custom resource types other than the\r
1075 //             standard RT_CURSOR, RT_BITMAP, etc.\r
1076 \r
1077 class CResource\r
1078 {\r
1079 public:\r
1080         HGLOBAL m_hGlobal;\r
1081         HRSRC m_hResource;\r
1082 \r
1083 // Constructor/destructor\r
1084         CResource() : m_hGlobal(NULL), m_hResource(NULL)\r
1085         { }\r
1086 \r
1087         ~CResource()\r
1088         {\r
1089                 Release();\r
1090         }\r
1091 \r
1092 // Load methods\r
1093         bool Load(ATL::_U_STRINGorID Type, ATL::_U_STRINGorID ID)\r
1094         {\r
1095                 ATLASSERT(m_hResource == NULL);\r
1096                 ATLASSERT(m_hGlobal == NULL);\r
1097 \r
1098                 m_hResource = ::FindResource(ModuleHelper::GetResourceInstance(), ID.m_lpstr, Type.m_lpstr);\r
1099                 if(m_hResource == NULL)\r
1100                         return false;\r
1101 \r
1102                 m_hGlobal = ::LoadResource(ModuleHelper::GetResourceInstance(), m_hResource);\r
1103                 if(m_hGlobal == NULL)\r
1104                 {\r
1105                         m_hResource = NULL;\r
1106                         return false;\r
1107                 }\r
1108 \r
1109                 return true;\r
1110         }\r
1111 \r
1112 #ifndef _WIN32_WCE\r
1113         bool LoadEx(ATL::_U_STRINGorID Type, ATL::_U_STRINGorID ID, WORD wLanguage)\r
1114         {\r
1115                 ATLASSERT(m_hResource == NULL);\r
1116                 ATLASSERT(m_hGlobal == NULL);\r
1117 \r
1118                 m_hResource = ::FindResourceEx(ModuleHelper::GetResourceInstance(), ID.m_lpstr, Type.m_lpstr, wLanguage);\r
1119                 if(m_hResource == NULL)\r
1120                         return false;\r
1121 \r
1122                 m_hGlobal = ::LoadResource(ModuleHelper::GetResourceInstance(), m_hResource);\r
1123                 if(m_hGlobal == NULL)\r
1124                 {\r
1125                         m_hResource = NULL;\r
1126                         return false;\r
1127                 }\r
1128 \r
1129                 return true;\r
1130         }\r
1131 #endif // !_WIN32_WCE\r
1132 \r
1133 // Misc. operations\r
1134         DWORD GetSize() const\r
1135         {\r
1136                 ATLASSERT(m_hResource != NULL);\r
1137                 return ::SizeofResource(ModuleHelper::GetResourceInstance(), m_hResource);\r
1138         }\r
1139 \r
1140         LPVOID Lock()\r
1141         {\r
1142                 ATLASSERT(m_hResource != NULL);\r
1143                 ATLASSERT(m_hGlobal != NULL);\r
1144                 LPVOID pVoid = ::LockResource(m_hGlobal);\r
1145                 ATLASSERT(pVoid != NULL);\r
1146                 return pVoid;\r
1147         }\r
1148 \r
1149         void Release()\r
1150         {\r
1151                 if(m_hGlobal != NULL)\r
1152                 {\r
1153                         FreeResource(m_hGlobal);\r
1154                         m_hGlobal = NULL;\r
1155                         m_hResource = NULL;\r
1156                 }\r
1157         }\r
1158 };\r
1159 \r
1160 }; // namespace WTL\r
1161 \r
1162 #endif // __ATLUSER_H__\r