Remove //third_party/wtl.

third_party/wtl/include/atlwince.h

-// Windows Template Library - WTL version 8.0
-// Copyright (C) Microsoft Corporation. All rights reserved.
-//
-// This file is a part of the Windows Template Library.
-// The use and distribution terms for this software are covered by the
-// Microsoft Permissive License (Ms-PL) which can be found in the file
-// Ms-PL.txt at the root of this distribution.
-
-#ifndef __ATLWINCE_H__
-#define __ATLWINCE_H__
-
-#pragma once
-
-#ifndef __cplusplus
-        #error ATL requires C++ compilation (use a .cpp suffix)
-#endif
-
-#ifndef __ATLAPP_H__
-        #error atlwince.h requires atlapp.h to be included first
-#endif
-
-#ifndef __ATLWIN_H__
-        #error atlwince.h requires atlwin.h to be included first
-#endif
-
-#ifndef _WIN32_WCE
-        #error atlwince.h compiles under Windows CE only
-#elif (_WIN32_WCE < 300)
-        #error atlwince.h requires Windows CE 3.0 or higher.
-#endif
-
-#if defined(WIN32_PLATFORM_WFSP) &&  _MSC_VER < 1400 // EVC compiling SmartPhone code
-  #if (WIN32_PLATFORM_WFSP < 200)
-        #error atlwince.h requires Smartphone 2003 or higher
-  #endif
-#endif // WIN32_PLATFORM_WFSP
-
-#if defined(WIN32_PLATFORM_PSPC) &&  _MSC_VER < 1400 // EVC compiling Pocket PC code
-  #if (WIN32_PLATFORM_PSPC < 310)
-        #error atlwince.h requires Pocket PC 2002 or higher
-  #endif
-#endif // WIN32_PLATFORM_PSPC
-
-#if !defined(_AYGSHELL_H_) && !defined(__AYGSHELL_H__)
-        #error atlwince.h requires aygshell.h to be included first
-#else
-  #if defined(WIN32_PLATFORM_WFSP) && !defined(_TPCSHELL_H_)
-        #error SmartPhone dialog classes require tpcshell.h to be included first
-  #endif
-#endif
-
-#if (_MSC_VER >= 1400) // VS2005
-  #include <DeviceResolutionAware.h>
-  #define _WTL_CE_DRA
-#endif // (_MSC_VER >= 1400)
-
-#if !defined(_WTL_CE_NO_DIALOGS) &&  !defined(__ATLFRAME_H__)
-        #error Orientation aware dialog classes require atlframe.h to be included first
-#endif
-
-#if !defined(_WTL_CE_NO_APPWINDOW) &&  !defined(__ATLFRAME_H__)
-        #error Application window class require atlframe.h to be included first
-#endif
-
-#if !defined(_WTL_CE_NO_ZOOMSCROLL) &&  !defined(__ATLSCRL_H__)
-        #error ZoomScroll implementation requires atlscrl.h to be included first
-#endif
-
-#if !defined(_WTL_CE_NO_ZOOMSCROLL)
-  #if !(defined(__ATLTYPES_H__) || (defined(__ATLMISC_H__) && !defined(_WTL_NO_WTYPES)))
-        #error ZoomScroll requires _WTL_NO_WTYPES not to be defined and either atlmisc.h or atltypes.h to be included first
-  #endif // !(defined(__ATLTYPES_H__) || (defined(__ATLMISC_H__) && !defined(_WTL_NO_WTYPES)))
-#endif // !defined(_WTL_CE_NO_ZOOMSCROLL)
-
-#if !defined(WIN32_PLATFORM_WFSP) && !defined(WIN32_PLATFORM_PSPC)
-  #define _WTL_CE_NO_CONTROLS
-#endif // !defined(WIN32_PLATFORM_WFSP) && !defined(WIN32_PLATFORM_PSPC)
-
-#ifndef _WTL_CE_NO_CONTROLS
-  #ifndef __ATLCTRLS_H__
-        #error The PPC/SmartPhone controls classes require atlctrls.h to be included first
-  #endif
-
-  #include <htmlctrl.h>
-  #pragma comment(lib, "htmlview.lib")
-
-  #include <voicectl.h>
-  #pragma comment(lib, "voicectl.lib")
-
-  #ifdef WIN32_PLATFORM_PSPC
-    #include <richink.h>
-    #pragma comment(lib, "richink.lib")
-
-    #include <inkx.h>
-    #pragma comment(lib, "inkx.lib")
-
-    #include <doclist.h>
-    #pragma comment(lib, "doclist.lib")
-  #endif
-#endif
-
-
-///////////////////////////////////////////////////////////////////////////////
-// Classes in this file:
-//
-// CStdDialogBase<T, t_shidiFlags, t_bModal> : Standard PPC/SmartPhone dialog base class
-// CStdDialogImplBase - Base implementation of standard dialog
-// CStdDialogImpl<T, t_shidiFlags, t_bModal> : Standard dialog implementation
-// CStdIndirectDialogImpl - implementation of standard indirect PPC/SmartPhone dialog
-// CStdAxDialogImpl<T, t_shidiFlags, t_bModal> : Standard AxDialog implementation
-// CStdSimpleDialog<t_wDlgTemplateID, t_shidiFlags> : Standard simple dialog
-// CStdDialogResizeImplBase - Base implementation of orientation resizing standard dialog
-// CStdDialogResizeImpl<T, t_shidiFlags, t_bModal> : Orientation resizing standard dialog implementation
-// CStdAxDialogResizeImpl - implementation of orientation resizing standard AxDialog
-// CStdSimpleDialogResizeImpl<T, t_wDlgTemplateID, t_shidiFlags> : Standard resizing simple dialog implementation
-// CStdOrientedDialogBase - Oriented PPC standard dialog base class
-// CStdOrientedDialogImplBase - Oriented PPC standard dialog base implementation
-// CStdOrientedDialogImpl<T, t_shidiFlags, t_bModal> : Oriented PPC standard dialog implementation
-// CStdAxOrientedDialogImpl - Oriented PPC standard AxDialog implementation
-// CStdSimpleOrientedDialog<t_wDlgTemplateID, t_wDlgLandscapeID, t_shidiFlags> : Standard simple orientable dialog
-//
-// CAppInfoBase  : Helper for application state save/restore to registry
-// CAppInfoT<T> : CAppInfoBase constructed from a CAppWindow<T>
-// CAppWindowBase<T> : Base class for PPC/SmartPhone well-behaved application window or dialog
-// CAppWindow<T> : PPC/SmartPhone well-behaved application window class
-// CAppDialog<T> : PPC/SmartPhone well-behaved application dialog class
-// CAppStdDialogImplBase - Base implementation of standard application dialogs
-// CAppStdDialogImpl<T, t_shidiFlags, t_bModal> : Implementation of standard application dialog
-// CAppStdDialogResizeImpl - implementation of orientation resizing standard application dialog
-// CAppStdAxDialogImpl - Implementation of standard application AxDialog 
-// CAppStdAxDialogResizeImpl - implementation of orientation resizing standard application AxDialog
-// CAppStdOrientedDialogImpl - implementation of oriented PPC standard application dialog
-// CAppStdAxOrientedDialogImpl - implementation of oriented PPC standard application AxDialog
-//
-// CFullScreenFrame<T, t_bHasSip> : Full screen frame class
-//
-// CZoomScrollImpl<T> : WinCE zooming implementation
-//
-// CBottomTabViewImpl<T, TBase, TWinTraits> - CBottomTabView 
-// CHtmlCtrlT<TBase> - CHtmlCtrl
-// CRichInkCtrlT<TBase> - CRichInkCtrl
-// CInkXCtrlT<TBase> - CInkXCtrl
-// CVoiceRecorderCtrlT<TBase> - CVoiceRecorderCtrl
-// CDocListCtrlT<TBase> - CDocListCtrl
-// CCapEditT<TBase> - CCapEdit
-// CTTStaticT<TBase> - CTTStatic
-// CTTButtonT<TBase> - CTTButton
-//
-// CSpinCtrlT<TBase> - CSpinCtrl : SmartPhone specific UpDown control
-// CSpinned<TBase, t_bExpandOnly> : SmartPhone association of control and Spin
-// CSpinListBox : SmartPhone spinned ListBox control
-// CExpandListBox : SmartPhone expandable ListBox control
-// CExpandEdit : SmartPhone expandable Edit control
-// CExpandCapEdit : SmartPhone expandable CapEdit control
-//
-// Global functions:
-//   AtlCreateMenuBar()
-//   AtlCreateEmptyMenuBar()
-//   AtlIsEditFocus()
-//   AtlActivateBackKey()
-
-namespace WTL
-{
-
-///////////////////////////////////////////////////////////////////////////////
-// MenuBar creation functions for property sheets and dialogs
-// Frame windows use CreateSimpleCEMenuBar
-
-inline HWND AtlCreateMenuBar(SHMENUBARINFO& mbi)
-{
-        ATLASSERT(::IsWindow(mbi.hwndParent));
-        ATLVERIFY(::SHCreateMenuBar(&mbi) != FALSE);
-        return mbi.hwndMB;
-};
-
-inline HWND AtlCreateMenuBar(HWND hWnd, UINT nToolBarId = ATL_IDW_TOOLBAR, DWORD dwFlags = 0, int nBmpId = 0, int cBmpImages = 0, COLORREF clrBk = 0)
-{
-        SHMENUBARINFO mbi = { sizeof(mbi), hWnd, dwFlags, nToolBarId, ModuleHelper::GetResourceInstance(), nBmpId, cBmpImages, 0, clrBk };
-        return AtlCreateMenuBar(mbi);
-}
-
-inline HWND AtlCreateEmptyMenuBar(HWND hWnd, bool bSip = true)
-{
-        SHMENUBARINFO embi = { sizeof(SHMENUBARINFO), hWnd, SHCMBF_EMPTYBAR };
-        if (!bSip)
-                embi.dwFlags |= SHCMBF_HIDESIPBUTTON;
-        
-        return AtlCreateMenuBar(embi);
-}
-        
-///////////////////////////////////////////////////////////////////////////////
-// Helper functions for SmartPhone back key handling
-
-inline bool AtlIsEditFocus()
-{
-        ATL::CWindow wCtrl = GetFocus();
-        if (wCtrl.IsWindow())
-        {
-                TCHAR szClassName[8] = {0};
-                ATLVERIFY(::GetClassName(wCtrl.m_hWnd, szClassName, 8));
-                return !_tcscmp(szClassName, _T("Edit")) || !_tcscmp(szClassName, WC_CAPEDIT);
-        }
-        return false;
-}
-
-#if defined WIN32_PLATFORM_WFSP
-inline void AtlActivateBackKey(HWND hMenuBar)
-{
-        ATLASSERT(::IsWindow(hMenuBar));
-        ::SendMessage(hMenuBar, SHCMBM_OVERRIDEKEY, VK_TBACK,
-                MAKELPARAM(SHMBOF_NODEFAULT | SHMBOF_NOTIFY, SHMBOF_NODEFAULT | SHMBOF_NOTIFY));
-}
-#endif // WIN32_PLATFORM_WFSP
-
-// --- Standard PPC/SmartPhone dialogs ---
-
-#ifndef _WTL_CE_NO_DIALOGS
-
-///////////////////////////////////////////////////////////////////////////////
-// CStdDialogBase - base class for standard PPC/SmartPhone dialogs
-
-#define WTL_STD_SHIDIF   SHIDIF_DONEBUTTON | SHIDIF_SIPDOWN | SHIDIF_SIZEDLGFULLSCREEN
-#define WTL_SP_SHIDIF    SHIDIF_SIZEDLGFULLSCREEN
-
-// Title setting macros
-#define WTL_DLG_TITLEHEIGHT(iHeight) static const int GetTitleHeight(){return iHeight;}
-#define WTL_DLG_NOTITLE  WTL_DLG_TITLEHEIGHT(0)
-
-///////////////////////////////////////////////////////////////////////////////
-// CStdDialogBase - Base class for standard PPC/SmartPhone dialog
-
-template <class T, UINT t_shidiFlags, bool t_bModal = true>
-class CStdDialogBase
-{
-public:
-#ifdef WIN32_PLATFORM_PSPC
-// Pocket PC only Dialog title handling
-        const int nTitleHeight;
-
-        CStdDialogBase() : nTitleHeight(T::GetTitleHeight())
-        { }
-
-// Overloads
-        BOOL GetClientRect(LPRECT lpRect) 
-        {
-                T* pT = static_cast<T*>(this);
-                ATLASSERT(pT->IsWindow());
-                BOOL bRes = ::GetClientRect(pT->m_hWnd, lpRect);
-                lpRect->top += nTitleHeight;
-                return bRes;
-        }
-
-        BOOL SetWindowText(LPCTSTR lpszString)
-        {
-                T* pT = static_cast<T*>(this);
-                ATLASSERT(pT->IsWindow());
-                BOOL bRes = ::SetWindowText(pT->m_hWnd, lpszString);
-                if (nTitleHeight != 0)
-                        pT->DoPaintTitle();
-                return bRes;
-        }
-
-// Overrideables
-        static const int GetTitleHeight()
-        {
-        #ifdef _WTL_CE_DRA
-                return DRA::SCALEY(24);
-        #else // !_WTL_CE_DRA
-                CWindowDC dc(NULL);
-                return dc.GetDeviceCaps(LOGPIXELSY) >> 2; // LOGPIXELSY * 24 / 96,
-        #endif // !_WTL_CE_DRA
-        }
-
-        // Title painting
-        bool DoPaintTitle()
-        {
-                T* pT = static_cast<T*>(this);
-                ATLASSERT(pT->IsWindow());
-                TCHAR sTitle[48];
-
-                // Preparation
-                CPaintDC dc(pT->m_hWnd);
-                CFont fontTitle = AtlCreateBoldFont();
-                CFontHandle fontOld = dc.SelectFont(fontTitle);
-                dc.SetTextColor(GetSysColor(COLOR_HIGHLIGHT));
-                int nLen = pT->GetWindowText(sTitle, 48);
-                int nWidth = dc.GetDeviceCaps(HORZRES);
-
-                // Display title text
-                RECT rTitle = { 0, 0, nWidth, nTitleHeight };
-                dc.FillRect(&rTitle, COLOR_3DHIGHLIGHT);
-        #ifdef _WTL_CE_DRA
-                rTitle.left = DRA::SCALEX(8);
-        #else // !_WTL_CE_DRA
-                rTitle.left = nTitleHeight / 3; // 8 == 24 / 3
-        #endif // !_WTL_CE_DRA
-                dc.DrawText(sTitle, nLen, &rTitle, DT_VCENTER | DT_SINGLELINE);
-                dc.SelectFont(fontOld);
-
-                // Draw bottom line, 2 pixels thick if HI_RES_AWARE
-                CPenHandle penOld = dc.SelectStockPen(BLACK_PEN);
-                POINT line[4] = {{0, nTitleHeight}, {nWidth, nTitleHeight}, {0, nTitleHeight - 1}, {nWidth, nTitleHeight - 1}};
-
-        #ifdef _WTL_CE_DRA
-                int nSeg = DRA::SCALEY(1);
-        #else // !_WTL_CE_DRA
-                int nSeg = nTitleHeight / 24; 
-        #endif // !_WTL_CE_DRA
-
-                dc.Polyline(line, nSeg <= 2 ? nSeg * 2 : 4);
-                dc.SelectPen(penOld);
-
-                return false;
-        }
-
-        // Title preparation: move the dialog controls down to make room for title
-        void DialogTitleInit()
-        {
-                T* pT = static_cast<T*>(this);
-                ATLASSERT(pT->IsWindow());
-
-                ATL::CWindow wCtl = pT->GetWindow(GW_CHILD);
-                while (wCtl.IsWindow())
-                {
-                        RECT rCtl = { 0 };
-                        wCtl.GetWindowRect(&rCtl);
-                        ::MapWindowPoints(NULL, pT->m_hWnd, (LPPOINT)&rCtl, 2);
-                        ::OffsetRect(&rCtl, 0, nTitleHeight);
-                        wCtl.MoveWindow(&rCtl, FALSE);
-                        wCtl = wCtl.GetWindow(GW_HWNDNEXT);
-                }
-        }
-
-        // SIP management
-        void DoSipInfo()
-        {
-                T* pT = static_cast<T*>(this);
-                ATLASSERT(pT->IsWindow());
-
-                SIPINFO si = {sizeof(SIPINFO)};
-                SipGetInfo(&si);
-                if ((si.fdwFlags & SIPF_ON) ^ SIPF_ON) 
-                        si.rcVisibleDesktop.bottom = si.rcSipRect.bottom;
-                pT->MoveWindow(&si.rcVisibleDesktop, FALSE);
-        }
-
-// Title painting handler
-        LRESULT OnPaintTitle(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
-        {
-                T* pT = static_cast<T*>(this);
-                return bHandled = nTitleHeight ? pT->DoPaintTitle() : FALSE;
-        }
-
-// SIP handler
-        LRESULT OnSettingChange(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
-        {
-                T* pT = static_cast<T*>(this);
-                if (wParam == SPI_SETSIPINFO)
-                {
-                        pT->DoSipInfo();
-                        return TRUE;
-                }
-                return bHandled = FALSE;
-        }
-
-#elif defined WIN32_PLATFORM_WFSP
-// SmartPhone VK_TBACK key standard management
-        LRESULT OnHotKey(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
-        {
-                T* pT = static_cast<T*>(this);
-                const UINT uModif = (UINT)LOWORD(lParam);
-                const UINT uVirtKey = (UINT)HIWORD(lParam);
-
-                if(uVirtKey == VK_TBACK)
-                        if (AtlIsEditFocus())
-                                ::SHSendBackToFocusWindow(uMsg, wParam, lParam);
-                        else if (uModif & MOD_KEYUP)
-                                        pT->StdCloseDialog(IDCANCEL);
-                return 1;
-        }
-
- // SmartPhone MenuBar and VK_TBACK key initialization
-        void StdSPInit()
-        {
-                T* pT = static_cast<T*>(this);
-                HWND hMenuBar = ::SHFindMenuBar(pT->m_hWnd);
-
-                if (!hMenuBar && (t_shidiFlags & SHIDIF_DONEBUTTON))
-                        hMenuBar = CreateMenuBar(ATL_IDM_MENU_DONE);
-
-                if(hMenuBar != NULL)
-                        AtlActivateBackKey(hMenuBar);
-        }
-
-        void SetStaticBold()
-        {
-                T* pT = static_cast<T*>(this);
-                ATLASSERT(pT->IsWindow());
-
-                CFontHandle fontBold = AtlCreateBoldFont(pT->GetFont());
-
-                ATL::CWindow wCtl = pT->GetWindow(GW_CHILD);
-
-                while (wCtl.IsWindow())
-                {
-                        if ((short int)wCtl.GetDlgCtrlID() == IDC_STATIC)
-                                wCtl.SetFont(fontBold);
-                        wCtl = wCtl.GetWindow(GW_HWNDNEXT);
-                }
-        }
-#endif // WIN32_PLATFORM_WFSP
-
-// Platform dependant initialization
-        void StdPlatformInit()
-        {
-                T* pT = static_cast<T*>(this);
-#ifdef WIN32_PLATFORM_PSPC // Pocket PC title initialization
-                if (nTitleHeight != 0)
-                        pT->DialogTitleInit();
-#elif defined(WIN32_PLATFORM_WFSP)
-                pT->StdSPInit();
-                SetStaticBold();
-#endif // WIN32_PLATFORM_WFSP
-        }
-
-        // Menu bar creation
-        HWND CreateMenuBar(UINT uiMB = T::IDD, int nBmpImages = 0)
-        {
-                T* pT = static_cast<T*>(this);
-                return AtlCreateMenuBar(pT->m_hWnd, uiMB, 0, nBmpImages ? uiMB : 0, nBmpImages);
-        }
-
-        // Dialog closing
-        void StdCloseDialog(WORD wID)
-        {
-                T* pT = static_cast<T*>(this);
-                if (t_bModal)
-                        ::EndDialog(pT->m_hWnd, wID);
-                else
-                        pT->DestroyWindow();
-        }
-
-        // Shell dialog layout initialization
-        void StdShidInit()
-        {
-                T* pT = static_cast<T*>(this);
-                SHINITDLGINFO shidi = { SHIDIM_FLAGS, pT->m_hWnd, t_shidiFlags };
-                ::SHInitDialog(&shidi);
-        }
-
-// IDC_INFOSTATIC background setting
-        LRESULT OnColorStatic(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
-        {
-                if (::GetDlgCtrlID((HWND)lParam) == IDC_INFOSTATIC)
-                {
-                        ::SetBkMode((HDC)wParam, TRANSPARENT);
-                        return (LRESULT)::GetSysColorBrush(COLOR_INFOBK);
-                }
-                return bHandled = FALSE;
-        }
-
-// Menu dialog ending
-        LRESULT OnMenuClose(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
-        {
-                T* pT = static_cast<T*>(this);
-                pT->StdCloseDialog((WORD)(wID - ID_MENU_OK + IDOK));
-                return 0;
-        }
-
-// Standard dialog ending: may be used with any command
-        LRESULT OnCloseCmd(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
-        {
-                T* pT = static_cast<T*>(this);
-                pT->StdCloseDialog(wID);
-                return 0;
-        }
-};
-
-
-///////////////////////////////////////////////////////////////////////////////
-// CStdDialogImplBase - Base implementation of standard PPC/SmartPhone dialog
-
-template <class T, UINT t_shidiFlags = WTL_STD_SHIDIF, bool t_bModal = true, class TBase = ATL::CDialogImpl< T > >
-class ATL_NO_VTABLE CStdDialogImplBase :
-                public TBase,
-                public CStdDialogBase<T, t_shidiFlags, t_bModal>
-{
-public:
-#ifdef WIN32_PLATFORM_PSPC
-        BOOL GetClientRect(LPRECT lpRect) 
-        {
-                return CStdDialogBase<T, t_shidiFlags, t_bModal>::GetClientRect(lpRect);
-        }
-
-        BOOL SetWindowText(LPCTSTR lpszString)
-        {
-                return CStdDialogBase<T, t_shidiFlags, t_bModal>::SetWindowText(lpszString);
-        }
-#endif
-
-        BEGIN_MSG_MAP(CStdDialogImplBase)
-#ifdef WIN32_PLATFORM_PSPC // Pocket PC title and SIP
-                MESSAGE_HANDLER(WM_PAINT, OnPaintTitle)
-                MESSAGE_HANDLER(WM_SETTINGCHANGE, OnSettingChange)
-#elif defined(WIN32_PLATFORM_WFSP) // SmartPhone VK_TBACK key
-                MESSAGE_HANDLER(WM_HOTKEY, OnHotKey)
-#endif
-                MESSAGE_HANDLER(WM_CTLCOLORSTATIC, OnColorStatic)
-                MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog)
-                COMMAND_RANGE_HANDLER(IDOK, IDCANCEL, OnCloseCmd)
-                COMMAND_RANGE_HANDLER(ID_MENU_OK, ID_MENU_CANCEL, OnMenuClose)
-        END_MSG_MAP()
-        
-        LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
-        {
-#ifdef _DEBUG
-                T* pT = static_cast<T*>(this);
-                ATLASSERT(t_bModal == pT->m_bModal);
-#endif
-                StdPlatformInit();
-                StdShidInit();
-                return bHandled = FALSE;
-        }
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// CStdDialogImpl - implementation of standard PPC/SmartPhone dialog
-
-template <class T, UINT t_shidiFlags = WTL_STD_SHIDIF, bool t_bModal = true >
-class ATL_NO_VTABLE CStdDialogImpl : public CStdDialogImplBase< T, t_shidiFlags, t_bModal>
-{};
-
-///////////////////////////////////////////////////////////////////////////////
-// CStdIndirectDialogImpl - implementation of standard indirect PPC/SmartPhone dialog
-
-#if defined __ATLDLGS_H__ 
-
-template <class T, UINT t_shidiFlags = WTL_STD_SHIDIF, bool t_bModal = true>
-class ATL_NO_VTABLE CStdIndirectDialogImpl : 
-        public CIndirectDialogImpl< T, CMemDlgTemplate, CStdDialogImpl<T, t_shidiFlags, t_bModal> >
-{
-public:
-        typedef CIndirectDialogImpl< T, CMemDlgTemplate, CStdDialogImpl<T, t_shidiFlags, t_bModal> >    _baseClass;
-        typedef CStdDialogImpl<T, t_shidiFlags, t_bModal> _baseStd;
-
-        INT_PTR DoModal(HWND hWndParent = ::GetActiveWindow(), LPARAM dwInitParam = NULL)
-        {
-                ATLASSERT(t_bModal);
-
-                if (!m_Template.IsValid())
-                        CreateTemplate();
-
-                if (m_Template.IsTemplateEx())
-                {
-                        if (m_Template.GetTemplateExPtr()->style & DS_CENTER)
-                        {
-                                ATLASSERT(m_Template.GetTemplateExPtr()->style ^ WS_CHILD);
-                                GetTemplateExPtr()->style |= WS_POPUP;
-                        }
-                }
-                else
-                {
-                        if (m_Template.GetTemplatePtr()->style & DS_CENTER)
-                        {
-                                ATLASSERT(m_Template.GetTemplatePtr()->style ^ WS_CHILD);
-                                m_Template.GetTemplatePtr()->style |= WS_POPUP;
-                        }
-                }
-
-                return _baseClass::DoModal(hWndParent, dwInitParam);
-        }
-
-        HWND Create(HWND hWndParent, LPARAM dwInitParam = NULL)
-        {
-                ATLASSERT(!t_bModal);
-
-                if (!m_Template.IsValid())
-                        CreateTemplate();
-
-                if (m_Template.IsTemplateEx())
-                {
-                        if (GetTemplateExPtr()->style & DS_CENTER)
-                        {
-                                ATLASSERT(GetTemplateExPtr()->style ^ WS_CHILD);
-                                GetTemplateExPtr()->style |= WS_POPUP;
-                        }
-                }
-                else
-                {
-                        if (GetTemplatePtr()->style & DS_CENTER)
-                        {
-                                ATLASSERT(GetTemplatePtr()->style ^ WS_CHILD);
-                                GetTemplatePtr()->style |= WS_POPUP;
-                        }
-                }
-
-                return _baseClass::Create(hWndParent, dwInitParam);
-        }
-
-        BEGIN_MSG_MAP(CStdIndirectDialogImpl)
-                CHAIN_MSG_MAP(_baseStd)
-        END_MSG_MAP()
-
-};
- 
-#endif // defined __ATLDLGS_H__ 
-
-#ifndef _ATL_NO_HOSTING
-
-///////////////////////////////////////////////////////////////////////////////
-// CStdAxDialogImpl - implementation of standard  PPC/SmartPhone AxDialog
-
-template <class T, UINT t_shidiFlags = WTL_STD_SHIDIF, bool t_bModal = true >
-class ATL_NO_VTABLE CStdAxDialogImpl : public CStdDialogImplBase< T, t_shidiFlags, t_bModal, ATL::CAxDialogImpl< T > >
-{};
-#endif // _ATL_NO_HOSTING
-
-///////////////////////////////////////////////////////////////////////////////
-// CStdSimpleDialog - standard PPC/SmartPhone simple dialog with SHIDIF_xxx flags
-
-template <WORD t_wDlgTemplateID, UINT t_shidiFlags = WTL_STD_SHIDIF>
-class CStdSimpleDialog :
-                public ATL::CSimpleDialog<t_wDlgTemplateID, FALSE>,
-                public CStdDialogBase<CStdSimpleDialog<t_wDlgTemplateID, t_shidiFlags>, t_shidiFlags>
-{
-public:
-        typedef CStdDialogBase<CStdSimpleDialog<t_wDlgTemplateID, t_shidiFlags>, t_shidiFlags> baseClass;
-
-#ifdef WIN32_PLATFORM_PSPC
-        BOOL GetClientRect(LPRECT lpRect) 
-        {
-                return baseClass::GetClientRect(lpRect);
-        }
-
-        BOOL SetWindowText(LPCTSTR lpszString)
-        {
-                return baseClass::SetWindowText(lpszString);
-        }
-#endif
-
-        BEGIN_MSG_MAP(CStdSimpleDialog)
-#ifdef WIN32_PLATFORM_PSPC // Pocket PC title and SIP
-                MESSAGE_HANDLER(WM_PAINT, OnPaintTitle)
-                MESSAGE_HANDLER(WM_SETTINGCHANGE, OnSettingChange)
-#elif defined(WIN32_PLATFORM_WFSP) // SmartPhone VK_TBACK key
-                MESSAGE_HANDLER(WM_HOTKEY, OnHotKey)
-#endif
-                MESSAGE_HANDLER(WM_CTLCOLORSTATIC, OnColorStatic)
-                MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog)
-                COMMAND_RANGE_HANDLER(ID_MENU_OK, ID_MENU_CANCEL, OnMenuClose)
-                COMMAND_RANGE_HANDLER(IDOK, IDCANCEL, baseClass::OnCloseCmd)
-        END_MSG_MAP()
-
-        LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
-        {
-                StdPlatformInit();
-                StdShidInit();
-                return bHandled = FALSE;
-        }
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// CStdDialogResizeImplBase - Base implementation of orientation resizing standard PPC/SmartPhone dialog
-
-template <class T, UINT t_shidiFlags = WTL_STD_SHIDIF, bool t_bModal = true, class TBase = ATL::CDialogImpl<T> >
-class ATL_NO_VTABLE CStdDialogResizeImplBase :
-                public CStdDialogImplBase< T, t_shidiFlags, t_bModal, TBase>,
-                public CDialogResize<T>
-{
-public:
-        // Note: BEGIN_DLGRESIZE_MAP is required in the derived class.
-
-        BEGIN_MSG_MAP(CStdResizeDialogImplBase)
-#ifdef WIN32_PLATFORM_PSPC // Pocket PC title
-                MESSAGE_HANDLER(WM_PAINT, OnPaintTitle)
-#elif defined(WIN32_PLATFORM_WFSP) // SmartPhone VK_TBACK key
-                MESSAGE_HANDLER(WM_HOTKEY, OnHotKey)
-#endif
-                MESSAGE_HANDLER(WM_CTLCOLORSTATIC, OnColorStatic)
-                MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog)
-                COMMAND_RANGE_HANDLER(IDOK, IDCANCEL, OnCloseCmd)
-                COMMAND_RANGE_HANDLER(ID_MENU_OK, ID_MENU_CANCEL, OnMenuClose)
-                CHAIN_MSG_MAP(CDialogResize< T >)
-        END_MSG_MAP()
-
-        LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
-        {
-#ifdef _DEBUG
-                T* pT = static_cast<T*>(this);
-                ATLASSERT(t_bModal == pT->m_bModal);
-#endif
-                StdPlatformInit();
-                DlgResize_Init(FALSE);
-                StdShidInit();
-                return bHandled = FALSE;
-        }
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// CStdDialogResizeImpl - implementation of orientation resizing standard PPC/SmartPhone dialog
-
-template <class T, UINT t_shidiFlags = WTL_STD_SHIDIF, bool t_bModal = true >
-class ATL_NO_VTABLE CStdDialogResizeImpl : public CStdDialogResizeImplBase< T, t_shidiFlags, t_bModal>
-{};
-
-#ifndef _ATL_NO_HOSTING
-
-///////////////////////////////////////////////////////////////////////////////
-// CStdAxDialogResizeImpl - implementation of orientation resizing standard PPC/SmartPhone AxDialog
-
-template <class T, UINT t_shidiFlags = WTL_STD_SHIDIF, bool t_bModal = true >
-class ATL_NO_VTABLE CStdAxDialogResizeImpl : public CStdDialogResizeImplBase< T, t_shidiFlags, t_bModal, ATL::CAxDialogImpl<T> >
-{};
-#endif // _ATL_NO_HOSTING
-
-///////////////////////////////////////////////////////////////////////////////
-// CStdSimpleDialogResizeImpl - implementation of standard resizing simple dialog with SHIDIF_xxx flags
-
-// Usage:
-//      class CMyDlg : public CStdSimpleDialogResize<CMyDlg,
-//              IDD_MYDLG, SHIDIF_DONEBUTTON | SHIDIF_FULLSCREENNOMENUBAR>
-//      {
-//      public:
-//              BEGIN_DLGRESIZE_MAP(CMyDlg)
-//              ...
-//              END_DLGRESIZE_MAP()
-//      };
-
-template <class T, WORD t_wDlgTemplateID, UINT t_shidiFlags = WTL_STD_SHIDIF>
-class ATL_NO_VTABLE CStdSimpleDialogResizeImpl :
-                public CStdSimpleDialog<t_wDlgTemplateID, t_shidiFlags>,
-                public CDialogResize< T >
-{
-public:
-        typedef CStdSimpleDialog<t_wDlgTemplateID, t_shidiFlags>::baseClass baseClass;
-
-        BEGIN_MSG_MAP(CStdSimpleDialogResizeImpl)
-#ifdef WIN32_PLATFORM_PSPC // Pocket PC title
-                MESSAGE_HANDLER(WM_PAINT, OnPaintTitle)
-#elif defined(WIN32_PLATFORM_WFSP) // SmartPhone VK_TBACK key
-                MESSAGE_HANDLER(WM_HOTKEY, OnHotKey)
-#endif
-                MESSAGE_HANDLER(WM_CTLCOLORSTATIC, OnColorStatic)
-                MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog)
-                COMMAND_RANGE_HANDLER(IDOK, IDCANCEL, baseClass::OnCloseCmd)
-                COMMAND_RANGE_HANDLER(ID_MENU_OK, ID_MENU_CANCEL, OnMenuClose)
-                CHAIN_MSG_MAP(CDialogResize< T >)
-        END_MSG_MAP()
-
-        LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
-        {
-                StdPlatformInit();
-                DlgResize_Init(FALSE);
-                StdShidInit();
-                return bHandled = FALSE;
-        }
-};
-
-#if defined(_WTL_CE_DRA) && defined(WIN32_PLATFORM_PSPC)
-
-///////////////////////////////////////////////////////////////////////////////
-// CStdOrientedDialogBase - Oriented PPC standard dialog base class
-
-template <class T>
-class CStdOrientedDialogBase
-{
-public:
-// Operation
-        BOOL SetOrientation(DRA::DisplayMode mode)
-        {
-                T* pT = static_cast<T*>(this);
-                ATLASSERT(pT->IsWindow());
-                ATLASSERT(mode == DRA::GetDisplayMode());
-                
-                // Derived dialog must enumerate TWO dialog templates with the same control ids and types ie:
-                // enum { IDD = IDD_MYDLG, IDD_LANDSCAPE = IDD_MYDLG_L };
-                UINT iResource = (mode == DRA::Landscape)? T::IDD_LANDSCAPE : T::IDD;
-
-                BOOL bRes = DRA::RelayoutDialog(ModuleHelper::GetResourceInstance(), pT->m_hWnd, MAKEINTRESOURCE(iResource));
-                pT->OnOrientation(mode);
-                return bRes;
-        }
-
-// Override
-        void OnOrientation(DRA::DisplayMode /*mode*/)
-        {}
-
-// Message handlers
-        LRESULT OnSettingChange(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
-        {
-                T* pT = static_cast<T*>(this);
-                ATLASSERT(pT->IsWindow());
-                if (wParam == SETTINGCHANGE_RESET)
-                {
-                        SetOrientation(DRA::GetDisplayMode());
-                        pT->StdPlatformInit();
-                        pT->StdShidInit();
-                }
-                else if (wParam == SPI_SETSIPINFO)
-                {
-                        pT->DoSipInfo();
-                        return TRUE;
-                }
-                return bHandled = FALSE;
-        }
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// CStdOrientedDialogImplBase - Oriented PPC standard dialog base implementation
-
-template <class T, UINT t_shidiFlags = WTL_STD_SHIDIF, bool t_bModal = true, class TBase = ATL::CDialogImpl<T> >
-class ATL_NO_VTABLE CStdOrientedDialogImplBase :
-                public CStdDialogImplBase< T, t_shidiFlags, t_bModal, TBase>,
-                public CStdOrientedDialogBase<T>
-{
-public:
-        BEGIN_MSG_MAP(CStdOrientedDialogImpl)
-                MESSAGE_HANDLER(WM_PAINT, OnPaintTitle)
-                MESSAGE_HANDLER(WM_CTLCOLORSTATIC, OnColorStatic)
-                MESSAGE_HANDLER(WM_SETTINGCHANGE, CStdOrientedDialogBase<T>::OnSettingChange)
-                MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog)
-                COMMAND_RANGE_HANDLER(IDOK, IDCANCEL, OnCloseCmd)
-                COMMAND_RANGE_HANDLER(ID_MENU_OK, ID_MENU_CANCEL, OnMenuClose)
-        END_MSG_MAP()
-
-        LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
-        {
-                T* pT = static_cast<T*>(this);
-#ifdef _DEBUG
-                ATLASSERT(t_bModal == pT->m_bModal);
-#endif
-                if (DRA::GetDisplayMode() == DRA::Landscape)
-                        SetOrientation(DRA::Landscape);
-                pT->StdPlatformInit();
-                pT->StdShidInit();
-                return bHandled = FALSE;
-        }
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// CStdOrientedDialogImpl - Oriented PPC standard dialog implementation
-
-template <class T, UINT t_shidiFlags = WTL_STD_SHIDIF, bool t_bModal = true >
-class ATL_NO_VTABLE CStdOrientedDialogImpl : public CStdOrientedDialogImplBase< T, t_shidiFlags, t_bModal>
-{};
-
-#ifndef _ATL_NO_HOSTING
-///////////////////////////////////////////////////////////////////////////////
-// CStdAxOrientedDialogImpl - Oriented PPC standard AxDialog implementation
-
-template <class T, UINT t_shidiFlags = WTL_STD_SHIDIF, bool t_bModal = true >
-class ATL_NO_VTABLE CStdAxOrientedDialogImpl : public CStdOrientedDialogImplBase< T, t_shidiFlags, t_bModal, ATL::CAxDialogImpl<T> >
-{};
-#endif // _ATL_NO_HOSTING
-
-///////////////////////////////////////////////////////////////////////////////
-// CStdSimpleOrientedDialog - Standard simple orientable dialog
-
-template <WORD t_wDlgTemplateID, WORD t_wDlgLandscapeID, UINT t_shidiFlags = WTL_STD_SHIDIF>
-class CStdSimpleOrientedDialog :
-                public CStdSimpleDialog<t_wDlgTemplateID, t_shidiFlags>,
-                public CStdOrientedDialogBase<CStdSimpleOrientedDialog<t_wDlgTemplateID, t_wDlgLandscapeID, t_shidiFlags> >
-{
-public:
-        typedef CStdSimpleDialog<t_wDlgTemplateID, t_shidiFlags>::baseClass baseClass;
-        typedef CStdOrientedDialogBase<CStdSimpleOrientedDialog<t_wDlgTemplateID, t_wDlgLandscapeID, t_shidiFlags> > baseOriented;
-
-        enum {IDD = t_wDlgTemplateID, IDD_LANDSCAPE = t_wDlgLandscapeID};
-
-        BEGIN_MSG_MAP(CStdSimpleDialog)
-                MESSAGE_HANDLER(WM_PAINT, OnPaintTitle)
-                MESSAGE_HANDLER(WM_CTLCOLORSTATIC, OnColorStatic)
-                MESSAGE_HANDLER(WM_SETTINGCHANGE, baseOriented::OnSettingChange)
-                MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog)
-                COMMAND_RANGE_HANDLER(IDOK, IDCANCEL, baseClass::OnCloseCmd)
-                COMMAND_RANGE_HANDLER(ID_MENU_OK, ID_MENU_CANCEL, OnMenuClose)
-        END_MSG_MAP()
-
-                LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
-        {
-                if (DRA::GetDisplayMode() == DRA::Landscape)
-                        SetOrientation(DRA::Landscape);
-                StdPlatformInit();
-                StdShidInit();
-                return bHandled = FALSE;
-        }
-};
-
-#endif // _WTL_CE_DRA
-
-
-#endif // _WTL_CE_NO_DIALOGS
-
-
-// --- PPC/SmartPhone application window and helpers ---
-
-#ifndef _WTL_CE_NO_APPWINDOW
-
-///////////////////////////////////////////////////////////////////////////////
-// CAppInfoBase - Helper for application state save/restore to registry
-
-class CAppInfoBase
-{
-public:
-        ATL::CRegKey m_Key;
-
-        CAppInfoBase(ATL::_U_STRINGorID sAppKey)
-        {
-                m_Key.Create(HKEY_CURRENT_USER, sAppKey.m_lpstr);
-                ATLASSERT(m_Key.m_hKey);
-        }
-
-        template <class V>
-        LONG Save(V& val, ATL::_U_STRINGorID sName)
-        {
-                return ::RegSetValueEx(m_Key, sName.m_lpstr, 0, REG_BINARY, (LPBYTE)&val, sizeof(V));
-        }
-
-        template <class V>
-        LONG Save(int nb, V& val0, ATL::_U_STRINGorID sName)
-        {
-                return ::RegSetValueEx(m_Key, sName.m_lpstr, 0, REG_BINARY, (LPBYTE)&val0, nb * sizeof(V));
-        }
-
-        template <class V>
-        LONG Restore(V& val, ATL::_U_STRINGorID sName)
-        {
-                DWORD valtype;
-                DWORD bufSize = sizeof(V);
-                return ::RegQueryValueEx(m_Key, sName.m_lpstr, 0, &valtype, (LPBYTE)&val, &bufSize);
-        }
-
-        template <class V>
-        LONG Restore(int nb, V& val0, ATL::_U_STRINGorID sName)
-        {
-                DWORD valtype;
-                DWORD bufSize = nb * sizeof(V);
-                return ::RegQueryValueEx(m_Key, sName.m_lpstr, 0, &valtype, (LPBYTE)&val0, &bufSize);
-        }
-
-#if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
-#if (_ATL_VER < 0x0800)
-        LONG Save(_CSTRING_NS::CString& sval, ATL::_U_STRINGorID sName)
-        {
-                return m_Key.SetValue(sval, sName.m_lpstr);
-        }
-
-        LONG Restore(_CSTRING_NS::CString& sval, ATL::_U_STRINGorID sName)
-        {
-                DWORD size = MAX_PATH;
-                LONG res = m_Key.QueryValue(sval.GetBuffer(size), sName.m_lpstr, &size);
-                sval.ReleaseBuffer();
-                return res;
-        }
-#else // !(_ATL_VER < 0x0800)
-        LONG Save(_CSTRING_NS::CString& sval, ATL::_U_STRINGorID sName)
-        {
-                return m_Key.SetStringValue(sName.m_lpstr, sval);
-        }
-
-        LONG Restore(_CSTRING_NS::CString& sval, ATL::_U_STRINGorID sName)
-        {
-                DWORD size = MAX_PATH;
-                LONG res = m_Key.QueryStringValue(sName.m_lpstr, sval.GetBuffer(size), &size);
-                sval.ReleaseBuffer();
-                return res;
-        }
-#endif // !(_ATL_VER < 0x0800)
-#else
-  #pragma message("Warning: CAppInfoBase compiles without CString support. Do not use CString in Save or Restore.")
-#endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
-        
-#if (_ATL_VER < 0x0800)
-        LONG Save(LPCTSTR sval, ATL::_U_STRINGorID sName)
-        {
-                return m_Key.SetValue(sval, sName.m_lpstr);
-        }
-
-        LONG Restore(LPTSTR sval, ATL::_U_STRINGorID sName, DWORD *plength)
-        {
-                return m_Key.QueryValue(sval, sName.m_lpstr, plength);
-        }
-#else // !(_ATL_VER < 0x0800)
-        LONG Save(LPCTSTR sval, ATL::_U_STRINGorID sName)
-        {
-                return m_Key.SetStringValue(sName.m_lpstr, sval);
-        }
-
-        LONG Restore(LPTSTR sval, ATL::_U_STRINGorID sName, DWORD *plength)
-        {
-                return m_Key.QueryStringValue(sName.m_lpstr, sval, plength);
-        }
-#endif // !(_ATL_VER < 0x0800)
-        
-        LONG Delete(ATL::_U_STRINGorID sName)
-        {
-                return  m_Key.DeleteValue(sName.m_lpstr);
-        }
-};
-
-
-///////////////////////////////////////////////////////////////////////////////
-// CAppInfoT - CAppInfoBase constructed from a class with T::GetAppKey() 
-
-// Macro for declaring AppKey
-#define DECLARE_APPKEY(uAppKey) \
-        static LPCTSTR GetAppKey() \
-        { \
-                static LPCTSTR sAppKey = ATL::_U_STRINGorID(uAppKey).m_lpstr; \
-                return sAppKey; \
-        }
-
-template <class T>
-class CAppInfoT : public CAppInfoBase
-{
-public:
-        CAppInfoT() : CAppInfoBase(T::GetAppKey()){}
-};
-
-
-///////////////////////////////////////////////////////////////////////////////
-// CAppWindowBase - Base class for PPC/SmartPhone "well-behaved" application window or dialog
-
-// Macros for declaring frame WNDCLASS and AppKey
-#define DECLARE_APP_FRAME_CLASS(WndClassName, uCommonResourceID, uAppKey) \
-        DECLARE_FRAME_WND_CLASS(WndClassName, uCommonResourceID) \
-        DECLARE_APPKEY(uAppKey)
-
-#define DECLARE_APP_FRAME_CLASS_EX(WndClassName, uCommonResourceID, style, bkgnd, uAppKey) \
-        DECLARE_FRAME_WND_CLASS_EX(WndClassName, uCommonResourceID, style, bkgnd) \
-        DECLARE_APPKEY(uAppKey)
-
-template <class T>
-class CAppWindowBase
-{
-public:
-        typedef class CAppInfoT< T > CAppInfo;
-
-#ifndef WIN32_PLATFORM_WFSP
-        SHACTIVATEINFO m_sai; // NoOp on SmartPhones
-#endif // WIN32_PLATFORM_WFSP
-
-        bool m_bHibernate;
-
-        CAppWindowBase< T >() : m_bHibernate(false)
-        {
-#ifndef WIN32_PLATFORM_WFSP
-                SHACTIVATEINFO sai = { sizeof(SHACTIVATEINFO) };
-                m_sai = sai;
-#endif // WIN32_PLATFORM_WFSP
-        };
-
-        // Same as WTL 7.1 AppWizard generated ActivatePreviousInstance + SendMessage WM_COPYDATA
-        static HRESULT ActivatePreviousInstance(HINSTANCE hInstance, LPCTSTR  lpstrCmdLine, bool bDialog)
-        {
-                // requires T does DECLARE_APP_FRAME_CLASS, DECLARE_APP_FRAME_CLASS_EX or DECLARE_APP_DLG_CLASS
-                CFrameWndClassInfo& classInfo = T::GetWndClassInfo();
-
-                ATLVERIFY(::LoadString(hInstance, classInfo.m_uCommonResourceID, classInfo.m_szAutoName, sizeof(classInfo.m_szAutoName)/sizeof(classInfo.m_szAutoName[0])) != 0);
-
-                classInfo.m_wc.lpszClassName = classInfo.m_szAutoName;
-
-                const TCHAR* pszClass = classInfo.m_wc.lpszClassName;
-
-                if(NULL == pszClass || '\0' == *pszClass)
-                {
-                        return E_FAIL;
-                }
-
-                const DWORD dRetryInterval = 100;
-                const int iMaxRetries = 25;
-
-                for(int i = 0; i < iMaxRetries; ++i)
-                {
-                        HANDLE hMutex = CreateMutex(NULL, FALSE, pszClass);
-
-                        DWORD dw = GetLastError();
-
-                        if(NULL == hMutex)
-                        {
-                                HRESULT hr;
-
-                                switch(dw)
-                                {
-                                case ERROR_INVALID_HANDLE:
-                                        // A non-mutext object with this name already exists.
-                                        hr = E_INVALIDARG;
-                                        break;
-                                default:
-                                        // This should never happen...
-                                        hr = E_FAIL;
-                                }
-
-                                return hr;
-                        }
-
-                        // If the mutex already exists, then there should be another instance running
-                        if(dw == ERROR_ALREADY_EXISTS)
-                        {
-                                CloseHandle(hMutex);
-                                
-                                HWND hwnd = NULL;
-                                if (bDialog)
-                                        hwnd = FindWindow(NULL, pszClass);
-                                else
-                                        hwnd = FindWindow(pszClass, NULL);
-
-                                if(hwnd == NULL)
-                                {
-                                        Sleep(dRetryInterval);
-                                        continue;
-                                }
-                                else
-                                {
-                                        // Transmit our params to previous instance
-                                        if (lpstrCmdLine && *lpstrCmdLine)
-                                        {
-                                                COPYDATASTRUCT cd = { NULL, sizeof(TCHAR) * (wcslen(lpstrCmdLine) + 1), (PVOID)lpstrCmdLine };
-                                                ::SendMessage(hwnd, WM_COPYDATA, NULL, (LPARAM)&cd);
-                                        }
-                                        // Set the previous instance as the foreground window
-                                        if(0 != SetForegroundWindow(reinterpret_cast<HWND>(reinterpret_cast<ULONG>(hwnd) | 0x1)))
-                                                return S_FALSE;
-                                }
-                        }
-                        else
-                        {
-                                return S_OK;
-                        }
-                }
-                return S_OK;
-        }
-
-// Operations overriden in derived class
-        bool AppHibernate(bool /*bHibernate*/)
-        {
-                return false;
-        }
-
-        bool AppNewInstance(LPCTSTR /*lpstrCmdLine*/)
-        {
-                return false;
-        }
-
-        void AppSave()
-        {
-        }
-
-#ifdef WIN32_PLATFORM_WFSP 
-        void AppBackKey() 
-        {
-                ::SHNavigateBack();
-        }
-#endif
-
-// Message map and handlers
-        BEGIN_MSG_MAP(CAppWindowBase)
-                MESSAGE_HANDLER(WM_ACTIVATE, OnActivate)
-#ifdef WIN32_PLATFORM_WFSP
-                MESSAGE_HANDLER(WM_HOTKEY, OnHotKey)
-#else
-                MESSAGE_HANDLER(WM_SETTINGCHANGE, OnSettingChange)
-#endif // WIN32_PLATFORM_WFSP
-                MESSAGE_HANDLER(WM_HIBERNATE, OnHibernate)
-                MESSAGE_HANDLER(WM_COPYDATA, OnNewInstance)
-                MESSAGE_HANDLER(WM_CLOSE, OnClose)
-        END_MSG_MAP()
-
-        LRESULT OnActivate(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
-        {
-                T* pT = static_cast<T*>(this);
-                if (m_bHibernate)
-                        m_bHibernate = pT->AppHibernate(false);
-#ifndef WIN32_PLATFORM_WFSP
-                ::SHHandleWMActivate(pT->m_hWnd, wParam, lParam, &m_sai, 0);
-#else
-                wParam;
-                lParam;
-#endif // WIN32_PLATFORM_WFSP
-                 return bHandled = FALSE;
-        }
-
-#ifdef WIN32_PLATFORM_WFSP
-// SmartPhone VK_TBACK key standard management
-        LRESULT OnHotKey(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
-        {
-                T* pT = static_cast<T*>(this);
-                const UINT uModif = (UINT)LOWORD(lParam);
-                const UINT uVirtKey = (UINT)HIWORD(lParam);
-                if(uVirtKey == VK_TBACK)
-                        if (AtlIsEditFocus())
-                                ::SHSendBackToFocusWindow(uMsg, wParam, lParam);
-                        else if (uModif & MOD_KEYUP)
-                                pT->AppBackKey();
-                return 1;
-        }
-
-#else // !WIN32_PLATFORM_WFSP
-// PPC SIP handling
-        LRESULT OnSettingChange(UINT /*uMsg*/, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
-        {
-                T* pT = static_cast<T*>(this);
-                bHandled = FALSE;
-                return ::SHHandleWMSettingChange(pT->m_hWnd, wParam, lParam, &m_sai);
-        }
-#endif // !WIN32_PLATFORM_WFSP
-
-        LRESULT OnHibernate(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
-        {
-                T* pT = static_cast<T*>(this);
-                return m_bHibernate = pT->AppHibernate(true);
-        }
-
-        LRESULT OnNewInstance(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& /*bHandled*/)
-        {
-                T* pT = static_cast<T*>(this);
-                PCOPYDATASTRUCT pcds = (PCOPYDATASTRUCT)lParam;
-                return pT->AppNewInstance((LPCTSTR)pcds->lpData);
-        }
-
-        LRESULT OnClose(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
-        {
-                T* pT = static_cast<T*>(this);
-                pT->AppSave();
-                bHandled = FALSE;
-                return 1;
-        }
-};
-
-
-///////////////////////////////////////////////////////////////////////////////
-// CAppWindow - PPC/SmartPhone "well-behaved" application window class
-
-template <class T>
-class CAppWindow : public CAppWindowBase< T >
-{
-public:
-        // Same as WTL 7.1 AppWizard generated Run + lpstrCmdLine in CreateEx
-        static int AppRun(LPTSTR lpstrCmdLine = NULL, int nCmdShow = SW_SHOWNORMAL)
-        {
-                CMessageLoop theLoop;
-                _Module.AddMessageLoop(&theLoop);
-
-                T wndMain;
-
-                if(wndMain.CreateEx(NULL, NULL, 0, 0, lpstrCmdLine) == NULL)
-                {
-                        ATLTRACE2(atlTraceUI, 0, _T("Main window creation failed!\n"));
-                        return 0;
-                }
-
-                wndMain.ShowWindow(nCmdShow);
-
-                int nRet = theLoop.Run();
-
-                _Module.RemoveMessageLoop();
-                return nRet;
-        }
-
-        static HRESULT ActivatePreviousInstance(HINSTANCE hInstance, LPCTSTR  lpstrCmdLine)
-        {
-                return CAppWindowBase< T >::ActivatePreviousInstance(hInstance, lpstrCmdLine, false);
-        }
-};
-
-
-#ifndef _WTL_CE_NO_DIALOGS
-
-///////////////////////////////////////////////////////////////////////////////
-// CAppDialog - PPC/SmartPhone "well-behaved" dialog application class
-
-// Macro for declaring dialog WNDCLASS and AppKey
-#define DECLARE_APP_DLG_CLASS(WndClassName, uCommonResourceID, uAppKey) \
-        static WTL::CFrameWndClassInfo& GetWndClassInfo() \
-        { \
-                static WTL::CFrameWndClassInfo wc = \
-                { \
-                        { 0, (WNDPROC)StartDialogProc, \
-                        0, 0, NULL, NULL, NULL, (HBRUSH)(COLOR_WINDOW + 1), NULL, WndClassName }, \
-                        NULL, NULL, IDC_ARROW, TRUE, 0, _T(""), uCommonResourceID \
-                }; \
-                return wc; \
-        }; \
-        DECLARE_APPKEY(uAppKey)
-
-template <class T>
-class CAppDialog : public CAppWindowBase< T >
-{
-public:
-        static int AppRun(LPTSTR lpstrCmdLine = NULL, int nCmdShow = SW_SHOWNORMAL)
-        {
-                CMessageLoop theLoop;
-                _Module.AddMessageLoop(&theLoop);
-
-                T dlgMain;
-
-                if(dlgMain.Create(NULL, (LPARAM)lpstrCmdLine) == NULL)
-                {
-                        ATLTRACE2(atlTraceUI, 0, _T("Main dialog creation failed!\n"));
-                        return 0;
-                }
-
-                dlgMain.ShowWindow(nCmdShow);
-
-                int nRet = theLoop.Run();
-
-                _Module.RemoveMessageLoop();
-                return nRet;
-        }
-
-        static HRESULT ActivatePreviousInstance(HINSTANCE hInstance, LPCTSTR  lpstrCmdLine)
-        {
-                return CAppWindowBase< T >::ActivatePreviousInstance(hInstance, lpstrCmdLine, true);
-        };
-};
-
-// PPC/SmartPhone standard application dialogs
-
-#ifdef WIN32_PLATFORM_WFSP
-#define WTL_APP_SHIDIF WTL_SP_SHIDIF
-#else
-#define WTL_APP_SHIDIF WTL_STD_SHIDIF
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// CAppStdDialogImplBase - Base implementation of standard application dialogs
-
-template <class T, class TImplBase, UINT t_shidiFlags = WTL_APP_SHIDIF, bool t_bModal = false>
-class ATL_NO_VTABLE CAppStdDialogImplBase :
-                public TImplBase, 
-                public CAppDialog< T >
-{ 
-public:
-        WTL_DLG_NOTITLE;
-
-        void StdCloseDialog(int nVal)
-        {
-                T* pT = static_cast<T*>(this);
-                if (nVal != IDCANCEL)
-                        pT->AppSave();
-                if (t_bModal == false)
-                {
-                        pT->DestroyWindow();
-                        ::PostQuitMessage(nVal);
-                }
-                else
-                        ::EndDialog(pT->m_hWnd, nVal);
-        }
-        
-        BEGIN_MSG_MAP(CAppStdDialogImplBase)
-                MESSAGE_HANDLER(WM_CLOSE, OnSystemClose)
-                CHAIN_MSG_MAP(TImplBase)
-                CHAIN_MSG_MAP(CAppDialog< T >)
-        END_MSG_MAP()
-
-        LRESULT OnSystemClose(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
-        {
-                T* pT = static_cast<T*>(this);
-                pT->StdCloseDialog(IDCANCEL);
-                return 0;
-        }
-};
-
-///////////////////////////////////////////////////////////////////////////////
-// CAppStdDialogImpl - Implementation of standard application dialog 
-
-template <class T, UINT t_shidiFlags = WTL_APP_SHIDIF, bool t_bModal = false>
-class ATL_NO_VTABLE CAppStdDialogImpl :
-                public CAppStdDialogImplBase<T, CStdDialogImpl<T, t_shidiFlags, t_bModal>, t_shidiFlags, t_bModal>
-{};
-
-///////////////////////////////////////////////////////////////////////////////
-// CAppStdDialogResizeImpl - implementation of orientation resizing standard application dialog
-
-template <class T, UINT t_shidiFlags = WTL_APP_SHIDIF, bool t_bModal = false>
-class ATL_NO_VTABLE CAppStdDialogResizeImpl :
-                public CAppStdDialogImplBase<T, CStdDialogResizeImpl<T, t_shidiFlags, t_bModal>, t_shidiFlags, t_bModal>
-{};
-
-#ifndef _ATL_NO_HOSTING
-///////////////////////////////////////////////////////////////////////////////
-// CAppStdAxDialogImpl - Implementation of standard application AxDialog 
-
-template <class T, UINT t_shidiFlags = WTL_APP_SHIDIF, bool t_bModal = false>
-class ATL_NO_VTABLE CAppStdAxDialogImpl :
-                public CAppStdDialogImplBase<T, CStdAxDialogImpl<T, t_shidiFlags, t_bModal>, t_shidiFlags, t_bModal>
-{};
-
-///////////////////////////////////////////////////////////////////////////////
-// CAppStdAxDialogResizeImpl - implementation of orientation resizing standard application AxDialog
-
-template <class T, UINT t_shidiFlags = WTL_APP_SHIDIF, bool t_bModal = false>
-class ATL_NO_VTABLE CAppStdAxDialogResizeImpl :
-                public CAppStdDialogImplBase<T, CStdAxDialogResizeImpl<T, t_shidiFlags, t_bModal>, t_shidiFlags, t_bModal>
-{};
-#endif // _ATL_NO_HOSTING
-
-#if defined(_WTL_CE_DRA) && defined(WIN32_PLATFORM_PSPC)
-///////////////////////////////////////////////////////////////////////////////
-// CAppStdOrientedDialogImpl - implementation of oriented PPC standard application dialog
-
-template <class T, UINT t_shidiFlags = WTL_APP_SHIDIF, bool t_bModal = false>
-class ATL_NO_VTABLE CAppStdOrientedDialogImpl :
-                public CAppStdDialogImplBase<T, CStdOrientedDialogImpl<T, t_shidiFlags, t_bModal>, t_shidiFlags, t_bModal>
-{};
-
-#ifndef _ATL_NO_HOSTING
-///////////////////////////////////////////////////////////////////////////////
-// CAppStdAxOrientedDialogImpl - implementation of oriented PPC standard application AxDialog
-
-template <class T, UINT t_shidiFlags = WTL_APP_SHIDIF, bool t_bModal = false>
-class ATL_NO_VTABLE CAppStdAxOrientedDialogImpl :
-                public CAppStdDialogImplBase<T, CStdAxOrientedDialogImpl<T, t_shidiFlags, t_bModal>, t_shidiFlags, t_bModal>
-{};
-#endif // _ATL_NO_HOSTING
-
-#endif // defined(_WTL_CE_DRA) && defined(WIN32_PLATFORM_PSPC)
-
-#endif // _WTL_CE_NO_DIALOGS
-
-#endif // _WTL_CE_NO_APPWINDOW
-
-
-// --- Full screen support ---
-
-#ifndef _WTL_CE_NO_FULLSCREEN
-
-///////////////////////////////////////////////////////////////////////////////
-// CFullScreenFrame - full screen frame implementation
-
-template <class T, bool t_bHasSip = true>
-class CFullScreenFrame
-{
-public:
-        bool m_bFullScreen;
-
-        CFullScreenFrame() : m_bFullScreen(false)
-        { }
-
-// Operation    
-        void SetFullScreen(bool bFull)
-        {
-                m_bFullScreen = bFull;
-                ShowTaskBar(!bFull, false);
-                ShowMenuBar(!bFull);
-        }
-
-// Manage TaskBar for modal dialogs and property sheets
-        template <class D>
-        int FSDoModal(D& dlg)
-        {
-                T* pT = static_cast<T*>(this);
-                pT;   // avoid level 4 warning
-                ATLASSERT(pT->IsWindow());
-                if (m_bFullScreen)   // Show taskbar if hidden
-                        ShowTaskBar(true, false);
-                int iRet = dlg.DoModal();
-                if (m_bFullScreen)   // Hide taskbar if restored
-                        ShowTaskBar(false);
-                return iRet;
-        }
-
-// Implementation
-        void ShowMenuBar(bool bShow)
-        {
-                T* pT = static_cast<T*>(this);
-                ATLASSERT(pT->IsWindow());
-                ATL::CWindow MenuBar = pT->m_hWndCECommandBar;
-                ATLASSERT(MenuBar.IsWindow());
-                MenuBar.ShowWindow(bShow ? SW_SHOWNORMAL : SW_HIDE);
-                pT->SizeToMenuBar();
-        }
-        
-        void ShowTaskBar(bool bShow, bool bRepaint = true)
-        {
-                T* pT = static_cast<T*>(this);
-                ATLASSERT(pT->IsWindow());
-                RECT rect = { 0 };
-                SystemParametersInfo(SPI_GETWORKAREA, NULL, &rect, FALSE);
-                if (!bShow)
-                        rect.top = 0;
-
-#ifdef WIN32_PLATFORM_PSPC // Pocket PC code
-                UINT uShow = t_bHasSip ? SHFS_SHOWTASKBAR | SHFS_SHOWSIPBUTTON : SHFS_SHOWTASKBAR | SHFS_HIDESIPBUTTON;         
-                SHFullScreen(pT->m_hWnd, bShow ? uShow : SHFS_HIDETASKBAR | SHFS_HIDESIPBUTTON);
-#elif _WIN32_WCE > 0x500 // Smartphone 2005 code
-                SHFullScreen(pT->m_hWnd, bShow ? SHFS_SHOWTASKBAR : SHFS_HIDETASKBAR);
-#else // Smartphone 2003
-                HWND hTaskBar = FindWindow(_T("tray"), NULL);
-                ATLASSERT(::IsWindow(hTaskBar));
-                ::ShowWindow(hTaskBar, bShow ? SW_SHOW : SW_HIDE);
-#endif // WIN32_PLATFORM_PSPC
-
-                pT->MoveWindow(&rect, bRepaint);
-        }
-
-// Message map and handler
-        BEGIN_MSG_MAP(CFullScreenFrame)
-                MESSAGE_HANDLER(WM_SETTINGCHANGE, OnSettingChange)
-                MESSAGE_HANDLER(WM_ACTIVATE, OnActivate)
-        END_MSG_MAP()
-
-        LRESULT OnSettingChange(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
-        {
-#ifndef SETTINGCHANGE_RESET // not defined for PPC 2002
-        #define SETTINGCHANGE_RESET SPI_SETWORKAREA
-#endif
-                if (m_bFullScreen && (wParam & SETTINGCHANGE_RESET))
-                        SetFullScreen(m_bFullScreen);
-                return bHandled = FALSE;
-        }
-
-        LRESULT OnActivate(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
-        {
-                if (m_bFullScreen)
-                {
-                        ShowTaskBar(!wParam);
-                        ShowMenuBar(!wParam);
-                }
-                return bHandled = FALSE;
-        }
-};
-
-#endif // _WTL_CE_NO_FULLSCREEN
-
-
-// --- WinCE zoom support ---
-
-#ifndef _WTL_CE_NO_ZOOMSCROLL
-
-///////////////////////////////////////////////////////////////////////////////
-// CZoomScrollImpl - WinCE zooming implementation on top of CScrollImpl
-
-template <class T>
-class  CZoomScrollImpl: public CScrollImpl< T >
-{
-public:
-// Data members
-        _WTYPES_NS::CSize m_sizeTrue;
-        double  m_fzoom;
-
-// Creation
-        CZoomScrollImpl() : m_sizeTrue(0), m_fzoom(1.)
-        { }
-
-// Zoom operations and access
-        void SetZoomScrollSize(_WTYPES_NS::CSize sizeTrue, double fzoom = 1., BOOL bRedraw = TRUE)
-        {
-                ATLASSERT(fzoom > 0.);
-                m_sizeTrue = sizeTrue;
-                m_fzoom = fzoom;
-
-                CScrollImpl< T >::SetScrollSize(sizeTrue / fzoom, bRedraw);
-        }
-
-        void SetZoomScrollSize(int cx, int cy, double fzoom=1., BOOL bRedraw = TRUE)
-        {
-                SetZoomScrollSize(_WTYPES_NS::CSize(cx, cy), fzoom, bRedraw);
-        }
-
-        void SetZoom(double fzoom, BOOL bRedraw = TRUE)
-        {
-                _WTYPES_NS::CPoint ptCenter = WndtoTrue(m_sizeClient / 2);
-                _WTYPES_NS::CSize sizePage = GetScrollPage();
-                _WTYPES_NS::CSize sizeLine = GetScrollLine();
-
-                SetZoomScrollSize(GetScrollSize(), fzoom, bRedraw);
-
-                SetScrollLine(sizeLine);
-                SetScrollPage(sizePage);
-                _WTYPES_NS::CPoint ptOffset = ptCenter - (m_sizeClient / 2) * fzoom;
-                SetScrollOffset(ptOffset, bRedraw);
-        }
-
-        double GetZoom()
-        {
-                return m_fzoom;
-        }
-
-// CScrollImpl overrides
-        void SetScrollOffset(int x, int y, BOOL bRedraw = TRUE)
-        {
-                CScrollImpl< T >::SetScrollOffset((int)(x / m_fzoom), (int)(y / m_fzoom), bRedraw);
-        }
-
-        void SetScrollOffset(POINT ptOffset, BOOL bRedraw = TRUE)
-        {
-                SetScrollOffset(ptOffset.x, ptOffset.y, bRedraw);
-        }
-
-        void GetScrollOffset(POINT& ptOffset)
-        {
-                ptOffset.x = (LONG)(m_ptOffset.x * m_fzoom);
-                ptOffset.y = (LONG)(m_ptOffset.y * m_fzoom);
-        }
-
-        void SetScrollSize(int cx, int cy, BOOL bRedraw = TRUE)
-        {
-                SetZoomScrollSize(cx, cy, GetZoom(), bRedraw);
-        }
-
-        void SetScrollSize(SIZE sizeTrue, BOOL bRedraw = TRUE)
-        {
-                SetZoomScrollSize(sizeTrue, GetZoom(), bRedraw);
-        }
-
-        void GetScrollSize(SIZE& sizeTrue) const
-        {
-                sizeTrue = m_sizeTrue;
-        }
-
-        void SetScrollPage(int cxPage, int cyPage)
-        {
-                SetScrollPage(_WTYPES_NS::CSize(cxPage, cyPage));
-        }
-
-        void SetScrollPage(SIZE sizePage)
-        {
-                CScrollImpl< T >::SetScrollPage(sizePage / m_fzoom);
-        }
-
-        void GetScrollPage(SIZE& sizePage) const
-        {
-                sizePage = m_sizePage * m_fzoom;
-        }
-
-        void SetScrollLine(int cxLine, int cyLine)
-        {
-                SetScrollLine(_WTYPES_NS::CSize(cxLine, cyLine));
-        }
-
-        void SetScrollLine(SIZE sizeLine)
-        {
-                CScrollImpl< T >::SetScrollLine(sizeLine / m_fzoom);
-        }
-
-        void GetScrollLine(SIZE& sizeLine) const
-        {
-                sizeLine = m_sizeLine * m_fzoom;
-        }
-
-// Data access complements
-        _WTYPES_NS::CSize GetScrollSize()
-        {
-                return m_sizeTrue;
-        }
-
-        _WTYPES_NS::CSize GetScrollPage()
-        {
-                return m_sizePage * m_fzoom;
-        }
-
-        _WTYPES_NS::CSize GetScrollLine()
-        {
-                return m_sizeLine * m_fzoom;
-        }
-
-        _WTYPES_NS::CPoint GetScrollOffset()
-        {
-                return (_WTYPES_NS::CSize)m_ptOffset * m_fzoom;
-        }
-
-// Helper coordinate functions
-        _WTYPES_NS::CPoint WndtoTrue(CPoint ptW)
-        {
-                return (_WTYPES_NS::CSize)ptW * GetZoom() + GetScrollOffset();
-        }
-
-        void WndtoTrue(LPPOINT aptW, int nPts)   // in place coord transformation
-        {
-                for (int i = 0 ; i < nPts ; i++)
-                        aptW[i] = WndtoTrue(aptW[i]);
-        }
-
-        void WndtoTrue(LPRECT prectW)   // in place coord transformation
-        {
-                WndtoTrue((LPPOINT)prectW, 2);
-        }
-
-        _WTYPES_NS::CPoint TruetoWnd(CPoint ptT)
-        {
-                return (ptT - GetScrollOffset()) / GetZoom();
-        }
-
-        void TruetoWnd(LPPOINT aptT, int nPts)   // in place coord transformation
-        {
-                for (int i = 0 ; i < nPts ; i++)
-                        aptT[i] = TruetoWnd(aptT[i]);
-        }
-
-        void TruetoWnd(LPRECT prectT)   // in place coord transformation
-        {
-                TruetoWnd((LPPOINT)prectT, 2);
-        }
-
-// Drawing operations : assume adequate setting of data members
-        BOOL Draw(HBITMAP hbm, HDC hdestDC, DWORD dwROP = SRCCOPY)
-        {
-                CDC memDC = CreateCompatibleDC(hdestDC);
-                CBitmapHandle bmpOld = memDC.SelectBitmap(hbm);
-                BOOL bRes = Draw(memDC, hdestDC, dwROP);
-                memDC.SelectBitmap(bmpOld);
-                return bRes;
-        }
-
-        BOOL Draw(HDC hsourceDC, HDC hdestDC, DWORD dwROP = SRCCOPY)
-        {
-                CDCHandle destDC = hdestDC;
-                destDC.SetViewportOrg(0,0);
-                _WTYPES_NS::CPoint ptOffset = GetScrollOffset();
-                _WTYPES_NS::CSize sizeZClient = m_sizeClient * GetZoom();
-                return destDC.StretchBlt(0, 0, m_sizeClient.cx, m_sizeClient.cy, hsourceDC, ptOffset.x, ptOffset.y, sizeZClient.cx, sizeZClient.cy, dwROP);
-        }
-
-#ifdef _IMAGING_H
-        BOOL Draw(IImage* pIImage, HDC hdestDC)
-        {
-                CDCHandle destDC = hdestDC;
-                destDC.SetViewportOrg(0,0);
-                return SUCCEEDED(pIImage->Draw(destDC, _WTYPES_NS::CRect(-_WTYPES_NS::CPoint(m_ptOffset), m_sizeAll), NULL));
-        }
-#endif
-
-// Message map and handlers
-        BEGIN_MSG_MAP(CZoomScrollImpl< T >)
-                MESSAGE_HANDLER(WM_ERASEBKGND, OnEraseBkgnd)
-                CHAIN_MSG_MAP(CScrollImpl< T >)
-        END_MSG_MAP()
-        
-        LRESULT OnEraseBkgnd(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
-        {
-                T* pT = static_cast<T*>(this);
-                ATLASSERT(::IsWindow(pT->m_hWnd));
-                if ((GetScrollExtendedStyle() & SCRL_ERASEBACKGROUND))
-                {
-                        _WTYPES_NS::CRect rect;
-                        pT->GetClientRect(rect);
-                        _WTYPES_NS::CSize sizeClient=rect.Size();
-
-                        if (m_sizeAll.cx < sizeClient.cx || m_sizeAll.cy < sizeClient.cy)
-                        {
-                                CDCHandle hdc = (HDC)wParam;
-                                HBRUSH hbr = GetSysColorBrush((int)T::GetWndClassInfo().m_wc.hbrBackground - 1);
-
-                                if (m_sizeAll.cx < sizeClient.cx)
-                                {
-                                        _WTYPES_NS::CRect rectBG(_WTYPES_NS::CPoint(m_sizeAll.cx, 0), sizeClient);
-                                        hdc.FillRect(rectBG, hbr);
-                                }
-
-                                if (m_sizeAll.cy < sizeClient.cy)
-                                {
-                                        _WTYPES_NS::CRect rectBG(_WTYPES_NS::CPoint(0, m_sizeAll.cy), sizeClient);
-                                        hdc.FillRect(rectBG, hbr);
-                                }
-                        }
-                }
-                else
-                {
-                        bHandled = FALSE;
-                }
-
-                return 1;
-        }
-};
-
-#endif // _WTL_CE_NO_ZOOMSCROLL
-
-#ifndef _WTL_CE_NO_CONTROLS
-
-// --- PPC bottom TabView control ---
-
-#if defined(__ATLCTRLX_H__) && defined(WIN32_PLATFORM_PSPC)
-
-///////////////////////////////////////////////////////////////////////////////
-// CBottomTabViewImpl
-
-template <class T, class TBase = ATL::CWindow, class TWinTraits = ATL::CControlWinTraits>
-class ATL_NO_VTABLE CBottomTabViewImpl : public CTabViewImpl<T, TBase, TWinTraits>
-{
-public:
-        DECLARE_WND_CLASS_EX(NULL, 0, COLOR_APPWORKSPACE)
-
-// Implementation overrideables
-        bool CreateTabControl()
-        {
-                m_tab.Create(m_hWnd, rcDefault, NULL, WS_CHILD | TCS_BOTTOM, 0, m_nTabID);
-
-                ATLASSERT(m_tab.m_hWnd != NULL);
-                if(m_tab.m_hWnd == NULL)
-                        return false;
-
-                m_tab.SendMessage(CCM_SETVERSION, COMCTL32_VERSION);
-                m_tab.SetItemExtra(sizeof(TABVIEWPAGE));
-
-                T* pT = static_cast<T*>(this);
-                m_cyTabHeight = pT->CalcTabHeight();
-
-                return true;
-        }
-
-        int CalcTabHeight()
-        {
-                int nCount = m_tab.GetItemCount();
-                TCITEMEXTRA tcix = { 0 };
-                tcix.tciheader.mask = TCIF_TEXT;
-                tcix.tciheader.pszText = _T("NS");
-                int nIndex = m_tab.InsertItem(nCount, tcix);
-
-                RECT rect = { 0 };
-                SystemParametersInfo(SPI_GETWORKAREA, 0, &rect, 0);
-                RECT rcWnd = rect;
-
-                m_tab.AdjustRect(FALSE, &rect);
-                rcWnd.top = rect.bottom;
-                ::AdjustWindowRectEx(&rcWnd, m_tab.GetStyle(), FALSE, m_tab.GetExStyle());
-                m_tab.DeleteItem(nIndex);
-
-                return rcWnd.bottom - rcWnd.top;
-        }
-
-        void UpdateLayout()
-        {
-                RECT rect;
-                GetClientRect(&rect);
-
-                if(m_tab.IsWindow() && ((m_tab.GetStyle() & WS_VISIBLE) != 0))
-                        m_tab.SetWindowPos(NULL, 0, rect.bottom - m_cyTabHeight, rect.right - rect.left, m_cyTabHeight, SWP_NOZORDER /*| SWP_SHOWWINDOW*/);
-
-                if(m_nActivePage != -1)
-                                ::SetWindowPos(GetPageHWND(m_nActivePage), NULL, 0, 0, rect.right - rect.left, rect.bottom - m_cyTabHeight, SWP_NOZORDER);
-        }
-
-};
-
-class CBottomTabView : public CBottomTabViewImpl<CBottomTabView>
-{
-public:
-        DECLARE_WND_CLASS_EX(_T("WTL_BottomTabView"), 0, COLOR_APPWORKSPACE)
-};
-
-#endif // defined(__ATLCTRLX_H__) && defined(WIN32_PLATFORM_PSPC)
-
-
-// --- PPC/SmartPhone controls ---
-
-////////////////////////////////////////////////////////////////////////////////
-// These are wrapper classes for the Pocket PC 2002/2003 and SmartPhone 2003 controls
-// To implement a window based on a control, use following:
-// Example: Implementing a window based on a Html control
-//
-// class CMyHtml : CWindowImpl<CMyHtml, CHtmlCtrl>
-// {
-// public:
-//      BEGIN_MSG_MAP(CMyHtml)
-//          // put your message handler entries here
-//      END_MSG_MAP()
-// };
-///////////////////////////////////////////////////////////////////////////////
-
-///////////////////////////////////////////////////////////////////////////////
-// CHtmlCtrl
-
-template <class TBase>
-class CHtmlCtrlT : public TBase
-{
-public:
-// Constructors
-        CHtmlCtrlT(HWND hWnd = NULL) : TBase(hWnd)
-        { }
-
-        CHtmlCtrlT< TBase >& operator =(HWND hWnd)
-        {
-                m_hWnd = hWnd;
-                return *this;
-        }
-
-        HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
-                        DWORD dwStyle = 0, DWORD dwExStyle = 0,
-                        ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
-        {
-                HWND hWnd = TBase::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);
-                ATLASSERT(hWnd != NULL);   // Did you remember to call InitHTMLControl(hInstance) ??
-                return hWnd;
-        }
-
-// Attributes
-        static LPCTSTR GetWndClassName()
-        {
-                return WC_HTML;
-        }
-
-#if (_WIN32_WCE >= 400)
-        void AddStyle(LPCWSTR pszStyle)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, DTM_ADDSTYLE, 0, (LPARAM)pszStyle);
-        }
-#endif // (_WIN32_WCE >= 400)
-
-        void AddText(BOOL bPlainText, LPCSTR pszText)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, DTM_ADDTEXT, (WPARAM)bPlainText, (LPARAM)pszText);
-        }
-
-        void AddHTML(LPCSTR pszHTML)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, DTM_ADDTEXT, (WPARAM)FALSE, (LPARAM)pszHTML);
-        }
-
-        void AddText(BOOL bPlainText, LPCWSTR pszText)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, DTM_ADDTEXTW, (WPARAM)bPlainText, (LPARAM)pszText);
-        }
-
-        void AddHTML(LPCWSTR pszHTML)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, DTM_ADDTEXTW, (WPARAM)FALSE, (LPARAM)pszHTML);
-        }
-
-        void Anchor(LPCSTR pszAnchor)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, DTM_ANCHOR, 0, (LPARAM)pszAnchor);
-        }
-
-        void Anchor(LPCWSTR pszAnchor)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, DTM_ANCHORW, 0, (LPARAM)pszAnchor);
-        }
-
-#if (_WIN32_WCE >= 420)
-        void GetBrowserDispatch(IDispatch** ppDispatch)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ATLASSERT(ppDispatch);
-                ATLASSERT(*ppDispatch==NULL);
-                ::SendMessage(m_hWnd, DTM_BROWSERDISPATCH, 0, (LPARAM)ppDispatch);
-        }
-        void GetDocumentDispatch(IDispatch** ppDispatch)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ATLASSERT(ppDispatch);
-                ATLASSERT(*ppDispatch==NULL);
-                ::SendMessage(m_hWnd, DTM_DOCUMENTDISPATCH , 0, (LPARAM)ppDispatch);
-        }
-#endif // (_WIN32_WCE >= 420)
-
-        void Clear()
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, DTM_CLEAR, 0, 0L);
-        }
-
-        void EnableClearType(BOOL bEnable = TRUE)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, DTM_ENABLECLEARTYPE, 0, (LPARAM)bEnable);
-        }
-
-        void EnableContextMenu(BOOL bEnable = TRUE)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, DTM_ENABLECONTEXTMENU, 0, (LPARAM)bEnable);
-        }
-
-        void EnableScripting(BOOL bEnable = TRUE)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, DTM_ENABLESCRIPTING, 0, (LPARAM)bEnable);
-        }
-
-        void EnableShrink(BOOL bEnable = TRUE)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, DTM_ENABLESHRINK, 0, (LPARAM)bEnable);
-        }
-
-        void EndOfSource()
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, DTM_ENDOFSOURCE, 0, 0L);
-        }
-
-        void ImageFail(DWORD dwCookie)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, DTM_IMAGEFAIL, 0, (LPARAM)dwCookie);
-        }
-
-        int GetLayoutHeight() const
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                return (int)::SendMessage(m_hWnd, DTM_LAYOUTHEIGHT, 0, 0L);
-        }
-
-        int GetLayoutWidth() const
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                return (int)::SendMessage(m_hWnd, DTM_LAYOUTWIDTH, 0, 0L);
-        }
-
-        void Navigate(LPCTSTR pstrURL, UINT uFlags = 0)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ATLASSERT(pstrURL);
-                ::SendMessage(m_hWnd, DTM_NAVIGATE, (WPARAM)uFlags, (LPARAM)pstrURL);
-        }
-
-        void SelectAll()
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, DTM_SELECTALL, 0, 0L);
-        }
-
-        void SetImage(INLINEIMAGEINFO* pImageInfo)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ATLASSERT(pImageInfo);
-                ::SendMessage(m_hWnd, DTM_SETIMAGE, 0, (LPARAM)pImageInfo);
-        }
-
-        void ZoomLevel(int iLevel)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, DTM_ZOOMLEVEL, 0, (LPARAM)iLevel);
-        }
-
-#if (_WIN32_WCE >= 400)
-        void Stop()
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, DTM_STOP, 0, 0L);
-        }
-#endif // (_WIN32_WCE >= 400)
-
-        void GetScriptDispatch(IDispatch** ppDispatch)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ATLASSERT(ppDispatch);
-                ATLASSERT(*ppDispatch==NULL);
-                ::SendMessage(m_hWnd, DTM_SCRIPTDISPATCH, 0, (LPARAM)ppDispatch);
-        }
-};
-
-typedef CHtmlCtrlT<ATL::CWindow> CHtmlCtrl;
-
-
-#ifdef WIN32_PLATFORM_PSPC
-
-///////////////////////////////////////////////////////////////////////////////
-// CRichInkCtrl
-
-template <class TBase>
-class CRichInkCtrlT : public TBase
-{
-public:
-// Constructors
-        CRichInkCtrlT(HWND hWnd = NULL) : TBase(hWnd)
-        { }
-
-        CRichInkCtrlT< TBase >& operator =(HWND hWnd)
-        {
-                m_hWnd = hWnd;
-                return *this;
-        }
-
-        HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
-                        DWORD dwStyle = 0, DWORD dwExStyle = 0,
-                        ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
-        {
-                HWND hWnd = TBase::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);
-                ATLASSERT(hWnd != NULL);   // Did you remember to call InitRichInkDLL() ??
-                return hWnd;
-        }
-
-// Attributes
-        static LPCTSTR GetWndClassName()
-        {
-                return WC_RICHINK;
-        }
-
-        BOOL CanPaste(UINT uFormat = 0) const
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                return (BOOL)::SendMessage(m_hWnd, EM_CANPASTE, (WPARAM)uFormat, 0L);
-        }
-
-        BOOL CanRedo() const
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                return (BOOL)::SendMessage(m_hWnd, EM_CANREDO, 0, 0L);
-        }
-
-        BOOL CanUndo() const
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                return (BOOL)::SendMessage(m_hWnd, EM_CANUNDO, 0, 0L);
-        }
-
-        void ClearAll(BOOL bRepaint = TRUE) const
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, EM_CLEARALL, (WPARAM)bRepaint, 0L);
-        }
-
-        BOOL GetModify() const
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                return (BOOL)::SendMessage(m_hWnd, EM_GETMODIFY, 0, 0L);
-        }
-
-        UINT GetPageStyle() const
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                return (UINT)::SendMessage(m_hWnd, EM_GETPAGESTYLE, 0, 0L);
-        }
-
-        UINT GetPenMode() const
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                return (UINT)::SendMessage(m_hWnd, EM_GETPENMODE, 0, 0L);
-        }
-
-        UINT GetViewStyle() const
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                return (UINT)::SendMessage(m_hWnd, EM_GETVIEW, 0, 0L);
-        }
-
-        UINT GetWrapMode() const
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                return (UINT)::SendMessage(m_hWnd, EM_GETWRAPMODE, 0, 0L);
-        }
-
-        UINT GetZoomPercent() const
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                return (UINT)::SendMessage(m_hWnd, EM_GETZOOMPERCENT, 0, 0L);
-        }
-
-        void InsertLinks(LPWSTR lpString, int cchLength = -1)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                if(cchLength == -1)
-                        cchLength = lstrlen(lpString);
-                ::SendMessage(m_hWnd, EM_INSERTLINKS, (WPARAM)cchLength, (LPARAM)lpString);
-        }
-
-        void RedoEvent()
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, EM_REDOEVENT, 0, 0L);
-        }
-
-        UINT SetInkLayer(UINT uLayer)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                return (UINT)::SendMessage(m_hWnd, EM_SETINKLAYER, (WPARAM)uLayer, 0L);
-        }
-
-        void SetPageStyle(UINT uStyle)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, EM_SETPAGESTYLE, (WPARAM)uStyle, 0L);
-        }
-
-        void SetPenMode(UINT uMode)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, EM_SETPENMODE, (WPARAM)uMode, 0L);
-        }
-
-        void SetViewStyle(UINT uStyle)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, EM_SETVIEW, (WPARAM)uStyle, 0L);
-        }
-
-        void SetViewAttributes(VIEWATTRIBUTES* pAttribs)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ATLASSERT(pAttribs);
-                ::SendMessage(m_hWnd, EM_SETVIEWATTRIBUTES, 0, (LPARAM)pAttribs);
-        }
-
-        void SetWrapMode(UINT uMode)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, EM_SETWRAPMODE, (WPARAM)uMode, 0L);
-        }
-
-        void SetZoomPercent(UINT uPercent)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, EM_SETZOOMPERCENT, (WPARAM)uPercent, 0L);
-        }
-
-        LONG StreamIn(UINT uFormat, EDITSTREAM& es)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                return (LONG)::SendMessage(m_hWnd, EM_STREAMIN, (WPARAM)uFormat, (LPARAM)&es);
-        }
-
-        LONG StreamOut(UINT uFormat, EDITSTREAM& es)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                return (LONG)::SendMessage(m_hWnd, EM_STREAMOUT, (WPARAM)uFormat, (LPARAM)&es);
-        }
-
-        void UndoEvent()
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, EM_UNDOEVENT, 0, 0L);
-        }
-
-// Standard EM_xxx messages
-        DWORD GetSel() const
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                return (DWORD)::SendMessage(m_hWnd, EM_GETSEL, 0, 0L);
-        }
-
-        void GetSel(int& nStartChar, int& nEndChar) const
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, EM_GETSEL, (WPARAM)&nStartChar, (LPARAM)&nEndChar);
-        }
-
-        void ReplaceSel(LPCTSTR lpszNewText, BOOL bCanUndo = FALSE)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, EM_REPLACESEL, (WPARAM)bCanUndo, (LPARAM)lpszNewText);
-        }
-
-        void SetModify(BOOL bModified = TRUE)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, EM_SETMODIFY, (WPARAM)bModified, 0L);
-        }
-
-        int GetTextLength() const
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                return (int)::SendMessage(m_hWnd, WM_GETTEXTLENGTH, 0, 0L);
-        }
-
-// Clipboard operations
-        void Clear()
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, WM_CLEAR, 0, 0L);
-        }
-
-        void Copy()
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, WM_COPY, 0, 0L);
-        }
-
-        void Cut()
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, WM_CUT, 0, 0L);
-        }
-
-        void Paste()
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, WM_PASTE, 0, 0L);
-        }
-};
-
-typedef CRichInkCtrlT<ATL::CWindow> CRichInkCtrl;
-
-
-///////////////////////////////////////////////////////////////////////////////
-// CInkXCtrl
-
-template <class TBase>
-class CInkXCtrlT : public TBase
-{
-public:
-// Constructors
-        CInkXCtrlT(HWND hWnd = NULL) : TBase(hWnd)
-        { }
-
-        CInkXCtrlT< TBase >& operator =(HWND hWnd)
-        {
-                m_hWnd = hWnd;
-                return *this;
-        }
-
-        HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
-                        DWORD dwStyle = 0, DWORD dwExStyle = 0,
-                        ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
-        {
-                HWND hWnd = TBase::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);
-                ATLASSERT(hWnd != NULL);   // Did you remember to call InitInkX() ??
-                return hWnd;
-        }
-
-// Attributes
-        static LPCTSTR GetWndClassName()
-        {
-                return WC_INKX;
-        }
-
-        static UINT GetHotRecordingMessage()
-        {
-                return ::RegisterWindowMessage(szHotRecording);
-        }
-
-        void ClearAll()
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, IM_CLEARALL, 0, 0L);
-        }
-
-        int GetData(BYTE* lpBuffer, INT cbBuffer) const
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ATLASSERT(lpBuffer);
-                return (int)::SendMessage(m_hWnd, IM_GETDATA, (WPARAM)cbBuffer, (LPARAM)lpBuffer);
-        }
-
-        int GetDataLen() const
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                return (int)::SendMessage(m_hWnd, IM_GETDATALEN, 0, 0L);
-        }
-
-        CRichInkCtrl GetRichInk() const
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                return (HWND)::SendMessage(m_hWnd, IM_GETRICHINK, 0, 0L);
-        }
-
-        BOOL IsRecording() const
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                return (BOOL)::SendMessage(m_hWnd, IM_RECORDING, 0, 0L);
-        }
-
-        void ReInit()
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, IM_REINIT, 0, 0L);
-        }
-
-        void SetData(const BYTE* lpInkData, INT cbInkData)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ATLASSERT(lpInkData);
-                ::SendMessage(m_hWnd, IM_SETDATA, (WPARAM)cbInkData, (LPARAM)lpInkData);
-        }
-
-        void VoicePlay()
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, IM_VOICE_PLAY, 0, 0L);
-        }
-
-        BOOL IsVoicePlaying() const
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                return (BOOL)::SendMessage(m_hWnd, IM_VOICE_PLAYING, 0, 0L);
-        }
-
-        BOOL VoiceRecord()
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                return (BOOL)::SendMessage(m_hWnd, IM_VOICE_RECORD, 0, 0L);
-        }
-
-        void VoiceStop()
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, IM_VOICE_STOP, 0, 0L);
-        }
-
-        void ShowVoiceBar(BOOL bShow = TRUE)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, IM_VOICEBAR, (WPARAM)bShow, 0L);
-        }
-};
-
-typedef CInkXCtrlT<ATL::CWindow> CInkXCtrl;
-
-#endif // WIN32_PLATFORM_PSPC
-
-
-///////////////////////////////////////////////////////////////////////////////
-// CVoiceRecorderCtrl
-
-template <class TBase>
-class CVoiceRecorderCtrlT : public TBase
-{
-public:
-// Constructors
-        CVoiceRecorderCtrlT(HWND hWnd = NULL) : TBase(hWnd)
-        { }
-
-        CVoiceRecorderCtrlT< TBase >& operator =(HWND hWnd)
-        {
-                m_hWnd = hWnd;
-                return *this;
-        }
-
-        HWND Create(HWND hWndParent, const POINT pt, LPTSTR pstrFileName, UINT nID, DWORD dwStyle = 0)
-        {
-                ATLASSERT(pstrFileName != NULL);
-                CM_VOICE_RECORDER cmvr = { 0 };
-                cmvr.cb = sizeof(CM_VOICE_RECORDER);
-                cmvr.dwStyle = dwStyle;
-                cmvr.xPos = pt.x;
-                cmvr.yPos = pt.y;
-                cmvr.hwndParent = hWndParent;
-                cmvr.id = nID;
-                cmvr.lpszRecordFileName = pstrFileName;
-                m_hWnd = VoiceRecorder_Create(&cmvr);
-                return m_hWnd;
-        }
-
-        HWND Create(LPCM_VOICE_RECORDER pAttribs)
-        {
-                ATLASSERT(pAttribs);
-                m_hWnd = VoiceRecorder_Create(pAttribs);
-                return m_hWnd;
-        }
-
-// Attributes
-        void Record()
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, VRM_RECORD, 0, 0L);
-        }
-
-        void Play()
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, VRM_PLAY, 0, 0L);
-        }
-
-        void Stop()
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, VRM_STOP, 0, 0L);
-        }
-
-        void Cancel()
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, VRM_CANCEL, 0, 0L);
-        }
-
-        void Done()
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, VRM_OK, 0, 0L);
-        }
-};
-
-typedef CVoiceRecorderCtrlT<ATL::CWindow> CVoiceRecorderCtrl;
-
-
-#ifdef WIN32_PLATFORM_PSPC
-
-///////////////////////////////////////////////////////////////////////////////
-// CDocListCtrl
-
-template <class TBase>
-class CDocListCtrlT : public TBase
-{
-public:
-// Attributes
-        DOCLISTCREATE m_dlc;
-        TCHAR m_szPath[MAX_PATH];
-
-// Constructors
-        CDocListCtrlT(HWND hWnd = NULL) : TBase(hWnd)
-        { }
-
-        CDocListCtrlT< TBase >& operator =(HWND hWnd)
-        {
-                m_hWnd = hWnd;
-                return *this;
-        }
-
-        HWND Create(HWND hWndParent, WORD wId, LPCTSTR pszFolder = NULL, LPCTSTR pstrFilter = NULL,
-                        WORD wFilterIndex = 0, DWORD dwFlags = DLF_SHOWEXTENSION)
-        {
-                ATLASSERT(pstrFilter != NULL);   // It seems to need a filter badly!!
-                ::ZeroMemory(&m_dlc, sizeof(DOCLISTCREATE));
-                ::ZeroMemory(m_szPath, sizeof(m_szPath));
-                if(pszFolder != NULL)
-                        ::lstrcpyn(m_szPath, pszFolder, MAX_PATH - 1);
-                m_dlc.dwStructSize = sizeof(DOCLISTCREATE);
-                m_dlc.hwndParent = hWndParent;
-                m_dlc.pszFolder = m_szPath;
-                m_dlc.pstrFilter = pstrFilter;
-                m_dlc.wFilterIndex = wFilterIndex;
-                m_dlc.wId = wId;
-                m_dlc.dwFlags = dwFlags;
-                m_hWnd = DocList_Create(&m_dlc);
-                return m_hWnd;
-        }
-
-        HWND Create(DOCLISTCREATE* pDlc)
-        {
-                m_dlc = *pDlc;
-                m_hWnd = DocList_Create(&m_dlc);
-                return m_hWnd;
-        }
-
-// Attributes
-        void DeleteSel()
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, DLM_DELETESEL, 0, 0L);
-        }
-
-        void DisableUpdates()
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, DLM_DISABLEUPDATES, 0, 0L);
-        }
-
-        void EnableUpdates()
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, DLM_ENABLEUPDATES, 0, 0L);
-        }
-
-        int GetFilterIndex() const
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                return (int)::SendMessage(m_hWnd, DLM_GETFILTERINDEX, 0, 0L);
-        }
-
-        int GetItemCount() const
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                return (int)::SendMessage(m_hWnd, DLM_GETITEMCOUNT, 0, 0L);
-        }
-
-        int GetNextItem(int iIndex, DWORD dwRelation = LVNI_ALL) const
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                return (int)::SendMessage(m_hWnd, DLM_GETNEXTITEM, (WPARAM)iIndex, (LPARAM)dwRelation);
-        }
-
-        int GetFirstItem(DWORD dwRelation = LVNI_ALL) const
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                return (int)::SendMessage(m_hWnd, DLM_GETNEXTITEM, (WPARAM)-1, (LPARAM)dwRelation);
-        }
-
-        BOOL GetNextWave(int* pIndex) const
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ATLASSERT(pIndex);
-                return (BOOL)::SendMessage(m_hWnd, DLM_GETNEXTWAVE, 0, (LPARAM)pIndex);
-        }
-
-        BOOL GetPrevWave(int* pIndex) const
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ATLASSERT(pIndex);
-                return (BOOL)::SendMessage(m_hWnd, DLM_GETPREVWAVE, 0, (LPARAM)pIndex);
-        }
-
-        int GetSelCount() const
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                return (int)::SendMessage(m_hWnd, DLM_GETSELCOUNT, 0, 0L);
-        }
-
-        BOOL GetSelPathName(LPTSTR pstrPath, int cchMax) const
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ATLASSERT(pstrPath);
-                return (BOOL)::SendMessage(m_hWnd, DLM_GETSELPATHNAME, (WPARAM)cchMax, (LPARAM)pstrPath);
-        }
-
-        void ReceiveIR(LPCTSTR pstrPath) const
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ATLASSERT(pstrPath);
-                ::SendMessage(m_hWnd, DLM_RECEIVEIR, 0, (LPARAM)pstrPath);
-        }
-
-        void Refresh()
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, DLM_REFRESH, 0, 0L);
-        }
-
-        BOOL RenameMoveSelectedItems()
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                return (BOOL)::SendMessage(m_hWnd, DLM_RENAMEMOVE, 0, 0L);
-        }
-
-        int SelectAll()
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                return (int)::SendMessage(m_hWnd, DLM_SELECTALL, 0, 0L);
-        }
-
-        HRESULT SelectItem(LPCTSTR pstrPath, BOOL bVisible = TRUE)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ATLASSERT(pstrPath);
-                return (HRESULT)::SendMessage(m_hWnd, DLM_SELECTITEM, (WPARAM)bVisible, (LPARAM)pstrPath);
-        }
-
-        void SendEMail(LPCTSTR pstrAttachment)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, DLM_SENDEMAIL, 0, (LPARAM)pstrAttachment);
-        }
-
-        void SendIR(LPCTSTR pstrPath)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, DLM_SENDIR, 0, (LPARAM)pstrPath);
-        }
-
-        HRESULT SetFilterIndex(int iIndex)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                return (HRESULT)::SendMessage(m_hWnd, DLM_SETFILTERINDEX, (WPARAM)iIndex, 0L);
-        }
-
-        void SetFolder(LPCTSTR pstrPath)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ATLASSERT(pstrPath);
-                ::SendMessage(m_hWnd, DLM_SETFOLDER, 0, (LPARAM)pstrPath);
-        }
-
-        BOOL SetItemState(int iIndex, const LVITEM* pItem)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ATLASSERT(pItem);
-                return (BOOL)::SendMessage(m_hWnd, DLM_SETITEMSTATE, (WPARAM)iIndex, (LPARAM)pItem);
-        }
-
-        BOOL SetItemState(int iIndex, UINT uState, UINT uMask)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                LV_ITEM lvi = { 0 };
-                lvi.stateMask = uMask;
-                lvi.state = uState;
-                return (BOOL)::SendMessage(m_hWnd, DLM_SETITEMSTATE, (WPARAM)iIndex, (LPARAM)&lvi);
-        }
-
-        void SetOneItem(int iIndex, LPCVOID pPA)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, DLM_SETONEITEM, (WPARAM)iIndex, (LPARAM)pPA);
-        }
-
-        void SetSelect(int iIndex)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ::SendMessage(m_hWnd, DLM_SETSELECT, (WPARAM)iIndex, 0L);
-        }
-
-        void SetSelPathName(LPCTSTR pstrPath)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ATLASSERT(pstrPath);
-                ::SendMessage(m_hWnd, DLM_SETSELPATHNAME, 0, (LPARAM)pstrPath);
-        }
-
-        BOOL SetSortOrder()
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                return (BOOL)::SendMessage(m_hWnd, DLM_SETSORTORDER, 0, 0L);
-        }
-
-        HRESULT Update()
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                return (HRESULT)::SendMessage(m_hWnd, DLM_UPDATE, 0, 0L);
-        }
-
-        BOOL ValidateFolder()
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                return (BOOL)::SendMessage(m_hWnd, DLM_VALIDATEFOLDER, 0, 0L);
-        }
-
-// Functions
-        BOOL GetFirstSelectedWaveFile(int* pIndex, LPTSTR szPath, const size_t cchPath)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                return DocList_GetFirstSelectedWaveFile(m_hWnd, pIndex, szPath, cchPath);
-        }
-
-        BOOL GetNextSelectedWaveFile(int* pIndex, LPTSTR szPath, const size_t cchPath)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                return DocList_GetNextSelectedWaveFile(m_hWnd, pIndex, szPath, cchPath);
-        }
-};
-
-typedef CDocListCtrlT<ATL::CWindow> CDocListCtrl;
-
-#endif // WIN32_PLATFORM_PSPC
-
-
-///////////////////////////////////////////////////////////////////////////////
-// CCapEdit
-
-template <class TBase>
-class CCapEditT : public TBase
-{
-public:
-// Constructors
-        CCapEditT(HWND hWnd = NULL) : TBase(hWnd)
-        { }
-
-        CCapEditT< TBase >& operator =(HWND hWnd)
-        {
-                m_hWnd = hWnd;
-                return *this;
-        }
-
-        HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
-                        DWORD dwStyle = 0, DWORD dwExStyle = 0,
-                        ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
-        {
-                HWND hWnd = /*TBase*/CWindow::Create(GetWndClassName(), hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);
-                ATLASSERT(hWnd != NULL);   // Did you remember to call SHInitExtraControls() ??
-                return hWnd;
-        }
-
-// Attributes
-        static LPCTSTR GetWndClassName()
-        {
-                return WC_CAPEDIT;
-        }
-};
-
-typedef CCapEditT<WTL::CEdit> CCapEdit;
-
-///////////////////////////////////////////////////////////////////////////////
-// CTTStatic
-
-#ifndef WIN32_PLATFORM_WFSP // Tooltips not supported on SmartPhone
-
-template <class TBase>
-class CTTStaticT : public TBase
-{
-public:
-// Constructors
-        CTTStaticT(HWND hWnd = NULL) : TBase(hWnd)
-        { }
-
-        CTTStaticT< TBase >& operator =(HWND hWnd)
-        {
-                m_hWnd = hWnd;
-                return *this;
-        }
-
-        HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
-                        DWORD dwStyle = 0, DWORD dwExStyle = 0,
-                        ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
-        {
-                HWND hWnd = TBase::Create(hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);
-                ATLASSERT(hWnd != NULL);   // Did you remember to call SHInitExtraControls() ??
-                return hWnd;
-        }
-
-// Attributes
-        static LPCTSTR GetWndClassName()
-        {
-                return WC_TSTATIC;
-        }
-
-// Operations
-        BOOL SetToolTipText(LPCTSTR pstrTipText)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ATLASSERT(pstrTipText);
-                ATLASSERT(lstrlen(pstrTipText)<= 253);
-                CTempBuffer<TCHAR, _WTL_STACK_ALLOC_THRESHOLD> buff;
-                LPTSTR pstr = buff.Allocate(lstrlen(pstrTipText) + 3);
-                if(pstr == NULL)
-                        return FALSE;
-                ::lstrcpy(pstr, _T("~~"));
-                ::lstrcat(pstr, pstrTipText);
-                return SetWindowText(pstr);
-        }
-};
-
-typedef CTTStaticT<WTL::CStatic> CTTStatic;
-
-
-///////////////////////////////////////////////////////////////////////////////
-// CTTButton
-
-template <class TBase>
-class CTTButtonT : public TBase
-{
-public:
-// Constructors
-        CTTButtonT(HWND hWnd = NULL) : TBase(hWnd)
-        { }
-
-        CTTButtonT< TBase >& operator =(HWND hWnd)
-        {
-                m_hWnd = hWnd;
-                return *this;
-        }
-
-        HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szWindowName = NULL,
-                        DWORD dwStyle = 0, DWORD dwExStyle = 0,
-                        ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
-        {
-                HWND hWnd = TBase::Create(hWndParent, rect.m_lpRect, szWindowName, dwStyle, dwExStyle, MenuOrID.m_hMenu, lpCreateParam);
-                ATLASSERT(hWnd != NULL);   // Did you remember to call SHInitExtraControls() ??
-                return hWnd;
-        }
-
-// Attributes
-        static LPCTSTR GetWndClassName()
-        {
-                return WC_TBUTTON;
-        }
-
-// Operations
-        BOOL SetToolTipText(LPCTSTR pstrTipText)
-        {
-                ATLASSERT(::IsWindow(m_hWnd));
-                ATLASSERT(pstrTipText);
-                ATLASSERT(lstrlen(pstrTipText)<= 253);
-                CTempBuffer<TCHAR, _WTL_STACK_ALLOC_THRESHOLD> buff;
-                LPTSTR pstr = buff.Allocate(lstrlen(pstrTipText) + 3);
-                if(pstr == NULL)
-                        return FALSE;
-                ::lstrcpy(pstr, _T("~~"));
-                ::lstrcat(pstr, pstrTipText);
-                return SetWindowText(pstr);
-        }
-};
-
-typedef CTTButtonT<WTL::CButton> CTTButton;
-
-#endif // !WIN32_PLATFORM_WFSP
-
-
-// --- SmartPhone specific controls ---
-
-#ifdef WIN32_PLATFORM_WFSP
-
-///////////////////////////////////////////////////////////////////////////////
-// CSpinCtrlT - CSpinCtrl : SmartPhone adapted UpDown control
-
-template <class TBase>
-class CSpinCtrlT : public CUpDownCtrlT< TBase >
-{
-public:
-// Constructors
-        CSpinCtrlT(HWND hWnd = NULL) : CUpDownCtrlT< TBase >(hWnd)
-        { }
-
-        CSpinCtrlT< TBase >& operator =(HWND hWnd)
-        {
-                m_hWnd = hWnd;
-                return *this;
-        }
-
-        HWND Create(HWND hWndParent, HWND hBuddy, DWORD dwStyle, int nID, LPCTSTR szExpandedName = NULL)
-        {
-                ATLASSERT(::IsWindow(hWndParent));
-                CUpDownCtrlT< TBase >::Create(hWndParent, NULL, szExpandedName, dwStyle, 0, nID, NULL);
-                ATLASSERT(m_hWnd != NULL);   // Did you remember to call AtlInitCommonControls(ICC_UPDOWN_CLASS)?
-                if (hBuddy != NULL)
-                {
-                        ATLASSERT(::IsWindow(hBuddy));
-                        SetBuddy(hBuddy);
-                }
-                return m_hWnd;
-        }
-};
-
-typedef CSpinCtrlT<ATL::CWindow> CSpinCtrl;
-
-
-///////////////////////////////////////////////////////////////////////////////
-// CSpinned - SmartPhone association of control and Spin
-
-template <class TBase, bool t_bExpandOnly>
-class CSpinned : public TBase
-{
-public:
-        CSpinCtrl m_SpinCtrl;
-        DWORD m_dwSpinnedStyle;
-
-// Constructors
-        CSpinned(HWND hWnd = NULL) : TBase(hWnd)
-        {
-                m_dwSpinnedStyle = WS_VISIBLE | UDS_ALIGNRIGHT | UDS_EXPANDABLE;
-                
-                if (t_bExpandOnly == true)
-                        m_dwSpinnedStyle |= UDS_NOSCROLL;
-                else
-                        m_dwSpinnedStyle |= UDS_HORZ | UDS_ARROWKEYS | UDS_SETBUDDYINT | UDS_WRAP;
-
-                if (hWnd != NULL)
-                        AttachOrCreateSpinCtrl();
-        }
-
-        CSpinned<TBase, t_bExpandOnly>& operator =(HWND hWnd)
-        {
-                Attach(hWnd);
-                return *this;
-        }
-
-        void Attach(HWND hWnd)
-        {
-                ATLASSERT(!IsWindow());
-                TBase* pT = static_cast<TBase*>(this);
-                pT->m_hWnd = hWnd;
-                if (hWnd != NULL)
-                        AttachOrCreateSpinCtrl();
-        }
-
-        HWND Create(HWND hWndParent, ATL::_U_RECT rect = NULL, LPCTSTR szExpandedName = NULL,
-                        DWORD dwStyle = 0, DWORD dwExStyle = 0,
-                        ATL::_U_MENUorID MenuOrID = 0U, LPVOID lpCreateParam = NULL)
-        {
-
-                TBase* pT = static_cast<TBase*>(this);
-                TBase::Create(hWndParent, rect, NULL, dwStyle, dwExStyle, MenuOrID, lpCreateParam);
-                ATLASSERT(pT->m_hWnd != NULL);
-
-                m_SpinCtrl.Create(hWndParent, pT->m_hWnd, m_dwSpinnedStyle, ATL_IDW_SPIN_ID + (int)MenuOrID.m_hMenu, szExpandedName);
-
-                ATLASSERT(m_SpinCtrl.m_hWnd != NULL);   // Did you remember to call AtlInitCommonControls(ICC_UPDOWN_CLASS)?
-
-                return pT->m_hWnd;
-        }
-
-// Attributes
-        CSpinCtrl& GetSpinCtrl()
-        {
-                return m_SpinCtrl;
-        }
-
-// Implementation
-        // Attach our existing SpinCtrl or create one
-        bool AttachOrCreateSpinCtrl()
-        {
-                TBase* pT = static_cast<TBase*>(this);
-
-                HWND hSpin = ::GetDlgItem(pT->GetParent(), ATL_IDW_SPIN_ID + pT->GetDlgCtrlID());
-
-                if (hSpin != NULL)
-                {
-                        m_SpinCtrl.Attach(hSpin);
-#ifdef DEBUG
-                        TCHAR sClassName[16];
-                        ::GetClassName(hSpin, sClassName, 16);
-                        ATLASSERT(!_tcscmp(sClassName, UPDOWN_CLASS));
-                        ATLASSERT(m_SpinCtrl.GetBuddy().m_hWnd == pT->m_hWnd);
-#endif // DEBUG
-                }
-                else
-                {
-                        m_SpinCtrl.Create(pT->GetParent(), pT->m_hWnd, m_dwSpinnedStyle, ATL_IDW_SPIN_ID + pT->GetDlgCtrlID());
-                }
-
-                return m_SpinCtrl.m_hWnd != NULL;
-        }
-};
-
-
-///////////////////////////////////////////////////////////////////////////////
-// CSpinListBox - SmartPhone spinned ListBox control
-// CExpandListBox - SmartPhone expandable ListBox control
-// CExpandEdit - SmartPhone expandable Edit control
-// CExpandCapEdit - SmartPhone expandable CapEdit control
-
-typedef CSpinned<CListBox, false>   CSpinListBox;
-typedef CSpinned<CListBox, true>    CExpandListBox;
-typedef CSpinned<CEdit, true>           CExpandEdit;
-typedef CSpinned<CCapEdit, true>    CExpandCapEdit;
-
-#endif // WIN32_PLATFORM_WFSP
-
-#endif // _WTL_CE_NO_CONTROLS
-
-}; // namespace WTL
-
-#endif // __ATLWINCE_H__