git.sesse.net Git - casparcg/blob - WTL80/include/atlwince.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 __ATLWINCE_H__\r
  13 #define __ATLWINCE_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 atlwince.h requires atlapp.h to be included first\r
  23 #endif\r
  24 \r
  25 #ifndef __ATLWIN_H__\r
  26         #error atlwince.h requires atlwin.h to be included first\r
  27 #endif\r
  28 \r
  29 #ifndef _WIN32_WCE\r
  30         #error atlwince.h compiles under Windows CE only\r
  31 #elif (_WIN32_WCE < 300)\r
  32         #error atlwince.h requires Windows CE 3.0 or higher.\r
  33 #endif\r
  34 \r
  35 #if defined(WIN32_PLATFORM_WFSP) &&  _MSC_VER < 1400 // EVC compiling SmartPhone code\r
  36   #if (WIN32_PLATFORM_WFSP < 200)\r
  37         #error atlwince.h requires Smartphone 2003 or higher\r
  38   #endif\r
  39 #endif // WIN32_PLATFORM_WFSP\r
  40 \r
  41 #if defined(WIN32_PLATFORM_PSPC) &&  _MSC_VER < 1400 // EVC compiling Pocket PC code\r
  42   #if (WIN32_PLATFORM_PSPC < 310)\r
  43         #error atlwince.h requires Pocket PC 2002 or higher\r
  44   #endif\r
  45 #endif // WIN32_PLATFORM_PSPC\r
  46 \r
  47 #if !defined(_AYGSHELL_H_) && !defined(__AYGSHELL_H__)\r
  48         #error atlwince.h requires aygshell.h to be included first\r
  49 #else\r
  50   #if defined(WIN32_PLATFORM_WFSP) && !defined(_TPCSHELL_H_)\r
  51         #error SmartPhone dialog classes require tpcshell.h to be included first\r
  52   #endif\r
  53 #endif\r
  54 \r
  55 #if (_MSC_VER >= 1400) // VS2005\r
  56   #include <DeviceResolutionAware.h>\r
  57   #define _WTL_CE_DRA\r
  58 #endif // (_MSC_VER >= 1400)\r
  59 \r
  60 #if !defined(_WTL_CE_NO_DIALOGS) &&  !defined(__ATLFRAME_H__)\r
  61         #error Orientation aware dialog classes require atlframe.h to be included first\r
  62 #endif\r
  63 \r
  64 #if !defined(_WTL_CE_NO_APPWINDOW) &&  !defined(__ATLFRAME_H__)\r
  65         #error Application window class require atlframe.h to be included first\r
  66 #endif\r
  67 \r
  68 #if !defined(_WTL_CE_NO_ZOOMSCROLL) &&  !defined(__ATLSCRL_H__)\r
  69         #error ZoomScroll implementation requires atlscrl.h to be included first\r
  70 #endif\r
  71 \r
  72 #if !defined(_WTL_CE_NO_ZOOMSCROLL)\r
  73   #if !(defined(__ATLTYPES_H__) || (defined(__ATLMISC_H__) && !defined(_WTL_NO_WTYPES)))\r
  74         #error ZoomScroll requires _WTL_NO_WTYPES not to be defined and either atlmisc.h or atltypes.h to be included first\r
  75   #endif // !(defined(__ATLTYPES_H__) || (defined(__ATLMISC_H__) && !defined(_WTL_NO_WTYPES)))\r
  76 #endif // !defined(_WTL_CE_NO_ZOOMSCROLL)\r
  77 \r
  78 #if !defined(WIN32_PLATFORM_WFSP) && !defined(WIN32_PLATFORM_PSPC)\r
  79   #define _WTL_CE_NO_CONTROLS\r
  80 #endif // !defined(WIN32_PLATFORM_WFSP) && !defined(WIN32_PLATFORM_PSPC)\r
  81 \r
  82 #ifndef _WTL_CE_NO_CONTROLS\r
  83   #ifndef __ATLCTRLS_H__\r
  84         #error The PPC/SmartPhone controls classes require atlctrls.h to be included first\r
  85   #endif\r
  86 \r
  87   #include <htmlctrl.h>\r
  88   #pragma comment(lib, "htmlview.lib")\r
  89 \r
  90   #include <voicectl.h>\r
  91   #pragma comment(lib, "voicectl.lib")\r
  92 \r
  93   #ifdef WIN32_PLATFORM_PSPC\r
  94     #include <richink.h>\r
  95     #pragma comment(lib, "richink.lib")\r
  96 \r
  97     #include <inkx.h>\r
  98     #pragma comment(lib, "inkx.lib")\r
  99 \r
 100     #include <doclist.h>\r
 101     #pragma comment(lib, "doclist.lib")\r
 102   #endif\r
 103 #endif\r
 104 \r
 105 \r
 106 ///////////////////////////////////////////////////////////////////////////////\r
 107 // Classes in this file:\r
 108 //\r
 109 // CStdDialogBase<T, t_shidiFlags, t_bModal> : Standard PPC/SmartPhone dialog base class\r
 110 // CStdDialogImplBase - Base implementation of standard dialog\r
 111 // CStdDialogImpl<T, t_shidiFlags, t_bModal> : Standard dialog implementation\r
 112 // CStdIndirectDialogImpl - implementation of standard indirect PPC/SmartPhone dialog\r
 113 // CStdAxDialogImpl<T, t_shidiFlags, t_bModal> : Standard AxDialog implementation\r
 114 // CStdSimpleDialog<t_wDlgTemplateID, t_shidiFlags> : Standard simple dialog\r
 115 // CStdDialogResizeImplBase - Base implementation of orientation resizing standard dialog\r
 116 // CStdDialogResizeImpl<T, t_shidiFlags, t_bModal> : Orientation resizing standard dialog implementation\r
 117 // CStdAxDialogResizeImpl - implementation of orientation resizing standard AxDialog\r
 118 // CStdSimpleDialogResizeImpl<T, t_wDlgTemplateID, t_shidiFlags> : Standard resizing simple dialog implementation\r
 119 // CStdOrientedDialogBase - Oriented PPC standard dialog base class\r
 120 // CStdOrientedDialogImplBase - Oriented PPC standard dialog base implementation\r
 121 // CStdOrientedDialogImpl<T, t_shidiFlags, t_bModal> : Oriented PPC standard dialog implementation\r
 122 // CStdAxOrientedDialogImpl - Oriented PPC standard AxDialog implementation\r
 123 // CStdSimpleOrientedDialog<t_wDlgTemplateID, t_wDlgLandscapeID, t_shidiFlags> : Standard simple orientable dialog\r
 124 //\r
 125 // CAppInfoBase  : Helper for application state save/restore to registry\r
 126 // CAppInfoT<T> : CAppInfoBase constructed from a CAppWindow<T>\r
 127 // CAppWindowBase<T> : Base class for PPC/SmartPhone well-behaved application window or dialog\r
 128 // CAppWindow<T> : PPC/SmartPhone well-behaved application window class\r
 129 // CAppDialog<T> : PPC/SmartPhone well-behaved application dialog class\r
 130 // CAppStdDialogImplBase - Base implementation of standard application dialogs\r
 131 // CAppStdDialogImpl<T, t_shidiFlags, t_bModal> : Implementation of standard application dialog\r
 132 // CAppStdDialogResizeImpl - implementation of orientation resizing standard application dialog\r
 133 // CAppStdAxDialogImpl - Implementation of standard application AxDialog \r
 134 // CAppStdAxDialogResizeImpl - implementation of orientation resizing standard application AxDialog\r
 135 // CAppStdOrientedDialogImpl - implementation of oriented PPC standard application dialog\r
 136 // CAppStdAxOrientedDialogImpl - implementation of oriented PPC standard application AxDialog\r
 137 //\r
 138 // CFullScreenFrame<T, t_bHasSip> : Full screen frame class\r
 139 //\r
 140 // CZoomScrollImpl<T> : WinCE zooming implementation\r
 141 //\r
 142 // CBottomTabViewImpl<T, TBase, TWinTraits> - CBottomTabView \r
 143 // CHtmlCtrlT<TBase> - CHtmlCtrl\r
 144 // CRichInkCtrlT<TBase> - CRichInkCtrl\r
 145 // CInkXCtrlT<TBase> - CInkXCtrl\r
 146 // CVoiceRecorderCtrlT<TBase> - CVoiceRecorderCtrl\r
 147 // CDocListCtrlT<TBase> - CDocListCtrl\r
 148 // CCapEditT<TBase> - CCapEdit\r
 149 // CTTStaticT<TBase> - CTTStatic\r
 150 // CTTButtonT<TBase> - CTTButton\r
 151 //\r
 152 // CSpinCtrlT<TBase> - CSpinCtrl : SmartPhone specific UpDown control\r
 153 // CSpinned<TBase, t_bExpandOnly> : SmartPhone association of control and Spin\r
 154 // CSpinListBox : SmartPhone spinned ListBox control\r
 155 // CExpandListBox : SmartPhone expandable ListBox control\r
 156 // CExpandEdit : SmartPhone expandable Edit control\r
 157 // CExpandCapEdit : SmartPhone expandable CapEdit control\r
 158 //\r
 159 // Global functions:\r
 160 //   AtlCreateMenuBar()\r
 161 //   AtlCreateEmptyMenuBar()\r
 162 //   AtlIsEditFocus()\r
 163 //   AtlActivateBackKey()\r
 164 \r
 165 namespace WTL\r
 166 {\r
 167 \r
 168 ///////////////////////////////////////////////////////////////////////////////\r
 169 // MenuBar creation functions for property sheets and dialogs\r
 170 // Frame windows use CreateSimpleCEMenuBar\r
 171 \r
 172 inline HWND AtlCreateMenuBar(SHMENUBARINFO& mbi)\r
 173 {\r
 174         ATLASSERT(::IsWindow(mbi.hwndParent));\r
 175         ATLVERIFY(::SHCreateMenuBar(&mbi) != FALSE);\r
 176         return mbi.hwndMB;\r
 177 };\r
 178 \r
 179 inline HWND AtlCreateMenuBar(HWND hWnd, UINT nToolBarId = ATL_IDW_TOOLBAR, DWORD dwFlags = 0, int nBmpId = 0, int cBmpImages = 0, COLORREF clrBk = 0)\r
 180 {\r
 181         SHMENUBARINFO mbi = { sizeof(mbi), hWnd, dwFlags, nToolBarId, ModuleHelper::GetResourceInstance(), nBmpId, cBmpImages, 0, clrBk };\r
 182         return AtlCreateMenuBar(mbi);\r
 183 }\r
 184 \r
 185 inline HWND AtlCreateEmptyMenuBar(HWND hWnd, bool bSip = true)\r
 186 {\r
 187         SHMENUBARINFO embi = { sizeof(SHMENUBARINFO), hWnd, SHCMBF_EMPTYBAR };\r
 188         if (!bSip)\r
 189                 embi.dwFlags |= SHCMBF_HIDESIPBUTTON;\r
 190         \r
 191         return AtlCreateMenuBar(embi);\r
 192 }\r
 193         \r
 194 ///////////////////////////////////////////////////////////////////////////////\r
 195 // Helper functions for SmartPhone back key handling\r
 196 \r
 197 inline bool AtlIsEditFocus()\r
 198 {\r
 199         ATL::CWindow wCtrl = GetFocus();\r
 200         if (wCtrl.IsWindow())\r
 201         {\r
 202                 TCHAR szClassName[8] = {0};\r
 203                 ATLVERIFY(::GetClassName(wCtrl.m_hWnd, szClassName, 8));\r
 204                 return !_tcscmp(szClassName, _T("Edit")) || !_tcscmp(szClassName, WC_CAPEDIT);\r
 205         }\r
 206         return false;\r
 207 }\r
 208 \r
 209 #if defined WIN32_PLATFORM_WFSP\r
 210 inline void AtlActivateBackKey(HWND hMenuBar)\r
 211 {\r
 212         ATLASSERT(::IsWindow(hMenuBar));\r
 213         ::SendMessage(hMenuBar, SHCMBM_OVERRIDEKEY, VK_TBACK,\r
 214                 MAKELPARAM(SHMBOF_NODEFAULT | SHMBOF_NOTIFY, SHMBOF_NODEFAULT | SHMBOF_NOTIFY));\r
 215 }\r
 216 #endif // WIN32_PLATFORM_WFSP\r
 217 \r
 218 // --- Standard PPC/SmartPhone dialogs ---\r
 219 \r
 220 #ifndef _WTL_CE_NO_DIALOGS\r
 221 \r
 222 ///////////////////////////////////////////////////////////////////////////////\r
 223 // CStdDialogBase - base class for standard PPC/SmartPhone dialogs\r
 224 \r
 225 #define WTL_STD_SHIDIF   SHIDIF_DONEBUTTON | SHIDIF_SIPDOWN | SHIDIF_SIZEDLGFULLSCREEN\r
 226 #define WTL_SP_SHIDIF    SHIDIF_SIZEDLGFULLSCREEN\r
 227 \r
 228 // Title setting macros\r
 229 #define WTL_DLG_TITLEHEIGHT(iHeight) static const int GetTitleHeight(){return iHeight;}\r
 230 #define WTL_DLG_NOTITLE  WTL_DLG_TITLEHEIGHT(0)\r
 231 \r
 232 ///////////////////////////////////////////////////////////////////////////////\r
 233 // CStdDialogBase - Base class for standard PPC/SmartPhone dialog\r
 234 \r
 235 template <class T, UINT t_shidiFlags, bool t_bModal = true>\r
 236 class CStdDialogBase\r
 237 {\r
 238 public:\r
 239 #ifdef WIN32_PLATFORM_PSPC\r
 240 // Pocket PC only Dialog title handling\r
 241         const int nTitleHeight;\r
 242 \r
 243         CStdDialogBase() : nTitleHeight(T::GetTitleHeight())\r
 244         { }\r
 245 \r
 246 // Overloads\r
 247         BOOL GetClientRect(LPRECT lpRect) \r
 248         {\r
 249                 T* pT = static_cast<T*>(this);\r
 250                 ATLASSERT(pT->IsWindow());\r
 251                 BOOL bRes = ::GetClientRect(pT->m_hWnd, lpRect);\r
 252                 lpRect->top += nTitleHeight;\r
 253                 return bRes;\r
 254         }\r
 255 \r
 256         BOOL SetWindowText(LPCTSTR lpszString)\r
 257         {\r
 258                 T* pT = static_cast<T*>(this);\r
 259                 ATLASSERT(pT->IsWindow());\r
 260                 BOOL bRes = ::SetWindowText(pT->m_hWnd, lpszString);\r
 261                 if (nTitleHeight != 0)\r
 262                         pT->DoPaintTitle();\r
 263                 return bRes;\r
 264         }\r
 265 \r
 266 // Overrideables\r
 267         static const int GetTitleHeight()\r
 268         {\r
 269         #ifdef _WTL_CE_DRA\r
 270                 return DRA::SCALEY(24);\r
 271         #else // !_WTL_CE_DRA\r
 272                 CWindowDC dc(NULL);\r
 273                 return dc.GetDeviceCaps(LOGPIXELSY) >> 2; // LOGPIXELSY * 24 / 96,\r
 274         #endif // !_WTL_CE_DRA\r
 275         }\r
 276 \r
 277         // Title painting\r
 278         bool DoPaintTitle()\r
 279         {\r
 280                 T* pT = static_cast<T*>(this);\r
 281                 ATLASSERT(pT->IsWindow());\r
 282                 TCHAR sTitle[48];\r
 283 \r
 284                 // Preparation\r
 285                 CPaintDC dc(pT->m_hWnd);\r
 286                 CFont fontTitle = AtlCreateBoldFont();\r
 287                 CFontHandle fontOld = dc.SelectFont(fontTitle);\r
 288                 dc.SetTextColor(GetSysColor(COLOR_HIGHLIGHT));\r
 289                 int nLen = pT->GetWindowText(sTitle, 48);\r
 290                 int nWidth = dc.GetDeviceCaps(HORZRES);\r
 291 \r
 292                 // Display title text\r
 293                 RECT rTitle = { 0, 0, nWidth, nTitleHeight };\r
 294                 dc.FillRect(&rTitle, COLOR_3DHIGHLIGHT);\r
 295         #ifdef _WTL_CE_DRA\r
 296                 rTitle.left = DRA::SCALEX(8);\r
 297         #else // !_WTL_CE_DRA\r
 298                 rTitle.left = nTitleHeight / 3; // 8 == 24 / 3\r
 299         #endif // !_WTL_CE_DRA\r
 300                 dc.DrawText(sTitle, nLen, &rTitle, DT_VCENTER | DT_SINGLELINE);\r
 301                 dc.SelectFont(fontOld);\r
 302 \r
 303                 // Draw bottom line, 2 pixels thick if HI_RES_AWARE\r
 304                 CPenHandle penOld = dc.SelectStockPen(BLACK_PEN);\r
 305                 POINT line[4] = {{0, nTitleHeight}, {nWidth, nTitleHeight}, {0, nTitleHeight - 1}, {nWidth, nTitleHeight - 1}};\r
 306 \r
 307         #ifdef _WTL_CE_DRA\r
 308                 int nSeg = DRA::SCALEY(1);\r
 309         #else // !_WTL_CE_DRA\r
 310                 int nSeg = nTitleHeight / 24; \r
 311         #endif // !_WTL_CE_DRA\r
 312 \r
 313                 dc.Polyline(line, nSeg <= 2 ? nSeg * 2 : 4);\r
 314                 dc.SelectPen(penOld);\r
 315 \r
 316                 return false;\r
 317         }\r
 318 \r
 319         // Title preparation: move the dialog controls down to make room for title\r
 320         void DialogTitleInit()\r
 321         {\r
 322                 T* pT = static_cast<T*>(this);\r
 323                 ATLASSERT(pT->IsWindow());\r
 324 \r
 325                 ATL::CWindow wCtl = pT->GetWindow(GW_CHILD);\r
 326                 while (wCtl.IsWindow())\r
 327                 {\r
 328                         RECT rCtl = { 0 };\r
 329                         wCtl.GetWindowRect(&rCtl);\r
 330                         ::MapWindowPoints(NULL, pT->m_hWnd, (LPPOINT)&rCtl, 2);\r
 331                         ::OffsetRect(&rCtl, 0, nTitleHeight);\r
 332                         wCtl.MoveWindow(&rCtl, FALSE);\r
 333                         wCtl = wCtl.GetWindow(GW_HWNDNEXT);\r
 334                 }\r
 335         }\r
 336 \r
 337         // SIP management\r
 338         void DoSipInfo()\r
 339         {\r
 340                 T* pT = static_cast<T*>(this);\r
 341                 ATLASSERT(pT->IsWindow());\r
 342 \r
 343                 SIPINFO si = {sizeof(SIPINFO)};\r
 344                 SipGetInfo(&si);\r
 345                 if ((si.fdwFlags & SIPF_ON) ^ SIPF_ON) \r
 346                         si.rcVisibleDesktop.bottom = si.rcSipRect.bottom;\r
 347                 pT->MoveWindow(&si.rcVisibleDesktop, FALSE);\r
 348         }\r
 349 \r
 350 // Title painting handler\r
 351         LRESULT OnPaintTitle(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)\r
 352         {\r
 353                 T* pT = static_cast<T*>(this);\r
 354                 return bHandled = nTitleHeight ? pT->DoPaintTitle() : FALSE;\r
 355         }\r
 356 \r
 357 // SIP handler\r
 358         LRESULT OnSettingChange(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)\r
 359         {\r
 360                 T* pT = static_cast<T*>(this);\r
 361                 if (wParam == SPI_SETSIPINFO)\r
 362                 {\r
 363                         pT->DoSipInfo();\r
 364                         return TRUE;\r
 365                 }\r
 366                 return bHandled = FALSE;\r
 367         }\r
 368 \r
 369 #elif defined WIN32_PLATFORM_WFSP\r
 370 // SmartPhone VK_TBACK key standard management\r
 371         LRESULT OnHotKey(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)\r
 372         {\r
 373                 T* pT = static_cast<T*>(this);\r
 374                 const UINT uModif = (UINT)LOWORD(lParam);\r
 375                 const UINT uVirtKey = (UINT)HIWORD(lParam);\r
 376 \r
 377                 if(uVirtKey == VK_TBACK)\r
 378                         if (AtlIsEditFocus())\r
 379                                 ::SHSendBackToFocusWindow(uMsg, wParam, lParam);\r
 380                         else if (uModif & MOD_KEYUP)\r
 381                                         pT->StdCloseDialog(IDCANCEL);\r
 382                 return 1;\r
 383         }\r
 384 \r
 385  // SmartPhone MenuBar and VK_TBACK key initialization\r
 386         void StdSPInit()\r
 387         {\r
 388                 T* pT = static_cast<T*>(this);\r
 389                 HWND hMenuBar = ::SHFindMenuBar(pT->m_hWnd);\r
 390 \r
 391                 if (!hMenuBar && (t_shidiFlags & SHIDIF_DONEBUTTON))\r
 392                         hMenuBar = CreateMenuBar(ATL_IDM_MENU_DONE);\r
 393 \r
 394                 if(hMenuBar != NULL)\r
 395                         AtlActivateBackKey(hMenuBar);\r
 396         }\r
 397 \r
 398         void SetStaticBold()\r
 399         {\r
 400                 T* pT = static_cast<T*>(this);\r
 401                 ATLASSERT(pT->IsWindow());\r
 402 \r
 403                 CFontHandle fontBold = AtlCreateBoldFont(pT->GetFont());\r
 404 \r
 405                 ATL::CWindow wCtl = pT->GetWindow(GW_CHILD);\r
 406 \r
 407                 while (wCtl.IsWindow())\r
 408                 {\r
 409                         if ((short int)wCtl.GetDlgCtrlID() == IDC_STATIC)\r
 410                                 wCtl.SetFont(fontBold);\r
 411                         wCtl = wCtl.GetWindow(GW_HWNDNEXT);\r
 412                 }\r
 413         }\r
 414 #endif // WIN32_PLATFORM_WFSP\r
 415 \r
 416 // Platform dependant initialization\r
 417         void StdPlatformInit()\r
 418         {\r
 419                 T* pT = static_cast<T*>(this);\r
 420 #ifdef WIN32_PLATFORM_PSPC // Pocket PC title initialization\r
 421                 if (nTitleHeight != 0)\r
 422                         pT->DialogTitleInit();\r
 423 #elif defined(WIN32_PLATFORM_WFSP)\r
 424                 pT->StdSPInit();\r
 425                 SetStaticBold();\r
 426 #endif // WIN32_PLATFORM_WFSP\r
 427         }\r
 428 \r
 429         // Menu bar creation\r
 430         HWND CreateMenuBar(UINT uiMB = T::IDD, int nBmpImages = 0)\r
 431         {\r
 432                 T* pT = static_cast<T*>(this);\r
 433                 return AtlCreateMenuBar(pT->m_hWnd, uiMB, 0, nBmpImages ? uiMB : 0, nBmpImages);\r
 434         }\r
 435 \r
 436         // Dialog closing\r
 437         void StdCloseDialog(WORD wID)\r
 438         {\r
 439                 T* pT = static_cast<T*>(this);\r
 440                 if (t_bModal)\r
 441                         ::EndDialog(pT->m_hWnd, wID);\r
 442                 else\r
 443                         pT->DestroyWindow();\r
 444         }\r
 445 \r
 446         // Shell dialog layout initialization\r
 447         void StdShidInit()\r
 448         {\r
 449                 T* pT = static_cast<T*>(this);\r
 450                 SHINITDLGINFO shidi = { SHIDIM_FLAGS, pT->m_hWnd, t_shidiFlags };\r
 451                 ::SHInitDialog(&shidi);\r
 452         }\r
 453 \r
 454 // IDC_INFOSTATIC background setting\r
 455         LRESULT OnColorStatic(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& bHandled)\r
 456         {\r
 457                 if (::GetDlgCtrlID((HWND)lParam) == IDC_INFOSTATIC)\r
 458                 {\r
 459                         ::SetBkMode((HDC)wParam, TRANSPARENT);\r
 460                         return (LRESULT)::GetSysColorBrush(COLOR_INFOBK);\r
 461                 }\r
 462                 return bHandled = FALSE;\r
 463         }\r
 464 \r
 465 // Menu dialog ending\r
 466         LRESULT OnMenuClose(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/)\r
 467         {\r
 468                 T* pT = static_cast<T*>(this);\r
 469                 pT->StdCloseDialog((WORD)(wID - ID_MENU_OK + IDOK));\r
 470                 return 0;\r
 471         }\r
 472 \r
 473 // Standard dialog ending: may be used with any command\r
 474         LRESULT OnCloseCmd(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/)\r
 475         {\r
 476                 T* pT = static_cast<T*>(this);\r
 477                 pT->StdCloseDialog(wID);\r
 478                 return 0;\r
 479         }\r
 480 };\r
 481 \r
 482 \r
 483 ///////////////////////////////////////////////////////////////////////////////\r
 484 // CStdDialogImplBase - Base implementation of standard PPC/SmartPhone dialog\r
 485 \r
 486 template <class T, UINT t_shidiFlags = WTL_STD_SHIDIF, bool t_bModal = true, class TBase = ATL::CDialogImpl< T > >\r
 487 class ATL_NO_VTABLE CStdDialogImplBase :\r
 488                 public TBase,\r
 489                 public CStdDialogBase<T, t_shidiFlags, t_bModal>\r
 490 {\r
 491 public:\r
 492 #ifdef WIN32_PLATFORM_PSPC\r
 493         BOOL GetClientRect(LPRECT lpRect) \r
 494         {\r
 495                 return CStdDialogBase<T, t_shidiFlags, t_bModal>::GetClientRect(lpRect);\r
 496         }\r
 497 \r
 498         BOOL SetWindowText(LPCTSTR lpszString)\r
 499         {\r
 500                 return CStdDialogBase<T, t_shidiFlags, t_bModal>::SetWindowText(lpszString);\r
 501         }\r
 502 #endif\r
 503 \r
 504         BEGIN_MSG_MAP(CStdDialogImplBase)\r
 505 #ifdef WIN32_PLATFORM_PSPC // Pocket PC title and SIP\r
 506                 MESSAGE_HANDLER(WM_PAINT, OnPaintTitle)\r
 507                 MESSAGE_HANDLER(WM_SETTINGCHANGE, OnSettingChange)\r
 508 #elif defined(WIN32_PLATFORM_WFSP) // SmartPhone VK_TBACK key\r
 509                 MESSAGE_HANDLER(WM_HOTKEY, OnHotKey)\r
 510 #endif\r
 511                 MESSAGE_HANDLER(WM_CTLCOLORSTATIC, OnColorStatic)\r
 512                 MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog)\r
 513                 COMMAND_RANGE_HANDLER(IDOK, IDCANCEL, OnCloseCmd)\r
 514                 COMMAND_RANGE_HANDLER(ID_MENU_OK, ID_MENU_CANCEL, OnMenuClose)\r
 515         END_MSG_MAP()\r
 516         \r
 517         LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)\r
 518         {\r
 519 #ifdef _DEBUG\r
 520                 T* pT = static_cast<T*>(this);\r
 521                 ATLASSERT(t_bModal == pT->m_bModal);\r
 522 #endif\r
 523                 StdPlatformInit();\r
 524                 StdShidInit();\r
 525                 return bHandled = FALSE;\r
 526         }\r
 527 };\r
 528 \r
 529 ///////////////////////////////////////////////////////////////////////////////\r
 530 // CStdDialogImpl - implementation of standard PPC/SmartPhone dialog\r
 531 \r
 532 template <class T, UINT t_shidiFlags = WTL_STD_SHIDIF, bool t_bModal = true >\r
 533 class ATL_NO_VTABLE CStdDialogImpl : public CStdDialogImplBase< T, t_shidiFlags, t_bModal>\r
 534 {};\r
 535 \r
 536 ///////////////////////////////////////////////////////////////////////////////\r
 537 // CStdIndirectDialogImpl - implementation of standard indirect PPC/SmartPhone dialog\r
 538 \r
 539 #if defined __ATLDLGS_H__ \r
 540 \r
 541 template <class T, UINT t_shidiFlags = WTL_STD_SHIDIF, bool t_bModal = true>\r
 542 class ATL_NO_VTABLE CStdIndirectDialogImpl : \r
 543         public CIndirectDialogImpl< T, CMemDlgTemplate, CStdDialogImpl<T, t_shidiFlags, t_bModal> >\r
 544 {\r
 545 public:\r
 546         typedef CIndirectDialogImpl< T, CMemDlgTemplate, CStdDialogImpl<T, t_shidiFlags, t_bModal> >    _baseClass;\r
 547         typedef CStdDialogImpl<T, t_shidiFlags, t_bModal> _baseStd;\r
 548 \r
 549         INT_PTR DoModal(HWND hWndParent = ::GetActiveWindow(), LPARAM dwInitParam = NULL)\r
 550         {\r
 551                 ATLASSERT(t_bModal);\r
 552 \r
 553                 if (!m_Template.IsValid())\r
 554                         CreateTemplate();\r
 555 \r
 556                 if (m_Template.IsTemplateEx())\r
 557                 {\r
 558                         if (m_Template.GetTemplateExPtr()->style & DS_CENTER)\r
 559                         {\r
 560                                 ATLASSERT(m_Template.GetTemplateExPtr()->style ^ WS_CHILD);\r
 561                                 GetTemplateExPtr()->style |= WS_POPUP;\r
 562                         }\r
 563                 }\r
 564                 else\r
 565                 {\r
 566                         if (m_Template.GetTemplatePtr()->style & DS_CENTER)\r
 567                         {\r
 568                                 ATLASSERT(m_Template.GetTemplatePtr()->style ^ WS_CHILD);\r
 569                                 m_Template.GetTemplatePtr()->style |= WS_POPUP;\r
 570                         }\r
 571                 }\r
 572 \r
 573                 return _baseClass::DoModal(hWndParent, dwInitParam);\r
 574         }\r
 575 \r
 576         HWND Create(HWND hWndParent, LPARAM dwInitParam = NULL)\r
 577         {\r
 578                 ATLASSERT(!t_bModal);\r
 579 \r
 580                 if (!m_Template.IsValid())\r
 581                         CreateTemplate();\r
 582 \r
 583                 if (m_Template.IsTemplateEx())\r
 584                 {\r
 585                         if (GetTemplateExPtr()->style & DS_CENTER)\r
 586                         {\r
 587                                 ATLASSERT(GetTemplateExPtr()->style ^ WS_CHILD);\r
 588                                 GetTemplateExPtr()->style |= WS_POPUP;\r
 589                         }\r
 590                 }\r
 591                 else\r
 592                 {\r
 593                         if (GetTemplatePtr()->style & DS_CENTER)\r
 594                         {\r
 595                                 ATLASSERT(GetTemplatePtr()->style ^ WS_CHILD);\r
 596                                 GetTemplatePtr()->style |= WS_POPUP;\r
 597                         }\r
 598                 }\r
 599 \r
 600                 return _baseClass::Create(hWndParent, dwInitParam);\r
 601         }\r
 602 \r
 603         BEGIN_MSG_MAP(CStdIndirectDialogImpl)\r
 604                 CHAIN_MSG_MAP(_baseStd)\r
 605         END_MSG_MAP()\r
 606 \r
 607 };\r
 608  \r
 609 #endif // defined __ATLDLGS_H__ \r
 610 \r
 611 #ifndef _ATL_NO_HOSTING\r
 612 \r
 613 ///////////////////////////////////////////////////////////////////////////////\r
 614 // CStdAxDialogImpl - implementation of standard  PPC/SmartPhone AxDialog\r
 615 \r
 616 template <class T, UINT t_shidiFlags = WTL_STD_SHIDIF, bool t_bModal = true >\r
 617 class ATL_NO_VTABLE CStdAxDialogImpl : public CStdDialogImplBase< T, t_shidiFlags, t_bModal, ATL::CAxDialogImpl< T > >\r
 618 {};\r
 619 #endif // _ATL_NO_HOSTING\r
 620 \r
 621 ///////////////////////////////////////////////////////////////////////////////\r
 622 // CStdSimpleDialog - standard PPC/SmartPhone simple dialog with SHIDIF_xxx flags\r
 623 \r
 624 template <WORD t_wDlgTemplateID, UINT t_shidiFlags = WTL_STD_SHIDIF>\r
 625 class CStdSimpleDialog :\r
 626                 public ATL::CSimpleDialog<t_wDlgTemplateID, FALSE>,\r
 627                 public CStdDialogBase<CStdSimpleDialog<t_wDlgTemplateID, t_shidiFlags>, t_shidiFlags>\r
 628 {\r
 629 public:\r
 630         typedef CStdDialogBase<CStdSimpleDialog<t_wDlgTemplateID, t_shidiFlags>, t_shidiFlags> baseClass;\r
 631 \r
 632 #ifdef WIN32_PLATFORM_PSPC\r
 633         BOOL GetClientRect(LPRECT lpRect) \r
 634         {\r
 635                 return baseClass::GetClientRect(lpRect);\r
 636         }\r
 637 \r
 638         BOOL SetWindowText(LPCTSTR lpszString)\r
 639         {\r
 640                 return baseClass::SetWindowText(lpszString);\r
 641         }\r
 642 #endif\r
 643 \r
 644         BEGIN_MSG_MAP(CStdSimpleDialog)\r
 645 #ifdef WIN32_PLATFORM_PSPC // Pocket PC title and SIP\r
 646                 MESSAGE_HANDLER(WM_PAINT, OnPaintTitle)\r
 647                 MESSAGE_HANDLER(WM_SETTINGCHANGE, OnSettingChange)\r
 648 #elif defined(WIN32_PLATFORM_WFSP) // SmartPhone VK_TBACK key\r
 649                 MESSAGE_HANDLER(WM_HOTKEY, OnHotKey)\r
 650 #endif\r
 651                 MESSAGE_HANDLER(WM_CTLCOLORSTATIC, OnColorStatic)\r
 652                 MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog)\r
 653                 COMMAND_RANGE_HANDLER(ID_MENU_OK, ID_MENU_CANCEL, OnMenuClose)\r
 654                 COMMAND_RANGE_HANDLER(IDOK, IDCANCEL, baseClass::OnCloseCmd)\r
 655         END_MSG_MAP()\r
 656 \r
 657         LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)\r
 658         {\r
 659                 StdPlatformInit();\r
 660                 StdShidInit();\r
 661                 return bHandled = FALSE;\r
 662         }\r
 663 };\r
 664 \r
 665 ///////////////////////////////////////////////////////////////////////////////\r
 666 // CStdDialogResizeImplBase - Base implementation of orientation resizing standard PPC/SmartPhone dialog\r
 667 \r
 668 template <class T, UINT t_shidiFlags = WTL_STD_SHIDIF, bool t_bModal = true, class TBase = ATL::CDialogImpl<T> >\r
 669 class ATL_NO_VTABLE CStdDialogResizeImplBase :\r
 670                 public CStdDialogImplBase< T, t_shidiFlags, t_bModal, TBase>,\r
 671                 public CDialogResize<T>\r
 672 {\r
 673 public:\r
 674         // Note: BEGIN_DLGRESIZE_MAP is required in the derived class.\r
 675 \r
 676         BEGIN_MSG_MAP(CStdResizeDialogImplBase)\r
 677 #ifdef WIN32_PLATFORM_PSPC // Pocket PC title\r
 678                 MESSAGE_HANDLER(WM_PAINT, OnPaintTitle)\r
 679 #elif defined(WIN32_PLATFORM_WFSP) // SmartPhone VK_TBACK key\r
 680                 MESSAGE_HANDLER(WM_HOTKEY, OnHotKey)\r
 681 #endif\r
 682                 MESSAGE_HANDLER(WM_CTLCOLORSTATIC, OnColorStatic)\r
 683                 MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog)\r
 684                 COMMAND_RANGE_HANDLER(IDOK, IDCANCEL, OnCloseCmd)\r
 685                 COMMAND_RANGE_HANDLER(ID_MENU_OK, ID_MENU_CANCEL, OnMenuClose)\r
 686                 CHAIN_MSG_MAP(CDialogResize< T >)\r
 687         END_MSG_MAP()\r
 688 \r
 689         LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)\r
 690         {\r
 691 #ifdef _DEBUG\r
 692                 T* pT = static_cast<T*>(this);\r
 693                 ATLASSERT(t_bModal == pT->m_bModal);\r
 694 #endif\r
 695                 StdPlatformInit();\r
 696                 DlgResize_Init(FALSE);\r
 697                 StdShidInit();\r
 698                 return bHandled = FALSE;\r
 699         }\r
 700 };\r
 701 \r
 702 ///////////////////////////////////////////////////////////////////////////////\r
 703 // CStdDialogResizeImpl - implementation of orientation resizing standard PPC/SmartPhone dialog\r
 704 \r
 705 template <class T, UINT t_shidiFlags = WTL_STD_SHIDIF, bool t_bModal = true >\r
 706 class ATL_NO_VTABLE CStdDialogResizeImpl : public CStdDialogResizeImplBase< T, t_shidiFlags, t_bModal>\r
 707 {};\r
 708 \r
 709 #ifndef _ATL_NO_HOSTING\r
 710 \r
 711 ///////////////////////////////////////////////////////////////////////////////\r
 712 // CStdAxDialogResizeImpl - implementation of orientation resizing standard PPC/SmartPhone AxDialog\r
 713 \r
 714 template <class T, UINT t_shidiFlags = WTL_STD_SHIDIF, bool t_bModal = true >\r
 715 class ATL_NO_VTABLE CStdAxDialogResizeImpl : public CStdDialogResizeImplBase< T, t_shidiFlags, t_bModal, ATL::CAxDialogImpl<T> >\r
 716 {};\r
 717 #endif // _ATL_NO_HOSTING\r
 718 \r
 719 ///////////////////////////////////////////////////////////////////////////////\r
 720 // CStdSimpleDialogResizeImpl - implementation of standard resizing simple dialog with SHIDIF_xxx flags\r
 721 \r
 722 // Usage:\r
 723 //      class CMyDlg : public CStdSimpleDialogResize<CMyDlg,\r
 724 //              IDD_MYDLG, SHIDIF_DONEBUTTON | SHIDIF_FULLSCREENNOMENUBAR>\r
 725 //      {\r
 726 //      public:\r
 727 //              BEGIN_DLGRESIZE_MAP(CMyDlg)\r
 728 //              ...\r
 729 //              END_DLGRESIZE_MAP()\r
 730 //      };\r
 731 \r
 732 template <class T, WORD t_wDlgTemplateID, UINT t_shidiFlags = WTL_STD_SHIDIF>\r
 733 class ATL_NO_VTABLE CStdSimpleDialogResizeImpl :\r
 734                 public CStdSimpleDialog<t_wDlgTemplateID, t_shidiFlags>,\r
 735                 public CDialogResize< T >\r
 736 {\r
 737 public:\r
 738         typedef CStdSimpleDialog<t_wDlgTemplateID, t_shidiFlags>::baseClass baseClass;\r
 739 \r
 740         BEGIN_MSG_MAP(CStdSimpleDialogResizeImpl)\r
 741 #ifdef WIN32_PLATFORM_PSPC // Pocket PC title\r
 742                 MESSAGE_HANDLER(WM_PAINT, OnPaintTitle)\r
 743 #elif defined(WIN32_PLATFORM_WFSP) // SmartPhone VK_TBACK key\r
 744                 MESSAGE_HANDLER(WM_HOTKEY, OnHotKey)\r
 745 #endif\r
 746                 MESSAGE_HANDLER(WM_CTLCOLORSTATIC, OnColorStatic)\r
 747                 MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog)\r
 748                 COMMAND_RANGE_HANDLER(IDOK, IDCANCEL, baseClass::OnCloseCmd)\r
 749                 COMMAND_RANGE_HANDLER(ID_MENU_OK, ID_MENU_CANCEL, OnMenuClose)\r
 750                 CHAIN_MSG_MAP(CDialogResize< T >)\r
 751         END_MSG_MAP()\r
 752 \r
 753         LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)\r
 754         {\r
 755                 StdPlatformInit();\r
 756                 DlgResize_Init(FALSE);\r
 757                 StdShidInit();\r
 758                 return bHandled = FALSE;\r
 759         }\r
 760 };\r
 761 \r
 762 #if defined(_WTL_CE_DRA) && defined(WIN32_PLATFORM_PSPC)\r
 763 \r
 764 ///////////////////////////////////////////////////////////////////////////////\r
 765 // CStdOrientedDialogBase - Oriented PPC standard dialog base class\r
 766 \r
 767 template <class T>\r
 768 class CStdOrientedDialogBase\r
 769 {\r
 770 public:\r
 771 // Operation\r
 772         BOOL SetOrientation(DRA::DisplayMode mode)\r
 773         {\r
 774                 T* pT = static_cast<T*>(this);\r
 775                 ATLASSERT(pT->IsWindow());\r
 776                 ATLASSERT(mode == DRA::GetDisplayMode());\r
 777                 \r
 778                 // Derived dialog must enumerate TWO dialog templates with the same control ids and types ie:\r
 779                 // enum { IDD = IDD_MYDLG, IDD_LANDSCAPE = IDD_MYDLG_L };\r
 780                 UINT iResource = (mode == DRA::Landscape)? T::IDD_LANDSCAPE : T::IDD;\r
 781 \r
 782                 BOOL bRes = DRA::RelayoutDialog(ModuleHelper::GetResourceInstance(), pT->m_hWnd, MAKEINTRESOURCE(iResource));\r
 783                 pT->OnOrientation(mode);\r
 784                 return bRes;\r
 785         }\r
 786 \r
 787 // Override\r
 788         void OnOrientation(DRA::DisplayMode /*mode*/)\r
 789         {}\r
 790 \r
 791 // Message handlers\r
 792         LRESULT OnSettingChange(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)\r
 793         {\r
 794                 T* pT = static_cast<T*>(this);\r
 795                 ATLASSERT(pT->IsWindow());\r
 796                 if (wParam == SETTINGCHANGE_RESET)\r
 797                 {\r
 798                         SetOrientation(DRA::GetDisplayMode());\r
 799                         pT->StdPlatformInit();\r
 800                         pT->StdShidInit();\r
 801                 }\r
 802                 else if (wParam == SPI_SETSIPINFO)\r
 803                 {\r
 804                         pT->DoSipInfo();\r
 805                         return TRUE;\r
 806                 }\r
 807                 return bHandled = FALSE;\r
 808         }\r
 809 };\r
 810 \r
 811 ///////////////////////////////////////////////////////////////////////////////\r
 812 // CStdOrientedDialogImplBase - Oriented PPC standard dialog base implementation\r
 813 \r
 814 template <class T, UINT t_shidiFlags = WTL_STD_SHIDIF, bool t_bModal = true, class TBase = ATL::CDialogImpl<T> >\r
 815 class ATL_NO_VTABLE CStdOrientedDialogImplBase :\r
 816                 public CStdDialogImplBase< T, t_shidiFlags, t_bModal, TBase>,\r
 817                 public CStdOrientedDialogBase<T>\r
 818 {\r
 819 public:\r
 820         BEGIN_MSG_MAP(CStdOrientedDialogImpl)\r
 821                 MESSAGE_HANDLER(WM_PAINT, OnPaintTitle)\r
 822                 MESSAGE_HANDLER(WM_CTLCOLORSTATIC, OnColorStatic)\r
 823                 MESSAGE_HANDLER(WM_SETTINGCHANGE, CStdOrientedDialogBase<T>::OnSettingChange)\r
 824                 MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog)\r
 825                 COMMAND_RANGE_HANDLER(IDOK, IDCANCEL, OnCloseCmd)\r
 826                 COMMAND_RANGE_HANDLER(ID_MENU_OK, ID_MENU_CANCEL, OnMenuClose)\r
 827         END_MSG_MAP()\r
 828 \r
 829         LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)\r
 830         {\r
 831                 T* pT = static_cast<T*>(this);\r
 832 #ifdef _DEBUG\r
 833                 ATLASSERT(t_bModal == pT->m_bModal);\r
 834 #endif\r
 835                 if (DRA::GetDisplayMode() == DRA::Landscape)\r
 836                         SetOrientation(DRA::Landscape);\r
 837                 pT->StdPlatformInit();\r
 838                 pT->StdShidInit();\r
 839                 return bHandled = FALSE;\r
 840         }\r
 841 };\r
 842 \r
 843 ///////////////////////////////////////////////////////////////////////////////\r
 844 // CStdOrientedDialogImpl - Oriented PPC standard dialog implementation\r
 845 \r
 846 template <class T, UINT t_shidiFlags = WTL_STD_SHIDIF, bool t_bModal = true >\r
 847 class ATL_NO_VTABLE CStdOrientedDialogImpl : public CStdOrientedDialogImplBase< T, t_shidiFlags, t_bModal>\r
 848 {};\r
 849 \r
 850 #ifndef _ATL_NO_HOSTING\r
 851 ///////////////////////////////////////////////////////////////////////////////\r
 852 // CStdAxOrientedDialogImpl - Oriented PPC standard AxDialog implementation\r
 853 \r
 854 template <class T, UINT t_shidiFlags = WTL_STD_SHIDIF, bool t_bModal = true >\r
 855 class ATL_NO_VTABLE CStdAxOrientedDialogImpl : public CStdOrientedDialogImplBase< T, t_shidiFlags, t_bModal, ATL::CAxDialogImpl<T> >\r
 856 {};\r
 857 #endif // _ATL_NO_HOSTING\r
 858 \r
 859 ///////////////////////////////////////////////////////////////////////////////\r
 860 // CStdSimpleOrientedDialog - Standard simple orientable dialog\r
 861 \r
 862 template <WORD t_wDlgTemplateID, WORD t_wDlgLandscapeID, UINT t_shidiFlags = WTL_STD_SHIDIF>\r
 863 class CStdSimpleOrientedDialog :\r
 864                 public CStdSimpleDialog<t_wDlgTemplateID, t_shidiFlags>,\r
 865                 public CStdOrientedDialogBase<CStdSimpleOrientedDialog<t_wDlgTemplateID, t_wDlgLandscapeID, t_shidiFlags> >\r
 866 {\r
 867 public:\r
 868         typedef CStdSimpleDialog<t_wDlgTemplateID, t_shidiFlags>::baseClass baseClass;\r
 869         typedef CStdOrientedDialogBase<CStdSimpleOrientedDialog<t_wDlgTemplateID, t_wDlgLandscapeID, t_shidiFlags> > baseOriented;\r
 870 \r
 871         enum {IDD = t_wDlgTemplateID, IDD_LANDSCAPE = t_wDlgLandscapeID};\r
 872 \r
 873         BEGIN_MSG_MAP(CStdSimpleDialog)\r
 874                 MESSAGE_HANDLER(WM_PAINT, OnPaintTitle)\r
 875                 MESSAGE_HANDLER(WM_CTLCOLORSTATIC, OnColorStatic)\r
 876                 MESSAGE_HANDLER(WM_SETTINGCHANGE, baseOriented::OnSettingChange)\r
 877                 MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog)\r
 878                 COMMAND_RANGE_HANDLER(IDOK, IDCANCEL, baseClass::OnCloseCmd)\r
 879                 COMMAND_RANGE_HANDLER(ID_MENU_OK, ID_MENU_CANCEL, OnMenuClose)\r
 880         END_MSG_MAP()\r
 881 \r
 882                 LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)\r
 883         {\r
 884                 if (DRA::GetDisplayMode() == DRA::Landscape)\r
 885                         SetOrientation(DRA::Landscape);\r
 886                 StdPlatformInit();\r
 887                 StdShidInit();\r
 888                 return bHandled = FALSE;\r
 889         }\r
 890 };\r
 891 \r
 892 #endif // _WTL_CE_DRA\r
 893 \r
 894 \r
 895 #endif // _WTL_CE_NO_DIALOGS\r
 896 \r
 897 \r
 898 // --- PPC/SmartPhone application window and helpers ---\r
 899 \r
 900 #ifndef _WTL_CE_NO_APPWINDOW\r
 901 \r
 902 ///////////////////////////////////////////////////////////////////////////////\r
 903 // CAppInfoBase - Helper for application state save/restore to registry\r
 904 \r
 905 class CAppInfoBase\r
 906 {\r
 907 public:\r
 908         ATL::CRegKey m_Key;\r
 909 \r
 910         CAppInfoBase(ATL::_U_STRINGorID sAppKey)\r
 911         {\r
 912                 m_Key.Create(HKEY_CURRENT_USER, sAppKey.m_lpstr);\r
 913                 ATLASSERT(m_Key.m_hKey);\r
 914         }\r
 915 \r
 916         template <class V>\r
 917         LONG Save(V& val, ATL::_U_STRINGorID sName)\r
 918         {\r
 919                 return ::RegSetValueEx(m_Key, sName.m_lpstr, 0, REG_BINARY, (LPBYTE)&val, sizeof(V));\r
 920         }\r
 921 \r
 922         template <class V>\r
 923         LONG Save(int nb, V& val0, ATL::_U_STRINGorID sName)\r
 924         {\r
 925                 return ::RegSetValueEx(m_Key, sName.m_lpstr, 0, REG_BINARY, (LPBYTE)&val0, nb * sizeof(V));\r
 926         }\r
 927 \r
 928         template <class V>\r
 929         LONG Restore(V& val, ATL::_U_STRINGorID sName)\r
 930         {\r
 931                 DWORD valtype;\r
 932                 DWORD bufSize = sizeof(V);\r
 933                 return ::RegQueryValueEx(m_Key, sName.m_lpstr, 0, &valtype, (LPBYTE)&val, &bufSize);\r
 934         }\r
 935 \r
 936         template <class V>\r
 937         LONG Restore(int nb, V& val0, ATL::_U_STRINGorID sName)\r
 938         {\r
 939                 DWORD valtype;\r
 940                 DWORD bufSize = nb * sizeof(V);\r
 941                 return ::RegQueryValueEx(m_Key, sName.m_lpstr, 0, &valtype, (LPBYTE)&val0, &bufSize);\r
 942         }\r
 943 \r
 944 #if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)\r
 945 #if (_ATL_VER < 0x0800)\r
 946         LONG Save(_CSTRING_NS::CString& sval, ATL::_U_STRINGorID sName)\r
 947         {\r
 948                 return m_Key.SetValue(sval, sName.m_lpstr);\r
 949         }\r
 950 \r
 951         LONG Restore(_CSTRING_NS::CString& sval, ATL::_U_STRINGorID sName)\r
 952         {\r
 953                 DWORD size = MAX_PATH;\r
 954                 LONG res = m_Key.QueryValue(sval.GetBuffer(size), sName.m_lpstr, &size);\r
 955                 sval.ReleaseBuffer();\r
 956                 return res;\r
 957         }\r
 958 #else // !(_ATL_VER < 0x0800)\r
 959         LONG Save(_CSTRING_NS::CString& sval, ATL::_U_STRINGorID sName)\r
 960         {\r
 961                 return m_Key.SetStringValue(sName.m_lpstr, sval);\r
 962         }\r
 963 \r
 964         LONG Restore(_CSTRING_NS::CString& sval, ATL::_U_STRINGorID sName)\r
 965         {\r
 966                 DWORD size = MAX_PATH;\r
 967                 LONG res = m_Key.QueryStringValue(sName.m_lpstr, sval.GetBuffer(size), &size);\r
 968                 sval.ReleaseBuffer();\r
 969                 return res;\r
 970         }\r
 971 #endif // !(_ATL_VER < 0x0800)\r
 972 #else\r
 973   #pragma message("Warning: CAppInfoBase compiles without CString support. Do not use CString in Save or Restore.")\r
 974 #endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)\r
 975         \r
 976 #if (_ATL_VER < 0x0800)\r
 977         LONG Save(LPCTSTR sval, ATL::_U_STRINGorID sName)\r
 978         {\r
 979                 return m_Key.SetValue(sval, sName.m_lpstr);\r
 980         }\r
 981 \r
 982         LONG Restore(LPTSTR sval, ATL::_U_STRINGorID sName, DWORD *plength)\r
 983         {\r
 984                 return m_Key.QueryValue(sval, sName.m_lpstr, plength);\r
 985         }\r
 986 #else // !(_ATL_VER < 0x0800)\r
 987         LONG Save(LPCTSTR sval, ATL::_U_STRINGorID sName)\r
 988         {\r
 989                 return m_Key.SetStringValue(sName.m_lpstr, sval);\r
 990         }\r
 991 \r
 992         LONG Restore(LPTSTR sval, ATL::_U_STRINGorID sName, DWORD *plength)\r
 993         {\r
 994                 return m_Key.QueryStringValue(sName.m_lpstr, sval, plength);\r
 995         }\r
 996 #endif // !(_ATL_VER < 0x0800)\r
 997         \r
 998         LONG Delete(ATL::_U_STRINGorID sName)\r
 999         {\r
1000                 return  m_Key.DeleteValue(sName.m_lpstr);\r
1001         }\r
1002 };\r
1003 \r
1004 \r
1005 ///////////////////////////////////////////////////////////////////////////////\r
1006 // CAppInfoT - CAppInfoBase constructed from a class with T::GetAppKey() \r
1007 \r
1008 // Macro for declaring AppKey\r
1009 #define DECLARE_APPKEY(uAppKey) \\r
1010         static LPCTSTR GetAppKey() \\r
1011         { \\r
1012                 static LPCTSTR sAppKey = ATL::_U_STRINGorID(uAppKey).m_lpstr; \\r
1013                 return sAppKey; \\r
1014         }\r
1015 \r
1016 template <class T>\r
1017 class CAppInfoT : public CAppInfoBase\r
1018 {\r
1019 public:\r
1020         CAppInfoT() : CAppInfoBase(T::GetAppKey()){}\r
1021 };\r
1022 \r
1023 \r
1024 ///////////////////////////////////////////////////////////////////////////////\r
1025 // CAppWindowBase - Base class for PPC/SmartPhone "well-behaved" application window or dialog\r
1026 \r
1027 // Macros for declaring frame WNDCLASS and AppKey\r
1028 #define DECLARE_APP_FRAME_CLASS(WndClassName, uCommonResourceID, uAppKey) \\r
1029         DECLARE_FRAME_WND_CLASS(WndClassName, uCommonResourceID) \\r
1030         DECLARE_APPKEY(uAppKey)\r
1031 \r
1032 #define DECLARE_APP_FRAME_CLASS_EX(WndClassName, uCommonResourceID, style, bkgnd, uAppKey) \\r
1033         DECLARE_FRAME_WND_CLASS_EX(WndClassName, uCommonResourceID, style, bkgnd) \\r
1034         DECLARE_APPKEY(uAppKey)\r
1035 \r
1036 template <class T>\r
1037 class CAppWindowBase\r
1038 {\r
1039 public:\r
1040         typedef class CAppInfoT< T > CAppInfo;\r
1041 \r
1042 #ifndef WIN32_PLATFORM_WFSP\r
1043         SHACTIVATEINFO m_sai; // NoOp on SmartPhones\r
1044 #endif // WIN32_PLATFORM_WFSP\r
1045 \r
1046         bool m_bHibernate;\r
1047 \r
1048         CAppWindowBase< T >() : m_bHibernate(false)\r
1049         {\r
1050 #ifndef WIN32_PLATFORM_WFSP\r
1051                 SHACTIVATEINFO sai = { sizeof(SHACTIVATEINFO) };\r
1052                 m_sai = sai;\r
1053 #endif // WIN32_PLATFORM_WFSP\r
1054         };\r
1055 \r
1056         // Same as WTL 7.1 AppWizard generated ActivatePreviousInstance + SendMessage WM_COPYDATA\r
1057         static HRESULT ActivatePreviousInstance(HINSTANCE hInstance, LPCTSTR  lpstrCmdLine, bool bDialog)\r
1058         {\r
1059                 // requires T does DECLARE_APP_FRAME_CLASS, DECLARE_APP_FRAME_CLASS_EX or DECLARE_APP_DLG_CLASS\r
1060                 CFrameWndClassInfo& classInfo = T::GetWndClassInfo();\r
1061 \r
1062                 ATLVERIFY(::LoadString(hInstance, classInfo.m_uCommonResourceID, classInfo.m_szAutoName, sizeof(classInfo.m_szAutoName)/sizeof(classInfo.m_szAutoName[0])) != 0);\r
1063 \r
1064                 classInfo.m_wc.lpszClassName = classInfo.m_szAutoName;\r
1065 \r
1066                 const TCHAR* pszClass = classInfo.m_wc.lpszClassName;\r
1067 \r
1068                 if(NULL == pszClass || '\0' == *pszClass)\r
1069                 {\r
1070                         return E_FAIL;\r
1071                 }\r
1072 \r
1073                 const DWORD dRetryInterval = 100;\r
1074                 const int iMaxRetries = 25;\r
1075 \r
1076                 for(int i = 0; i < iMaxRetries; ++i)\r
1077                 {\r
1078                         HANDLE hMutex = CreateMutex(NULL, FALSE, pszClass);\r
1079 \r
1080                         DWORD dw = GetLastError();\r
1081 \r
1082                         if(NULL == hMutex)\r
1083                         {\r
1084                                 HRESULT hr;\r
1085 \r
1086                                 switch(dw)\r
1087                                 {\r
1088                                 case ERROR_INVALID_HANDLE:\r
1089                                         // A non-mutext object with this name already exists.\r
1090                                         hr = E_INVALIDARG;\r
1091                                         break;\r
1092                                 default:\r
1093                                         // This should never happen...\r
1094                                         hr = E_FAIL;\r
1095                                 }\r
1096 \r
1097                                 return hr;\r
1098                         }\r
1099 \r
1100                         // If the mutex already exists, then there should be another instance running\r
1101                         if(dw == ERROR_ALREADY_EXISTS)\r
1102                         {\r
1103                                 CloseHandle(hMutex);\r
1104                                 \r
1105                                 HWND hwnd = NULL;\r
1106                                 if (bDialog)\r
1107                                         hwnd = FindWindow(NULL, pszClass);\r
1108                                 else\r
1109                                         hwnd = FindWindow(pszClass, NULL);\r
1110 \r
1111                                 if(hwnd == NULL)\r
1112                                 {\r
1113                                         Sleep(dRetryInterval);\r
1114                                         continue;\r
1115                                 }\r
1116                                 else\r
1117                                 {\r
1118                                         // Transmit our params to previous instance\r
1119                                         if (lpstrCmdLine && *lpstrCmdLine)\r
1120                                         {\r
1121                                                 COPYDATASTRUCT cd = { NULL, sizeof(TCHAR) * (wcslen(lpstrCmdLine) + 1), (PVOID)lpstrCmdLine };\r
1122                                                 ::SendMessage(hwnd, WM_COPYDATA, NULL, (LPARAM)&cd);\r
1123                                         }\r
1124                                         // Set the previous instance as the foreground window\r
1125                                         if(0 != SetForegroundWindow(reinterpret_cast<HWND>(reinterpret_cast<ULONG>(hwnd) | 0x1)))\r
1126                                                 return S_FALSE;\r
1127                                 }\r
1128                         }\r
1129                         else\r
1130                         {\r
1131                                 return S_OK;\r
1132                         }\r
1133                 }\r
1134                 return S_OK;\r
1135         }\r
1136 \r
1137 // Operations overriden in derived class\r
1138         bool AppHibernate(bool /*bHibernate*/)\r
1139         {\r
1140                 return false;\r
1141         }\r
1142 \r
1143         bool AppNewInstance(LPCTSTR /*lpstrCmdLine*/)\r
1144         {\r
1145                 return false;\r
1146         }\r
1147 \r
1148         void AppSave()\r
1149         {\r
1150         }\r
1151 \r
1152 #ifdef WIN32_PLATFORM_WFSP \r
1153         void AppBackKey() \r
1154         {\r
1155                 ::SHNavigateBack();\r
1156         }\r
1157 #endif\r
1158 \r
1159 // Message map and handlers\r
1160         BEGIN_MSG_MAP(CAppWindowBase)\r
1161                 MESSAGE_HANDLER(WM_ACTIVATE, OnActivate)\r
1162 #ifdef WIN32_PLATFORM_WFSP\r
1163                 MESSAGE_HANDLER(WM_HOTKEY, OnHotKey)\r
1164 #else\r
1165                 MESSAGE_HANDLER(WM_SETTINGCHANGE, OnSettingChange)\r
1166 #endif // WIN32_PLATFORM_WFSP\r
1167                 MESSAGE_HANDLER(WM_HIBERNATE, OnHibernate)\r
1168                 MESSAGE_HANDLER(WM_COPYDATA, OnNewInstance)\r
1169                 MESSAGE_HANDLER(WM_CLOSE, OnClose)\r
1170         END_MSG_MAP()\r
1171 \r
1172         LRESULT OnActivate(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& bHandled)\r
1173         {\r
1174                 T* pT = static_cast<T*>(this);\r
1175                 if (m_bHibernate)\r
1176                         m_bHibernate = pT->AppHibernate(false);\r
1177 #ifndef WIN32_PLATFORM_WFSP\r
1178                 ::SHHandleWMActivate(pT->m_hWnd, wParam, lParam, &m_sai, 0);\r
1179 #else\r
1180                 wParam;\r
1181                 lParam;\r
1182 #endif // WIN32_PLATFORM_WFSP\r
1183                  return bHandled = FALSE;\r
1184         }\r
1185 \r
1186 #ifdef WIN32_PLATFORM_WFSP\r
1187 // SmartPhone VK_TBACK key standard management\r
1188         LRESULT OnHotKey(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)\r
1189         {\r
1190                 T* pT = static_cast<T*>(this);\r
1191                 const UINT uModif = (UINT)LOWORD(lParam);\r
1192                 const UINT uVirtKey = (UINT)HIWORD(lParam);\r
1193                 if(uVirtKey == VK_TBACK)\r
1194                         if (AtlIsEditFocus())\r
1195                                 ::SHSendBackToFocusWindow(uMsg, wParam, lParam);\r
1196                         else if (uModif & MOD_KEYUP)\r
1197                                 pT->AppBackKey();\r
1198                 return 1;\r
1199         }\r
1200 \r
1201 #else // !WIN32_PLATFORM_WFSP\r
1202 // PPC SIP handling\r
1203         LRESULT OnSettingChange(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& bHandled)\r
1204         {\r
1205                 T* pT = static_cast<T*>(this);\r
1206                 bHandled = FALSE;\r
1207                 return ::SHHandleWMSettingChange(pT->m_hWnd, wParam, lParam, &m_sai);\r
1208         }\r
1209 #endif // !WIN32_PLATFORM_WFSP\r
1210 \r
1211         LRESULT OnHibernate(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)\r
1212         {\r
1213                 T* pT = static_cast<T*>(this);\r
1214                 return m_bHibernate = pT->AppHibernate(true);\r
1215         }\r
1216 \r
1217         LRESULT OnNewInstance(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& /*bHandled*/)\r
1218         {\r
1219                 T* pT = static_cast<T*>(this);\r
1220                 PCOPYDATASTRUCT pcds = (PCOPYDATASTRUCT)lParam;\r
1221                 return pT->AppNewInstance((LPCTSTR)pcds->lpData);\r
1222         }\r
1223 \r
1224         LRESULT OnClose(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)\r
1225         {\r
1226                 T* pT = static_cast<T*>(this);\r
1227                 pT->AppSave();\r
1228                 bHandled = FALSE;\r
1229                 return 1;\r
1230         }\r
1231 };\r
1232 \r
1233 \r
1234 ///////////////////////////////////////////////////////////////////////////////\r
1235 // CAppWindow - PPC/SmartPhone "well-behaved" application window class\r
1236 \r
1237 template <class T>\r
1238 class CAppWindow : public CAppWindowBase< T >\r
1239 {\r
1240 public:\r
1241         // Same as WTL 7.1 AppWizard generated Run + lpstrCmdLine in CreateEx\r
1242         static int AppRun(LPTSTR lpstrCmdLine = NULL, int nCmdShow = SW_SHOWNORMAL)\r
1243         {\r
1244                 CMessageLoop theLoop;\r
1245                 _Module.AddMessageLoop(&theLoop);\r
1246 \r
1247                 T wndMain;\r
1248 \r
1249                 if(wndMain.CreateEx(NULL, NULL, 0, 0, lpstrCmdLine) == NULL)\r
1250                 {\r
1251                         ATLTRACE2(atlTraceUI, 0, _T("Main window creation failed!\n"));\r
1252                         return 0;\r
1253                 }\r
1254 \r
1255                 wndMain.ShowWindow(nCmdShow);\r
1256 \r
1257                 int nRet = theLoop.Run();\r
1258 \r
1259                 _Module.RemoveMessageLoop();\r
1260                 return nRet;\r
1261         }\r
1262 \r
1263         static HRESULT ActivatePreviousInstance(HINSTANCE hInstance, LPCTSTR  lpstrCmdLine)\r
1264         {\r
1265                 return CAppWindowBase< T >::ActivatePreviousInstance(hInstance, lpstrCmdLine, false);\r
1266         }\r
1267 };\r
1268 \r
1269 \r
1270 #ifndef _WTL_CE_NO_DIALOGS\r
1271 \r
1272 ///////////////////////////////////////////////////////////////////////////////\r
1273 // CAppDialog - PPC/SmartPhone "well-behaved" dialog application class\r
1274 \r
1275 // Macro for declaring dialog WNDCLASS and AppKey\r
1276 #define DECLARE_APP_DLG_CLASS(WndClassName, uCommonResourceID, uAppKey) \\r
1277         static WTL::CFrameWndClassInfo& GetWndClassInfo() \\r
1278         { \\r
1279                 static WTL::CFrameWndClassInfo wc = \\r
1280                 { \\r
1281                         { 0, (WNDPROC)StartDialogProc, \\r
1282                         0, 0, NULL, NULL, NULL, (HBRUSH)(COLOR_WINDOW + 1), NULL, WndClassName }, \\r
1283                         NULL, NULL, IDC_ARROW, TRUE, 0, _T(""), uCommonResourceID \\r
1284                 }; \\r
1285                 return wc; \\r
1286         }; \\r
1287         DECLARE_APPKEY(uAppKey)\r
1288 \r
1289 template <class T>\r
1290 class CAppDialog : public CAppWindowBase< T >\r
1291 {\r
1292 public:\r
1293         static int AppRun(LPTSTR lpstrCmdLine = NULL, int nCmdShow = SW_SHOWNORMAL)\r
1294         {\r
1295                 CMessageLoop theLoop;\r
1296                 _Module.AddMessageLoop(&theLoop);\r
1297 \r
1298                 T dlgMain;\r
1299 \r
1300                 if(dlgMain.Create(NULL, (LPARAM)lpstrCmdLine) == NULL)\r
1301                 {\r
1302                         ATLTRACE2(atlTraceUI, 0, _T("Main dialog creation failed!\n"));\r
1303                         return 0;\r
1304                 }\r
1305 \r
1306                 dlgMain.ShowWindow(nCmdShow);\r
1307 \r
1308                 int nRet = theLoop.Run();\r
1309 \r
1310                 _Module.RemoveMessageLoop();\r
1311                 return nRet;\r
1312         }\r
1313 \r
1314         static HRESULT ActivatePreviousInstance(HINSTANCE hInstance, LPCTSTR  lpstrCmdLine)\r
1315         {\r
1316                 return CAppWindowBase< T >::ActivatePreviousInstance(hInstance, lpstrCmdLine, true);\r
1317         };\r
1318 };\r
1319 \r
1320 // PPC/SmartPhone standard application dialogs\r
1321 \r
1322 #ifdef WIN32_PLATFORM_WFSP\r
1323 #define WTL_APP_SHIDIF WTL_SP_SHIDIF\r
1324 #else\r
1325 #define WTL_APP_SHIDIF WTL_STD_SHIDIF\r
1326 #endif\r
1327 \r
1328 ///////////////////////////////////////////////////////////////////////////////\r
1329 // CAppStdDialogImplBase - Base implementation of standard application dialogs\r
1330 \r
1331 template <class T, class TImplBase, UINT t_shidiFlags = WTL_APP_SHIDIF, bool t_bModal = false>\r
1332 class ATL_NO_VTABLE CAppStdDialogImplBase :\r
1333                 public TImplBase, \r
1334                 public CAppDialog< T >\r
1335 { \r
1336 public:\r
1337         WTL_DLG_NOTITLE;\r
1338 \r
1339         void StdCloseDialog(int nVal)\r
1340         {\r
1341                 T* pT = static_cast<T*>(this);\r
1342                 if (nVal != IDCANCEL)\r
1343                         pT->AppSave();\r
1344                 if (t_bModal == false)\r
1345                 {\r
1346                         pT->DestroyWindow();\r
1347                         ::PostQuitMessage(nVal);\r
1348                 }\r
1349                 else\r
1350                         ::EndDialog(pT->m_hWnd, nVal);\r
1351         }\r
1352         \r
1353         BEGIN_MSG_MAP(CAppStdDialogImplBase)\r
1354                 MESSAGE_HANDLER(WM_CLOSE, OnSystemClose)\r
1355                 CHAIN_MSG_MAP(TImplBase)\r
1356                 CHAIN_MSG_MAP(CAppDialog< T >)\r
1357         END_MSG_MAP()\r
1358 \r
1359         LRESULT OnSystemClose(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)\r
1360         {\r
1361                 T* pT = static_cast<T*>(this);\r
1362                 pT->StdCloseDialog(IDCANCEL);\r
1363                 return 0;\r
1364         }\r
1365 };\r
1366 \r
1367 ///////////////////////////////////////////////////////////////////////////////\r
1368 // CAppStdDialogImpl - Implementation of standard application dialog \r
1369 \r
1370 template <class T, UINT t_shidiFlags = WTL_APP_SHIDIF, bool t_bModal = false>\r
1371 class ATL_NO_VTABLE CAppStdDialogImpl :\r
1372                 public CAppStdDialogImplBase<T, CStdDialogImpl<T, t_shidiFlags, t_bModal>, t_shidiFlags, t_bModal>\r
1373 {};\r
1374 \r
1375 ///////////////////////////////////////////////////////////////////////////////\r
1376 // CAppStdDialogResizeImpl - implementation of orientation resizing standard application dialog\r
1377 \r
1378 template <class T, UINT t_shidiFlags = WTL_APP_SHIDIF, bool t_bModal = false>\r
1379 class ATL_NO_VTABLE CAppStdDialogResizeImpl :\r
1380                 public CAppStdDialogImplBase<T, CStdDialogResizeImpl<T, t_shidiFlags, t_bModal>, t_shidiFlags, t_bModal>\r
1381 {};\r
1382 \r
1383 #ifndef _ATL_NO_HOSTING\r
1384 ///////////////////////////////////////////////////////////////////////////////\r
1385 // CAppStdAxDialogImpl - Implementation of standard application AxDialog \r
1386 \r
1387 template <class T, UINT t_shidiFlags = WTL_APP_SHIDIF, bool t_bModal = false>\r
1388 class ATL_NO_VTABLE CAppStdAxDialogImpl :\r
1389                 public CAppStdDialogImplBase<T, CStdAxDialogImpl<T, t_shidiFlags, t_bModal>, t_shidiFlags, t_bModal>\r
1390 {};\r
1391 \r
1392 ///////////////////////////////////////////////////////////////////////////////\r
1393 // CAppStdAxDialogResizeImpl - implementation of orientation resizing standard application AxDialog\r
1394 \r
1395 template <class T, UINT t_shidiFlags = WTL_APP_SHIDIF, bool t_bModal = false>\r
1396 class ATL_NO_VTABLE CAppStdAxDialogResizeImpl :\r
1397                 public CAppStdDialogImplBase<T, CStdAxDialogResizeImpl<T, t_shidiFlags, t_bModal>, t_shidiFlags, t_bModal>\r
1398 {};\r
1399 #endif // _ATL_NO_HOSTING\r
1400 \r
1401 #if defined(_WTL_CE_DRA) && defined(WIN32_PLATFORM_PSPC)\r
1402 ///////////////////////////////////////////////////////////////////////////////\r
1403 // CAppStdOrientedDialogImpl - implementation of oriented PPC standard application dialog\r
1404 \r
1405 template <class T, UINT t_shidiFlags = WTL_APP_SHIDIF, bool t_bModal = false>\r
1406 class ATL_NO_VTABLE CAppStdOrientedDialogImpl :\r
1407                 public CAppStdDialogImplBase<T, CStdOrientedDialogImpl<T, t_shidiFlags, t_bModal>, t_shidiFlags, t_bModal>\r
1408 {};\r
1409 \r
1410 #ifndef _ATL_NO_HOSTING\r
1411 ///////////////////////////////////////////////////////////////////////////////\r
1412 // CAppStdAxOrientedDialogImpl - implementation of oriented PPC standard application AxDialog\r
1413 \r
1414 template <class T, UINT t_shidiFlags = WTL_APP_SHIDIF, bool t_bModal = false>\r
1415 class ATL_NO_VTABLE CAppStdAxOrientedDialogImpl :\r
1416                 public CAppStdDialogImplBase<T, CStdAxOrientedDialogImpl<T, t_shidiFlags, t_bModal>, t_shidiFlags, t_bModal>\r
1417 {};\r
1418 #endif // _ATL_NO_HOSTING\r
1419 \r
1420 #endif // defined(_WTL_CE_DRA) && defined(WIN32_PLATFORM_PSPC)\r
1421 \r
1422 #endif // _WTL_CE_NO_DIALOGS\r
1423 \r
1424 #endif // _WTL_CE_NO_APPWINDOW\r
1425 \r
1426 \r
1427 // --- Full screen support ---\r
1428 \r
1429 #ifndef _WTL_CE_NO_FULLSCREEN\r
1430 \r
1431 ///////////////////////////////////////////////////////////////////////////////\r
1432 // CFullScreenFrame - full screen frame implementation\r
1433 \r
1434 template <class T, bool t_bHasSip = true>\r
1435 class CFullScreenFrame\r
1436 {\r
1437 public:\r
1438         bool m_bFullScreen;\r
1439 \r
1440         CFullScreenFrame() : m_bFullScreen(false)\r
1441         { }\r
1442 \r
1443 // Operation    \r
1444         void SetFullScreen(bool bFull)\r
1445         {\r
1446                 m_bFullScreen = bFull;\r
1447                 ShowTaskBar(!bFull, false);\r
1448                 ShowMenuBar(!bFull);\r
1449         }\r
1450 \r
1451 // Manage TaskBar for modal dialogs and property sheets\r
1452         template <class D>\r
1453         int FSDoModal(D& dlg)\r
1454         {\r
1455                 T* pT = static_cast<T*>(this);\r
1456                 pT;   // avoid level 4 warning\r
1457                 ATLASSERT(pT->IsWindow());\r
1458                 if (m_bFullScreen)   // Show taskbar if hidden\r
1459                         ShowTaskBar(true, false);\r
1460                 int iRet = dlg.DoModal();\r
1461                 if (m_bFullScreen)   // Hide taskbar if restored\r
1462                         ShowTaskBar(false);\r
1463                 return iRet;\r
1464         }\r
1465 \r
1466 // Implementation\r
1467         void ShowMenuBar(bool bShow)\r
1468         {\r
1469                 T* pT = static_cast<T*>(this);\r
1470                 ATLASSERT(pT->IsWindow());\r
1471                 ATL::CWindow MenuBar = pT->m_hWndCECommandBar;\r
1472                 ATLASSERT(MenuBar.IsWindow());\r
1473                 MenuBar.ShowWindow(bShow ? SW_SHOWNORMAL : SW_HIDE);\r
1474                 pT->SizeToMenuBar();\r
1475         }\r
1476         \r
1477         void ShowTaskBar(bool bShow, bool bRepaint = true)\r
1478         {\r
1479                 T* pT = static_cast<T*>(this);\r
1480                 ATLASSERT(pT->IsWindow());\r
1481                 RECT rect = { 0 };\r
1482                 SystemParametersInfo(SPI_GETWORKAREA, NULL, &rect, FALSE);\r
1483                 if (!bShow)\r
1484                         rect.top = 0;\r
1485 \r
1486 #ifdef WIN32_PLATFORM_PSPC // Pocket PC code\r
1487                 UINT uShow = t_bHasSip ? SHFS_SHOWTASKBAR | SHFS_SHOWSIPBUTTON : SHFS_SHOWTASKBAR | SHFS_HIDESIPBUTTON;         \r
1488                 SHFullScreen(pT->m_hWnd, bShow ? uShow : SHFS_HIDETASKBAR | SHFS_HIDESIPBUTTON);\r
1489 #elif _WIN32_WCE > 0x500 // Smartphone 2005 code\r
1490                 SHFullScreen(pT->m_hWnd, bShow ? SHFS_SHOWTASKBAR : SHFS_HIDETASKBAR);\r
1491 #else // Smartphone 2003\r
1492                 HWND hTaskBar = FindWindow(_T("tray"), NULL);\r
1493                 ATLASSERT(::IsWindow(hTaskBar));\r
1494                 ::ShowWindow(hTaskBar, bShow ? SW_SHOW : SW_HIDE);\r
1495 #endif // WIN32_PLATFORM_PSPC\r
1496 \r
1497                 pT->MoveWindow(&rect, bRepaint);\r
1498         }\r
1499 \r
1500 // Message map and handler\r
1501         BEGIN_MSG_MAP(CFullScreenFrame)\r
1502                 MESSAGE_HANDLER(WM_SETTINGCHANGE, OnSettingChange)\r
1503                 MESSAGE_HANDLER(WM_ACTIVATE, OnActivate)\r
1504         END_MSG_MAP()\r
1505 \r
1506         LRESULT OnSettingChange(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)\r
1507         {\r
1508 #ifndef SETTINGCHANGE_RESET // not defined for PPC 2002\r
1509         #define SETTINGCHANGE_RESET SPI_SETWORKAREA\r
1510 #endif\r
1511                 if (m_bFullScreen && (wParam & SETTINGCHANGE_RESET))\r
1512                         SetFullScreen(m_bFullScreen);\r
1513                 return bHandled = FALSE;\r
1514         }\r
1515 \r
1516         LRESULT OnActivate(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)\r
1517         {\r
1518                 if (m_bFullScreen)\r
1519                 {\r
1520                         ShowTaskBar(!wParam);\r
1521                         ShowMenuBar(!wParam);\r
1522                 }\r
1523                 return bHandled = FALSE;\r
1524         }\r
1525 };\r
1526 \r
1527 #endif // _WTL_CE_NO_FULLSCREEN\r
1528 \r
1529 \r
1530 // --- WinCE zoom support ---\r
1531 \r
1532 #ifndef _WTL_CE_NO_ZOOMSCROLL\r
1533 \r
1534 ///////////////////////////////////////////////////////////////////////////////\r
1535 // CZoomScrollImpl - WinCE zooming implementation on top of CScrollImpl\r
1536 \r
1537 template <class T>\r
1538 class  CZoomScrollImpl: public CScrollImpl< T >\r
1539 {\r
1540 public:\r
1541 // Data members\r
1542         _WTYPES_NS::CSize m_sizeTrue;\r
1543         double  m_fzoom;\r
1544 \r
1545 // Creation\r
1546         CZoomScrollImpl() : m_sizeTrue(0), m_fzoom(1.)\r
1547         { }\r
1548 \r
1549 // Zoom operations and access\r
1550         void SetZoomScrollSize(_WTYPES_NS::CSize sizeTrue, double fzoom = 1., BOOL bRedraw = TRUE)\r
1551         {\r
1552                 ATLASSERT(fzoom > 0.);\r
1553                 m_sizeTrue = sizeTrue;\r
1554                 m_fzoom = fzoom;\r
1555 \r
1556                 CScrollImpl< T >::SetScrollSize(sizeTrue / fzoom, bRedraw);\r
1557         }\r
1558 \r
1559         void SetZoomScrollSize(int cx, int cy, double fzoom=1., BOOL bRedraw = TRUE)\r
1560         {\r
1561                 SetZoomScrollSize(_WTYPES_NS::CSize(cx, cy), fzoom, bRedraw);\r
1562         }\r
1563 \r
1564         void SetZoom(double fzoom, BOOL bRedraw = TRUE)\r
1565         {\r
1566                 _WTYPES_NS::CPoint ptCenter = WndtoTrue(m_sizeClient / 2);\r
1567                 _WTYPES_NS::CSize sizePage = GetScrollPage();\r
1568                 _WTYPES_NS::CSize sizeLine = GetScrollLine();\r
1569 \r
1570                 SetZoomScrollSize(GetScrollSize(), fzoom, bRedraw);\r
1571 \r
1572                 SetScrollLine(sizeLine);\r
1573                 SetScrollPage(sizePage);\r
1574                 _WTYPES_NS::CPoint ptOffset = ptCenter - (m_sizeClient / 2) * fzoom;\r
1575                 SetScrollOffset(ptOffset, bRedraw);\r
1576         }\r
1577 \r
1578         double GetZoom()\r
1579         {\r
1580                 return m_fzoom;\r
1581         }\r
1582 \r
1583 // CScrollImpl overrides\r
1584         void SetScrollOffset(int x, int y, BOOL bRedraw = TRUE)\r
1585         {\r
1586                 CScrollImpl< T >::SetScrollOffset((int)(x / m_fzoom), (int)(y / m_fzoom), bRedraw);\r
1587         }\r
1588 \r
1589         void SetScrollOffset(POINT ptOffset, BOOL bRedraw = TRUE)\r
1590         {\r
1591                 SetScrollOffset(ptOffset.x, ptOffset.y, bRedraw);\r
1592         }\r
1593 \r
1594         void GetScrollOffset(POINT& ptOffset)\r
1595         {\r
1596                 ptOffset.x = (LONG)(m_ptOffset.x * m_fzoom);\r
1597                 ptOffset.y = (LONG)(m_ptOffset.y * m_fzoom);\r
1598         }\r
1599 \r
1600         void SetScrollSize(int cx, int cy, BOOL bRedraw = TRUE)\r
1601         {\r
1602                 SetZoomScrollSize(cx, cy, GetZoom(), bRedraw);\r
1603         }\r
1604 \r
1605         void SetScrollSize(SIZE sizeTrue, BOOL bRedraw = TRUE)\r
1606         {\r
1607                 SetZoomScrollSize(sizeTrue, GetZoom(), bRedraw);\r
1608         }\r
1609 \r
1610         void GetScrollSize(SIZE& sizeTrue) const\r
1611         {\r
1612                 sizeTrue = m_sizeTrue;\r
1613         }\r
1614 \r
1615         void SetScrollPage(int cxPage, int cyPage)\r
1616         {\r
1617                 SetScrollPage(_WTYPES_NS::CSize(cxPage, cyPage));\r
1618         }\r
1619 \r
1620         void SetScrollPage(SIZE sizePage)\r
1621         {\r
1622                 CScrollImpl< T >::SetScrollPage(sizePage / m_fzoom);\r
1623         }\r
1624 \r
1625         void GetScrollPage(SIZE& sizePage) const\r
1626         {\r
1627                 sizePage = m_sizePage * m_fzoom;\r
1628         }\r
1629 \r
1630         void SetScrollLine(int cxLine, int cyLine)\r
1631         {\r
1632                 SetScrollLine(_WTYPES_NS::CSize(cxLine, cyLine));\r
1633         }\r
1634 \r
1635         void SetScrollLine(SIZE sizeLine)\r
1636         {\r
1637                 CScrollImpl< T >::SetScrollLine(sizeLine / m_fzoom);\r
1638         }\r
1639 \r
1640         void GetScrollLine(SIZE& sizeLine) const\r
1641         {\r
1642                 sizeLine = m_sizeLine * m_fzoom;\r
1643         }\r
1644 \r
1645 // Data access complements\r
1646         _WTYPES_NS::CSize GetScrollSize()\r
1647         {\r
1648                 return m_sizeTrue;\r
1649         }\r
1650 \r
1651         _WTYPES_NS::CSize GetScrollPage()\r
1652         {\r
1653                 return m_sizePage * m_fzoom;\r
1654         }\r
1655 \r
1656         _WTYPES_NS::CSize GetScrollLine()\r
1657         {\r
1658                 return m_sizeLine * m_fzoom;\r
1659         }\r
1660 \r
1661         _WTYPES_NS::CPoint GetScrollOffset()\r
1662         {\r
1663                 return (_WTYPES_NS::CSize)m_ptOffset * m_fzoom;\r
1664         }\r
1665 \r
1666 // Helper coordinate functions\r
1667         _WTYPES_NS::CPoint WndtoTrue(CPoint ptW)\r
1668         {\r
1669                 return (_WTYPES_NS::CSize)ptW * GetZoom() + GetScrollOffset();\r
1670         }\r
1671 \r
1672         void WndtoTrue(LPPOINT aptW, int nPts)   // in place coord transformation\r
1673         {\r
1674                 for (int i = 0 ; i < nPts ; i++)\r
1675                         aptW[i] = WndtoTrue(aptW[i]);\r
1676         }\r
1677 \r
1678         void WndtoTrue(LPRECT prectW)   // in place coord transformation\r
1679         {\r
1680                 WndtoTrue((LPPOINT)prectW, 2);\r
1681         }\r
1682 \r
1683         _WTYPES_NS::CPoint TruetoWnd(CPoint ptT)\r
1684         {\r
1685                 return (ptT - GetScrollOffset()) / GetZoom();\r
1686         }\r
1687 \r
1688         void TruetoWnd(LPPOINT aptT, int nPts)   // in place coord transformation\r
1689         {\r
1690                 for (int i = 0 ; i < nPts ; i++)\r
1691                         aptT[i] = TruetoWnd(aptT[i]);\r
1692         }\r
1693 \r
1694         void TruetoWnd(LPRECT prectT)   // in place coord transformation\r
1695         {\r
1696                 TruetoWnd((LPPOINT)prectT, 2);\r
1697         }\r
1698 \r
1699 // Drawing operations : assume adequate setting of data members\r
1700         BOOL Draw(HBITMAP hbm, HDC hdestDC, DWORD dwROP = SRCCOPY)\r
1701         {\r
1702                 CDC memDC = CreateCompatibleDC(hdestDC);\r
1703                 CBitmapHandle bmpOld = memDC.SelectBitmap(hbm);\r
1704                 BOOL bRes = Draw(memDC, hdestDC, dwROP);\r
1705                 memDC.SelectBitmap(bmpOld);\r
1706                 return bRes;\r
1707         }\r
1708 \r
1709         BOOL Draw(HDC hsourceDC, HDC hdestDC, DWORD dwROP = SRCCOPY)\r
1710         {\r
1711                 CDCHandle destDC = hdestDC;\r
1712                 destDC.SetViewportOrg(0,0);\r
1713                 _WTYPES_NS::CPoint ptOffset = GetScrollOffset();\r
1714                 _WTYPES_NS::CSize sizeZClient = m_sizeClient * GetZoom();\r
1715                 return destDC.StretchBlt(0, 0, m_sizeClient.cx, m_sizeClient.cy, hsourceDC, ptOffset.x, ptOffset.y, sizeZClient.cx, sizeZClient.cy, dwROP);\r
1716         }\r
1717 \r
1718 #ifdef _IMAGING_H\r
1719         BOOL Draw(IImage* pIImage, HDC hdestDC)\r
1720         {\r
1721                 CDCHandle destDC = hdestDC;\r
1722                 destDC.SetViewportOrg(0,0);\r
1723                 return SUCCEEDED(pIImage->Draw(destDC, _WTYPES_NS::CRect(-_WTYPES_NS::CPoint(m_ptOffset), m_sizeAll), NULL));\r
1724         }\r
1725 #endif\r
1726 \r
1727 // Message map and handlers\r
1728         BEGIN_MSG_MAP(CZoomScrollImpl< T >)\r
1729                 MESSAGE_HANDLER(WM_ERASEBKGND, OnEraseBkgnd)\r
1730                 CHAIN_MSG_MAP(CScrollImpl< T >)\r
1731         END_MSG_MAP()\r
1732         \r
1733         LRESULT OnEraseBkgnd(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)\r
1734         {\r
1735                 T* pT = static_cast<T*>(this);\r
1736                 ATLASSERT(::IsWindow(pT->m_hWnd));\r
1737                 if ((GetScrollExtendedStyle() & SCRL_ERASEBACKGROUND))\r
1738                 {\r
1739                         _WTYPES_NS::CRect rect;\r
1740                         pT->GetClientRect(rect);\r
1741                         _WTYPES_NS::CSize sizeClient=rect.Size();\r
1742 \r
1743                         if (m_sizeAll.cx < sizeClient.cx || m_sizeAll.cy < sizeClient.cy)\r
1744                         {\r
1745                                 CDCHandle hdc = (HDC)wParam;\r
1746                                 HBRUSH hbr = GetSysColorBrush((int)T::GetWndClassInfo().m_wc.hbrBackground - 1);\r
1747 \r
1748                                 if (m_sizeAll.cx < sizeClient.cx)\r
1749                                 {\r
1750                                         _WTYPES_NS::CRect rectBG(_WTYPES_NS::CPoint(m_sizeAll.cx, 0), sizeClient);\r
1751                                         hdc.FillRect(rectBG, hbr);\r
1752                                 }\r
1753 \r
1754                                 if (m_sizeAll.cy < sizeClient.cy)\r
1755                                 {\r
1756                                         _WTYPES_NS::CRect rectBG(_WTYPES_NS::CPoint(0, m_sizeAll.cy), sizeClient);\r
1757                                         hdc.FillRect(rectBG, hbr);\r
1758                                 }\r
1759                         }\r
1760                 }\r
1761                 else\r
1762                 {\r
1763                         bHandled = FALSE;\r
1764                 }\r
1765 \r
1766                 return 1;\r
1767         }\r
1768 };\r
1769 \r
1770 #endif // _WTL_CE_NO_ZOOMSCROLL\r
1771 \r
1772 #ifndef _WTL_CE_NO_CONTROLS\r
1773 \r
1774 // --- PPC bottom TabView control ---\r
1775 \r
1776 #if defined(__ATLCTRLX_H__) && defined(WIN32_PLATFORM_PSPC)\r
1777 \r
1778 ///////////////////////////////////////////////////////////////////////////////\r
1779 // CBottomTabViewImpl\r
1780 \r
1781 template <class T, class TBase = ATL::CWindow, class TWinTraits = ATL::CControlWinTraits>\r
1782 class ATL_NO_VTABLE CBottomTabViewImpl : public CTabViewImpl<T, TBase, TWinTraits>\r
1783 {\r
1784 public:\r
1785         DECLARE_WND_CLASS_EX(NULL, 0, COLOR_APPWORKSPACE)\r
1786 \r
1787 // Implementation overrideables\r
1788         bool CreateTabControl()\r
1789         {\r
1790                 m_tab.Create(m_hWnd, rcDefault, NULL, WS_CHILD | TCS_BOTTOM, 0, m_nTabID);\r
1791 \r
1792                 ATLASSERT(m_tab.m_hWnd != NULL);\r
1793                 if(m_tab.m_hWnd == NULL)\r
1794                         return false;\r
1795 \r
1796                 m_tab.SendMessage(CCM_SETVERSION, COMCTL32_VERSION);\r
1797                 m_tab.SetItemExtra(sizeof(TABVIEWPAGE));\r
1798 \r
1799                 T* pT = static_cast<T*>(this);\r
1800                 m_cyTabHeight = pT->CalcTabHeight();\r
1801 \r
1802                 return true;\r
1803         }\r
1804 \r
1805         int CalcTabHeight()\r
1806         {\r
1807                 int nCount = m_tab.GetItemCount();\r
1808                 TCITEMEXTRA tcix = { 0 };\r
1809                 tcix.tciheader.mask = TCIF_TEXT;\r
1810                 tcix.tciheader.pszText = _T("NS");\r
1811                 int nIndex = m_tab.InsertItem(nCount, tcix);\r
1812 \r
1813                 RECT rect = { 0 };\r
1814                 SystemParametersInfo(SPI_GETWORKAREA, 0, &rect, 0);\r
1815                 RECT rcWnd = rect;\r
1816 \r
1817                 m_tab.AdjustRect(FALSE, &rect);\r
1818                 rcWnd.top = rect.bottom;\r
1819                 ::AdjustWindowRectEx(&rcWnd, m_tab.GetStyle(), FALSE, m_tab.GetExStyle());\r
1820                 m_tab.DeleteItem(nIndex);\r
1821 \r
1822                 return rcWnd.bottom - rcWnd.top;\r
1823         }\r
1824 \r
1825         void UpdateLayout()\r
1826         {\r
1827                 RECT rect;\r
1828                 GetClientRect(&rect);\r
1829 \r
1830                 if(m_tab.IsWindow() && ((m_tab.GetStyle() & WS_VISIBLE) != 0))\r
1831                         m_tab.SetWindowPos(NULL, 0, rect.bottom - m_cyTabHeight, rect.right - rect.left, m_cyTabHeight, SWP_NOZORDER /*| SWP_SHOWWINDOW*/);\r
1832 \r
1833                 if(m_nActivePage != -1)\r
1834                                 ::SetWindowPos(GetPageHWND(m_nActivePage), NULL, 0, 0, rect.right - rect.left, rect.bottom - m_cyTabHeight, SWP_NOZORDER);\r
1835         }\r
1836 \r
1837 };\r
1838 \r
1839 class CBottomTabView : public CBottomTabViewImpl<CBottomTabView>\r
1840 {\r
1841 public:\r
1842         DECLARE_WND_CLASS_EX(_T("WTL_BottomTabView"), 0, COLOR_APPWORKSPACE)\r
1843 };\r
1844 \r
1845 #endif // defined(__ATLCTRLX_H__) && defined(WIN32_PLATFORM_PSPC)\r
1846 \r
1847 \r
1848 // --- PPC/SmartPhone controls ---\r
1849 \r
1850 ////////////////////////////////////////////////////////////////////////////////\r
1851 // These are wrapper classes for the Pocket PC 2002/2003 and SmartPhone 2003 controls\r
1852 // To implement a window based on a control, use following:\r
1853 // Example: Implementing a window based on a Html control\r
1854 //\r
1855 // class CMyHtml : CWindowImpl<CMyHtml, CHtmlCtrl>\r
1856 // {\r
1857 // public:\r
1858 //      BEGIN_MSG_MAP(CMyHtml)\r
1859 //          // put your message handler entries here\r
1860 //      END_MSG_MAP()\r
1861 // };\r
1862 ///////////////////////////////////////////////////////////////////////////////\r
1863 \r
1864 ///////////////////////////////////////////////////////////////////////////////\r
1865 // CHtmlCtrl\r
1866 \r
1867 template <class TBase>\r
1868 class CHtmlCtrlT : public TBase\r
1869 {\r
1870 public:\r
1871 // Constructors\r
1872         CHtmlCtrlT(HWND hWnd = NULL) : TBase(hWnd)\r
1873         { }\r
1874 \r
1875         CHtmlCtrlT< TBase >& operator =(HWND hWnd)\r
1876         {\r
1877                 m_hWnd = hWnd;\r
1878                 return *this;\r
1879         }\r
1880 \r
1881         HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,\r
1882                         DWORD dwStyle = 0, DWORD dwExStyle = 0,\r
1883                         ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)\r
1884         {\r
1885                 HWND hWnd = TBase::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);\r
1886                 ATLASSERT(hWnd != NULL);   // Did you remember to call InitHTMLControl(hInstance) ??\r
1887                 return hWnd;\r
1888         }\r
1889 \r
1890 // Attributes\r
1891         static LPCTSTR GetWndClassName()\r
1892         {\r
1893                 return WC_HTML;\r
1894         }\r
1895 \r
1896 #if (_WIN32_WCE >= 400)\r
1897         void AddStyle(LPCWSTR pszStyle)\r
1898         {\r
1899                 ATLASSERT(::IsWindow(m_hWnd));\r
1900                 ::SendMessage(m_hWnd, DTM_ADDSTYLE, 0, (LPARAM)pszStyle);\r
1901         }\r
1902 #endif // (_WIN32_WCE >= 400)\r
1903 \r
1904         void AddText(BOOL bPlainText, LPCSTR pszText)\r
1905         {\r
1906                 ATLASSERT(::IsWindow(m_hWnd));\r
1907                 ::SendMessage(m_hWnd, DTM_ADDTEXT, (WPARAM)bPlainText, (LPARAM)pszText);\r
1908         }\r
1909 \r
1910         void AddHTML(LPCSTR pszHTML)\r
1911         {\r
1912                 ATLASSERT(::IsWindow(m_hWnd));\r
1913                 ::SendMessage(m_hWnd, DTM_ADDTEXT, (WPARAM)FALSE, (LPARAM)pszHTML);\r
1914         }\r
1915 \r
1916         void AddText(BOOL bPlainText, LPCWSTR pszText)\r
1917         {\r
1918                 ATLASSERT(::IsWindow(m_hWnd));\r
1919                 ::SendMessage(m_hWnd, DTM_ADDTEXTW, (WPARAM)bPlainText, (LPARAM)pszText);\r
1920         }\r
1921 \r
1922         void AddHTML(LPCWSTR pszHTML)\r
1923         {\r
1924                 ATLASSERT(::IsWindow(m_hWnd));\r
1925                 ::SendMessage(m_hWnd, DTM_ADDTEXTW, (WPARAM)FALSE, (LPARAM)pszHTML);\r
1926         }\r
1927 \r
1928         void Anchor(LPCSTR pszAnchor)\r
1929         {\r
1930                 ATLASSERT(::IsWindow(m_hWnd));\r
1931                 ::SendMessage(m_hWnd, DTM_ANCHOR, 0, (LPARAM)pszAnchor);\r
1932         }\r
1933 \r
1934         void Anchor(LPCWSTR pszAnchor)\r
1935         {\r
1936                 ATLASSERT(::IsWindow(m_hWnd));\r
1937                 ::SendMessage(m_hWnd, DTM_ANCHORW, 0, (LPARAM)pszAnchor);\r
1938         }\r
1939 \r
1940 #if (_WIN32_WCE >= 420)\r
1941         void GetBrowserDispatch(IDispatch** ppDispatch)\r
1942         {\r
1943                 ATLASSERT(::IsWindow(m_hWnd));\r
1944                 ATLASSERT(ppDispatch);\r
1945                 ATLASSERT(*ppDispatch==NULL);\r
1946                 ::SendMessage(m_hWnd, DTM_BROWSERDISPATCH, 0, (LPARAM)ppDispatch);\r
1947         }\r
1948         void GetDocumentDispatch(IDispatch** ppDispatch)\r
1949         {\r
1950                 ATLASSERT(::IsWindow(m_hWnd));\r
1951                 ATLASSERT(ppDispatch);\r
1952                 ATLASSERT(*ppDispatch==NULL);\r
1953                 ::SendMessage(m_hWnd, DTM_DOCUMENTDISPATCH , 0, (LPARAM)ppDispatch);\r
1954         }\r
1955 #endif // (_WIN32_WCE >= 420)\r
1956 \r
1957         void Clear()\r
1958         {\r
1959                 ATLASSERT(::IsWindow(m_hWnd));\r
1960                 ::SendMessage(m_hWnd, DTM_CLEAR, 0, 0L);\r
1961         }\r
1962 \r
1963         void EnableClearType(BOOL bEnable = TRUE)\r
1964         {\r
1965                 ATLASSERT(::IsWindow(m_hWnd));\r
1966                 ::SendMessage(m_hWnd, DTM_ENABLECLEARTYPE, 0, (LPARAM)bEnable);\r
1967         }\r
1968 \r
1969         void EnableContextMenu(BOOL bEnable = TRUE)\r
1970         {\r
1971                 ATLASSERT(::IsWindow(m_hWnd));\r
1972                 ::SendMessage(m_hWnd, DTM_ENABLECONTEXTMENU, 0, (LPARAM)bEnable);\r
1973         }\r
1974 \r
1975         void EnableScripting(BOOL bEnable = TRUE)\r
1976         {\r
1977                 ATLASSERT(::IsWindow(m_hWnd));\r
1978                 ::SendMessage(m_hWnd, DTM_ENABLESCRIPTING, 0, (LPARAM)bEnable);\r
1979         }\r
1980 \r
1981         void EnableShrink(BOOL bEnable = TRUE)\r
1982         {\r
1983                 ATLASSERT(::IsWindow(m_hWnd));\r
1984                 ::SendMessage(m_hWnd, DTM_ENABLESHRINK, 0, (LPARAM)bEnable);\r
1985         }\r
1986 \r
1987         void EndOfSource()\r
1988         {\r
1989                 ATLASSERT(::IsWindow(m_hWnd));\r
1990                 ::SendMessage(m_hWnd, DTM_ENDOFSOURCE, 0, 0L);\r
1991         }\r
1992 \r
1993         void ImageFail(DWORD dwCookie)\r
1994         {\r
1995                 ATLASSERT(::IsWindow(m_hWnd));\r
1996                 ::SendMessage(m_hWnd, DTM_IMAGEFAIL, 0, (LPARAM)dwCookie);\r
1997         }\r
1998 \r
1999         int GetLayoutHeight() const\r
2000         {\r
2001                 ATLASSERT(::IsWindow(m_hWnd));\r
2002                 return (int)::SendMessage(m_hWnd, DTM_LAYOUTHEIGHT, 0, 0L);\r
2003         }\r
2004 \r
2005         int GetLayoutWidth() const\r
2006         {\r
2007                 ATLASSERT(::IsWindow(m_hWnd));\r
2008                 return (int)::SendMessage(m_hWnd, DTM_LAYOUTWIDTH, 0, 0L);\r
2009         }\r
2010 \r
2011         void Navigate(LPCTSTR pstrURL, UINT uFlags = 0)\r
2012         {\r
2013                 ATLASSERT(::IsWindow(m_hWnd));\r
2014                 ATLASSERT(pstrURL);\r
2015                 ::SendMessage(m_hWnd, DTM_NAVIGATE, (WPARAM)uFlags, (LPARAM)pstrURL);\r
2016         }\r
2017 \r
2018         void SelectAll()\r
2019         {\r
2020                 ATLASSERT(::IsWindow(m_hWnd));\r
2021                 ::SendMessage(m_hWnd, DTM_SELECTALL, 0, 0L);\r
2022         }\r
2023 \r
2024         void SetImage(INLINEIMAGEINFO* pImageInfo)\r
2025         {\r
2026                 ATLASSERT(::IsWindow(m_hWnd));\r
2027                 ATLASSERT(pImageInfo);\r
2028                 ::SendMessage(m_hWnd, DTM_SETIMAGE, 0, (LPARAM)pImageInfo);\r
2029         }\r
2030 \r
2031         void ZoomLevel(int iLevel)\r
2032         {\r
2033                 ATLASSERT(::IsWindow(m_hWnd));\r
2034                 ::SendMessage(m_hWnd, DTM_ZOOMLEVEL, 0, (LPARAM)iLevel);\r
2035         }\r
2036 \r
2037 #if (_WIN32_WCE >= 400)\r
2038         void Stop()\r
2039         {\r
2040                 ATLASSERT(::IsWindow(m_hWnd));\r
2041                 ::SendMessage(m_hWnd, DTM_STOP, 0, 0L);\r
2042         }\r
2043 #endif // (_WIN32_WCE >= 400)\r
2044 \r
2045         void GetScriptDispatch(IDispatch** ppDispatch)\r
2046         {\r
2047                 ATLASSERT(::IsWindow(m_hWnd));\r
2048                 ATLASSERT(ppDispatch);\r
2049                 ATLASSERT(*ppDispatch==NULL);\r
2050                 ::SendMessage(m_hWnd, DTM_SCRIPTDISPATCH, 0, (LPARAM)ppDispatch);\r
2051         }\r
2052 };\r
2053 \r
2054 typedef CHtmlCtrlT<ATL::CWindow> CHtmlCtrl;\r
2055 \r
2056 \r
2057 #ifdef WIN32_PLATFORM_PSPC\r
2058 \r
2059 ///////////////////////////////////////////////////////////////////////////////\r
2060 // CRichInkCtrl\r
2061 \r
2062 template <class TBase>\r
2063 class CRichInkCtrlT : public TBase\r
2064 {\r
2065 public:\r
2066 // Constructors\r
2067         CRichInkCtrlT(HWND hWnd = NULL) : TBase(hWnd)\r
2068         { }\r
2069 \r
2070         CRichInkCtrlT< TBase >& operator =(HWND hWnd)\r
2071         {\r
2072                 m_hWnd = hWnd;\r
2073                 return *this;\r
2074         }\r
2075 \r
2076         HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,\r
2077                         DWORD dwStyle = 0, DWORD dwExStyle = 0,\r
2078                         ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)\r
2079         {\r
2080                 HWND hWnd = TBase::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);\r
2081                 ATLASSERT(hWnd != NULL);   // Did you remember to call InitRichInkDLL() ??\r
2082                 return hWnd;\r
2083         }\r
2084 \r
2085 // Attributes\r
2086         static LPCTSTR GetWndClassName()\r
2087         {\r
2088                 return WC_RICHINK;\r
2089         }\r
2090 \r
2091         BOOL CanPaste(UINT uFormat = 0) const\r
2092         {\r
2093                 ATLASSERT(::IsWindow(m_hWnd));\r
2094                 return (BOOL)::SendMessage(m_hWnd, EM_CANPASTE, (WPARAM)uFormat, 0L);\r
2095         }\r
2096 \r
2097         BOOL CanRedo() const\r
2098         {\r
2099                 ATLASSERT(::IsWindow(m_hWnd));\r
2100                 return (BOOL)::SendMessage(m_hWnd, EM_CANREDO, 0, 0L);\r
2101         }\r
2102 \r
2103         BOOL CanUndo() const\r
2104         {\r
2105                 ATLASSERT(::IsWindow(m_hWnd));\r
2106                 return (BOOL)::SendMessage(m_hWnd, EM_CANUNDO, 0, 0L);\r
2107         }\r
2108 \r
2109         void ClearAll(BOOL bRepaint = TRUE) const\r
2110         {\r
2111                 ATLASSERT(::IsWindow(m_hWnd));\r
2112                 ::SendMessage(m_hWnd, EM_CLEARALL, (WPARAM)bRepaint, 0L);\r
2113         }\r
2114 \r
2115         BOOL GetModify() const\r
2116         {\r
2117                 ATLASSERT(::IsWindow(m_hWnd));\r
2118                 return (BOOL)::SendMessage(m_hWnd, EM_GETMODIFY, 0, 0L);\r
2119         }\r
2120 \r
2121         UINT GetPageStyle() const\r
2122         {\r
2123                 ATLASSERT(::IsWindow(m_hWnd));\r
2124                 return (UINT)::SendMessage(m_hWnd, EM_GETPAGESTYLE, 0, 0L);\r
2125         }\r
2126 \r
2127         UINT GetPenMode() const\r
2128         {\r
2129                 ATLASSERT(::IsWindow(m_hWnd));\r
2130                 return (UINT)::SendMessage(m_hWnd, EM_GETPENMODE, 0, 0L);\r
2131         }\r
2132 \r
2133         UINT GetViewStyle() const\r
2134         {\r
2135                 ATLASSERT(::IsWindow(m_hWnd));\r
2136                 return (UINT)::SendMessage(m_hWnd, EM_GETVIEW, 0, 0L);\r
2137         }\r
2138 \r
2139         UINT GetWrapMode() const\r
2140         {\r
2141                 ATLASSERT(::IsWindow(m_hWnd));\r
2142                 return (UINT)::SendMessage(m_hWnd, EM_GETWRAPMODE, 0, 0L);\r
2143         }\r
2144 \r
2145         UINT GetZoomPercent() const\r
2146         {\r
2147                 ATLASSERT(::IsWindow(m_hWnd));\r
2148                 return (UINT)::SendMessage(m_hWnd, EM_GETZOOMPERCENT, 0, 0L);\r
2149         }\r
2150 \r
2151         void InsertLinks(LPWSTR lpString, int cchLength = -1)\r
2152         {\r
2153                 ATLASSERT(::IsWindow(m_hWnd));\r
2154                 if(cchLength == -1)\r
2155                         cchLength = lstrlen(lpString);\r
2156                 ::SendMessage(m_hWnd, EM_INSERTLINKS, (WPARAM)cchLength, (LPARAM)lpString);\r
2157         }\r
2158 \r
2159         void RedoEvent()\r
2160         {\r
2161                 ATLASSERT(::IsWindow(m_hWnd));\r
2162                 ::SendMessage(m_hWnd, EM_REDOEVENT, 0, 0L);\r
2163         }\r
2164 \r
2165         UINT SetInkLayer(UINT uLayer)\r
2166         {\r
2167                 ATLASSERT(::IsWindow(m_hWnd));\r
2168                 return (UINT)::SendMessage(m_hWnd, EM_SETINKLAYER, (WPARAM)uLayer, 0L);\r
2169         }\r
2170 \r
2171         void SetPageStyle(UINT uStyle)\r
2172         {\r
2173                 ATLASSERT(::IsWindow(m_hWnd));\r
2174                 ::SendMessage(m_hWnd, EM_SETPAGESTYLE, (WPARAM)uStyle, 0L);\r
2175         }\r
2176 \r
2177         void SetPenMode(UINT uMode)\r
2178         {\r
2179                 ATLASSERT(::IsWindow(m_hWnd));\r
2180                 ::SendMessage(m_hWnd, EM_SETPENMODE, (WPARAM)uMode, 0L);\r
2181         }\r
2182 \r
2183         void SetViewStyle(UINT uStyle)\r
2184         {\r
2185                 ATLASSERT(::IsWindow(m_hWnd));\r
2186                 ::SendMessage(m_hWnd, EM_SETVIEW, (WPARAM)uStyle, 0L);\r
2187         }\r
2188 \r
2189         void SetViewAttributes(VIEWATTRIBUTES* pAttribs)\r
2190         {\r
2191                 ATLASSERT(::IsWindow(m_hWnd));\r
2192                 ATLASSERT(pAttribs);\r
2193                 ::SendMessage(m_hWnd, EM_SETVIEWATTRIBUTES, 0, (LPARAM)pAttribs);\r
2194         }\r
2195 \r
2196         void SetWrapMode(UINT uMode)\r
2197         {\r
2198                 ATLASSERT(::IsWindow(m_hWnd));\r
2199                 ::SendMessage(m_hWnd, EM_SETWRAPMODE, (WPARAM)uMode, 0L);\r
2200         }\r
2201 \r
2202         void SetZoomPercent(UINT uPercent)\r
2203         {\r
2204                 ATLASSERT(::IsWindow(m_hWnd));\r
2205                 ::SendMessage(m_hWnd, EM_SETZOOMPERCENT, (WPARAM)uPercent, 0L);\r
2206         }\r
2207 \r
2208         LONG StreamIn(UINT uFormat, EDITSTREAM& es)\r
2209         {\r
2210                 ATLASSERT(::IsWindow(m_hWnd));\r
2211                 return (LONG)::SendMessage(m_hWnd, EM_STREAMIN, (WPARAM)uFormat, (LPARAM)&es);\r
2212         }\r
2213 \r
2214         LONG StreamOut(UINT uFormat, EDITSTREAM& es)\r
2215         {\r
2216                 ATLASSERT(::IsWindow(m_hWnd));\r
2217                 return (LONG)::SendMessage(m_hWnd, EM_STREAMOUT, (WPARAM)uFormat, (LPARAM)&es);\r
2218         }\r
2219 \r
2220         void UndoEvent()\r
2221         {\r
2222                 ATLASSERT(::IsWindow(m_hWnd));\r
2223                 ::SendMessage(m_hWnd, EM_UNDOEVENT, 0, 0L);\r
2224         }\r
2225 \r
2226 // Standard EM_xxx messages\r
2227         DWORD GetSel() const\r
2228         {\r
2229                 ATLASSERT(::IsWindow(m_hWnd));\r
2230                 return (DWORD)::SendMessage(m_hWnd, EM_GETSEL, 0, 0L);\r
2231         }\r
2232 \r
2233         void GetSel(int& nStartChar, int& nEndChar) const\r
2234         {\r
2235                 ATLASSERT(::IsWindow(m_hWnd));\r
2236                 ::SendMessage(m_hWnd, EM_GETSEL, (WPARAM)&nStartChar, (LPARAM)&nEndChar);\r
2237         }\r
2238 \r
2239         void ReplaceSel(LPCTSTR lpszNewText, BOOL bCanUndo = FALSE)\r
2240         {\r
2241                 ATLASSERT(::IsWindow(m_hWnd));\r
2242                 ::SendMessage(m_hWnd, EM_REPLACESEL, (WPARAM)bCanUndo, (LPARAM)lpszNewText);\r
2243         }\r
2244 \r
2245         void SetModify(BOOL bModified = TRUE)\r
2246         {\r
2247                 ATLASSERT(::IsWindow(m_hWnd));\r
2248                 ::SendMessage(m_hWnd, EM_SETMODIFY, (WPARAM)bModified, 0L);\r
2249         }\r
2250 \r
2251         int GetTextLength() const\r
2252         {\r
2253                 ATLASSERT(::IsWindow(m_hWnd));\r
2254                 return (int)::SendMessage(m_hWnd, WM_GETTEXTLENGTH, 0, 0L);\r
2255         }\r
2256 \r
2257 // Clipboard operations\r
2258         void Clear()\r
2259         {\r
2260                 ATLASSERT(::IsWindow(m_hWnd));\r
2261                 ::SendMessage(m_hWnd, WM_CLEAR, 0, 0L);\r
2262         }\r
2263 \r
2264         void Copy()\r
2265         {\r
2266                 ATLASSERT(::IsWindow(m_hWnd));\r
2267                 ::SendMessage(m_hWnd, WM_COPY, 0, 0L);\r
2268         }\r
2269 \r
2270         void Cut()\r
2271         {\r
2272                 ATLASSERT(::IsWindow(m_hWnd));\r
2273                 ::SendMessage(m_hWnd, WM_CUT, 0, 0L);\r
2274         }\r
2275 \r
2276         void Paste()\r
2277         {\r
2278                 ATLASSERT(::IsWindow(m_hWnd));\r
2279                 ::SendMessage(m_hWnd, WM_PASTE, 0, 0L);\r
2280         }\r
2281 };\r
2282 \r
2283 typedef CRichInkCtrlT<ATL::CWindow> CRichInkCtrl;\r
2284 \r
2285 \r
2286 ///////////////////////////////////////////////////////////////////////////////\r
2287 // CInkXCtrl\r
2288 \r
2289 template <class TBase>\r
2290 class CInkXCtrlT : public TBase\r
2291 {\r
2292 public:\r
2293 // Constructors\r
2294         CInkXCtrlT(HWND hWnd = NULL) : TBase(hWnd)\r
2295         { }\r
2296 \r
2297         CInkXCtrlT< TBase >& operator =(HWND hWnd)\r
2298         {\r
2299                 m_hWnd = hWnd;\r
2300                 return *this;\r
2301         }\r
2302 \r
2303         HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,\r
2304                         DWORD dwStyle = 0, DWORD dwExStyle = 0,\r
2305                         ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)\r
2306         {\r
2307                 HWND hWnd = TBase::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);\r
2308                 ATLASSERT(hWnd != NULL);   // Did you remember to call InitInkX() ??\r
2309                 return hWnd;\r
2310         }\r
2311 \r
2312 // Attributes\r
2313         static LPCTSTR GetWndClassName()\r
2314         {\r
2315                 return WC_INKX;\r
2316         }\r
2317 \r
2318         static UINT GetHotRecordingMessage()\r
2319         {\r
2320                 return ::RegisterWindowMessage(szHotRecording);\r
2321         }\r
2322 \r
2323         void ClearAll()\r
2324         {\r
2325                 ATLASSERT(::IsWindow(m_hWnd));\r
2326                 ::SendMessage(m_hWnd, IM_CLEARALL, 0, 0L);\r
2327         }\r
2328 \r
2329         int GetData(BYTE* lpBuffer, INT cbBuffer) const\r
2330         {\r
2331                 ATLASSERT(::IsWindow(m_hWnd));\r
2332                 ATLASSERT(lpBuffer);\r
2333                 return (int)::SendMessage(m_hWnd, IM_GETDATA, (WPARAM)cbBuffer, (LPARAM)lpBuffer);\r
2334         }\r
2335 \r
2336         int GetDataLen() const\r
2337         {\r
2338                 ATLASSERT(::IsWindow(m_hWnd));\r
2339                 return (int)::SendMessage(m_hWnd, IM_GETDATALEN, 0, 0L);\r
2340         }\r
2341 \r
2342         CRichInkCtrl GetRichInk() const\r
2343         {\r
2344                 ATLASSERT(::IsWindow(m_hWnd));\r
2345                 return (HWND)::SendMessage(m_hWnd, IM_GETRICHINK, 0, 0L);\r
2346         }\r
2347 \r
2348         BOOL IsRecording() const\r
2349         {\r
2350                 ATLASSERT(::IsWindow(m_hWnd));\r
2351                 return (BOOL)::SendMessage(m_hWnd, IM_RECORDING, 0, 0L);\r
2352         }\r
2353 \r
2354         void ReInit()\r
2355         {\r
2356                 ATLASSERT(::IsWindow(m_hWnd));\r
2357                 ::SendMessage(m_hWnd, IM_REINIT, 0, 0L);\r
2358         }\r
2359 \r
2360         void SetData(const BYTE* lpInkData, INT cbInkData)\r
2361         {\r
2362                 ATLASSERT(::IsWindow(m_hWnd));\r
2363                 ATLASSERT(lpInkData);\r
2364                 ::SendMessage(m_hWnd, IM_SETDATA, (WPARAM)cbInkData, (LPARAM)lpInkData);\r
2365         }\r
2366 \r
2367         void VoicePlay()\r
2368         {\r
2369                 ATLASSERT(::IsWindow(m_hWnd));\r
2370                 ::SendMessage(m_hWnd, IM_VOICE_PLAY, 0, 0L);\r
2371         }\r
2372 \r
2373         BOOL IsVoicePlaying() const\r
2374         {\r
2375                 ATLASSERT(::IsWindow(m_hWnd));\r
2376                 return (BOOL)::SendMessage(m_hWnd, IM_VOICE_PLAYING, 0, 0L);\r
2377         }\r
2378 \r
2379         BOOL VoiceRecord()\r
2380         {\r
2381                 ATLASSERT(::IsWindow(m_hWnd));\r
2382                 return (BOOL)::SendMessage(m_hWnd, IM_VOICE_RECORD, 0, 0L);\r
2383         }\r
2384 \r
2385         void VoiceStop()\r
2386         {\r
2387                 ATLASSERT(::IsWindow(m_hWnd));\r
2388                 ::SendMessage(m_hWnd, IM_VOICE_STOP, 0, 0L);\r
2389         }\r
2390 \r
2391         void ShowVoiceBar(BOOL bShow = TRUE)\r
2392         {\r
2393                 ATLASSERT(::IsWindow(m_hWnd));\r
2394                 ::SendMessage(m_hWnd, IM_VOICEBAR, (WPARAM)bShow, 0L);\r
2395         }\r
2396 };\r
2397 \r
2398 typedef CInkXCtrlT<ATL::CWindow> CInkXCtrl;\r
2399 \r
2400 #endif // WIN32_PLATFORM_PSPC\r
2401 \r
2402 \r
2403 ///////////////////////////////////////////////////////////////////////////////\r
2404 // CVoiceRecorderCtrl\r
2405 \r
2406 template <class TBase>\r
2407 class CVoiceRecorderCtrlT : public TBase\r
2408 {\r
2409 public:\r
2410 // Constructors\r
2411         CVoiceRecorderCtrlT(HWND hWnd = NULL) : TBase(hWnd)\r
2412         { }\r
2413 \r
2414         CVoiceRecorderCtrlT< TBase >& operator =(HWND hWnd)\r
2415         {\r
2416                 m_hWnd = hWnd;\r
2417                 return *this;\r
2418         }\r
2419 \r
2420         HWND Create(HWND hWndParent, const POINT pt, LPTSTR pstrFileName, UINT nID, DWORD dwStyle = 0)\r
2421         {\r
2422                 ATLASSERT(pstrFileName != NULL);\r
2423                 CM_VOICE_RECORDER cmvr = { 0 };\r
2424                 cmvr.cb = sizeof(CM_VOICE_RECORDER);\r
2425                 cmvr.dwStyle = dwStyle;\r
2426                 cmvr.xPos = pt.x;\r
2427                 cmvr.yPos = pt.y;\r
2428                 cmvr.hwndParent = hWndParent;\r
2429                 cmvr.id = nID;\r
2430                 cmvr.lpszRecordFileName = pstrFileName;\r
2431                 m_hWnd = VoiceRecorder_Create(&cmvr);\r
2432                 return m_hWnd;\r
2433         }\r
2434 \r
2435         HWND Create(LPCM_VOICE_RECORDER pAttribs)\r
2436         {\r
2437                 ATLASSERT(pAttribs);\r
2438                 m_hWnd = VoiceRecorder_Create(pAttribs);\r
2439                 return m_hWnd;\r
2440         }\r
2441 \r
2442 // Attributes\r
2443         void Record()\r
2444         {\r
2445                 ATLASSERT(::IsWindow(m_hWnd));\r
2446                 ::SendMessage(m_hWnd, VRM_RECORD, 0, 0L);\r
2447         }\r
2448 \r
2449         void Play()\r
2450         {\r
2451                 ATLASSERT(::IsWindow(m_hWnd));\r
2452                 ::SendMessage(m_hWnd, VRM_PLAY, 0, 0L);\r
2453         }\r
2454 \r
2455         void Stop()\r
2456         {\r
2457                 ATLASSERT(::IsWindow(m_hWnd));\r
2458                 ::SendMessage(m_hWnd, VRM_STOP, 0, 0L);\r
2459         }\r
2460 \r
2461         void Cancel()\r
2462         {\r
2463                 ATLASSERT(::IsWindow(m_hWnd));\r
2464                 ::SendMessage(m_hWnd, VRM_CANCEL, 0, 0L);\r
2465         }\r
2466 \r
2467         void Done()\r
2468         {\r
2469                 ATLASSERT(::IsWindow(m_hWnd));\r
2470                 ::SendMessage(m_hWnd, VRM_OK, 0, 0L);\r
2471         }\r
2472 };\r
2473 \r
2474 typedef CVoiceRecorderCtrlT<ATL::CWindow> CVoiceRecorderCtrl;\r
2475 \r
2476 \r
2477 #ifdef WIN32_PLATFORM_PSPC\r
2478 \r
2479 ///////////////////////////////////////////////////////////////////////////////\r
2480 // CDocListCtrl\r
2481 \r
2482 template <class TBase>\r
2483 class CDocListCtrlT : public TBase\r
2484 {\r
2485 public:\r
2486 // Attributes\r
2487         DOCLISTCREATE m_dlc;\r
2488         TCHAR m_szPath[MAX_PATH];\r
2489 \r
2490 // Constructors\r
2491         CDocListCtrlT(HWND hWnd = NULL) : TBase(hWnd)\r
2492         { }\r
2493 \r
2494         CDocListCtrlT< TBase >& operator =(HWND hWnd)\r
2495         {\r
2496                 m_hWnd = hWnd;\r
2497                 return *this;\r
2498         }\r
2499 \r
2500         HWND Create(HWND hWndParent, WORD wId, LPCTSTR pszFolder = NULL, LPCTSTR pstrFilter = NULL,\r
2501                         WORD wFilterIndex = 0, DWORD dwFlags = DLF_SHOWEXTENSION)\r
2502         {\r
2503                 ATLASSERT(pstrFilter != NULL);   // It seems to need a filter badly!!\r
2504                 ::ZeroMemory(&m_dlc, sizeof(DOCLISTCREATE));\r
2505                 ::ZeroMemory(m_szPath, sizeof(m_szPath));\r
2506                 if(pszFolder != NULL)\r
2507                         ::lstrcpyn(m_szPath, pszFolder, MAX_PATH - 1);\r
2508                 m_dlc.dwStructSize = sizeof(DOCLISTCREATE);\r
2509                 m_dlc.hwndParent = hWndParent;\r
2510                 m_dlc.pszFolder = m_szPath;\r
2511                 m_dlc.pstrFilter = pstrFilter;\r
2512                 m_dlc.wFilterIndex = wFilterIndex;\r
2513                 m_dlc.wId = wId;\r
2514                 m_dlc.dwFlags = dwFlags;\r
2515                 m_hWnd = DocList_Create(&m_dlc);\r
2516                 return m_hWnd;\r
2517         }\r
2518 \r
2519         HWND Create(DOCLISTCREATE* pDlc)\r
2520         {\r
2521                 m_dlc = *pDlc;\r
2522                 m_hWnd = DocList_Create(&m_dlc);\r
2523                 return m_hWnd;\r
2524         }\r
2525 \r
2526 // Attributes\r
2527         void DeleteSel()\r
2528         {\r
2529                 ATLASSERT(::IsWindow(m_hWnd));\r
2530                 ::SendMessage(m_hWnd, DLM_DELETESEL, 0, 0L);\r
2531         }\r
2532 \r
2533         void DisableUpdates()\r
2534         {\r
2535                 ATLASSERT(::IsWindow(m_hWnd));\r
2536                 ::SendMessage(m_hWnd, DLM_DISABLEUPDATES, 0, 0L);\r
2537         }\r
2538 \r
2539         void EnableUpdates()\r
2540         {\r
2541                 ATLASSERT(::IsWindow(m_hWnd));\r
2542                 ::SendMessage(m_hWnd, DLM_ENABLEUPDATES, 0, 0L);\r
2543         }\r
2544 \r
2545         int GetFilterIndex() const\r
2546         {\r
2547                 ATLASSERT(::IsWindow(m_hWnd));\r
2548                 return (int)::SendMessage(m_hWnd, DLM_GETFILTERINDEX, 0, 0L);\r
2549         }\r
2550 \r
2551         int GetItemCount() const\r
2552         {\r
2553                 ATLASSERT(::IsWindow(m_hWnd));\r
2554                 return (int)::SendMessage(m_hWnd, DLM_GETITEMCOUNT, 0, 0L);\r
2555         }\r
2556 \r
2557         int GetNextItem(int iIndex, DWORD dwRelation = LVNI_ALL) const\r
2558         {\r
2559                 ATLASSERT(::IsWindow(m_hWnd));\r
2560                 return (int)::SendMessage(m_hWnd, DLM_GETNEXTITEM, (WPARAM)iIndex, (LPARAM)dwRelation);\r
2561         }\r
2562 \r
2563         int GetFirstItem(DWORD dwRelation = LVNI_ALL) const\r
2564         {\r
2565                 ATLASSERT(::IsWindow(m_hWnd));\r
2566                 return (int)::SendMessage(m_hWnd, DLM_GETNEXTITEM, (WPARAM)-1, (LPARAM)dwRelation);\r
2567         }\r
2568 \r
2569         BOOL GetNextWave(int* pIndex) const\r
2570         {\r
2571                 ATLASSERT(::IsWindow(m_hWnd));\r
2572                 ATLASSERT(pIndex);\r
2573                 return (BOOL)::SendMessage(m_hWnd, DLM_GETNEXTWAVE, 0, (LPARAM)pIndex);\r
2574         }\r
2575 \r
2576         BOOL GetPrevWave(int* pIndex) const\r
2577         {\r
2578                 ATLASSERT(::IsWindow(m_hWnd));\r
2579                 ATLASSERT(pIndex);\r
2580                 return (BOOL)::SendMessage(m_hWnd, DLM_GETPREVWAVE, 0, (LPARAM)pIndex);\r
2581         }\r
2582 \r
2583         int GetSelCount() const\r
2584         {\r
2585                 ATLASSERT(::IsWindow(m_hWnd));\r
2586                 return (int)::SendMessage(m_hWnd, DLM_GETSELCOUNT, 0, 0L);\r
2587         }\r
2588 \r
2589         BOOL GetSelPathName(LPTSTR pstrPath, int cchMax) const\r
2590         {\r
2591                 ATLASSERT(::IsWindow(m_hWnd));\r
2592                 ATLASSERT(pstrPath);\r
2593                 return (BOOL)::SendMessage(m_hWnd, DLM_GETSELPATHNAME, (WPARAM)cchMax, (LPARAM)pstrPath);\r
2594         }\r
2595 \r
2596         void ReceiveIR(LPCTSTR pstrPath) const\r
2597         {\r
2598                 ATLASSERT(::IsWindow(m_hWnd));\r
2599                 ATLASSERT(pstrPath);\r
2600                 ::SendMessage(m_hWnd, DLM_RECEIVEIR, 0, (LPARAM)pstrPath);\r
2601         }\r
2602 \r
2603         void Refresh()\r
2604         {\r
2605                 ATLASSERT(::IsWindow(m_hWnd));\r
2606                 ::SendMessage(m_hWnd, DLM_REFRESH, 0, 0L);\r
2607         }\r
2608 \r
2609         BOOL RenameMoveSelectedItems()\r
2610         {\r
2611                 ATLASSERT(::IsWindow(m_hWnd));\r
2612                 return (BOOL)::SendMessage(m_hWnd, DLM_RENAMEMOVE, 0, 0L);\r
2613         }\r
2614 \r
2615         int SelectAll()\r
2616         {\r
2617                 ATLASSERT(::IsWindow(m_hWnd));\r
2618                 return (int)::SendMessage(m_hWnd, DLM_SELECTALL, 0, 0L);\r
2619         }\r
2620 \r
2621         HRESULT SelectItem(LPCTSTR pstrPath, BOOL bVisible = TRUE)\r
2622         {\r
2623                 ATLASSERT(::IsWindow(m_hWnd));\r
2624                 ATLASSERT(pstrPath);\r
2625                 return (HRESULT)::SendMessage(m_hWnd, DLM_SELECTITEM, (WPARAM)bVisible, (LPARAM)pstrPath);\r
2626         }\r
2627 \r
2628         void SendEMail(LPCTSTR pstrAttachment)\r
2629         {\r
2630                 ATLASSERT(::IsWindow(m_hWnd));\r
2631                 ::SendMessage(m_hWnd, DLM_SENDEMAIL, 0, (LPARAM)pstrAttachment);\r
2632         }\r
2633 \r
2634         void SendIR(LPCTSTR pstrPath)\r
2635         {\r
2636                 ATLASSERT(::IsWindow(m_hWnd));\r
2637                 ::SendMessage(m_hWnd, DLM_SENDIR, 0, (LPARAM)pstrPath);\r
2638         }\r
2639 \r
2640         HRESULT SetFilterIndex(int iIndex)\r
2641         {\r
2642                 ATLASSERT(::IsWindow(m_hWnd));\r
2643                 return (HRESULT)::SendMessage(m_hWnd, DLM_SETFILTERINDEX, (WPARAM)iIndex, 0L);\r
2644         }\r
2645 \r
2646         void SetFolder(LPCTSTR pstrPath)\r
2647         {\r
2648                 ATLASSERT(::IsWindow(m_hWnd));\r
2649                 ATLASSERT(pstrPath);\r
2650                 ::SendMessage(m_hWnd, DLM_SETFOLDER, 0, (LPARAM)pstrPath);\r
2651         }\r
2652 \r
2653         BOOL SetItemState(int iIndex, const LVITEM* pItem)\r
2654         {\r
2655                 ATLASSERT(::IsWindow(m_hWnd));\r
2656                 ATLASSERT(pItem);\r
2657                 return (BOOL)::SendMessage(m_hWnd, DLM_SETITEMSTATE, (WPARAM)iIndex, (LPARAM)pItem);\r
2658         }\r
2659 \r
2660         BOOL SetItemState(int iIndex, UINT uState, UINT uMask)\r
2661         {\r
2662                 ATLASSERT(::IsWindow(m_hWnd));\r
2663                 LV_ITEM lvi = { 0 };\r
2664                 lvi.stateMask = uMask;\r
2665                 lvi.state = uState;\r
2666                 return (BOOL)::SendMessage(m_hWnd, DLM_SETITEMSTATE, (WPARAM)iIndex, (LPARAM)&lvi);\r
2667         }\r
2668 \r
2669         void SetOneItem(int iIndex, LPCVOID pPA)\r
2670         {\r
2671                 ATLASSERT(::IsWindow(m_hWnd));\r
2672                 ::SendMessage(m_hWnd, DLM_SETONEITEM, (WPARAM)iIndex, (LPARAM)pPA);\r
2673         }\r
2674 \r
2675         void SetSelect(int iIndex)\r
2676         {\r
2677                 ATLASSERT(::IsWindow(m_hWnd));\r
2678                 ::SendMessage(m_hWnd, DLM_SETSELECT, (WPARAM)iIndex, 0L);\r
2679         }\r
2680 \r
2681         void SetSelPathName(LPCTSTR pstrPath)\r
2682         {\r
2683                 ATLASSERT(::IsWindow(m_hWnd));\r
2684                 ATLASSERT(pstrPath);\r
2685                 ::SendMessage(m_hWnd, DLM_SETSELPATHNAME, 0, (LPARAM)pstrPath);\r
2686         }\r
2687 \r
2688         BOOL SetSortOrder()\r
2689         {\r
2690                 ATLASSERT(::IsWindow(m_hWnd));\r
2691                 return (BOOL)::SendMessage(m_hWnd, DLM_SETSORTORDER, 0, 0L);\r
2692         }\r
2693 \r
2694         HRESULT Update()\r
2695         {\r
2696                 ATLASSERT(::IsWindow(m_hWnd));\r
2697                 return (HRESULT)::SendMessage(m_hWnd, DLM_UPDATE, 0, 0L);\r
2698         }\r
2699 \r
2700         BOOL ValidateFolder()\r
2701         {\r
2702                 ATLASSERT(::IsWindow(m_hWnd));\r
2703                 return (BOOL)::SendMessage(m_hWnd, DLM_VALIDATEFOLDER, 0, 0L);\r
2704         }\r
2705 \r
2706 // Functions\r
2707         BOOL GetFirstSelectedWaveFile(int* pIndex, LPTSTR szPath, const size_t cchPath)\r
2708         {\r
2709                 ATLASSERT(::IsWindow(m_hWnd));\r
2710                 return DocList_GetFirstSelectedWaveFile(m_hWnd, pIndex, szPath, cchPath);\r
2711         }\r
2712 \r
2713         BOOL GetNextSelectedWaveFile(int* pIndex, LPTSTR szPath, const size_t cchPath)\r
2714         {\r
2715                 ATLASSERT(::IsWindow(m_hWnd));\r
2716                 return DocList_GetNextSelectedWaveFile(m_hWnd, pIndex, szPath, cchPath);\r
2717         }\r
2718 };\r
2719 \r
2720 typedef CDocListCtrlT<ATL::CWindow> CDocListCtrl;\r
2721 \r
2722 #endif // WIN32_PLATFORM_PSPC\r
2723 \r
2724 \r
2725 ///////////////////////////////////////////////////////////////////////////////\r
2726 // CCapEdit\r
2727 \r
2728 template <class TBase>\r
2729 class CCapEditT : public TBase\r
2730 {\r
2731 public:\r
2732 // Constructors\r
2733         CCapEditT(HWND hWnd = NULL) : TBase(hWnd)\r
2734         { }\r
2735 \r
2736         CCapEditT< TBase >& operator =(HWND hWnd)\r
2737         {\r
2738                 m_hWnd = hWnd;\r
2739                 return *this;\r
2740         }\r
2741 \r
2742         HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,\r
2743                         DWORD dwStyle = 0, DWORD dwExStyle = 0,\r
2744                         ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)\r
2745         {\r
2746                 HWND hWnd = /*TBase*/CWindow::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);\r
2747                 ATLASSERT(hWnd != NULL);   // Did you remember to call SHInitExtraControls() ??\r
2748                 return hWnd;\r
2749         }\r
2750 \r
2751 // Attributes\r
2752         static LPCTSTR GetWndClassName()\r
2753         {\r
2754                 return WC_CAPEDIT;\r
2755         }\r
2756 };\r
2757 \r
2758 typedef CCapEditT<WTL::CEdit> CCapEdit;\r
2759 \r
2760 ///////////////////////////////////////////////////////////////////////////////\r
2761 // CTTStatic\r
2762 \r
2763 #ifndef WIN32_PLATFORM_WFSP // Tooltips not supported on SmartPhone\r
2764 \r
2765 template <class TBase>\r
2766 class CTTStaticT : public TBase\r
2767 {\r
2768 public:\r
2769 // Constructors\r
2770         CTTStaticT(HWND hWnd = NULL) : TBase(hWnd)\r
2771         { }\r
2772 \r
2773         CTTStaticT< TBase >& operator =(HWND hWnd)\r
2774         {\r
2775                 m_hWnd = hWnd;\r
2776                 return *this;\r
2777         }\r
2778 \r
2779         HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,\r
2780                         DWORD dwStyle = 0, DWORD dwExStyle = 0,\r
2781                         ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)\r
2782         {\r
2783                 HWND hWnd = TBase::Create(hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);\r
2784                 ATLASSERT(hWnd != NULL);   // Did you remember to call SHInitExtraControls() ??\r
2785                 return hWnd;\r
2786         }\r
2787 \r
2788 // Attributes\r
2789         static LPCTSTR GetWndClassName()\r
2790         {\r
2791                 return WC_TSTATIC;\r
2792         }\r
2793 \r
2794 // Operations\r
2795         BOOL SetToolTipText(LPCTSTR pstrTipText)\r
2796         {\r
2797                 ATLASSERT(::IsWindow(m_hWnd));\r
2798                 ATLASSERT(pstrTipText);\r
2799                 ATLASSERT(lstrlen(pstrTipText)<= 253);\r
2800                 CTempBuffer<TCHAR, _WTL_STACK_ALLOC_THRESHOLD> buff;\r
2801                 LPTSTR pstr = buff.Allocate(lstrlen(pstrTipText) + 3);\r
2802                 if(pstr == NULL)\r
2803                         return FALSE;\r
2804                 ::lstrcpy(pstr, _T("~~"));\r
2805                 ::lstrcat(pstr, pstrTipText);\r
2806                 return SetWindowText(pstr);\r
2807         }\r
2808 };\r
2809 \r
2810 typedef CTTStaticT<WTL::CStatic> CTTStatic;\r
2811 \r
2812 \r
2813 ///////////////////////////////////////////////////////////////////////////////\r
2814 // CTTButton\r
2815 \r
2816 template <class TBase>\r
2817 class CTTButtonT : public TBase\r
2818 {\r
2819 public:\r
2820 // Constructors\r
2821         CTTButtonT(HWND hWnd = NULL) : TBase(hWnd)\r
2822         { }\r
2823 \r
2824         CTTButtonT< TBase >& operator =(HWND hWnd)\r
2825         {\r
2826                 m_hWnd = hWnd;\r
2827                 return *this;\r
2828         }\r
2829 \r
2830         HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,\r
2831                         DWORD dwStyle = 0, DWORD dwExStyle = 0,\r
2832                         ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)\r
2833         {\r
2834                 HWND hWnd = TBase::Create(hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);\r
2835                 ATLASSERT(hWnd != NULL);   // Did you remember to call SHInitExtraControls() ??\r
2836                 return hWnd;\r
2837         }\r
2838 \r
2839 // Attributes\r
2840         static LPCTSTR GetWndClassName()\r
2841         {\r
2842                 return WC_TBUTTON;\r
2843         }\r
2844 \r
2845 // Operations\r
2846         BOOL SetToolTipText(LPCTSTR pstrTipText)\r
2847         {\r
2848                 ATLASSERT(::IsWindow(m_hWnd));\r
2849                 ATLASSERT(pstrTipText);\r
2850                 ATLASSERT(lstrlen(pstrTipText)<= 253);\r
2851                 CTempBuffer<TCHAR, _WTL_STACK_ALLOC_THRESHOLD> buff;\r
2852                 LPTSTR pstr = buff.Allocate(lstrlen(pstrTipText) + 3);\r
2853                 if(pstr == NULL)\r
2854                         return FALSE;\r
2855                 ::lstrcpy(pstr, _T("~~"));\r
2856                 ::lstrcat(pstr, pstrTipText);\r
2857                 return SetWindowText(pstr);\r
2858         }\r
2859 };\r
2860 \r
2861 typedef CTTButtonT<WTL::CButton> CTTButton;\r
2862 \r
2863 #endif // !WIN32_PLATFORM_WFSP\r
2864 \r
2865 \r
2866 // --- SmartPhone specific controls ---\r
2867 \r
2868 #ifdef WIN32_PLATFORM_WFSP\r
2869 \r
2870 ///////////////////////////////////////////////////////////////////////////////\r
2871 // CSpinCtrlT - CSpinCtrl : SmartPhone adapted UpDown control\r
2872 \r
2873 template <class TBase>\r
2874 class CSpinCtrlT : public CUpDownCtrlT< TBase >\r
2875 {\r
2876 public:\r
2877 // Constructors\r
2878         CSpinCtrlT(HWND hWnd = NULL) : CUpDownCtrlT< TBase >(hWnd)\r
2879         { }\r
2880 \r
2881         CSpinCtrlT< TBase >& operator =(HWND hWnd)\r
2882         {\r
2883                 m_hWnd = hWnd;\r
2884                 return *this;\r
2885         }\r
2886 \r
2887         HWND Create(HWND hWndParent, HWND hBuddy, DWORD dwStyle, int nID, LPCTSTR szExpandedName = NULL)\r
2888         {\r
2889                 ATLASSERT(::IsWindow(hWndParent));\r
2890                 CUpDownCtrlT< TBase >::Create(hWndParent, NULL, szExpandedName, dwStyle, 0, nID, NULL);\r
2891                 ATLASSERT(m_hWnd != NULL);   // Did you remember to call AtlInitCommonControls(ICC_UPDOWN_CLASS)?\r
2892                 if (hBuddy != NULL)\r
2893                 {\r
2894                         ATLASSERT(::IsWindow(hBuddy));\r
2895                         SetBuddy(hBuddy);\r
2896                 }\r
2897                 return m_hWnd;\r
2898         }\r
2899 };\r
2900 \r
2901 typedef CSpinCtrlT<ATL::CWindow> CSpinCtrl;\r
2902 \r
2903 \r
2904 ///////////////////////////////////////////////////////////////////////////////\r
2905 // CSpinned - SmartPhone association of control and Spin\r
2906 \r
2907 template <class TBase, bool t_bExpandOnly>\r
2908 class CSpinned : public TBase\r
2909 {\r
2910 public:\r
2911         CSpinCtrl m_SpinCtrl;\r
2912         DWORD m_dwSpinnedStyle;\r
2913 \r
2914 // Constructors\r
2915         CSpinned(HWND hWnd = NULL) : TBase(hWnd)\r
2916         {\r
2917                 m_dwSpinnedStyle = WS_VISIBLE | UDS_ALIGNRIGHT | UDS_EXPANDABLE;\r
2918                 \r
2919                 if (t_bExpandOnly == true)\r
2920                         m_dwSpinnedStyle |= UDS_NOSCROLL;\r
2921                 else\r
2922                         m_dwSpinnedStyle |= UDS_HORZ | UDS_ARROWKEYS | UDS_SETBUDDYINT | UDS_WRAP;\r
2923 \r
2924                 if (hWnd != NULL)\r
2925                         AttachOrCreateSpinCtrl();\r
2926         }\r
2927 \r
2928         CSpinned<TBase, t_bExpandOnly>& operator =(HWND hWnd)\r
2929         {\r
2930                 Attach(hWnd);\r
2931                 return *this;\r
2932         }\r
2933 \r
2934         void Attach(HWND hWnd)\r
2935         {\r
2936                 ATLASSERT(!IsWindow());\r
2937                 TBase* pT = static_cast<TBase*>(this);\r
2938                 pT->m_hWnd = hWnd;\r
2939                 if (hWnd != NULL)\r
2940                         AttachOrCreateSpinCtrl();\r
2941         }\r
2942 \r
2943         HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szExpandedName = NULL,\r
2944                         DWORD dwStyle = 0, DWORD dwExStyle = 0,\r
2945                         ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)\r
2946         {\r
2947 \r
2948                 TBase* pT = static_cast<TBase*>(this);\r
2949                 TBase::Create(hWndParent, rect, NULL, dwStyle, dwExStyle, MenuOrID, lpCreateParam);\r
2950                 ATLASSERT(pT->m_hWnd != NULL);\r
2951 \r
2952                 m_SpinCtrl.Create(hWndParent, pT->m_hWnd, m_dwSpinnedStyle, ATL_IDW_SPIN_ID + (int)MenuOrID.m_hMenu, szExpandedName);\r
2953 \r
2954                 ATLASSERT(m_SpinCtrl.m_hWnd != NULL);   // Did you remember to call AtlInitCommonControls(ICC_UPDOWN_CLASS)?\r
2955 \r
2956                 return pT->m_hWnd;\r
2957         }\r
2958 \r
2959 // Attributes\r
2960         CSpinCtrl& GetSpinCtrl()\r
2961         {\r
2962                 return m_SpinCtrl;\r
2963         }\r
2964 \r
2965 // Implementation\r
2966         // Attach our existing SpinCtrl or create one\r
2967         bool AttachOrCreateSpinCtrl()\r
2968         {\r
2969                 TBase* pT = static_cast<TBase*>(this);\r
2970 \r
2971                 HWND hSpin = ::GetDlgItem(pT->GetParent(), ATL_IDW_SPIN_ID + pT->GetDlgCtrlID());\r
2972 \r
2973                 if (hSpin != NULL)\r
2974                 {\r
2975                         m_SpinCtrl.Attach(hSpin);\r
2976 #ifdef DEBUG\r
2977                         TCHAR sClassName[16];\r
2978                         ::GetClassName(hSpin, sClassName, 16);\r
2979                         ATLASSERT(!_tcscmp(sClassName, UPDOWN_CLASS));\r
2980                         ATLASSERT(m_SpinCtrl.GetBuddy().m_hWnd == pT->m_hWnd);\r
2981 #endif // DEBUG\r
2982                 }\r
2983                 else\r
2984                 {\r
2985                         m_SpinCtrl.Create(pT->GetParent(), pT->m_hWnd, m_dwSpinnedStyle, ATL_IDW_SPIN_ID + pT->GetDlgCtrlID());\r
2986                 }\r
2987 \r
2988                 return m_SpinCtrl.m_hWnd != NULL;\r
2989         }\r
2990 };\r
2991 \r
2992 \r
2993 ///////////////////////////////////////////////////////////////////////////////\r
2994 // CSpinListBox - SmartPhone spinned ListBox control\r
2995 // CExpandListBox - SmartPhone expandable ListBox control\r
2996 // CExpandEdit - SmartPhone expandable Edit control\r
2997 // CExpandCapEdit - SmartPhone expandable CapEdit control\r
2998 \r
2999 typedef CSpinned<CListBox, false>   CSpinListBox;\r
3000 typedef CSpinned<CListBox, true>    CExpandListBox;\r
3001 typedef CSpinned<CEdit, true>           CExpandEdit;\r
3002 typedef CSpinned<CCapEdit, true>    CExpandCapEdit;\r
3003 \r
3004 #endif // WIN32_PLATFORM_WFSP\r
3005 \r
3006 #endif // _WTL_CE_NO_CONTROLS\r
3007 \r
3008 }; // namespace WTL\r
3009 \r
3010 #endif // __ATLWINCE_H__\r