Logo Search packages:      
Sourcecode: chromium-browser version File versions  Download package

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__

Generated by  Doxygen 1.6.0   Back to index