More Windows build fixes.

third_party/wtl/include/atldlgs.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 __ATLDLGS_H__
+#define __ATLDLGS_H__
+
+#pragma once
+
+#ifndef __cplusplus
+        #error ATL requires C++ compilation (use a .cpp suffix)
+#endif
+
+#ifndef __ATLAPP_H__
+        #error atldlgs.h requires atlapp.h to be included first
+#endif
+
+#ifndef __ATLWIN_H__
+        #error atldlgs.h requires atlwin.h to be included first
+#endif
+
+#include <commdlg.h>
+#include <shlobj.h>
+
+#if (_WIN32_WINNT >= 0x0600) && !defined(_WIN32_WCE)
+  #include <shobjidl.h>
+#endif // (_WIN32_WINNT >= 0x0600) && !defined(_WIN32_WCE)
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Classes in this file:
+//
+// CFileDialogImpl<T>
+// CFileDialog
+// CFileDialogEx
+// CMultiFileDialogImpl<T>
+// CMultiFileDialog
+// CShellFileDialogImpl<T>
+// CShellFileOpenDialogImpl<T>
+// CShellFileOpenDialog
+// CShellFileSaveDialogImpl<T>
+// CShellFileSaveDialog
+// CFolderDialogImpl<T>
+// CFolderDialog
+// CFontDialogImpl<T>
+// CFontDialog
+// CRichEditFontDialogImpl<T>
+// CRichEditFontDialog
+// CColorDialogImpl<T>
+// CColorDialog
+// CPrintDialogImpl<T>
+// CPrintDialog
+// CPrintDialogExImpl<T>
+// CPrintDialogEx
+// CPageSetupDialogImpl<T>
+// CPageSetupDialog
+// CFindReplaceDialogImpl<T>
+// CFindReplaceDialog
+//
+// CMemDlgTemplate
+// CIndirectDialogImpl<T, TDlgTemplate, TBase>
+//
+// CPropertySheetWindow
+// CPropertySheetImpl<T, TBase>
+// CPropertySheet
+// CPropertyPageWindow
+// CPropertyPageImpl<T, TBase>
+// CPropertyPage<t_wDlgTemplateID>
+// CAxPropertyPageImpl<T, TBase>
+// CAxPropertyPage<t_wDlgTemplateID>
+//
+// CWizard97SheetWindow
+// CWizard97SheetImpl<T, TBase>
+// CWizard97Sheet
+// CWizard97PageWindow
+// CWizard97PageImpl<T, TBase>
+// CWizard97ExteriorPageImpl<T, TBase>
+// CWizard97InteriorPageImpl<T, TBase>
+//
+// CAeroWizardFrameWindow
+// CAeroWizardFrameImpl<T, TBase>
+// CAeroWizardFrame
+// CAeroWizardPageWindow
+// CAeroWizardPageImpl<T, TBase>
+// CAeroWizardPage<t_wDlgTemplateID>
+// CAeroWizardAxPageImpl<T, TBase>
+// CAeroWizardAxPage<t_wDlgTemplateID>
+//
+// CTaskDialogConfig
+// CTaskDialogImpl<T>
+// CTaskDialog
+//
+// Global functions:
+//   AtlTaskDialog()
+
+
+namespace WTL
+{
+
+///////////////////////////////////////////////////////////////////////////////
+// CFileDialogImpl - used for File Open or File Save As
+
+// compatibility with the old (vc6.0) headers
+#if (_WIN32_WINNT >= 0x0500) && !defined(OPENFILENAME_SIZE_VERSION_400)
+  #ifndef CDSIZEOF_STRUCT
+    #define CDSIZEOF_STRUCT(structname, member)  (((int)((LPBYTE)(&((structname*)0)->member) - ((LPBYTE)((structname*)0)))) + sizeof(((structname*)0)->member))
+  #endif
+  #define OPENFILENAME_SIZE_VERSION_400A  CDSIZEOF_STRUCT(OPENFILENAMEA,lpTemplateName)
+  #define OPENFILENAME_SIZE_VERSION_400W  CDSIZEOF_STRUCT(OPENFILENAMEW,lpTemplateName)
+  #ifdef UNICODE
+    #define OPENFILENAME_SIZE_VERSION_400  OPENFILENAME_SIZE_VERSION_400W
+  #else
+    #define OPENFILENAME_SIZE_VERSION_400  OPENFILENAME_SIZE_VERSION_400A
+  #endif // !UNICODE
+#endif // (_WIN32_WINNT >= 0x0500) && !defined(OPENFILENAME_SIZE_VERSION_400)
+
+#if !defined(_WIN32_WCE) && !defined(CDN_INCLUDEITEM)
+  #define CDN_INCLUDEITEM         (CDN_FIRST - 0x0007)
+#endif
+
+template <class T>
+class ATL_NO_VTABLE CFileDialogImpl : public ATL::CDialogImplBase
+{
+public:
+#if defined(__AYGSHELL_H__) && (_WIN32_WCE >= 0x0501)
+        OPENFILENAMEEX m_ofn;
+#else
+        OPENFILENAME m_ofn;
+#endif
+        BOOL m_bOpenFileDialog;            // TRUE for file open, FALSE for file save
+        TCHAR m_szFileTitle[_MAX_FNAME];   // contains file title after return
+        TCHAR m_szFileName[_MAX_PATH];     // contains full path name after return
+
+        CFileDialogImpl(BOOL bOpenFileDialog, // TRUE for FileOpen, FALSE for FileSaveAs
+                        LPCTSTR lpszDefExt = NULL,
+                        LPCTSTR lpszFileName = NULL,
+                        DWORD dwFlags = OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
+                        LPCTSTR lpszFilter = NULL,
+                        HWND hWndParent = NULL)
+        {
+                memset(&m_ofn, 0, sizeof(m_ofn)); // initialize structure to 0/NULL
+                m_szFileName[0] = _T('\0');
+                m_szFileTitle[0] = _T('\0');
+
+                m_bOpenFileDialog = bOpenFileDialog;
+
+                m_ofn.lStructSize = sizeof(m_ofn);
+#if (_WIN32_WINNT >= 0x0500)
+                // adjust struct size if running on older version of Windows
+                if(AtlIsOldWindows())
+                {
+                        ATLASSERT(sizeof(m_ofn) > OPENFILENAME_SIZE_VERSION_400);   // must be
+                        m_ofn.lStructSize = OPENFILENAME_SIZE_VERSION_400;
+                }
+#endif // (_WIN32_WINNT >= 0x0500)
+                m_ofn.lpstrFile = m_szFileName;
+                m_ofn.nMaxFile = _MAX_PATH;
+                m_ofn.lpstrDefExt = lpszDefExt;
+                m_ofn.lpstrFileTitle = (LPTSTR)m_szFileTitle;
+                m_ofn.nMaxFileTitle = _MAX_FNAME;
+#ifndef _WIN32_WCE
+                m_ofn.Flags = dwFlags | OFN_EXPLORER | OFN_ENABLEHOOK | OFN_ENABLESIZING;
+#else // CE specific
+                m_ofn.Flags = dwFlags | OFN_EXPLORER | OFN_ENABLEHOOK;
+#endif // !_WIN32_WCE
+                m_ofn.lpstrFilter = lpszFilter;
+                m_ofn.hInstance = ModuleHelper::GetResourceInstance();
+                m_ofn.lpfnHook = (LPOFNHOOKPROC)T::StartDialogProc;
+                m_ofn.hwndOwner = hWndParent;
+
+                // setup initial file name
+                if(lpszFileName != NULL)
+                SecureHelper::strncpy_x(m_szFileName, _countof(m_szFileName), lpszFileName, _TRUNCATE);
+        }
+
+        INT_PTR DoModal(HWND hWndParent = ::GetActiveWindow())
+        {
+                ATLASSERT((m_ofn.Flags & OFN_ENABLEHOOK) != 0);
+                ATLASSERT(m_ofn.lpfnHook != NULL);   // can still be a user hook
+
+                ATLASSERT((m_ofn.Flags & OFN_EXPLORER) != 0);
+
+                if(m_ofn.hwndOwner == NULL)   // set only if not specified before
+                        m_ofn.hwndOwner = hWndParent;
+
+                ATLASSERT(m_hWnd == NULL);
+                ModuleHelper::AddCreateWndData(&m_thunk.cd, (ATL::CDialogImplBase*)this);
+
+                BOOL bRet;
+                if(m_bOpenFileDialog)
+#if defined(__AYGSHELL_H__) && (_WIN32_WCE >= 0x0501)
+                        bRet = ::GetOpenFileNameEx(&m_ofn);
+                else
+                        bRet = ::GetSaveFileName((LPOPENFILENAME)&m_ofn);
+#else
+                        bRet = ::GetOpenFileName(&m_ofn);
+                else
+                        bRet = ::GetSaveFileName(&m_ofn);
+#endif
+
+                m_hWnd = NULL;
+
+                return bRet ? IDOK : IDCANCEL;
+        }
+
+// Attributes
+        ATL::CWindow GetFileDialogWindow() const
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                return ATL::CWindow(GetParent());
+        }
+
+        int GetFilePath(LPTSTR lpstrFilePath, int nLength) const
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT((m_ofn.Flags & OFN_EXPLORER) != 0);
+
+                return (int)GetFileDialogWindow().SendMessage(CDM_GETFILEPATH, nLength, (LPARAM)lpstrFilePath);
+        }
+
+        int GetFolderIDList(LPVOID lpBuff, int nLength) const
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT((m_ofn.Flags & OFN_EXPLORER) != 0);
+
+                return (int)GetFileDialogWindow().SendMessage(CDM_GETFOLDERIDLIST, nLength, (LPARAM)lpBuff);
+        }
+
+        int GetFolderPath(LPTSTR lpstrFolderPath, int nLength) const
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT((m_ofn.Flags & OFN_EXPLORER) != 0);
+
+                return (int)GetFileDialogWindow().SendMessage(CDM_GETFOLDERPATH, nLength, (LPARAM)lpstrFolderPath);
+        }
+
+        int GetSpec(LPTSTR lpstrSpec, int nLength) const
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT((m_ofn.Flags & OFN_EXPLORER) != 0);
+
+                return (int)GetFileDialogWindow().SendMessage(CDM_GETSPEC, nLength, (LPARAM)lpstrSpec);
+        }
+
+        void SetControlText(int nCtrlID, LPCTSTR lpstrText)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT((m_ofn.Flags & OFN_EXPLORER) != 0);
+
+                GetFileDialogWindow().SendMessage(CDM_SETCONTROLTEXT, nCtrlID, (LPARAM)lpstrText);
+        }
+
+        void SetDefExt(LPCTSTR lpstrExt)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT((m_ofn.Flags & OFN_EXPLORER) != 0);
+
+                GetFileDialogWindow().SendMessage(CDM_SETDEFEXT, 0, (LPARAM)lpstrExt);
+        }
+
+        BOOL GetReadOnlyPref() const    // return TRUE if readonly checked
+        {
+                return ((m_ofn.Flags & OFN_READONLY) != 0) ? TRUE : FALSE;
+        }
+
+// Operations
+        void HideControl(int nCtrlID)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT((m_ofn.Flags & OFN_EXPLORER) != 0);
+
+                GetFileDialogWindow().SendMessage(CDM_HIDECONTROL, nCtrlID);
+        }
+
+// Special override for common dialogs
+        BOOL EndDialog(INT_PTR /*nRetCode*/ = 0)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                GetFileDialogWindow().SendMessage(WM_COMMAND, MAKEWPARAM(IDCANCEL, 0));
+                return TRUE;
+        }
+
+// Message map and handlers
+        BEGIN_MSG_MAP(CFileDialogImpl)
+                NOTIFY_CODE_HANDLER(CDN_FILEOK, _OnFileOK)
+                NOTIFY_CODE_HANDLER(CDN_FOLDERCHANGE, _OnFolderChange)
+                NOTIFY_CODE_HANDLER(CDN_HELP, _OnHelp)
+                NOTIFY_CODE_HANDLER(CDN_INITDONE, _OnInitDone)
+                NOTIFY_CODE_HANDLER(CDN_SELCHANGE, _OnSelChange)
+                NOTIFY_CODE_HANDLER(CDN_SHAREVIOLATION, _OnShareViolation)
+                NOTIFY_CODE_HANDLER(CDN_TYPECHANGE, _OnTypeChange)
+#ifndef _WIN32_WCE
+                NOTIFY_CODE_HANDLER(CDN_INCLUDEITEM, _OnIncludeItem)
+#endif // !_WIN32_WCE
+        END_MSG_MAP()
+
+        LRESULT _OnFileOK(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                T* pT = static_cast<T*>(this);
+                return !pT->OnFileOK((LPOFNOTIFY)pnmh);
+        }
+
+        LRESULT _OnFolderChange(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                T* pT = static_cast<T*>(this);
+                pT->OnFolderChange((LPOFNOTIFY)pnmh);
+                return 0;
+        }
+
+        LRESULT _OnHelp(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                T* pT = static_cast<T*>(this);
+                pT->OnHelp((LPOFNOTIFY)pnmh);
+                return 0;
+        }
+
+        LRESULT _OnInitDone(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                T* pT = static_cast<T*>(this);
+                pT->OnInitDone((LPOFNOTIFY)pnmh);
+                return 0;
+        }
+
+        LRESULT _OnSelChange(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                T* pT = static_cast<T*>(this);
+                pT->OnSelChange((LPOFNOTIFY)pnmh);
+                return 0;
+        }
+
+        LRESULT _OnShareViolation(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                T* pT = static_cast<T*>(this);
+                return pT->OnShareViolation((LPOFNOTIFY)pnmh);
+        }
+
+        LRESULT _OnTypeChange(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                T* pT = static_cast<T*>(this);
+                pT->OnTypeChange((LPOFNOTIFY)pnmh);
+                return 0;
+        }
+
+#ifndef _WIN32_WCE
+        LRESULT _OnIncludeItem(int /*idCtrl*/, LPNMHDR pnmh, BOOL& /*bHandled*/)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                T* pT = static_cast<T*>(this);
+                return pT->OnIncludeItem((LPOFNOTIFYEX)pnmh);
+        }
+#endif // !_WIN32_WCE
+
+// Overrideables
+        BOOL OnFileOK(LPOFNOTIFY /*lpon*/)
+        {
+                return TRUE;
+        }
+
+        void OnFolderChange(LPOFNOTIFY /*lpon*/)
+        {
+        }
+
+        void OnHelp(LPOFNOTIFY /*lpon*/)
+        {
+        }
+
+        void OnInitDone(LPOFNOTIFY /*lpon*/)
+        {
+        }
+
+        void OnSelChange(LPOFNOTIFY /*lpon*/)
+        {
+        }
+
+        int OnShareViolation(LPOFNOTIFY /*lpon*/)
+        {
+                return 0;
+        }
+
+        void OnTypeChange(LPOFNOTIFY /*lpon*/)
+        {
+        }
+
+#ifndef _WIN32_WCE
+        BOOL OnIncludeItem(LPOFNOTIFYEX /*lponex*/)
+        {
+                return TRUE;   // include item
+        }
+#endif // !_WIN32_WCE
+};
+
+class CFileDialog : public CFileDialogImpl<CFileDialog>
+{
+public:
+        CFileDialog(BOOL bOpenFileDialog, // TRUE for FileOpen, FALSE for FileSaveAs
+                LPCTSTR lpszDefExt = NULL,
+                LPCTSTR lpszFileName = NULL,
+                DWORD dwFlags = OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
+                LPCTSTR lpszFilter = NULL,
+                HWND hWndParent = NULL)
+                : CFileDialogImpl<CFileDialog>(bOpenFileDialog, lpszDefExt, lpszFileName, dwFlags, lpszFilter, hWndParent)
+        { }
+
+        // override base class map and references to handlers
+        DECLARE_EMPTY_MSG_MAP()
+};
+
+#if defined(__AYGSHELL_H__) && (_WIN32_WCE >= 0x0501)
+class CFileDialogEx : public CFileDialogImpl<CFileDialogEx>
+{
+public:
+        CFileDialogEx( // Supports only FileOpen
+                LPCTSTR lpszDefExt = NULL,
+                LPCTSTR lpszFileName = NULL,
+                DWORD dwFlags = OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
+                OFN_EXFLAG ExFlags = OFN_EXFLAG_THUMBNAILVIEW,
+                OFN_SORTORDER dwSortOrder = OFN_SORTORDER_AUTO,         
+                LPCTSTR lpszFilter = NULL,
+                HWND hWndParent = NULL)
+                : CFileDialogImpl<CFileDialogEx>(TRUE, lpszDefExt, lpszFileName, dwFlags, lpszFilter, hWndParent)
+        {
+                m_ofn.ExFlags = ExFlags;
+                m_ofn.dwSortOrder = dwSortOrder;
+        }
+
+        // override base class map and references to handlers
+        DECLARE_EMPTY_MSG_MAP()
+};
+#endif // defined(__AYGSHELL_H__) && (_WIN32_WCE >= 0x0501)
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Multi File Dialog - Multi-select File Open dialog
+
+#ifndef _WIN32_WCE
+
+// The class dynamically resizes the buffer as the file selection changes
+// (as described in Knowledge Base article 131462). It also expands selected
+// shortcut files to take into account the full path of the target file.
+// Note that this doesn't work on Win9x for the old style dialogs, as well as
+// on NT for non-Unicode builds. 
+
+#ifndef _WTL_FIXED_OFN_BUFFER_LENGTH
+  #define _WTL_FIXED_OFN_BUFFER_LENGTH 0x10000
+#endif
+
+template <class T>
+class ATL_NO_VTABLE CMultiFileDialogImpl : public CFileDialogImpl< T >
+{
+public:
+        mutable LPCTSTR m_pNextFile; 
+#ifndef _UNICODE
+        bool m_bIsNT;
+#endif
+
+        CMultiFileDialogImpl(
+                LPCTSTR lpszDefExt = NULL,
+                LPCTSTR lpszFileName = NULL,
+                DWORD dwFlags = OFN_HIDEREADONLY,
+                LPCTSTR lpszFilter = NULL,
+                HWND hWndParent = NULL)
+                : CFileDialogImpl<T>(TRUE, lpszDefExt, lpszFileName, dwFlags, lpszFilter, hWndParent), 
+                  m_pNextFile(NULL)
+        {
+                m_ofn.Flags |= OFN_ALLOWMULTISELECT;   // Force multiple selection mode
+
+#ifndef _UNICODE
+                OSVERSIONINFO ovi = { sizeof(ovi) };
+                ::GetVersionEx(&ovi);
+                m_bIsNT = (ovi.dwPlatformId == VER_PLATFORM_WIN32_NT);
+                if (m_bIsNT)
+                {
+                        // On NT platforms, GetOpenFileNameA thunks to GetOpenFileNameW and there 
+                        // is absolutely nothing we can do except to start off with a large buffer.
+                        ATLVERIFY(ResizeFilenameBuffer(_WTL_FIXED_OFN_BUFFER_LENGTH));
+                }
+#endif
+        }
+
+        ~CMultiFileDialogImpl()
+        {
+                if (m_ofn.lpstrFile != m_szFileName)   // Free the buffer if we allocated it
+                        delete[] m_ofn.lpstrFile;
+        }
+
+// Operations
+        // Get the directory that the files were chosen from.
+        // The function returns the number of characters copied, not including the terminating zero. 
+        // If the buffer is NULL, the function returns the required size, in characters, including the terminating zero.
+        // If the function fails, the return value is zero.
+        int GetDirectory(LPTSTR pBuffer, int nBufLen) const
+        {
+                if (m_ofn.lpstrFile == NULL)
+                        return 0;
+
+                LPCTSTR pStr = m_ofn.lpstrFile;
+                int nLength = lstrlen(pStr);
+                if (pStr[nLength + 1] == 0)
+                {
+                        // The OFN buffer contains a single item so extract its path.
+                        LPCTSTR pSep = _strrchr(pStr, _T('\\'));
+                        if (pSep != NULL)
+                                nLength = (int)(DWORD_PTR)(pSep - pStr);
+                }
+
+                int nRet = 0;
+                if (pBuffer == NULL)   // If the buffer is NULL, return the required length
+                {
+                        nRet = nLength + 1;
+                }
+                else if (nBufLen > nLength)
+                {
+                        SecureHelper::strncpy_x(pBuffer, nBufLen, pStr, nLength);
+                        nRet = nLength;
+                }
+
+                return nRet;
+        }
+
+#if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
+        bool GetDirectory(_CSTRING_NS::CString& strDir) const
+        {
+                bool bRet = false;
+
+                int nLength = GetDirectory(NULL, 0);
+                if (nLength > 0)
+                {
+                        bRet = (GetDirectory(strDir.GetBuffer(nLength), nLength) > 0);
+                        strDir.ReleaseBuffer(nLength - 1);
+                }
+
+                return bRet;
+        }
+#endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
+
+        // Get the first filename as a pointer into the buffer.
+        LPCTSTR GetFirstFileName() const
+        {
+                if (m_ofn.lpstrFile == NULL)
+                        return NULL;
+
+                m_pNextFile = NULL;   // Reset internal buffer pointer
+
+                LPCTSTR pStr = m_ofn.lpstrFile;
+                int nLength = lstrlen(pStr);
+                if (pStr[nLength + 1] != 0)
+                {
+                        // Multiple items were selected. The first string is the directory,
+                        // so skip forwards to the second string.
+                        pStr += nLength + 1;
+
+                        // Set up m_pNext so it points to the second item (or null).
+                        m_pNextFile = pStr;
+                        GetNextFileName();
+                }
+                else
+                {
+                        // A single item was selected. Skip forward past the path.
+                        LPCTSTR pSep = _strrchr(pStr, _T('\\'));
+                        if (pSep != NULL)
+                                pStr = pSep + 1;
+                }
+
+                return pStr;
+        }
+
+        // Get the next filename as a pointer into the buffer.
+        LPCTSTR GetNextFileName() const
+        {
+                if (m_pNextFile == NULL)
+                        return NULL;
+
+                LPCTSTR pStr = m_pNextFile;
+                // Set "m_pNextFile" to point to the next file name, or null if we 
+                // have reached the last file in the list.
+                int nLength = lstrlen(pStr);
+                m_pNextFile = (pStr[nLength + 1] != 0) ? &pStr[nLength + 1] : NULL;
+
+                return pStr;
+        }
+
+        // Get the first filename as a full path.
+        // The function returns the number of characters copied, not including the terminating zero. 
+        // If the buffer is NULL, the function returns the required size, in characters, including the terminating zero.
+        // If the function fails, the return value is zero.
+        int GetFirstPathName(LPTSTR pBuffer, int nBufLen) const
+        {
+                LPCTSTR pStr = GetFirstFileName();
+                int nLengthDir = GetDirectory(NULL, 0);
+                if((pStr == NULL) || (nLengthDir == 0))
+                        return 0;
+
+                // Figure out the required length.
+                int nLengthTotal = nLengthDir + lstrlen(pStr);
+
+                int nRet = 0;
+                if(pBuffer == NULL) // If the buffer is NULL, return the required length
+                {
+                        nRet = nLengthTotal + 1;
+                }
+                else if (nBufLen > nLengthTotal) // If the buffer is big enough, go ahead and construct the path
+                {               
+                        GetDirectory(pBuffer, nBufLen);
+                        SecureHelper::strcat_x(pBuffer, nBufLen, _T("\\"));
+                        SecureHelper::strcat_x(pBuffer, nBufLen, pStr);
+                        nRet = nLengthTotal;
+                }
+
+                return nRet;
+        }
+
+#if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
+        bool GetFirstPathName(_CSTRING_NS::CString& strPath) const
+        {
+                bool bRet = false;
+
+                int nLength = GetFirstPathName(NULL, 0);
+                if (nLength > 0)
+                {
+                        bRet = (GetFirstPathName(strPath.GetBuffer(nLength), nLength) > 0);
+                        strPath.ReleaseBuffer(nLength - 1);
+                }
+
+                return bRet;
+        }
+#endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
+
+        // Get the next filename as a full path.
+        // The function returns the number of characters copied, not including the terminating zero. 
+        // If the buffer is NULL, the function returns the required size, in characters, including the terminating zero.
+        // If the function fails, the return value is zero.
+        // The internal position marker is moved forward only if the function succeeds and the buffer was large enough.
+        int GetNextPathName(LPTSTR pBuffer, int nBufLen) const
+        {
+                if (m_pNextFile == NULL)
+                        return 0;
+
+                int nRet = 0;
+                LPCTSTR pStr = m_pNextFile;
+                // Does the filename contain a backslash?
+                if (_strrchr(pStr, _T('\\')) != NULL)
+                {
+                        // Yes, so we'll assume it's a full path.
+                        int nLength = lstrlen(pStr);
+
+                        if (pBuffer == NULL) // If the buffer is NULL, return the required length
+                        {
+                                nRet = nLength + 1;
+                        }
+                        else if (nBufLen > nLength) // The buffer is big enough, so go ahead and copy the filename
+                        {
+                                SecureHelper::strcpy_x(pBuffer, nBufLen, GetNextFileName());
+                                nRet = nBufLen;
+                        }
+                }
+                else
+                {
+                        // The filename is relative, so construct the full path.
+                        int nLengthDir = GetDirectory(NULL, 0);
+                        if (nLengthDir > 0)
+                        {
+                                // Calculate the required space.
+                                int nLengthTotal = nLengthDir + lstrlen(pStr);
+
+                                if(pBuffer == NULL) // If the buffer is NULL, return the required length
+                                {
+                                        nRet = nLengthTotal + 1;
+                                }
+                                else if (nBufLen > nLengthTotal) // If the buffer is big enough, go ahead and construct the path
+                                {
+                                        GetDirectory(pBuffer, nBufLen);
+                                        SecureHelper::strcat_x(pBuffer, nBufLen, _T("\\"));
+                                        SecureHelper::strcat_x(pBuffer, nBufLen, GetNextFileName());
+                                        nRet = nLengthTotal;
+                                }
+                        }
+                }
+
+                return nRet;
+        }
+
+#if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
+        bool GetNextPathName(_CSTRING_NS::CString& strPath) const
+        {
+                bool bRet = false;
+
+                int nLength = GetNextPathName(NULL, 0);
+                if (nLength > 0)
+                {
+                        bRet = (GetNextPathName(strPath.GetBuffer(nLength), nLength) > 0);
+                        strPath.ReleaseBuffer(nLength - 1);
+                }
+
+                return bRet;
+        }
+#endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
+
+// Implementation
+        bool ResizeFilenameBuffer(DWORD dwLength)
+        {
+                if (dwLength > m_ofn.nMaxFile)
+                {
+                        // Free the old buffer.
+                        if (m_ofn.lpstrFile != m_szFileName)
+                        {
+                                delete[] m_ofn.lpstrFile;
+                                m_ofn.lpstrFile = NULL;
+                                m_ofn.nMaxFile = 0;
+                        }
+
+                        // Allocate the new buffer.
+                        LPTSTR lpstrBuff = NULL;
+                        ATLTRY(lpstrBuff = new TCHAR[dwLength]);
+                        if (lpstrBuff != NULL)
+                        {
+                                m_ofn.lpstrFile = lpstrBuff;
+                                m_ofn.lpstrFile[0] = 0;
+                                m_ofn.nMaxFile = dwLength;
+                        }
+                }
+
+                return (m_ofn.lpstrFile != NULL);
+        }
+
+        void OnSelChange(LPOFNOTIFY /*lpon*/)
+        {
+#ifndef _UNICODE
+                // There is no point resizing the buffer in ANSI builds running on NT.
+                if (m_bIsNT)
+                        return;
+#endif
+
+                // Get the buffer length required to hold the spec.
+                int nLength = GetSpec(NULL, 0);
+                if (nLength <= 1)
+                        return; // no files are selected, presumably
+                
+                // Add room for the directory, and an extra terminating zero.
+                nLength += GetFolderPath(NULL, 0) + 1;
+
+                if (!ResizeFilenameBuffer(nLength))
+                {
+                        ATLASSERT(FALSE);
+                        return;
+                }
+
+                // If we are not following links then our work is done.
+                if ((m_ofn.Flags & OFN_NODEREFERENCELINKS) != 0)
+                        return;
+
+                // Get the file spec, which is the text in the edit control.
+                if (GetSpec(m_ofn.lpstrFile, m_ofn.nMaxFile) <= 0)
+                        return;
+                
+                // Get the ID-list of the current folder.
+                int nBytes = GetFolderIDList(NULL, 0);
+                CTempBuffer<ITEMIDLIST> idlist;
+                idlist.AllocateBytes(nBytes);
+                if ((nBytes <= 0) || (GetFolderIDList(idlist, nBytes) <= 0))
+                        return;
+
+                // First bind to the desktop folder, then to the current folder.
+                ATL::CComPtr<IShellFolder> pDesktop, pFolder;
+                if (FAILED(::SHGetDesktopFolder(&pDesktop)))
+                        return;
+                if (FAILED(pDesktop->BindToObject(idlist, NULL, IID_IShellFolder, (void**)&pFolder)))
+                        return;
+
+                // Work through the file spec, looking for quoted filenames. If we find a shortcut file, then 
+                // we need to add enough extra buffer space to hold its target path.
+                DWORD nExtraChars = 0;
+                bool bInsideQuotes = false;
+                LPCTSTR pAnchor = m_ofn.lpstrFile;
+                LPCTSTR pChar = m_ofn.lpstrFile;
+                for ( ; *pChar; ++pChar)
+                {
+                        // Look for quotation marks.
+                        if (*pChar == _T('\"'))
+                        {
+                                // We are either entering or leaving a passage of quoted text.
+                                bInsideQuotes = !bInsideQuotes;
+
+                                // Is it an opening or closing quote?
+                                if (bInsideQuotes)
+                                {
+                                        // We found an opening quote, so set "pAnchor" to the following character.
+                                        pAnchor = pChar + 1;
+                                }
+                                else // closing quote
+                                {
+                                        // Each quoted entity should be shorter than MAX_PATH.
+                                        if (pChar - pAnchor >= MAX_PATH)
+                                                return;
+
+                                        // Get the ID-list and attributes of the file.
+                                        USES_CONVERSION;
+                                        int nFileNameLength = (int)(DWORD_PTR)(pChar - pAnchor);
+                                        TCHAR szFileName[MAX_PATH];
+                                        SecureHelper::strncpy_x(szFileName, MAX_PATH, pAnchor, nFileNameLength);
+                                        LPITEMIDLIST pidl = NULL;
+                                        DWORD dwAttrib = SFGAO_LINK;
+                                        if (SUCCEEDED(pFolder->ParseDisplayName(NULL, NULL, T2W(szFileName), NULL, &pidl, &dwAttrib)))
+                                        {
+                                                // Is it a shortcut file?
+                                                if (dwAttrib & SFGAO_LINK)
+                                                {
+                                                        // Bind to its IShellLink interface.
+                                                        ATL::CComPtr<IShellLink> pLink;
+                                                        if (SUCCEEDED(pFolder->BindToObject(pidl, NULL, IID_IShellLink, (void**)&pLink)))
+                                                        {
+                                                                // Get the shortcut's target path.
+                                                                TCHAR szPath[MAX_PATH];
+                                                                if (SUCCEEDED(pLink->GetPath(szPath, MAX_PATH, NULL, 0)))
+                                                                {
+                                                                        // If the target path is longer than the shortcut name, then add on the number 
+                                                                        // of extra characters that are required.
+                                                                        int nNewLength = lstrlen(szPath);
+                                                                        if (nNewLength > nFileNameLength)
+                                                                                nExtraChars += nNewLength - nFileNameLength;
+                                                                }
+                                                        }
+                                                }
+
+                                                // Free the ID-list returned by ParseDisplayName.
+                                                ::CoTaskMemFree(pidl);
+                                        }
+                                }
+                        }
+                }
+
+                // If we need more space for shortcut targets, then reallocate.
+                if (nExtraChars > 0)
+                        ATLVERIFY(ResizeFilenameBuffer(m_ofn.nMaxFile + nExtraChars));
+        }
+
+        // Helper for _ATM_MIN_CRT
+        static const TCHAR* _strrchr(const TCHAR* p, TCHAR ch)
+        {
+#ifndef _ATL_MIN_CRT
+                return _tcsrchr(p, ch);
+#else // _ATL_MIN_CRT
+                const TCHAR* lpsz = NULL;
+                while (*p != 0)
+                {
+                        if (*p == ch)
+                                lpsz = p;
+                        p = ::CharNext(p);
+                }
+                return lpsz;
+#endif // _ATL_MIN_CRT
+        }
+};
+
+class CMultiFileDialog : public CMultiFileDialogImpl<CMultiFileDialog>
+{
+public:
+        CMultiFileDialog(
+                LPCTSTR lpszDefExt = NULL,
+                LPCTSTR lpszFileName = NULL,
+                DWORD dwFlags = OFN_HIDEREADONLY,
+                LPCTSTR lpszFilter = NULL,
+                HWND hWndParent = NULL)
+                : CMultiFileDialogImpl<CMultiFileDialog>(lpszDefExt, lpszFileName, dwFlags, lpszFilter, hWndParent)
+        { }
+
+        BEGIN_MSG_MAP(CMultiFileDialog)
+                CHAIN_MSG_MAP(CMultiFileDialogImpl<CMultiFileDialog>)
+        END_MSG_MAP()
+};
+
+#endif // !_WIN32_WCE
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Shell File Dialog - new Shell File Open and Save dialogs in Vista
+
+// Note: Use GetPtr() to access dialog interface methods.
+// Example:
+//      CShellFileOpenDialog dlg;
+//      dlg.GetPtr()->SetTitle(L"MyFileOpenDialog");
+
+#if (_WIN32_WINNT >= 0x0600) && !defined(_WIN32_WCE)
+
+///////////////////////////////////////////////////////////////////////////////
+// CShellFileDialogImpl - base class for CShellFileOpenDialogImpl and CShellFileSaveDialogImpl
+
+template <class T>
+class ATL_NO_VTABLE CShellFileDialogImpl : public IFileDialogEvents
+{
+public:
+// Operations
+        INT_PTR DoModal(HWND hWndParent = ::GetActiveWindow())
+        {
+                INT_PTR nRet = -1;
+
+                T* pT = static_cast<T*>(this);
+                if(pT->m_spFileDlg == NULL)
+                {
+                        ATLASSERT(FALSE);
+                        return nRet;
+                }
+
+                DWORD dwCookie = 0;
+                pT->_Advise(dwCookie);
+
+                HRESULT hRet = pT->m_spFileDlg->Show(hWndParent);
+                if(SUCCEEDED(hRet))
+                        nRet = IDOK;
+                else if(hRet == HRESULT_FROM_WIN32(ERROR_CANCELLED))
+                        nRet = IDCANCEL;
+                else
+                        ATLASSERT(FALSE);   // error
+
+                pT->_Unadvise(dwCookie);
+
+                return nRet;
+        }
+
+        bool IsNull() const
+        {
+                const T* pT = static_cast<const T*>(this);
+                return (pT->m_spFileDlg == NULL);
+        }
+
+// Operations - get file path after dialog returns
+        HRESULT GetFilePath(LPWSTR lpstrFilePath, int cchLength)
+        {
+                T* pT = static_cast<T*>(this);
+                ATLASSERT(pT->m_spFileDlg != NULL);
+
+                ATL::CComPtr<IShellItem> spItem;
+                HRESULT hRet = pT->m_spFileDlg->GetResult(&spItem);
+
+                if(SUCCEEDED(hRet))
+                        hRet = GetFileNameFromShellItem(spItem, SIGDN_FILESYSPATH, lpstrFilePath, cchLength);
+
+                return hRet;
+        }
+
+        HRESULT GetFileTitle(LPWSTR lpstrFileTitle, int cchLength)
+        {
+                T* pT = static_cast<T*>(this);
+                ATLASSERT(pT->m_spFileDlg != NULL);
+
+                ATL::CComPtr<IShellItem> spItem;
+                HRESULT hRet = pT->m_spFileDlg->GetResult(&spItem);
+
+                if(SUCCEEDED(hRet))
+                        hRet = GetFileNameFromShellItem(spItem, SIGDN_NORMALDISPLAY, lpstrFileTitle, cchLength);
+
+                return hRet;
+        }
+
+#if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
+        HRESULT GetFilePath(_CSTRING_NS::CString& strFilePath)
+        {
+                T* pT = static_cast<T*>(this);
+                ATLASSERT(pT->m_spFileDlg != NULL);
+
+                ATL::CComPtr<IShellItem> spItem;
+                HRESULT hRet = pT->m_spFileDlg->GetResult(&spItem);
+
+                if(SUCCEEDED(hRet))
+                        hRet = GetFileNameFromShellItem(spItem, SIGDN_FILESYSPATH, strFilePath);
+
+                return hRet;
+        }
+
+        HRESULT GetFileTitle(_CSTRING_NS::CString& strFileTitle)
+        {
+                T* pT = static_cast<T*>(this);
+                ATLASSERT(pT->m_spFileDlg != NULL);
+
+                ATL::CComPtr<IShellItem> spItem;
+                HRESULT hRet = pT->m_spFileDlg->GetResult(&spItem);
+
+                if(SUCCEEDED(hRet))
+                        hRet = GetFileNameFromShellItem(spItem, SIGDN_NORMALDISPLAY, strFileTitle);
+
+                return hRet;
+        }
+#endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
+
+// Helpers for IShellItem
+        static HRESULT GetFileNameFromShellItem(IShellItem* pShellItem, SIGDN type, LPWSTR lpstr, int cchLength)
+        {
+                ATLASSERT(pShellItem != NULL);
+
+                LPWSTR lpstrName = NULL;
+                HRESULT hRet = pShellItem->GetDisplayName(type, &lpstrName);
+
+                if(SUCCEEDED(hRet))
+                {
+                        if(lstrlenW(lpstrName) < cchLength)
+                        {
+                                SecureHelper::strcpyW_x(lpstr, cchLength, lpstrName);
+                        }
+                        else
+                        {
+                                ATLASSERT(FALSE);
+                                hRet = DISP_E_BUFFERTOOSMALL;
+                        }
+
+                        ::CoTaskMemFree(lpstrName);
+                }
+
+                return hRet;
+        }
+
+#if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
+        static HRESULT GetFileNameFromShellItem(IShellItem* pShellItem, SIGDN type, _CSTRING_NS::CString& str)
+        {
+                ATLASSERT(pShellItem != NULL);
+
+                LPWSTR lpstrName = NULL;
+                HRESULT hRet = pShellItem->GetDisplayName(type, &lpstrName);
+
+                if(SUCCEEDED(hRet))
+                {
+                        str = lpstrName;
+                        ::CoTaskMemFree(lpstrName);
+                }
+
+                return hRet;
+        }
+#endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
+
+// Implementation
+        void _Advise(DWORD& dwCookie)
+        {
+                T* pT = static_cast<T*>(this);
+                ATLASSERT(pT->m_spFileDlg != NULL);
+                HRESULT hRet = pT->m_spFileDlg->Advise((IFileDialogEvents*)this, &dwCookie);
+                ATLVERIFY(SUCCEEDED(hRet));
+        }
+
+        void _Unadvise(DWORD dwCookie)
+        {
+                T* pT = static_cast<T*>(this);
+                ATLASSERT(pT->m_spFileDlg != NULL);
+                HRESULT hRet = pT->m_spFileDlg->Unadvise(dwCookie);
+                ATLVERIFY(SUCCEEDED(hRet));
+        }
+
+        void _Init(LPCWSTR lpszFileName, DWORD dwOptions, LPCWSTR lpszDefExt, const COMDLG_FILTERSPEC* arrFilterSpec, UINT uFilterSpecCount)
+        {
+                T* pT = static_cast<T*>(this);
+                ATLASSERT(pT->m_spFileDlg != NULL);
+
+                HRESULT hRet = E_FAIL;
+
+                if(lpszFileName != NULL)
+                {
+                        hRet = pT->m_spFileDlg->SetFileName(lpszFileName);
+                        ATLASSERT(SUCCEEDED(hRet));
+                }
+
+                hRet = pT->m_spFileDlg->SetOptions(dwOptions);
+                ATLASSERT(SUCCEEDED(hRet));
+
+                if(lpszDefExt != NULL)
+                {
+                        hRet = pT->m_spFileDlg->SetDefaultExtension(lpszDefExt);
+                        ATLASSERT(SUCCEEDED(hRet));
+                }
+
+                if(arrFilterSpec != NULL && uFilterSpecCount != 0U)
+                {
+                        hRet = pT->m_spFileDlg->SetFileTypes(uFilterSpecCount, arrFilterSpec);
+                        ATLASSERT(SUCCEEDED(hRet));
+                }
+        }
+
+// Implementation - IUnknown interface
+        STDMETHOD(QueryInterface)(REFIID riid, void** ppvObject)
+        {
+                if(ppvObject == NULL)
+                        return E_POINTER;
+
+                T* pT = static_cast<T*>(this);
+                if(IsEqualGUID(riid, IID_IUnknown) || IsEqualGUID(riid, IID_IFileDialogEvents))
+                {
+                        *ppvObject = (IFileDialogEvents*)pT;
+                        // AddRef() not needed
+                        return S_OK;
+                }
+
+                return E_NOINTERFACE;
+        }
+
+        virtual ULONG STDMETHODCALLTYPE AddRef()
+        {
+                return 1;
+        }
+
+        virtual ULONG STDMETHODCALLTYPE Release()
+        {
+                return 1;
+        }
+
+// Implementation - IFileDialogEvents interface
+        virtual HRESULT STDMETHODCALLTYPE IFileDialogEvents::OnFileOk(IFileDialog* pfd)
+        {
+                T* pT = static_cast<T*>(this);
+                ATLASSERT(pT->m_spFileDlg.IsEqualObject(pfd));
+                pfd;   // avoid level 4 warning
+                return pT->OnFileOk();
+        }
+
+        virtual HRESULT STDMETHODCALLTYPE IFileDialogEvents::OnFolderChanging(IFileDialog* pfd, IShellItem* psiFolder)
+        {
+                T* pT = static_cast<T*>(this);
+                ATLASSERT(pT->m_spFileDlg.IsEqualObject(pfd));
+                pfd;   // avoid level 4 warning
+                return pT->OnFolderChanging(psiFolder);
+        }
+
+        virtual HRESULT STDMETHODCALLTYPE IFileDialogEvents::OnFolderChange(IFileDialog* pfd)
+        {
+                T* pT = static_cast<T*>(this);
+                ATLASSERT(pT->m_spFileDlg.IsEqualObject(pfd));
+                pfd;   // avoid level 4 warning
+                return pT->OnFolderChange();
+        }
+
+        virtual HRESULT STDMETHODCALLTYPE IFileDialogEvents::OnSelectionChange(IFileDialog* pfd)
+        {
+                T* pT = static_cast<T*>(this);
+                ATLASSERT(pT->m_spFileDlg.IsEqualObject(pfd));
+                pfd;   // avoid level 4 warning
+                return pT->OnSelectionChange();
+        }
+
+        virtual HRESULT STDMETHODCALLTYPE IFileDialogEvents::OnShareViolation(IFileDialog* pfd, IShellItem* psi, FDE_SHAREVIOLATION_RESPONSE* pResponse)
+        {
+                T* pT = static_cast<T*>(this);
+                ATLASSERT(pT->m_spFileDlg.IsEqualObject(pfd));
+                pfd;   // avoid level 4 warning
+                return pT->OnShareViolation(psi, pResponse);
+        }
+
+        virtual HRESULT STDMETHODCALLTYPE IFileDialogEvents::OnTypeChange(IFileDialog* pfd)
+        {
+                T* pT = static_cast<T*>(this);
+                ATLASSERT(pT->m_spFileDlg.IsEqualObject(pfd));
+                pfd;   // avoid level 4 warning
+                return pT->OnTypeChange();
+        }
+
+        virtual HRESULT STDMETHODCALLTYPE IFileDialogEvents::OnOverwrite(IFileDialog* pfd, IShellItem* psi, FDE_OVERWRITE_RESPONSE* pResponse)
+        {
+                T* pT = static_cast<T*>(this);
+                ATLASSERT(pT->m_spFileDlg.IsEqualObject(pfd));
+                pfd;   // avoid level 4 warning
+                return pT->OnOverwrite(psi, pResponse);
+        }
+
+// Overrideables - Event handlers
+        HRESULT OnFileOk()
+        {
+                return E_NOTIMPL;
+        }
+
+        HRESULT OnFolderChanging(IShellItem* /*psiFolder*/)
+        {
+                return E_NOTIMPL;
+        }
+
+        HRESULT OnFolderChange()
+        {
+                return E_NOTIMPL;
+        }
+
+        HRESULT OnSelectionChange()
+        {
+                return E_NOTIMPL;
+        }
+
+        HRESULT OnShareViolation(IShellItem* /*psi*/, FDE_SHAREVIOLATION_RESPONSE* /*pResponse*/)
+        {
+                return E_NOTIMPL;
+        }
+
+        HRESULT OnTypeChange()
+        {
+                return E_NOTIMPL;
+        }
+
+        HRESULT OnOverwrite(IShellItem* /*psi*/, FDE_OVERWRITE_RESPONSE* /*pResponse*/)
+        {
+                return E_NOTIMPL;
+        }
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CShellFileOpenDialogImpl - implements new Shell File Open dialog
+
+template <class T>
+class ATL_NO_VTABLE CShellFileOpenDialogImpl : public CShellFileDialogImpl< T >
+{
+public:
+        ATL::CComPtr<IFileOpenDialog> m_spFileDlg;
+
+        CShellFileOpenDialogImpl(LPCWSTR lpszFileName = NULL, 
+                                 DWORD dwOptions = FOS_FORCEFILESYSTEM | FOS_PATHMUSTEXIST | FOS_FILEMUSTEXIST, 
+                                 LPCWSTR lpszDefExt = NULL, 
+                                 const COMDLG_FILTERSPEC* arrFilterSpec = NULL, 
+                                 UINT uFilterSpecCount = 0U)
+        {
+                HRESULT hRet = m_spFileDlg.CoCreateInstance(CLSID_FileOpenDialog);
+
+                if(SUCCEEDED(hRet))
+                        _Init(lpszFileName, dwOptions, lpszDefExt, arrFilterSpec, uFilterSpecCount);
+        }
+
+        IFileOpenDialog* GetPtr()
+        {
+                return m_spFileDlg;
+        }
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CShellFileOpenDialog - new Shell File Open dialog without events
+
+class CShellFileOpenDialog : public CShellFileOpenDialogImpl<CShellFileOpenDialog>
+{
+public:
+        CShellFileOpenDialog(LPCWSTR lpszFileName = NULL, 
+                             DWORD dwOptions = FOS_FORCEFILESYSTEM | FOS_PATHMUSTEXIST | FOS_FILEMUSTEXIST, 
+                             LPCWSTR lpszDefExt = NULL, 
+                             const COMDLG_FILTERSPEC* arrFilterSpec = NULL, 
+                             UINT uFilterSpecCount = 0U) : CShellFileOpenDialogImpl<CShellFileOpenDialog>(lpszFileName, dwOptions, lpszDefExt, arrFilterSpec, uFilterSpecCount)
+        { }
+
+// Implementation (remove _Advise/_Unadvise code using template magic)
+        void _Advise(DWORD& /*dwCookie*/)
+        { }
+
+        void _Unadvise(DWORD /*dwCookie*/)
+        { }
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CShellFileSaveDialogImpl - implements new Shell File Save dialog
+
+template <class T>
+class ATL_NO_VTABLE CShellFileSaveDialogImpl : public CShellFileDialogImpl< T >
+{
+public:
+        ATL::CComPtr<IFileSaveDialog> m_spFileDlg;
+
+        CShellFileSaveDialogImpl(LPCWSTR lpszFileName = NULL, 
+                                 DWORD dwOptions = FOS_FORCEFILESYSTEM | FOS_PATHMUSTEXIST | FOS_OVERWRITEPROMPT, 
+                                 LPCWSTR lpszDefExt = NULL, 
+                                 const COMDLG_FILTERSPEC* arrFilterSpec = NULL, 
+                                 UINT uFilterSpecCount = 0U)
+        {
+                HRESULT hRet = m_spFileDlg.CoCreateInstance(CLSID_FileSaveDialog);
+
+                if(SUCCEEDED(hRet))
+                        _Init(lpszFileName, dwOptions, lpszDefExt, arrFilterSpec, uFilterSpecCount);
+        }
+
+        IFileSaveDialog* GetPtr()
+        {
+                return m_spFileDlg;
+        }
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CShellFileSaveDialog - new Shell File Save dialog without events
+
+class CShellFileSaveDialog : public CShellFileSaveDialogImpl<CShellFileSaveDialog>
+{
+public:
+        CShellFileSaveDialog(LPCWSTR lpszFileName = NULL, 
+                             DWORD dwOptions = FOS_FORCEFILESYSTEM | FOS_PATHMUSTEXIST | FOS_OVERWRITEPROMPT, 
+                             LPCWSTR lpszDefExt = NULL, 
+                             const COMDLG_FILTERSPEC* arrFilterSpec = NULL, 
+                             UINT uFilterSpecCount = 0U) : CShellFileSaveDialogImpl<CShellFileSaveDialog>(lpszFileName, dwOptions, lpszDefExt, arrFilterSpec, uFilterSpecCount)
+        { }
+
+// Implementation (remove _Advise/_Unadvise code using template magic)
+        void _Advise(DWORD& /*dwCookie*/)
+        { }
+
+        void _Unadvise(DWORD /*dwCookie*/)
+        { }
+};
+
+#endif // (_WIN32_WINNT >= 0x0600) && !defined(_WIN32_WCE)
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CFolderDialogImpl - used for browsing for a folder
+
+#ifndef _WIN32_WCE
+
+template <class T>
+class ATL_NO_VTABLE CFolderDialogImpl
+{
+public:
+        BROWSEINFO m_bi;
+        LPCTSTR m_lpstrInitialFolder;
+        LPCITEMIDLIST m_pidlInitialSelection;
+        bool m_bExpandInitialSelection;
+        TCHAR m_szFolderDisplayName[MAX_PATH];
+        TCHAR m_szFolderPath[MAX_PATH];
+        LPITEMIDLIST m_pidlSelected;
+        HWND m_hWnd;   // used only in the callback function
+
+// Constructor
+        CFolderDialogImpl(HWND hWndParent = NULL, LPCTSTR lpstrTitle = NULL, UINT uFlags = BIF_RETURNONLYFSDIRS) : 
+                        m_lpstrInitialFolder(NULL), m_pidlInitialSelection(NULL), m_bExpandInitialSelection(false), m_pidlSelected(NULL), m_hWnd(NULL)
+        {
+                memset(&m_bi, 0, sizeof(m_bi)); // initialize structure to 0/NULL
+
+                m_bi.hwndOwner = hWndParent;
+                m_bi.pidlRoot = NULL;
+                m_bi.pszDisplayName = m_szFolderDisplayName;
+                m_bi.lpszTitle = lpstrTitle;
+                m_bi.ulFlags = uFlags;
+                m_bi.lpfn = BrowseCallbackProc;
+                m_bi.lParam = (LPARAM)static_cast<T*>(this);
+
+                m_szFolderPath[0] = 0;
+                m_szFolderDisplayName[0] = 0;
+        }
+
+        ~CFolderDialogImpl()
+        {
+                ::CoTaskMemFree(m_pidlSelected);
+        }
+
+// Operations
+        INT_PTR DoModal(HWND hWndParent = ::GetActiveWindow())
+        {
+                if(m_bi.hwndOwner == NULL)   // set only if not specified before
+                        m_bi.hwndOwner = hWndParent;
+
+                // Clear out any previous results
+                m_szFolderPath[0] = 0;
+                m_szFolderDisplayName[0] = 0;
+                ::CoTaskMemFree(m_pidlSelected);
+
+                INT_PTR nRet = IDCANCEL;
+                m_pidlSelected = ::SHBrowseForFolder(&m_bi);
+
+                if(m_pidlSelected != NULL)
+                {
+                        nRet = IDOK;
+
+                        // If BIF_RETURNONLYFSDIRS is set, we try to get the filesystem path.
+                        // Otherwise, the caller must handle the ID-list directly.
+                        if((m_bi.ulFlags & BIF_RETURNONLYFSDIRS) != 0)
+                        {
+                                if(::SHGetPathFromIDList(m_pidlSelected, m_szFolderPath) == FALSE)
+                                        nRet = IDCANCEL;
+                        }
+                }
+
+                return nRet;
+        }
+
+        // Methods to call before DoModal
+        void SetInitialFolder(LPCTSTR lpstrInitialFolder, bool bExpand = true)
+        {
+                // lpstrInitialFolder may be a file if BIF_BROWSEINCLUDEFILES is specified
+                m_lpstrInitialFolder = lpstrInitialFolder;
+                m_bExpandInitialSelection = bExpand;
+        }
+
+        void SetInitialSelection(LPCITEMIDLIST pidl, bool bExpand = true)
+        {
+                m_pidlInitialSelection = pidl;
+                m_bExpandInitialSelection = bExpand;
+        }
+
+        // Methods to call after DoModal
+        LPITEMIDLIST GetSelectedItem(bool bDetach = false)
+        {
+                LPITEMIDLIST pidl = m_pidlSelected;
+                if(bDetach)
+                        m_pidlSelected = NULL;
+
+                return pidl;
+        }
+
+        LPCTSTR GetFolderPath() const
+        {
+                return m_szFolderPath;
+        }
+
+        LPCTSTR GetFolderDisplayName() const
+        {
+                return m_szFolderDisplayName;
+        }
+
+        int GetFolderImageIndex() const
+        {
+                return m_bi.iImage;
+        }
+
+// Callback function and overrideables
+        static int CALLBACK BrowseCallbackProc(HWND hWnd, UINT uMsg, LPARAM lParam, LPARAM lpData)
+        {
+#ifndef BFFM_VALIDATEFAILED
+  #ifdef UNICODE
+                const int BFFM_VALIDATEFAILED = 4;
+  #else
+                const int BFFM_VALIDATEFAILED = 3;
+  #endif
+#endif // !BFFM_VALIDATEFAILED
+#ifndef BFFM_IUNKNOWN
+                const int BFFM_IUNKNOWN = 5;
+#endif // !BFFM_IUNKNOWN
+#ifndef BIF_NEWDIALOGSTYLE
+                const UINT BIF_NEWDIALOGSTYLE = 0x0040;
+#endif // !BIF_NEWDIALOGSTYLE
+
+                int nRet = 0;
+                T* pT = (T*)lpData;
+                bool bClear = false;
+                if(pT->m_hWnd == NULL)
+                {
+                        pT->m_hWnd = hWnd;
+                        bClear = true;
+                }
+                else
+                {
+                        ATLASSERT(pT->m_hWnd == hWnd);
+                }
+
+                switch(uMsg)
+                {
+                case BFFM_INITIALIZED:
+                        // Set initial selection
+                        // Note that m_pidlInitialSelection, if set, takes precedence over m_lpstrInitialFolder
+                        if(pT->m_pidlInitialSelection != NULL)
+                                pT->SetSelection(pT->m_pidlInitialSelection);
+                        else if(pT->m_lpstrInitialFolder != NULL)
+                                pT->SetSelection(pT->m_lpstrInitialFolder);
+
+                        // Expand initial selection if appropriate
+                        if(pT->m_bExpandInitialSelection && ((pT->m_bi.ulFlags & BIF_NEWDIALOGSTYLE) != 0))
+                        {
+                                if(pT->m_pidlInitialSelection != NULL)
+                                        pT->SetExpanded(pT->m_pidlInitialSelection);
+                                else if(pT->m_lpstrInitialFolder != NULL)
+                                        pT->SetExpanded(pT->m_lpstrInitialFolder);
+                        }
+                        pT->OnInitialized();
+                        break;
+                case BFFM_SELCHANGED:
+                        pT->OnSelChanged((LPITEMIDLIST)lParam);
+                        break;
+                case BFFM_VALIDATEFAILED:
+                        nRet = pT->OnValidateFailed((LPCTSTR)lParam);
+                        break;
+                case BFFM_IUNKNOWN:
+                        pT->OnIUnknown((IUnknown*)lParam);
+                        break;
+                default:
+                        ATLTRACE2(atlTraceUI, 0, _T("Unknown message received in CFolderDialogImpl::BrowseCallbackProc\n"));
+                        break;
+                }
+
+                if(bClear)
+                        pT->m_hWnd = NULL;
+                return nRet;
+        }
+
+        void OnInitialized()
+        {
+        }
+
+        void OnSelChanged(LPITEMIDLIST /*pItemIDList*/)
+        {
+        }
+
+        int OnValidateFailed(LPCTSTR /*lpstrFolderPath*/)
+        {
+                return 1;   // 1=continue, 0=EndDialog
+        }
+
+        void OnIUnknown(IUnknown* /*pUnknown*/)
+        {
+        }
+
+        // Commands - valid to call only from handlers
+        void EnableOK(BOOL bEnable)
+        {
+                ATLASSERT(m_hWnd != NULL);
+                ::SendMessage(m_hWnd, BFFM_ENABLEOK, 0, bEnable);
+        }
+
+        void SetSelection(LPCITEMIDLIST pItemIDList)
+        {
+                ATLASSERT(m_hWnd != NULL);
+                ::SendMessage(m_hWnd, BFFM_SETSELECTION, FALSE, (LPARAM)pItemIDList);
+        }
+
+        void SetSelection(LPCTSTR lpstrFolderPath)
+        {
+                ATLASSERT(m_hWnd != NULL);
+                ::SendMessage(m_hWnd, BFFM_SETSELECTION, TRUE, (LPARAM)lpstrFolderPath);
+        }
+
+        void SetStatusText(LPCTSTR lpstrText)
+        {
+                ATLASSERT(m_hWnd != NULL);
+                ::SendMessage(m_hWnd, BFFM_SETSTATUSTEXT, 0, (LPARAM)lpstrText);
+        }
+
+        void SetOKText(LPCTSTR lpstrOKText)
+        {
+#ifndef BFFM_SETOKTEXT
+                const UINT BFFM_SETOKTEXT = WM_USER + 105;
+#endif
+                ATLASSERT(m_hWnd != NULL);
+                USES_CONVERSION;
+                LPCWSTR lpstr = T2CW(lpstrOKText);
+                ::SendMessage(m_hWnd, BFFM_SETOKTEXT, (WPARAM)lpstr, 0L);
+        }
+
+        void SetExpanded(LPCITEMIDLIST pItemIDList)
+        {
+#ifndef BFFM_SETEXPANDED
+                const UINT BFFM_SETEXPANDED = WM_USER + 106;
+#endif
+                ATLASSERT(m_hWnd != NULL);
+                ::SendMessage(m_hWnd, BFFM_SETEXPANDED, FALSE, (LPARAM)pItemIDList);
+        }
+
+        void SetExpanded(LPCTSTR lpstrFolderPath)
+        {
+#ifndef BFFM_SETEXPANDED
+                const UINT BFFM_SETEXPANDED = WM_USER + 106;
+#endif
+                ATLASSERT(m_hWnd != NULL);
+                USES_CONVERSION;
+                LPCWSTR lpstr = T2CW(lpstrFolderPath);
+                ::SendMessage(m_hWnd, BFFM_SETEXPANDED, TRUE, (LPARAM)lpstr);
+        }
+};
+
+class CFolderDialog : public CFolderDialogImpl<CFolderDialog>
+{
+public:
+        CFolderDialog(HWND hWndParent = NULL, LPCTSTR lpstrTitle = NULL, UINT uFlags = BIF_RETURNONLYFSDIRS)
+                : CFolderDialogImpl<CFolderDialog>(hWndParent, lpstrTitle, uFlags)
+        { }
+};
+
+#endif // !_WIN32_WCE
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CCommonDialogImplBase - base class for common dialog classes
+
+class ATL_NO_VTABLE CCommonDialogImplBase : public ATL::CWindowImplBase
+{
+public:
+        static UINT_PTR APIENTRY HookProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+        {
+                if(uMsg != WM_INITDIALOG)
+                        return 0;
+                CCommonDialogImplBase* pT = (CCommonDialogImplBase*)ModuleHelper::ExtractCreateWndData();
+                ATLASSERT(pT != NULL);
+                ATLASSERT(pT->m_hWnd == NULL);
+                ATLASSERT(::IsWindow(hWnd));
+                // subclass dialog's window
+                if(!pT->SubclassWindow(hWnd))
+                {
+                        ATLTRACE2(atlTraceUI, 0, _T("Subclassing a common dialog failed\n"));
+                        return 0;
+                }
+                // check message map for WM_INITDIALOG handler
+                LRESULT lRes = 0;
+                if(pT->ProcessWindowMessage(pT->m_hWnd, uMsg, wParam, lParam, lRes, 0) == FALSE)
+                        return 0;
+                return lRes;
+        }
+
+// Special override for common dialogs
+        BOOL EndDialog(INT_PTR /*nRetCode*/ = 0)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                SendMessage(WM_COMMAND, MAKEWPARAM(IDABORT, 0));
+                return TRUE;
+        }
+
+// Implementation - try to override these, to prevent errors
+        HWND Create(HWND, ATL::_U_RECT, LPCTSTR, DWORD, DWORD, ATL::_U_MENUorID, ATOM, LPVOID)
+        {
+                ATLASSERT(FALSE);   // should not be called
+                return NULL;
+        }
+
+        static LRESULT CALLBACK StartWindowProc(HWND /*hWnd*/, UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/)
+        {
+                ATLASSERT(FALSE);   // should not be called
+                return 0;
+        }
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CFontDialogImpl - font selection dialog
+
+#ifndef _WIN32_WCE
+
+template <class T>
+class ATL_NO_VTABLE CFontDialogImpl : public CCommonDialogImplBase
+{
+public:
+        enum { _cchStyleName = 64 };
+
+        CHOOSEFONT m_cf;
+        TCHAR m_szStyleName[_cchStyleName];  // contains style name after return
+        LOGFONT m_lf;                        // default LOGFONT to store the info
+
+// Constructors
+        CFontDialogImpl(LPLOGFONT lplfInitial = NULL,
+                        DWORD dwFlags = CF_EFFECTS | CF_SCREENFONTS,
+                        HDC hDCPrinter = NULL,
+                        HWND hWndParent = NULL)
+        {
+                memset(&m_cf, 0, sizeof(m_cf));
+                memset(&m_lf, 0, sizeof(m_lf));
+                memset(&m_szStyleName, 0, sizeof(m_szStyleName));
+
+                m_cf.lStructSize = sizeof(m_cf);
+                m_cf.hwndOwner = hWndParent;
+                m_cf.rgbColors = RGB(0, 0, 0);
+                m_cf.lpszStyle = (LPTSTR)&m_szStyleName;
+                m_cf.Flags = dwFlags | CF_ENABLEHOOK;
+                m_cf.lpfnHook = (LPCFHOOKPROC)T::HookProc;
+
+                if(lplfInitial != NULL)
+                {
+                        m_cf.lpLogFont = lplfInitial;
+                        m_cf.Flags |= CF_INITTOLOGFONTSTRUCT;
+                        m_lf = *lplfInitial;
+                }
+                else
+                {
+                        m_cf.lpLogFont = &m_lf;
+                }
+
+                if(hDCPrinter != NULL)
+                {
+                        m_cf.hDC = hDCPrinter;
+                        m_cf.Flags |= CF_PRINTERFONTS;
+                }
+        }
+
+// Operations
+        INT_PTR DoModal(HWND hWndParent = ::GetActiveWindow())
+        {
+                ATLASSERT((m_cf.Flags & CF_ENABLEHOOK) != 0);
+                ATLASSERT(m_cf.lpfnHook != NULL);   // can still be a user hook
+
+                if(m_cf.hwndOwner == NULL)          // set only if not specified before
+                        m_cf.hwndOwner = hWndParent;
+
+                ATLASSERT(m_hWnd == NULL);
+                ModuleHelper::AddCreateWndData(&m_thunk.cd, (CCommonDialogImplBase*)this);
+
+                BOOL bRet = ::ChooseFont(&m_cf);
+
+                m_hWnd = NULL;
+
+                if(bRet)   // copy logical font from user's initialization buffer (if needed)
+                        SecureHelper::memcpy_x(&m_lf, sizeof(m_lf), m_cf.lpLogFont, sizeof(m_lf));
+
+                return bRet ? IDOK : IDCANCEL;
+        }
+
+        // works only when the dialog is dislayed or after
+        void GetCurrentFont(LPLOGFONT lplf) const
+        {
+                ATLASSERT(lplf != NULL);
+
+                if(m_hWnd != NULL)
+                        ::SendMessage(m_hWnd, WM_CHOOSEFONT_GETLOGFONT, 0, (LPARAM)lplf);
+                else
+                        *lplf = m_lf;
+        }
+
+        // works only when the dialog is dislayed or before
+#ifndef _WIN32_WCE
+        void SetLogFont(LPLOGFONT lplf)
+        {
+                ATLASSERT(lplf != NULL);
+#ifndef WM_CHOOSEFONT_SETLOGFONT
+                const UINT WM_CHOOSEFONT_SETLOGFONT = (WM_USER + 101);
+#endif
+                if(m_hWnd != NULL)
+                {
+                        ::SendMessage(m_hWnd, WM_CHOOSEFONT_SETLOGFONT, 0, (LPARAM)lplf);
+                }
+                else
+                {
+                        m_lf = *lplf;
+                        m_cf.Flags |= CF_INITTOLOGFONTSTRUCT;
+                }
+        }
+
+        void SetFlags(DWORD dwFlags)
+        {
+#ifndef WM_CHOOSEFONT_SETFLAGS
+                const UINT WM_CHOOSEFONT_SETFLAGS = (WM_USER + 102);
+#endif
+                if(m_hWnd != NULL)
+                {
+                        CHOOSEFONT cf = { sizeof(CHOOSEFONT) };
+                        cf.Flags = dwFlags;
+                        ::SendMessage(m_hWnd, WM_CHOOSEFONT_SETFLAGS, 0, (LPARAM)&cf);
+                }
+                else
+                {
+                        m_cf.Flags = dwFlags;
+                }
+        }
+#endif // !_WIN32_WCE
+
+        // Helpers for parsing information after successful return
+        LPCTSTR GetFaceName() const   // return the face name of the font
+        {
+                return (LPCTSTR)m_cf.lpLogFont->lfFaceName;
+        }
+
+        LPCTSTR GetStyleName() const  // return the style name of the font
+        {
+                return m_cf.lpszStyle;
+        }
+
+        int GetSize() const           // return the pt size of the font
+        {
+                return m_cf.iPointSize;
+        }
+
+        COLORREF GetColor() const     // return the color of the font
+        {
+                return m_cf.rgbColors;
+        }
+
+        int GetWeight() const         // return the chosen font weight
+        {
+                return (int)m_cf.lpLogFont->lfWeight;
+        }
+
+        BOOL IsStrikeOut() const      // return TRUE if strikeout
+        {
+                return (m_cf.lpLogFont->lfStrikeOut) ? TRUE : FALSE;
+        }
+
+        BOOL IsUnderline() const      // return TRUE if underline
+        {
+                return (m_cf.lpLogFont->lfUnderline) ? TRUE : FALSE;
+        }
+
+        BOOL IsBold() const           // return TRUE if bold font
+        {
+                return (m_cf.lpLogFont->lfWeight == FW_BOLD) ? TRUE : FALSE;
+        }
+
+        BOOL IsItalic() const         // return TRUE if italic font
+        {
+                return m_cf.lpLogFont->lfItalic ? TRUE : FALSE;
+        }
+};
+
+class CFontDialog : public CFontDialogImpl<CFontDialog>
+{
+public:
+        CFontDialog(LPLOGFONT lplfInitial = NULL,
+                DWORD dwFlags = CF_EFFECTS | CF_SCREENFONTS,
+                HDC hDCPrinter = NULL,
+                HWND hWndParent = NULL)
+                : CFontDialogImpl<CFontDialog>(lplfInitial, dwFlags, hDCPrinter, hWndParent)
+        { }
+
+        DECLARE_EMPTY_MSG_MAP()
+};
+
+#endif // _WIN32_WCE
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CRichEditFontDialogImpl - font selection for the Rich Edit ctrl
+
+#if defined(_RICHEDIT_) && !defined(_WIN32_WCE)
+
+template <class T>
+class ATL_NO_VTABLE CRichEditFontDialogImpl : public CFontDialogImpl< T >
+{
+public:
+        CRichEditFontDialogImpl(const CHARFORMAT& charformat,
+                        DWORD dwFlags = CF_SCREENFONTS,
+                        HDC hDCPrinter = NULL,
+                        HWND hWndParent = NULL)
+                        : CFontDialogImpl< T >(NULL, dwFlags, hDCPrinter, hWndParent)
+        {
+                m_cf.Flags |= CF_INITTOLOGFONTSTRUCT;
+                m_cf.Flags |= FillInLogFont(charformat);
+                m_cf.lpLogFont = &m_lf;
+
+                if((charformat.dwMask & CFM_COLOR) != 0)
+                        m_cf.rgbColors = charformat.crTextColor;
+        }
+
+        void GetCharFormat(CHARFORMAT& cf) const
+        {
+                USES_CONVERSION;
+                cf.dwEffects = 0;
+                cf.dwMask = 0;
+                if((m_cf.Flags & CF_NOSTYLESEL) == 0)
+                {
+                        cf.dwMask |= CFM_BOLD | CFM_ITALIC;
+                        cf.dwEffects |= IsBold() ? CFE_BOLD : 0;
+                        cf.dwEffects |= IsItalic() ? CFE_ITALIC : 0;
+                }
+                if((m_cf.Flags & CF_NOSIZESEL) == 0)
+                {
+                        cf.dwMask |= CFM_SIZE;
+                        // GetSize() returns in tenths of points so mulitply by 2 to get twips
+                        cf.yHeight = GetSize() * 2;
+                }
+
+                if((m_cf.Flags & CF_NOFACESEL) == 0)
+                {
+                        cf.dwMask |= CFM_FACE;
+                        cf.bPitchAndFamily = m_cf.lpLogFont->lfPitchAndFamily;
+#if (_RICHEDIT_VER >= 0x0200)
+                        SecureHelper::strcpy_x(cf.szFaceName, _countof(cf.szFaceName), GetFaceName());
+#else // !(_RICHEDIT_VER >= 0x0200)
+                        SecureHelper::strcpyA_x(cf.szFaceName, _countof(cf.szFaceName), T2A((LPTSTR)(LPCTSTR)GetFaceName()));
+#endif // !(_RICHEDIT_VER >= 0x0200)
+                }
+
+                if((m_cf.Flags & CF_EFFECTS) != 0)
+                {
+                        cf.dwMask |= CFM_UNDERLINE | CFM_STRIKEOUT | CFM_COLOR;
+                        cf.dwEffects |= IsUnderline() ? CFE_UNDERLINE : 0;
+                        cf.dwEffects |= IsStrikeOut() ? CFE_STRIKEOUT : 0;
+                        cf.crTextColor = GetColor();
+                }
+                if((m_cf.Flags & CF_NOSCRIPTSEL) == 0)
+                {
+                        cf.bCharSet = m_cf.lpLogFont->lfCharSet;
+                        cf.dwMask |= CFM_CHARSET;
+                }
+                cf.yOffset = 0;
+        }
+
+        DWORD FillInLogFont(const CHARFORMAT& cf)
+        {
+                USES_CONVERSION;
+                DWORD dwFlags = 0;
+                if((cf.dwMask & CFM_SIZE) != 0)
+                {
+                        HDC hDC = ::CreateDC(_T("DISPLAY"), NULL, NULL, NULL);
+                        LONG yPerInch = ::GetDeviceCaps(hDC, LOGPIXELSY);
+                        m_lf.lfHeight = -(int)((cf.yHeight * yPerInch) / 1440);
+                }
+                else
+                        m_lf.lfHeight = 0;
+
+                m_lf.lfWidth = 0;
+                m_lf.lfEscapement = 0;
+                m_lf.lfOrientation = 0;
+
+                if((cf.dwMask & (CFM_ITALIC | CFM_BOLD)) == (CFM_ITALIC | CFM_BOLD))
+                {
+                        m_lf.lfWeight = ((cf.dwEffects & CFE_BOLD) != 0) ? FW_BOLD : FW_NORMAL;
+                        m_lf.lfItalic = (BYTE)(((cf.dwEffects & CFE_ITALIC) != 0) ? TRUE : FALSE);
+                }
+                else
+                {
+                        dwFlags |= CF_NOSTYLESEL;
+                        m_lf.lfWeight = FW_DONTCARE;
+                        m_lf.lfItalic = FALSE;
+                }
+
+                if((cf.dwMask & (CFM_UNDERLINE | CFM_STRIKEOUT | CFM_COLOR)) == (CFM_UNDERLINE|CFM_STRIKEOUT|CFM_COLOR))
+                {
+                        dwFlags |= CF_EFFECTS;
+                        m_lf.lfUnderline = (BYTE)(((cf.dwEffects & CFE_UNDERLINE) != 0) ? TRUE : FALSE);
+                        m_lf.lfStrikeOut = (BYTE)(((cf.dwEffects & CFE_STRIKEOUT) != 0) ? TRUE : FALSE);
+                }
+                else
+                {
+                        m_lf.lfUnderline = (BYTE)FALSE;
+                        m_lf.lfStrikeOut = (BYTE)FALSE;
+                }
+
+                if((cf.dwMask & CFM_CHARSET) != 0)
+                        m_lf.lfCharSet = cf.bCharSet;
+                else
+                        dwFlags |= CF_NOSCRIPTSEL;
+                m_lf.lfOutPrecision = OUT_DEFAULT_PRECIS;
+                m_lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
+                m_lf.lfQuality = DEFAULT_QUALITY;
+                if((cf.dwMask & CFM_FACE) != 0)
+                {
+                        m_lf.lfPitchAndFamily = cf.bPitchAndFamily;
+#if (_RICHEDIT_VER >= 0x0200)
+                        SecureHelper::strcpy_x(m_lf.lfFaceName, _countof(m_lf.lfFaceName), cf.szFaceName);
+#else // !(_RICHEDIT_VER >= 0x0200)
+                        SecureHelper::strcpy_x(m_lf.lfFaceName, _countof(m_lf.lfFaceName), A2T((LPSTR)cf.szFaceName));
+#endif // !(_RICHEDIT_VER >= 0x0200)
+                }
+                else
+                {
+                        m_lf.lfPitchAndFamily = DEFAULT_PITCH|FF_DONTCARE;
+                        m_lf.lfFaceName[0] = (TCHAR)0;
+                }
+                return dwFlags;
+        }
+};
+
+class CRichEditFontDialog : public CRichEditFontDialogImpl<CRichEditFontDialog>
+{
+public:
+        CRichEditFontDialog(const CHARFORMAT& charformat,
+                DWORD dwFlags = CF_SCREENFONTS,
+                HDC hDCPrinter = NULL,
+                HWND hWndParent = NULL)
+                : CRichEditFontDialogImpl<CRichEditFontDialog>(charformat, dwFlags, hDCPrinter, hWndParent)
+        { }
+
+        DECLARE_EMPTY_MSG_MAP()
+};
+
+#endif // defined(_RICHEDIT_) && !defined(_WIN32_WCE)
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CColorDialogImpl - color selection
+
+#if !defined(_WIN32_WCE) || ((_WIN32_WCE > 420) && !(defined(WIN32_PLATFORM_WFSP) && (_WIN32_WCE > 0x0500)))
+
+#ifdef _WIN32_WCE
+  #pragma comment(lib, "commdlg.lib")
+
+  #ifndef SETRGBSTRING
+    #define SETRGBSTRING _T("commdlg_SetRGBColor")
+  #endif
+
+  #ifndef COLOROKSTRING
+    #define COLOROKSTRING _T("commdlg_ColorOK")
+  #endif
+#endif
+
+template <class T>
+class ATL_NO_VTABLE CColorDialogImpl : public CCommonDialogImplBase
+{
+public:
+        CHOOSECOLOR m_cc;
+
+// Constructor
+        CColorDialogImpl(COLORREF clrInit = 0, DWORD dwFlags = 0, HWND hWndParent = NULL)
+        {
+                memset(&m_cc, 0, sizeof(m_cc));
+
+                m_cc.lStructSize = sizeof(m_cc);
+                m_cc.lpCustColors = GetCustomColors();
+                m_cc.hwndOwner = hWndParent;
+                m_cc.Flags = dwFlags | CC_ENABLEHOOK;
+                m_cc.lpfnHook = (LPCCHOOKPROC)T::HookProc;
+
+                if(clrInit != 0)
+                {
+                        m_cc.rgbResult = clrInit;
+                        m_cc.Flags |= CC_RGBINIT;
+                }
+        }
+
+// Operations
+        INT_PTR DoModal(HWND hWndParent = ::GetActiveWindow())
+        {
+                ATLASSERT((m_cc.Flags & CC_ENABLEHOOK) != 0);
+                ATLASSERT(m_cc.lpfnHook != NULL);   // can still be a user hook
+
+                if(m_cc.hwndOwner == NULL)          // set only if not specified before
+                        m_cc.hwndOwner = hWndParent;
+
+                ATLASSERT(m_hWnd == NULL);
+                ModuleHelper::AddCreateWndData(&m_thunk.cd, (CCommonDialogImplBase*)this);
+
+                BOOL bRet = ::ChooseColor(&m_cc);
+
+                m_hWnd = NULL;
+
+                return bRet ? IDOK : IDCANCEL;
+        }
+
+        // Set the current color while dialog is displayed
+        void SetCurrentColor(COLORREF clr)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                SendMessage(_GetSetRGBMessage(), 0, (LPARAM)clr);
+        }
+
+        // Get the selected color after DoModal returns, or in OnColorOK
+        COLORREF GetColor() const
+        {
+                return m_cc.rgbResult;
+        }
+
+// Special override for the color dialog
+        static UINT_PTR APIENTRY HookProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+        {
+                if(uMsg != WM_INITDIALOG && uMsg != _GetColorOKMessage())
+                        return 0;
+
+                LPCHOOSECOLOR lpCC = (LPCHOOSECOLOR)lParam;
+                CCommonDialogImplBase* pT = NULL;
+
+                if(uMsg == WM_INITDIALOG)
+                {
+                        pT = (CCommonDialogImplBase*)ModuleHelper::ExtractCreateWndData();
+                        lpCC->lCustData = (LPARAM)pT;
+                        ATLASSERT(pT != NULL);
+                        ATLASSERT(pT->m_hWnd == NULL);
+                        ATLASSERT(::IsWindow(hWnd));
+                        // subclass dialog's window
+                        if(!pT->SubclassWindow(hWnd))
+                        {
+                                ATLTRACE2(atlTraceUI, 0, _T("Subclassing a Color common dialog failed\n"));
+                                return 0;
+                        }
+                }
+                else if(uMsg == _GetColorOKMessage())
+                {
+                        pT = (CCommonDialogImplBase*)lpCC->lCustData;
+                        ATLASSERT(pT != NULL);
+                        ATLASSERT(::IsWindow(pT->m_hWnd));
+                }
+
+                // pass to the message map
+                LRESULT lRes;
+                if(pT->ProcessWindowMessage(pT->m_hWnd, uMsg, wParam, lParam, lRes, 0) == FALSE)
+                        return 0;
+                return lRes;
+        }
+
+// Helpers
+        static COLORREF* GetCustomColors()
+        {
+                static COLORREF rgbCustomColors[16] =
+                {
+                        RGB(255, 255, 255), RGB(255, 255, 255), 
+                        RGB(255, 255, 255), RGB(255, 255, 255), 
+                        RGB(255, 255, 255), RGB(255, 255, 255), 
+                        RGB(255, 255, 255), RGB(255, 255, 255), 
+                        RGB(255, 255, 255), RGB(255, 255, 255), 
+                        RGB(255, 255, 255), RGB(255, 255, 255), 
+                        RGB(255, 255, 255), RGB(255, 255, 255), 
+                        RGB(255, 255, 255), RGB(255, 255, 255), 
+                };
+
+                return rgbCustomColors;
+        }
+
+        static UINT _GetSetRGBMessage()
+        {
+                static UINT uSetRGBMessage = 0;
+                if(uSetRGBMessage == 0)
+                {
+                        CStaticDataInitCriticalSectionLock lock;
+                        if(FAILED(lock.Lock()))
+                        {
+                                ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to lock critical section in CColorDialogImpl::_GetSetRGBMessage.\n"));
+                                ATLASSERT(FALSE);
+                                return 0;
+                        }
+
+                        if(uSetRGBMessage == 0)
+                                uSetRGBMessage = ::RegisterWindowMessage(SETRGBSTRING);
+
+                        lock.Unlock();
+                }
+                ATLASSERT(uSetRGBMessage != 0);
+                return uSetRGBMessage;
+        }
+
+        static UINT _GetColorOKMessage()
+        {
+                static UINT uColorOKMessage = 0;
+                if(uColorOKMessage == 0)
+                {
+                        CStaticDataInitCriticalSectionLock lock;
+                        if(FAILED(lock.Lock()))
+                        {
+                                ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to lock critical section in CColorDialogImpl::_GetColorOKMessage.\n"));
+                                ATLASSERT(FALSE);
+                                return 0;
+                        }
+
+                        if(uColorOKMessage == 0)
+                                uColorOKMessage = ::RegisterWindowMessage(COLOROKSTRING);
+
+                        lock.Unlock();
+                }
+                ATLASSERT(uColorOKMessage != 0);
+                return uColorOKMessage;
+        }
+
+// Message map and handlers
+        BEGIN_MSG_MAP(CColorDialogImpl)
+                MESSAGE_HANDLER(_GetColorOKMessage(), _OnColorOK)
+        END_MSG_MAP()
+
+        LRESULT _OnColorOK(UINT, WPARAM, LPARAM, BOOL&)
+        {
+                T* pT = static_cast<T*>(this);
+                return pT->OnColorOK();
+        }
+
+// Overrideable
+        BOOL OnColorOK()        // validate color
+        {
+                return FALSE;
+        }
+};
+
+class CColorDialog : public CColorDialogImpl<CColorDialog>
+{
+public:
+        CColorDialog(COLORREF clrInit = 0, DWORD dwFlags = 0, HWND hWndParent = NULL)
+                : CColorDialogImpl<CColorDialog>(clrInit, dwFlags, hWndParent)
+        { }
+
+        // override base class map and references to handlers
+        DECLARE_EMPTY_MSG_MAP()
+};
+
+#endif // !defined(_WIN32_WCE) || ((_WIN32_WCE > 420) && !(defined(WIN32_PLATFORM_WFSP) && (_WIN32_WCE > 0x0500)))
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CPrintDialogImpl - used for Print... and PrintSetup...
+
+#ifndef _WIN32_WCE
+
+// global helper
+static HDC _AtlCreateDC(HGLOBAL hDevNames, HGLOBAL hDevMode)
+{
+        if(hDevNames == NULL)
+                return NULL;
+
+        LPDEVNAMES lpDevNames = (LPDEVNAMES)::GlobalLock(hDevNames);
+        LPDEVMODE  lpDevMode = (hDevMode != NULL) ? (LPDEVMODE)::GlobalLock(hDevMode) : NULL;
+
+        if(lpDevNames == NULL)
+                return NULL;
+
+        HDC hDC = ::CreateDC((LPCTSTR)lpDevNames + lpDevNames->wDriverOffset,
+                                          (LPCTSTR)lpDevNames + lpDevNames->wDeviceOffset,
+                                          (LPCTSTR)lpDevNames + lpDevNames->wOutputOffset,
+                                          lpDevMode);
+
+        ::GlobalUnlock(hDevNames);
+        if(hDevMode != NULL)
+                ::GlobalUnlock(hDevMode);
+        return hDC;
+}
+
+template <class T>
+class ATL_NO_VTABLE CPrintDialogImpl : public CCommonDialogImplBase
+{
+public:
+        // print dialog parameter block (note this is a reference)
+        PRINTDLG& m_pd;
+
+// Constructors
+        CPrintDialogImpl(BOOL bPrintSetupOnly = FALSE,  // TRUE for Print Setup, FALSE for Print Dialog
+                        DWORD dwFlags = PD_ALLPAGES | PD_USEDEVMODECOPIES | PD_NOPAGENUMS | PD_NOSELECTION,
+                        HWND hWndParent = NULL)
+                        : m_pd(m_pdActual)
+        {
+                memset(&m_pdActual, 0, sizeof(m_pdActual));
+
+                m_pd.lStructSize = sizeof(m_pdActual);
+                m_pd.hwndOwner = hWndParent;
+                m_pd.Flags = (dwFlags | PD_ENABLEPRINTHOOK | PD_ENABLESETUPHOOK);
+                m_pd.lpfnPrintHook = (LPPRINTHOOKPROC)T::HookProc;
+                m_pd.lpfnSetupHook = (LPSETUPHOOKPROC)T::HookProc;
+
+                if(bPrintSetupOnly)
+                        m_pd.Flags |= PD_PRINTSETUP;
+                else
+                        m_pd.Flags |= PD_RETURNDC;
+
+                m_pd.Flags &= ~PD_RETURNIC; // do not support information context
+        }
+
+// Operations
+        INT_PTR DoModal(HWND hWndParent = ::GetActiveWindow())
+        {
+                ATLASSERT((m_pd.Flags & PD_ENABLEPRINTHOOK) != 0);
+                ATLASSERT((m_pd.Flags & PD_ENABLESETUPHOOK) != 0);
+                ATLASSERT(m_pd.lpfnPrintHook != NULL);   // can still be a user hook
+                ATLASSERT(m_pd.lpfnSetupHook != NULL);   // can still be a user hook
+                ATLASSERT((m_pd.Flags & PD_RETURNDEFAULT) == 0);   // use GetDefaults for this
+
+                if(m_pd.hwndOwner == NULL)   // set only if not specified before
+                        m_pd.hwndOwner = hWndParent;
+
+                ATLASSERT(m_hWnd == NULL);
+                ModuleHelper::AddCreateWndData(&m_thunk.cd, (CCommonDialogImplBase*)this);
+
+                BOOL bRet = ::PrintDlg(&m_pd);
+
+                m_hWnd = NULL;
+
+                return bRet ? IDOK : IDCANCEL;
+        }
+
+        // GetDefaults will not display a dialog but will get device defaults
+        BOOL GetDefaults()
+        {
+                m_pd.Flags |= PD_RETURNDEFAULT;
+                ATLASSERT(m_pd.hDevMode == NULL);    // must be NULL
+                ATLASSERT(m_pd.hDevNames == NULL);   // must be NULL
+
+                return ::PrintDlg(&m_pd);
+        }
+
+        // Helpers for parsing information after successful return num. copies requested
+        int GetCopies() const
+        {
+                if((m_pd.Flags & PD_USEDEVMODECOPIES) != 0)
+                {
+                        LPDEVMODE lpDevMode = GetDevMode();
+                        return (lpDevMode != NULL) ? lpDevMode->dmCopies : -1;
+                }
+
+                return m_pd.nCopies;
+        }
+
+        BOOL PrintCollate() const       // TRUE if collate checked
+        {
+                return ((m_pd.Flags & PD_COLLATE) != 0) ? TRUE : FALSE;
+        }
+
+        BOOL PrintSelection() const     // TRUE if printing selection
+        {
+                return ((m_pd.Flags & PD_SELECTION) != 0) ? TRUE : FALSE;
+        }
+
+        BOOL PrintAll() const           // TRUE if printing all pages
+        {
+                return (!PrintRange() && !PrintSelection()) ? TRUE : FALSE;
+        }
+
+        BOOL PrintRange() const         // TRUE if printing page range
+        {
+                return ((m_pd.Flags & PD_PAGENUMS) != 0) ? TRUE : FALSE;
+        }
+
+        BOOL PrintToFile() const        // TRUE if printing to a file
+        {
+                return ((m_pd.Flags & PD_PRINTTOFILE) != 0) ? TRUE : FALSE;
+        }
+
+        int GetFromPage() const         // starting page if valid
+        {
+                return PrintRange() ? m_pd.nFromPage : -1;
+        }
+
+        int GetToPage() const           // ending page if valid
+        {
+                return PrintRange() ? m_pd.nToPage : -1;
+        }
+
+        LPDEVMODE GetDevMode() const    // return DEVMODE
+        {
+                if(m_pd.hDevMode == NULL)
+                        return NULL;
+
+                return (LPDEVMODE)::GlobalLock(m_pd.hDevMode);
+        }
+
+        LPCTSTR GetDriverName() const   // return driver name
+        {
+                if(m_pd.hDevNames == NULL)
+                        return NULL;
+
+                LPDEVNAMES lpDev = (LPDEVNAMES)::GlobalLock(m_pd.hDevNames);
+                if(lpDev == NULL)
+                        return NULL;
+
+                return (LPCTSTR)lpDev + lpDev->wDriverOffset;
+        }
+
+        LPCTSTR GetDeviceName() const   // return device name
+        {
+                if(m_pd.hDevNames == NULL)
+                        return NULL;
+
+                LPDEVNAMES lpDev = (LPDEVNAMES)::GlobalLock(m_pd.hDevNames);
+                if(lpDev == NULL)
+                        return NULL;
+
+                return (LPCTSTR)lpDev + lpDev->wDeviceOffset;
+        }
+
+        LPCTSTR GetPortName() const     // return output port name
+        {
+                if(m_pd.hDevNames == NULL)
+                        return NULL;
+
+                LPDEVNAMES lpDev = (LPDEVNAMES)::GlobalLock(m_pd.hDevNames);
+                if(lpDev == NULL)
+                        return NULL;
+
+                return (LPCTSTR)lpDev + lpDev->wOutputOffset;
+        }
+
+        HDC GetPrinterDC() const        // return HDC (caller must delete)
+        {
+                ATLASSERT((m_pd.Flags & PD_RETURNDC) != 0);
+                return m_pd.hDC;
+        }
+
+        // This helper creates a DC based on the DEVNAMES and DEVMODE structures.
+        // This DC is returned, but also stored in m_pd.hDC as though it had been
+        // returned by CommDlg.  It is assumed that any previously obtained DC
+        // has been/will be deleted by the user.  This may be
+        // used without ever invoking the print/print setup dialogs.
+        HDC CreatePrinterDC()
+        {
+                m_pd.hDC = _AtlCreateDC(m_pd.hDevNames, m_pd.hDevMode);
+                return m_pd.hDC;
+        }
+
+// Implementation
+        PRINTDLG m_pdActual; // the Print/Print Setup need to share this
+
+        // The following handle the case of print setup... from the print dialog
+        CPrintDialogImpl(PRINTDLG& pdInit) : m_pd(pdInit)
+        { }
+
+        BEGIN_MSG_MAP(CPrintDialogImpl)
+#ifdef psh1
+                COMMAND_ID_HANDLER(psh1, OnPrintSetup) // print setup button when print is displayed
+#else // !psh1
+                COMMAND_ID_HANDLER(0x0400, OnPrintSetup) // value from dlgs.h
+#endif // !psh1
+        END_MSG_MAP()
+
+        LRESULT OnPrintSetup(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& /*bHandled*/)
+        {
+                T dlgSetup(m_pd);
+                ModuleHelper::AddCreateWndData(&dlgSetup.m_thunk.cd, (CCommonDialogImplBase*)&dlgSetup);
+                return DefWindowProc(WM_COMMAND, MAKEWPARAM(wID, wNotifyCode), (LPARAM)hWndCtl);
+        }
+};
+
+class CPrintDialog : public CPrintDialogImpl<CPrintDialog>
+{
+public:
+        CPrintDialog(BOOL bPrintSetupOnly = FALSE,
+                DWORD dwFlags = PD_ALLPAGES | PD_USEDEVMODECOPIES | PD_NOPAGENUMS | PD_NOSELECTION,
+                HWND hWndParent = NULL)
+                : CPrintDialogImpl<CPrintDialog>(bPrintSetupOnly, dwFlags, hWndParent)
+        { }
+
+        CPrintDialog(PRINTDLG& pdInit) : CPrintDialogImpl<CPrintDialog>(pdInit)
+        { }
+};
+
+#endif // _WIN32_WCE
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CPrintDialogExImpl - new print dialog for Windows 2000
+
+#if (WINVER >= 0x0500) && !defined(_WIN32_WCE)
+
+}; // namespace WTL
+
+#include <atlcom.h>
+
+extern "C" const __declspec(selectany) IID IID_IPrintDialogCallback = {0x5852a2c3, 0x6530, 0x11d1, {0xb6, 0xa3, 0x0, 0x0, 0xf8, 0x75, 0x7b, 0xf9}};
+extern "C" const __declspec(selectany) IID IID_IPrintDialogServices = {0x509aaeda, 0x5639, 0x11d1, {0xb6, 0xa1, 0x0, 0x0, 0xf8, 0x75, 0x7b, 0xf9}};
+
+namespace WTL
+{
+
+template <class T>
+class ATL_NO_VTABLE CPrintDialogExImpl : 
+                                public ATL::CWindow,
+                                public ATL::CMessageMap,
+                                public IPrintDialogCallback,
+                                public ATL::IObjectWithSiteImpl< T >
+{
+public:
+        PRINTDLGEX m_pdex;
+
+// Constructor
+        CPrintDialogExImpl(DWORD dwFlags = PD_ALLPAGES | PD_USEDEVMODECOPIES | PD_NOPAGENUMS | PD_NOSELECTION | PD_NOCURRENTPAGE,
+                                HWND hWndParent = NULL)
+        {
+                memset(&m_pdex, 0, sizeof(m_pdex));
+
+                m_pdex.lStructSize = sizeof(PRINTDLGEX);
+                m_pdex.hwndOwner = hWndParent;
+                m_pdex.Flags = dwFlags;
+                m_pdex.nStartPage = START_PAGE_GENERAL;
+                // callback object will be set in DoModal
+
+                m_pdex.Flags &= ~PD_RETURNIC; // do not support information context
+        }
+
+// Operations
+        HRESULT DoModal(HWND hWndParent = ::GetActiveWindow())
+        {
+                ATLASSERT(m_hWnd == NULL);
+                ATLASSERT((m_pdex.Flags & PD_RETURNDEFAULT) == 0);   // use GetDefaults for this
+
+                if(m_pdex.hwndOwner == NULL)   // set only if not specified before
+                        m_pdex.hwndOwner = hWndParent;
+
+                T* pT = static_cast<T*>(this);
+                m_pdex.lpCallback = (IUnknown*)(IPrintDialogCallback*)pT;
+
+                HRESULT hResult = ::PrintDlgEx(&m_pdex);
+
+                m_hWnd = NULL;
+
+                return hResult;
+        }
+
+        BOOL EndDialog(INT_PTR /*nRetCode*/ = 0)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                SendMessage(WM_COMMAND, MAKEWPARAM(IDABORT, 0));
+                return TRUE;
+        }
+
+        // GetDefaults will not display a dialog but will get device defaults
+        HRESULT GetDefaults()
+        {
+                m_pdex.Flags |= PD_RETURNDEFAULT;
+                ATLASSERT(m_pdex.hDevMode == NULL);    // must be NULL
+                ATLASSERT(m_pdex.hDevNames == NULL);   // must be NULL
+
+                return ::PrintDlgEx(&m_pdex);
+        }
+
+        // Helpers for parsing information after successful return num. copies requested
+        int GetCopies() const
+        {
+                if((m_pdex.Flags & PD_USEDEVMODECOPIES) != 0)
+                {
+                        LPDEVMODE lpDevMode = GetDevMode();
+                        return (lpDevMode != NULL) ? lpDevMode->dmCopies : -1;
+                }
+
+                return m_pdex.nCopies;
+        }
+
+        BOOL PrintCollate() const       // TRUE if collate checked
+        {
+                return ((m_pdex.Flags & PD_COLLATE) != 0) ? TRUE : FALSE;
+        }
+
+        BOOL PrintSelection() const     // TRUE if printing selection
+        {
+                return ((m_pdex.Flags & PD_SELECTION) != 0) ? TRUE : FALSE;
+        }
+
+        BOOL PrintAll() const           // TRUE if printing all pages
+        {
+                return (!PrintRange() && !PrintSelection()) ? TRUE : FALSE;
+        }
+
+        BOOL PrintRange() const         // TRUE if printing page range
+        {
+                return ((m_pdex.Flags & PD_PAGENUMS) != 0) ? TRUE : FALSE;
+        }
+
+        BOOL PrintToFile() const        // TRUE if printing to a file
+        {
+                return ((m_pdex.Flags & PD_PRINTTOFILE) != 0) ? TRUE : FALSE;
+        }
+
+        LPDEVMODE GetDevMode() const    // return DEVMODE
+        {
+                if(m_pdex.hDevMode == NULL)
+                        return NULL;
+
+                return (LPDEVMODE)::GlobalLock(m_pdex.hDevMode);
+        }
+
+        LPCTSTR GetDriverName() const   // return driver name
+        {
+                if(m_pdex.hDevNames == NULL)
+                        return NULL;
+
+                LPDEVNAMES lpDev = (LPDEVNAMES)::GlobalLock(m_pdex.hDevNames);
+                if(lpDev == NULL)
+                        return NULL;
+
+                return (LPCTSTR)lpDev + lpDev->wDriverOffset;
+        }
+
+        LPCTSTR GetDeviceName() const   // return device name
+        {
+                if(m_pdex.hDevNames == NULL)
+                        return NULL;
+
+                LPDEVNAMES lpDev = (LPDEVNAMES)::GlobalLock(m_pdex.hDevNames);
+                if(lpDev == NULL)
+                        return NULL;
+
+                return (LPCTSTR)lpDev + lpDev->wDeviceOffset;
+        }
+
+        LPCTSTR GetPortName() const     // return output port name
+        {
+                if(m_pdex.hDevNames == NULL)
+                        return NULL;
+
+                LPDEVNAMES lpDev = (LPDEVNAMES)::GlobalLock(m_pdex.hDevNames);
+                if(lpDev == NULL)
+                        return NULL;
+
+                return (LPCTSTR)lpDev + lpDev->wOutputOffset;
+        }
+
+        HDC GetPrinterDC() const        // return HDC (caller must delete)
+        {
+                ATLASSERT((m_pdex.Flags & PD_RETURNDC) != 0);
+                return m_pdex.hDC;
+        }
+
+        // This helper creates a DC based on the DEVNAMES and DEVMODE structures.
+        // This DC is returned, but also stored in m_pdex.hDC as though it had been
+        // returned by CommDlg.  It is assumed that any previously obtained DC
+        // has been/will be deleted by the user.  This may be
+        // used without ever invoking the print/print setup dialogs.
+        HDC CreatePrinterDC()
+        {
+                m_pdex.hDC = _AtlCreateDC(m_pdex.hDevNames, m_pdex.hDevMode);
+                return m_pdex.hDC;
+        }
+
+// Implementation - interfaces
+
+// IUnknown
+        STDMETHOD(QueryInterface)(REFIID riid, void** ppvObject)
+        {
+                if(ppvObject == NULL)
+                        return E_POINTER;
+
+                T* pT = static_cast<T*>(this);
+                if(IsEqualGUID(riid, IID_IUnknown) || IsEqualGUID(riid, IID_IPrintDialogCallback))
+                {
+                        *ppvObject = (IPrintDialogCallback*)pT;
+                        // AddRef() not needed
+                        return S_OK;
+                }
+                else if(IsEqualGUID(riid, IID_IObjectWithSite))
+                {
+                        *ppvObject = (IObjectWithSite*)pT;
+                        // AddRef() not needed
+                        return S_OK;
+                }
+
+                return E_NOINTERFACE;
+        }
+
+        virtual ULONG STDMETHODCALLTYPE AddRef()
+        {
+                return 1;
+        }
+
+        virtual ULONG STDMETHODCALLTYPE Release()
+        {
+                return 1;
+        }
+
+// IPrintDialogCallback
+        STDMETHOD(InitDone)()
+        {
+                return S_FALSE;
+        }
+
+        STDMETHOD(SelectionChange)()
+        {
+                return S_FALSE;
+        }
+
+        STDMETHOD(HandleMessage)(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LRESULT* plResult)
+        {
+                // set up m_hWnd the first time
+                if(m_hWnd == NULL)
+                        Attach(hWnd);
+
+                // call message map
+                HRESULT hRet = ProcessWindowMessage(hWnd, uMsg, wParam, lParam, *plResult, 0) ? S_OK : S_FALSE;
+                if(hRet == S_OK && uMsg == WM_NOTIFY)   // return in DWLP_MSGRESULT
+                        ::SetWindowLongPtr(GetParent(), DWLP_MSGRESULT, (LONG_PTR)*plResult);
+
+                if(uMsg == WM_INITDIALOG && hRet == S_OK && (BOOL)*plResult != FALSE)
+                        hRet = S_FALSE;
+
+                return hRet;
+        }
+};
+
+class CPrintDialogEx : public CPrintDialogExImpl<CPrintDialogEx>
+{
+public:
+        CPrintDialogEx(
+                DWORD dwFlags = PD_ALLPAGES | PD_USEDEVMODECOPIES | PD_NOPAGENUMS | PD_NOSELECTION | PD_NOCURRENTPAGE,
+                HWND hWndParent = NULL)
+                : CPrintDialogExImpl<CPrintDialogEx>(dwFlags, hWndParent)
+        { }
+
+        DECLARE_EMPTY_MSG_MAP()
+};
+
+#endif // (WINVER >= 0x0500) && !defined(_WIN32_WCE)
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CPageSetupDialogImpl - Page Setup dialog
+
+#ifndef _WIN32_WCE
+
+template <class T>
+class ATL_NO_VTABLE CPageSetupDialogImpl : public CCommonDialogImplBase
+{
+public:
+        PAGESETUPDLG m_psd;
+        ATL::CWndProcThunk m_thunkPaint;
+
+// Constructors
+        CPageSetupDialogImpl(DWORD dwFlags = PSD_MARGINS | PSD_INWININIINTLMEASURE, HWND hWndParent = NULL)
+        {
+                memset(&m_psd, 0, sizeof(m_psd));
+
+                m_psd.lStructSize = sizeof(m_psd);
+                m_psd.hwndOwner = hWndParent;
+                m_psd.Flags = (dwFlags | PSD_ENABLEPAGESETUPHOOK | PSD_ENABLEPAGEPAINTHOOK);
+                m_psd.lpfnPageSetupHook = (LPPAGESETUPHOOK)T::HookProc;
+                m_thunkPaint.Init((WNDPROC)T::PaintHookProc, this);
+#if (_ATL_VER >= 0x0700)
+                m_psd.lpfnPagePaintHook = (LPPAGEPAINTHOOK)m_thunkPaint.GetWNDPROC();
+#else
+                m_psd.lpfnPagePaintHook = (LPPAGEPAINTHOOK)&(m_thunkPaint.thunk);
+#endif
+        }
+
+        DECLARE_EMPTY_MSG_MAP()
+
+// Attributes
+        LPDEVMODE GetDevMode() const    // return DEVMODE
+        {
+                if(m_psd.hDevMode == NULL)
+                        return NULL;
+
+                return (LPDEVMODE)::GlobalLock(m_psd.hDevMode);
+        }
+
+        LPCTSTR GetDriverName() const   // return driver name
+        {
+                if(m_psd.hDevNames == NULL)
+                        return NULL;
+
+                LPDEVNAMES lpDev = (LPDEVNAMES)::GlobalLock(m_psd.hDevNames);
+                return (LPCTSTR)lpDev + lpDev->wDriverOffset;
+        }
+
+        LPCTSTR GetDeviceName() const   // return device name
+        {
+                if(m_psd.hDevNames == NULL)
+                        return NULL;
+
+                LPDEVNAMES lpDev = (LPDEVNAMES)::GlobalLock(m_psd.hDevNames);
+                return (LPCTSTR)lpDev + lpDev->wDeviceOffset;
+        }
+
+        LPCTSTR GetPortName() const     // return output port name
+        {
+                if(m_psd.hDevNames == NULL)
+                        return NULL;
+
+                LPDEVNAMES lpDev = (LPDEVNAMES)::GlobalLock(m_psd.hDevNames);
+                return (LPCTSTR)lpDev + lpDev->wOutputOffset;
+        }
+
+        HDC CreatePrinterDC()
+        {
+                return _AtlCreateDC(m_psd.hDevNames, m_psd.hDevMode);
+        }
+
+        SIZE GetPaperSize() const
+        {
+                SIZE size;
+                size.cx = m_psd.ptPaperSize.x;
+                size.cy = m_psd.ptPaperSize.y;
+                return size;
+        }
+
+        void GetMargins(LPRECT lpRectMargins, LPRECT lpRectMinMargins) const
+        {
+                if(lpRectMargins != NULL)
+                        *lpRectMargins = m_psd.rtMargin;
+                if(lpRectMinMargins != NULL)
+                        *lpRectMinMargins = m_psd.rtMinMargin;
+        }
+
+// Operations
+        INT_PTR DoModal(HWND hWndParent = ::GetActiveWindow())
+        {
+                ATLASSERT((m_psd.Flags & PSD_ENABLEPAGESETUPHOOK) != 0);
+                ATLASSERT((m_psd.Flags & PSD_ENABLEPAGEPAINTHOOK) != 0);
+                ATLASSERT(m_psd.lpfnPageSetupHook != NULL);   // can still be a user hook
+                ATLASSERT(m_psd.lpfnPagePaintHook != NULL);   // can still be a user hook
+
+                if(m_psd.hwndOwner == NULL)   // set only if not specified before
+                        m_psd.hwndOwner = hWndParent;
+
+                ATLASSERT(m_hWnd == NULL);
+                ModuleHelper::AddCreateWndData(&m_thunk.cd, (CCommonDialogImplBase*)this);
+
+                BOOL bRet = ::PageSetupDlg(&m_psd);
+
+                m_hWnd = NULL;
+
+                return bRet ? IDOK : IDCANCEL;
+        }
+
+// Implementation
+        static UINT_PTR CALLBACK PaintHookProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+        {
+                T* pT = (T*)hWnd;
+                UINT_PTR uRet = 0;
+                switch(uMsg)
+                {
+                case WM_PSD_PAGESETUPDLG:
+                        uRet = pT->PreDrawPage(LOWORD(wParam), HIWORD(wParam), (LPPAGESETUPDLG)lParam);
+                        break;
+                case WM_PSD_FULLPAGERECT:
+                case WM_PSD_MINMARGINRECT:
+                case WM_PSD_MARGINRECT:
+                case WM_PSD_GREEKTEXTRECT:
+                case WM_PSD_ENVSTAMPRECT:
+                case WM_PSD_YAFULLPAGERECT:
+                        uRet = pT->OnDrawPage(uMsg, (HDC)wParam, (LPRECT)lParam);
+                        break;
+                default:
+                        ATLTRACE2(atlTraceUI, 0, _T("CPageSetupDialogImpl::PaintHookProc - unknown message received\n"));
+                        break;
+                }
+                return uRet;
+        }
+
+// Overridables
+        UINT_PTR PreDrawPage(WORD /*wPaper*/, WORD /*wFlags*/, LPPAGESETUPDLG /*pPSD*/)
+        {
+                // return 1 to prevent any more drawing
+                return 0;
+        }
+
+        UINT_PTR OnDrawPage(UINT /*uMsg*/, HDC /*hDC*/, LPRECT /*lpRect*/)
+        {
+                return 0; // do the default
+        }
+};
+
+class CPageSetupDialog : public CPageSetupDialogImpl<CPageSetupDialog>
+{
+public:
+        CPageSetupDialog(DWORD dwFlags = PSD_MARGINS | PSD_INWININIINTLMEASURE, HWND hWndParent = NULL)
+                : CPageSetupDialogImpl<CPageSetupDialog>(dwFlags, hWndParent)
+        { }
+
+        // override PaintHookProc and references to handlers
+        static UINT_PTR CALLBACK PaintHookProc(HWND, UINT, WPARAM, LPARAM)
+        {
+                return 0;
+        }
+};
+
+#endif // _WIN32_WCE
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CFindReplaceDialogImpl - Find/FindReplace modeless dialogs
+
+#ifndef _WIN32_WCE
+
+template <class T>
+class ATL_NO_VTABLE CFindReplaceDialogImpl : public CCommonDialogImplBase
+{
+public:
+        enum { _cchFindReplaceBuffer = 128 };
+
+        FINDREPLACE m_fr;
+        TCHAR m_szFindWhat[_cchFindReplaceBuffer];
+        TCHAR m_szReplaceWith[_cchFindReplaceBuffer];
+
+// Constructors
+        CFindReplaceDialogImpl()
+        {
+                memset(&m_fr, 0, sizeof(m_fr));
+                m_szFindWhat[0] = _T('\0');
+                m_szReplaceWith[0] = _T('\0');
+
+                m_fr.lStructSize = sizeof(m_fr);
+                m_fr.Flags = FR_ENABLEHOOK;
+                m_fr.lpfnHook = (LPFRHOOKPROC)T::HookProc;
+                m_fr.lpstrFindWhat = (LPTSTR)m_szFindWhat;
+                m_fr.wFindWhatLen = _cchFindReplaceBuffer;
+                m_fr.lpstrReplaceWith = (LPTSTR)m_szReplaceWith;
+                m_fr.wReplaceWithLen = _cchFindReplaceBuffer;
+        }
+
+        // Note: You must allocate the object on the heap.
+        //       If you do not, you must override OnFinalMessage()
+        virtual void OnFinalMessage(HWND /*hWnd*/)
+        {
+                delete this;
+        }
+
+        HWND Create(BOOL bFindDialogOnly, // TRUE for Find, FALSE for FindReplace
+                        LPCTSTR lpszFindWhat,
+                        LPCTSTR lpszReplaceWith = NULL,
+                        DWORD dwFlags = FR_DOWN,
+                        HWND hWndParent = NULL)
+        {
+                ATLASSERT((m_fr.Flags & FR_ENABLEHOOK) != 0);
+                ATLASSERT(m_fr.lpfnHook != NULL);
+
+                m_fr.Flags |= dwFlags;
+
+                if(hWndParent == NULL)
+                        m_fr.hwndOwner = ::GetActiveWindow();
+                else
+                        m_fr.hwndOwner = hWndParent;
+                ATLASSERT(m_fr.hwndOwner != NULL); // must have an owner for modeless dialog
+
+                if(lpszFindWhat != NULL)
+                        SecureHelper::strncpy_x(m_szFindWhat, _countof(m_szFindWhat), lpszFindWhat, _TRUNCATE);
+
+                if(lpszReplaceWith != NULL)
+                        SecureHelper::strncpy_x(m_szReplaceWith, _countof(m_szReplaceWith), lpszReplaceWith, _TRUNCATE);
+
+                ATLASSERT(m_hWnd == NULL);
+                ModuleHelper::AddCreateWndData(&m_thunk.cd, (CCommonDialogImplBase*)this);
+
+                HWND hWnd = NULL;
+                if(bFindDialogOnly)
+                        hWnd = ::FindText(&m_fr);
+                else
+                        hWnd = ::ReplaceText(&m_fr);
+
+                ATLASSERT(m_hWnd == hWnd);
+                return hWnd;
+        }
+
+        static const UINT GetFindReplaceMsg()
+        {
+                static const UINT nMsgFindReplace = ::RegisterWindowMessage(FINDMSGSTRING);
+                return nMsgFindReplace;
+        }
+        // call while handling FINDMSGSTRING registered message
+        // to retreive the object
+        static T* PASCAL GetNotifier(LPARAM lParam)
+        {
+                ATLASSERT(lParam != NULL);
+                T* pDlg = (T*)(lParam - offsetof(T, m_fr));
+                return pDlg;
+        }
+
+// Operations
+        // Helpers for parsing information after successful return
+        LPCTSTR GetFindString() const    // get find string
+        {
+                return (LPCTSTR)m_fr.lpstrFindWhat;
+        }
+
+        LPCTSTR GetReplaceString() const // get replacement string
+        {
+                return (LPCTSTR)m_fr.lpstrReplaceWith;
+        }
+
+        BOOL SearchDown() const          // TRUE if search down, FALSE is up
+        {
+                return ((m_fr.Flags & FR_DOWN) != 0) ? TRUE : FALSE;
+        }
+
+        BOOL FindNext() const            // TRUE if command is find next
+        {
+                return ((m_fr.Flags & FR_FINDNEXT) != 0) ? TRUE : FALSE;
+        }
+
+        BOOL MatchCase() const           // TRUE if matching case
+        {
+                return ((m_fr.Flags & FR_MATCHCASE) != 0) ? TRUE : FALSE;
+        }
+
+        BOOL MatchWholeWord() const      // TRUE if matching whole words only
+        {
+                return ((m_fr.Flags & FR_WHOLEWORD) != 0) ? TRUE : FALSE;
+        }
+
+        BOOL ReplaceCurrent() const      // TRUE if replacing current string
+        {
+                return ((m_fr. Flags & FR_REPLACE) != 0) ? TRUE : FALSE;
+        }
+
+        BOOL ReplaceAll() const          // TRUE if replacing all occurrences
+        {
+                return ((m_fr.Flags & FR_REPLACEALL) != 0) ? TRUE : FALSE;
+        }
+
+        BOOL IsTerminating() const       // TRUE if terminating dialog
+        {
+                return ((m_fr.Flags & FR_DIALOGTERM) != 0) ? TRUE : FALSE ;
+        }
+};
+
+class CFindReplaceDialog : public CFindReplaceDialogImpl<CFindReplaceDialog>
+{
+public:
+        DECLARE_EMPTY_MSG_MAP()
+};
+
+#endif // !_WIN32_WCE
+
+
+#if (_ATL_VER >= 0x800)
+typedef ATL::_DialogSplitHelper::DLGTEMPLATEEX DLGTEMPLATEEX;
+typedef ATL::_DialogSplitHelper::DLGITEMTEMPLATEEX DLGITEMTEMPLATEEX;
+#else // (_ATL_VER >= 0x800)
+typedef ATL::_DialogSizeHelper::_ATL_DLGTEMPLATEEX DLGTEMPLATEEX;
+#pragma pack(push, 4)
+struct DLGITEMTEMPLATEEX
+{
+        DWORD helpID;
+        DWORD exStyle;
+        DWORD style;
+        short x;
+        short y;
+        short cx;
+        short cy;
+        WORD id;
+};
+#pragma pack(pop)
+#endif // (_ATL_VER >= 0x800)
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CMemDlgTemplate - in-memory dialog template - DLGTEMPLATE or DLGTEMPLATEEX
+
+class CMemDlgTemplate
+{
+public:
+        enum StdCtrlType
+        {
+                CTRL_BUTTON    = 0x0080,
+                CTRL_EDIT      = 0x0081,
+                CTRL_STATIC    = 0x0082,
+                CTRL_LISTBOX   = 0x0083,
+                CTRL_SCROLLBAR = 0x0084,
+                CTRL_COMBOBOX  = 0x0085
+        };
+
+        CMemDlgTemplate() : m_pData(NULL), m_pPtr(NULL), m_cAllocated(0)
+        { }
+
+        ~CMemDlgTemplate()
+        {
+                Reset();
+        }
+
+        bool IsValid() const
+        {
+                return (m_pData != NULL);
+        }
+
+        bool IsTemplateEx() const
+        {
+                return (IsValid() && ((DLGTEMPLATEEX*)m_pData)->signature == 0xFFFF);
+        }
+
+        LPDLGTEMPLATE GetTemplatePtr()
+        {
+                return reinterpret_cast<LPDLGTEMPLATE>(m_pData);
+        }
+
+        DLGTEMPLATEEX* GetTemplateExPtr()
+        {
+                return reinterpret_cast<DLGTEMPLATEEX*>(m_pData);
+        }
+
+        void Reset()
+        {
+                if (IsValid())
+                        ATLVERIFY(::GlobalFree(m_pData) == NULL);
+
+                m_pData = NULL;
+                m_pPtr = NULL;
+                m_cAllocated = 0;
+        }
+
+        void Create(bool bDlgEx, LPCTSTR lpszCaption, short nX, short nY, short nWidth, short nHeight, DWORD dwStyle = 0, DWORD dwExStyle = 0, 
+                    LPCTSTR lpstrFontName = NULL, WORD wFontSize = 0, WORD wWeight = 0, BYTE bItalic = 0, BYTE bCharset = 0, DWORD dwHelpID = 0,
+                                ATL::_U_STRINGorID ClassName = 0U, ATL::_U_STRINGorID Menu = 0U)
+        {
+                // Should have DS_SETFONT style to set the dialog font name and size
+                if (lpstrFontName != NULL)
+                {
+                        dwStyle |= DS_SETFONT;
+                }
+                else
+                {
+                        dwStyle &= ~DS_SETFONT;
+                }
+
+                if (bDlgEx)
+                {
+                        DLGTEMPLATEEX dlg = {1, 0xFFFF, dwHelpID, dwExStyle, dwStyle, 0, nX, nY, nWidth, nHeight};
+                        AddData(&dlg, sizeof(dlg));
+                }
+                else
+                {
+                        DLGTEMPLATE dlg = {dwStyle, dwExStyle, 0, nX, nY, nWidth, nHeight};
+                        AddData(&dlg, sizeof(dlg));
+                }
+
+#ifndef _WIN32_WCE
+                if (Menu.m_lpstr == NULL)
+                {
+                        WORD menuData = 0;
+                        AddData(&menuData, sizeof(WORD));
+                }
+                else if (IS_INTRESOURCE(Menu.m_lpstr))
+                {
+                        WORD menuData[] = {0xFFFF, (WORD)Menu.m_lpstr};
+                        AddData(menuData, sizeof(menuData));
+                }
+                else
+                {
+                        AddString(Menu.m_lpstr);
+                }
+#else // _WIN32_WCE
+                // Windows CE doesn't support the addition of menus to a dialog box
+                ATLASSERT(Menu.m_lpstr == NULL);
+                Menu.m_lpstr;   // avoid level 4 warning
+                WORD menuData = 0;
+                AddData(&menuData, sizeof(WORD));
+#endif // _WIN32_WCE
+
+                if (ClassName.m_lpstr == NULL)
+                {
+                        WORD classData = 0;
+                        AddData(&classData, sizeof(WORD));
+                }
+                else if (IS_INTRESOURCE(ClassName.m_lpstr))
+                {
+                        WORD classData[] = {0xFFFF, (WORD)ClassName.m_lpstr};
+                        AddData(classData, sizeof(classData));
+                }
+                else
+                {
+                        AddString(ClassName.m_lpstr);
+                }
+
+                // Set dialog caption
+                AddString(lpszCaption);
+
+                if (lpstrFontName != NULL)
+                {
+                        AddData(&wFontSize, sizeof(wFontSize));
+
+                        if (bDlgEx)
+                        {
+                                AddData(&wWeight, sizeof(wWeight));
+                                AddData(&bItalic, sizeof(bItalic));
+                                AddData(&bCharset, sizeof(bCharset));
+                        }
+
+                        AddString(lpstrFontName);
+                }
+        }
+
+        void AddControl(ATL::_U_STRINGorID ClassName, WORD wId, short nX, short nY, short nWidth, short nHeight, DWORD dwStyle, DWORD dwExStyle,
+                        ATL::_U_STRINGorID Text, const WORD* pCreationData = NULL, WORD nCreationData = 0, DWORD dwHelpID = 0)
+        {
+                ATLASSERT(IsValid());
+
+                // DWORD align data
+                m_pPtr = (LPBYTE)(DWORD_PTR)((DWORD)(DWORD_PTR)(m_pPtr + 3) & (~3));
+
+                if (IsTemplateEx())
+                {
+                        DLGTEMPLATEEX* dlg = (DLGTEMPLATEEX*)m_pData;
+                        dlg->cDlgItems++;
+
+                        DLGITEMTEMPLATEEX item = {dwHelpID, ATL::CControlWinTraits::GetWndExStyle(0) | dwExStyle, ATL::CControlWinTraits::GetWndStyle(0) | dwStyle, nX, nY, nWidth, nHeight, wId};
+                        AddData(&item, sizeof(item));
+                }
+                else
+                {
+                        LPDLGTEMPLATE dlg = (LPDLGTEMPLATE)m_pData;
+                        dlg->cdit++;
+
+                        DLGITEMTEMPLATE item = {ATL::CControlWinTraits::GetWndStyle(0) | dwStyle, ATL::CControlWinTraits::GetWndExStyle(0) | dwExStyle, nX, nY, nWidth, nHeight, wId};
+                        AddData(&item, sizeof(item));
+                }
+
+                ATLASSERT(ClassName.m_lpstr != NULL);
+                if (IS_INTRESOURCE(ClassName.m_lpstr))
+                {
+                        WORD wData[] = {0xFFFF, (WORD)ClassName.m_lpstr};
+                        AddData(wData, sizeof(wData));
+                }
+                else
+                {
+                        AddString(ClassName.m_lpstr);
+                }
+
+                if (Text.m_lpstr == NULL)
+                {
+                        WORD classData = 0;
+                        AddData(&classData, sizeof(WORD));
+                }
+                else if (IS_INTRESOURCE(Text.m_lpstr))
+                {
+                        WORD wData[] = {0xFFFF, (WORD)Text.m_lpstr};
+                        AddData(wData, sizeof(wData));
+                }
+                else
+                {
+                        AddString(Text.m_lpstr);
+                }
+
+                AddData(&nCreationData, sizeof(nCreationData));
+
+                if ((nCreationData != 0))
+                {
+                        ATLASSERT(pCreationData != NULL);
+                        AddData(pCreationData, nCreationData * sizeof(WORD));
+                }
+        }
+
+        void AddStdControl(StdCtrlType CtrlType, WORD wId, short nX, short nY, short nWidth, short nHeight,
+                           DWORD dwStyle, DWORD dwExStyle, ATL::_U_STRINGorID Text, const WORD* pCreationData = NULL, WORD nCreationData = 0, DWORD dwHelpID = 0)
+        {
+                AddControl(CtrlType, wId, nX, nY, nWidth, nHeight, dwStyle, dwExStyle, Text, pCreationData, nCreationData, dwHelpID);
+        }
+
+protected:
+        void AddData(LPCVOID pData, size_t nData)
+        {
+                ATLASSERT(pData != NULL);
+
+                const size_t ALLOCATION_INCREMENT = 1024;
+
+                if (m_pData == NULL)
+                {
+                        m_cAllocated = ((nData / ALLOCATION_INCREMENT) + 1) * ALLOCATION_INCREMENT;
+                        m_pPtr = m_pData = static_cast<LPBYTE>(::GlobalAlloc(GPTR, m_cAllocated));
+                        ATLASSERT(m_pData != NULL);
+                }
+                else if (((m_pPtr - m_pData) + nData) > m_cAllocated)
+                {
+                        size_t ptrPos = (m_pPtr - m_pData);
+                        m_cAllocated += ((nData / ALLOCATION_INCREMENT) + 1) * ALLOCATION_INCREMENT;
+                        m_pData = static_cast<LPBYTE>(::GlobalReAlloc(m_pData, m_cAllocated, 0));
+                        ATLASSERT(m_pData != NULL);
+                        m_pPtr = m_pData + ptrPos;
+                }
+
+                SecureHelper::memcpy_x(m_pPtr, m_cAllocated - (m_pPtr - m_pData), pData, nData);
+
+                m_pPtr += nData;
+        }
+
+        void AddString(LPCTSTR lpszStr)
+        {
+                if (lpszStr == NULL)
+                {
+                        WCHAR szEmpty = 0;
+                        AddData(&szEmpty, sizeof(szEmpty));
+                }
+                else
+                {
+                        USES_CONVERSION;
+                        LPCWSTR lpstr = T2CW(lpszStr);
+                        int nSize = lstrlenW(lpstr) + 1;
+                        AddData(lpstr, nSize * sizeof(WCHAR));
+                }
+        }
+
+        LPBYTE m_pData;
+        LPBYTE m_pPtr;
+        SIZE_T m_cAllocated;
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Dialog and control macros for indirect dialogs
+
+// for DLGTEMPLATE
+#define BEGIN_DIALOG(x, y, width, height) \
+        void DoInitTemplate() \
+        { \
+                bool bExTemplate = false; \
+                short nX = x, nY = y, nWidth = width, nHeight = height; \
+                LPCTSTR szCaption = NULL; \
+                DWORD dwStyle = WS_POPUP | WS_BORDER | WS_SYSMENU; \
+                DWORD dwExStyle = 0; \
+                LPCTSTR szFontName = NULL; \
+                WORD wFontSize = 0; \
+                WORD wWeight = 0; \
+                BYTE bItalic = 0; \
+                BYTE bCharset = 0; \
+                DWORD dwHelpID = 0; \
+                ATL::_U_STRINGorID Menu = 0U; \
+                ATL::_U_STRINGorID ClassName = 0U;
+
+// for DLGTEMPLATEEX
+#define BEGIN_DIALOG_EX(x, y, width, height, helpID) \
+        void DoInitTemplate() \
+        { \
+                bool bExTemplate = true; \
+                short nX = x, nY = y, nWidth = width, nHeight = height; \
+                LPCTSTR szCaption = NULL; \
+                DWORD dwStyle = WS_POPUP | WS_BORDER | WS_SYSMENU; \
+                DWORD dwExStyle = 0; \
+                LPCTSTR szFontName = NULL; \
+                WORD wFontSize = 0; \
+                WORD wWeight = 0; \
+                BYTE bItalic = 0; \
+                BYTE bCharset = 0; \
+                DWORD dwHelpID = helpID; \
+                ATL::_U_STRINGorID Menu = 0U; \
+                ATL::_U_STRINGorID ClassName = 0U;
+
+#define END_DIALOG() \
+                m_Template.Create(bExTemplate, szCaption, nX, nY, nWidth, nHeight, dwStyle, dwExStyle, szFontName, wFontSize, wWeight, bItalic, bCharset, dwHelpID, ClassName, Menu); \
+        };
+
+#define DIALOG_CAPTION(caption) \
+                szCaption = caption;
+#define DIALOG_STYLE(style) \
+                dwStyle = style;
+#define DIALOG_EXSTYLE(exStyle) \
+                dwExStyle = exStyle;
+#define DIALOG_FONT(pointSize, typeFace) \
+                wFontSize = pointSize; \
+                szFontName = typeFace;
+#define DIALOG_FONT_EX(pointsize, typeface, weight, italic, charset) \
+                ATLASSERT(bExTemplate); \
+                wFontSize = pointsize; \
+                szFontName = typeface; \
+                wWeight = weight; \
+                bItalic = italic; \
+                bCharset = charset;
+#define DIALOG_MENU(menuName) \
+                Menu = menuName;
+#define DIALOG_CLASS(className) \
+                ClassName = className;
+
+#define BEGIN_CONTROLS_MAP() \
+        void DoInitControls() \
+        {
+
+#define END_CONTROLS_MAP() \
+        };
+
+
+#define CONTROL_LTEXT(text, id, x, y, width, height, style, exStyle) \
+        m_Template.AddStdControl(WTL::CMemDlgTemplate::CTRL_STATIC, (WORD)id, x, y, width, height, style | SS_LEFT | WS_GROUP, exStyle, text, NULL, 0);
+#define CONTROL_CTEXT(text, id, x, y, width, height, style, exStyle) \
+        m_Template.AddStdControl(WTL::CMemDlgTemplate::CTRL_STATIC, (WORD)id, x, y, width, height, style | SS_CENTER | WS_GROUP, exStyle, text, NULL, 0);
+#define CONTROL_RTEXT(text, id, x, y, width, height, style, exStyle) \
+        m_Template.AddStdControl(WTL::CMemDlgTemplate::CTRL_STATIC, (WORD)id, x, y, width, height, style | SS_RIGHT | WS_GROUP, exStyle, text, NULL, 0);
+#define CONTROL_PUSHBUTTON(text, id, x, y, width, height, style, exStyle) \
+        m_Template.AddStdControl(WTL::CMemDlgTemplate::CTRL_BUTTON, (WORD)id, x, y, width, height, style | BS_PUSHBUTTON | WS_TABSTOP, exStyle, text, NULL, 0);
+#define CONTROL_DEFPUSHBUTTON(text, id, x, y, width, height, style, exStyle) \
+        m_Template.AddStdControl(WTL::CMemDlgTemplate::CTRL_BUTTON, (WORD)id, x, y, width, height, style | BS_DEFPUSHBUTTON | WS_TABSTOP, exStyle, text, NULL, 0);
+#ifndef _WIN32_WCE
+#define CONTROL_PUSHBOX(text, id, x, y, width, height, style, exStyle) \
+        m_Template.AddStdControl(WTL::CMemDlgTemplate::CTRL_BUTTON, (WORD)id, x, y, width, height, style | BS_PUSHBOX | WS_TABSTOP, exStyle, text, NULL, 0);
+#endif // !_WIN32_WCE
+#define CONTROL_STATE3(text, id, x, y, width, height, style, exStyle) \
+        m_Template.AddStdControl(WTL::CMemDlgTemplate::CTRL_BUTTON, (WORD)id, x, y, width, height, style | BS_3STATE | WS_TABSTOP, exStyle, text, NULL, 0);
+#define CONTROL_AUTO3STATE(text, id, x, y, width, height, style, exStyle) \
+        m_Template.AddStdControl(WTL::CMemDlgTemplate::CTRL_BUTTON, (WORD)id, x, y, width, height, style | BS_AUTO3STATE | WS_TABSTOP, exStyle, text, NULL, 0);
+#define CONTROL_CHECKBOX(text, id, x, y, width, height, style, exStyle) \
+        m_Template.AddStdControl(WTL::CMemDlgTemplate::CTRL_BUTTON, (WORD)id, x, y, width, height, style | BS_CHECKBOX | WS_TABSTOP, exStyle, text, NULL, 0);
+#define CONTROL_AUTOCHECKBOX(text, id, x, y, width, height, style, exStyle) \
+        m_Template.AddStdControl(WTL::CMemDlgTemplate::CTRL_BUTTON, (WORD)id, x, y, width, height, style | BS_AUTOCHECKBOX | WS_TABSTOP, exStyle, text, NULL, 0);
+#define CONTROL_RADIOBUTTON(text, id, x, y, width, height, style, exStyle) \
+        m_Template.AddStdControl(WTL::CMemDlgTemplate::CTRL_BUTTON, (WORD)id, x, y, width, height, style | BS_RADIOBUTTON | WS_TABSTOP, exStyle, text, NULL, 0);
+#define CONTROL_AUTORADIOBUTTON(text, id, x, y, width, height, style, exStyle) \
+        m_Template.AddStdControl(WTL::CMemDlgTemplate::CTRL_BUTTON, (WORD)id, x, y, width, height, style | BS_AUTORADIOBUTTON | WS_TABSTOP, exStyle, text, NULL, 0);
+#define CONTROL_COMBOBOX(id, x, y, width, height, style, exStyle) \
+        m_Template.AddStdControl(WTL::CMemDlgTemplate::CTRL_COMBOBOX, (WORD)id, x, y, width, height, style | CBS_DROPDOWN | WS_TABSTOP, exStyle, (LPCTSTR)NULL, NULL, 0);
+#define CONTROL_EDITTEXT(id, x, y, width, height, style, exStyle) \
+        m_Template.AddStdControl(WTL::CMemDlgTemplate::CTRL_EDIT, (WORD)id, x, y, width, height, style | ES_LEFT | WS_BORDER | WS_TABSTOP, exStyle, (LPCTSTR)NULL, NULL, 0);
+#define CONTROL_GROUPBOX(text, id, x, y, width, height, style, exStyle) \
+        m_Template.AddStdControl(WTL::CMemDlgTemplate::CTRL_BUTTON, (WORD)id, x, y, width, height, style | BS_GROUPBOX, exStyle, text, NULL, 0);
+#define CONTROL_LISTBOX(id, x, y, width, height, style, exStyle) \
+        m_Template.AddStdControl(WTL::CMemDlgTemplate::CTRL_LISTBOX, (WORD)id, x, y, width, height, style | LBS_NOTIFY | WS_BORDER, exStyle, (LPCTSTR)NULL, NULL, 0);
+#define CONTROL_SCROLLBAR(id, x, y, width, height, style, exStyle) \
+        m_Template.AddStdControl(WTL::CMemDlgTemplate::CTRL_SCROLLBAR, (WORD)id, x, y, width, height, style | SBS_HORZ, exStyle, (LPCTSTR)NULL, NULL, 0);
+#define CONTROL_ICON(text, id, x, y, width, height, style, exStyle) \
+        m_Template.AddStdControl(WTL::CMemDlgTemplate::CTRL_STATIC, (WORD)id, x, y, width, height, style | SS_ICON, exStyle, text, NULL, 0);
+#define CONTROL_CONTROL(text, id, className, style, x, y, width, height, exStyle) \
+        m_Template.AddControl(className, (WORD)id, x, y, width, height, style, exStyle, text, NULL, 0);
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CIndirectDialogImpl - dialogs with template in memory
+
+template <class T, class TDlgTemplate = CMemDlgTemplate, class TBase = ATL::CDialogImpl<T, ATL::CWindow> >
+class ATL_NO_VTABLE CIndirectDialogImpl : public TBase
+{
+public:
+        enum { IDD = 0 };   // no dialog template resource
+
+        TDlgTemplate m_Template;
+
+        void CreateTemplate()
+        {
+                T* pT = static_cast<T*>(this);
+                pT->DoInitTemplate();
+                pT->DoInitControls();
+        }
+
+        INT_PTR DoModal(HWND hWndParent = ::GetActiveWindow(), LPARAM dwInitParam = NULL)
+        {
+                T* pT = static_cast<T*>(this);
+                ATLASSERT(pT->m_hWnd == NULL);
+
+                if (!m_Template.IsValid())
+                        CreateTemplate();
+
+#if (_ATL_VER >= 0x0800)
+                // Allocate the thunk structure here, where we can fail gracefully.
+                BOOL result = m_thunk.Init(NULL, NULL);
+                if (result == FALSE)
+                {
+                        SetLastError(ERROR_OUTOFMEMORY);
+                        return -1;
+                }
+#endif // (_ATL_VER >= 0x0800)
+
+                ModuleHelper::AddCreateWndData(&m_thunk.cd, pT);
+
+#ifdef _DEBUG
+                m_bModal = true;
+#endif // _DEBUG
+
+                return ::DialogBoxIndirectParam(ModuleHelper::GetResourceInstance(), m_Template.GetTemplatePtr(), hWndParent, (DLGPROC)T::StartDialogProc, dwInitParam);
+        }
+
+        HWND Create(HWND hWndParent, LPARAM dwInitParam = NULL)
+        {
+                T* pT = static_cast<T*>(this);
+                ATLASSERT(pT->m_hWnd == NULL);
+
+                if (!m_Template.IsValid())
+                        CreateTemplate();
+
+#if (_ATL_VER >= 0x0800)
+                // Allocate the thunk structure here, where we can fail gracefully.
+                BOOL result = m_thunk.Init(NULL, NULL);
+                if (result == FALSE) 
+                {
+                        SetLastError(ERROR_OUTOFMEMORY);
+                        return NULL;
+                }
+#endif // (_ATL_VER >= 0x0800)
+
+                ModuleHelper::AddCreateWndData(&m_thunk.cd, pT);
+
+#ifdef _DEBUG
+                m_bModal = false;
+#endif // _DEBUG
+
+                HWND hWnd = ::CreateDialogIndirectParam(ModuleHelper::GetResourceInstance(), (LPCDLGTEMPLATE)m_Template.GetTemplatePtr(), hWndParent, (DLGPROC)T::StartDialogProc, dwInitParam);
+                ATLASSERT(m_hWnd == hWnd);
+
+                return hWnd;
+        }
+
+        // for CComControl
+        HWND Create(HWND hWndParent, RECT&, LPARAM dwInitParam = NULL)
+        {
+                return Create(hWndParent, dwInitParam);
+        }
+
+        void DoInitTemplate() 
+        {
+                ATLASSERT(FALSE);   // MUST be defined in derived class
+        }
+
+        void DoInitControls() 
+        {
+                ATLASSERT(FALSE);   // MUST be defined in derived class
+        }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// CPropertySheetWindow - client side for a property sheet
+
+class CPropertySheetWindow : public ATL::CWindow
+{
+public:
+// Constructors
+        CPropertySheetWindow(HWND hWnd = NULL) : ATL::CWindow(hWnd)
+        { }
+
+        CPropertySheetWindow& operator =(HWND hWnd)
+        {
+                m_hWnd = hWnd;
+                return *this;
+        }
+
+// Attributes
+        int GetPageCount() const
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                HWND hWndTabCtrl = GetTabControl();
+                ATLASSERT(hWndTabCtrl != NULL);
+                return (int)::SendMessage(hWndTabCtrl, TCM_GETITEMCOUNT, 0, 0L);
+        }
+
+        HWND GetActivePage() const
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                return (HWND)::SendMessage(m_hWnd, PSM_GETCURRENTPAGEHWND, 0, 0L);
+        }
+
+        int GetActiveIndex() const
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                HWND hWndTabCtrl = GetTabControl();
+                ATLASSERT(hWndTabCtrl != NULL);
+                return (int)::SendMessage(hWndTabCtrl, TCM_GETCURSEL, 0, 0L);
+        }
+
+        BOOL SetActivePage(int nPageIndex)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                return (BOOL)::SendMessage(m_hWnd, PSM_SETCURSEL, nPageIndex, 0L);
+        }
+
+        BOOL SetActivePage(HPROPSHEETPAGE hPage)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT(hPage != NULL);
+                return (BOOL)::SendMessage(m_hWnd, PSM_SETCURSEL, 0, (LPARAM)hPage);
+        }
+
+        BOOL SetActivePageByID(int nPageID)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                return (BOOL)::SendMessage(m_hWnd, PSM_SETCURSELID, 0, nPageID);
+        }
+
+        void SetTitle(LPCTSTR lpszText, UINT nStyle = 0)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT((nStyle & ~PSH_PROPTITLE) == 0); // only PSH_PROPTITLE is valid
+                ATLASSERT(lpszText != NULL);
+                ::SendMessage(m_hWnd, PSM_SETTITLE, nStyle, (LPARAM)lpszText);
+        }
+
+        HWND GetTabControl() const
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                return (HWND)::SendMessage(m_hWnd, PSM_GETTABCONTROL, 0, 0L);
+        }
+
+        void SetFinishText(LPCTSTR lpszText)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ::SendMessage(m_hWnd, PSM_SETFINISHTEXT, 0, (LPARAM)lpszText);
+        }
+
+        void SetWizardButtons(DWORD dwFlags)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ::PostMessage(m_hWnd, PSM_SETWIZBUTTONS, 0, dwFlags);
+        }
+
+// Operations
+        BOOL AddPage(HPROPSHEETPAGE hPage)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT(hPage != NULL);
+                return (BOOL)::SendMessage(m_hWnd, PSM_ADDPAGE, 0, (LPARAM)hPage);
+        }
+
+        BOOL AddPage(LPCPROPSHEETPAGE pPage)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT(pPage != NULL);
+                HPROPSHEETPAGE hPage = ::CreatePropertySheetPage(pPage);
+                if(hPage == NULL)
+                        return FALSE;
+                return (BOOL)::SendMessage(m_hWnd, PSM_ADDPAGE, 0, (LPARAM)hPage);
+        }
+
+#ifndef _WIN32_WCE
+        BOOL InsertPage(int nNewPageIndex, HPROPSHEETPAGE hPage)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT(hPage != NULL);
+                return (BOOL)::SendMessage(m_hWnd, PSM_INSERTPAGE, nNewPageIndex, (LPARAM)hPage);
+        }
+
+        BOOL InsertPage(int nNewPageIndex, LPCPROPSHEETPAGE pPage)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT(pPage != NULL);
+                HPROPSHEETPAGE hPage = ::CreatePropertySheetPage(pPage);
+                if(hPage == NULL)
+                        return FALSE;
+                return (BOOL)::SendMessage(m_hWnd, PSM_INSERTPAGE, nNewPageIndex, (LPARAM)hPage);
+        }
+
+        BOOL InsertPage(HPROPSHEETPAGE hPageInsertAfter, HPROPSHEETPAGE hPage)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT(hPage != NULL);
+                return (BOOL)::SendMessage(m_hWnd, PSM_INSERTPAGE, (WPARAM)hPageInsertAfter, (LPARAM)hPage);
+        }
+
+        BOOL InsertPage(HPROPSHEETPAGE hPageInsertAfter, LPCPROPSHEETPAGE pPage)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT(pPage != NULL);
+                HPROPSHEETPAGE hPage = ::CreatePropertySheetPage(pPage);
+                if(hPage == NULL)
+                        return FALSE;
+                return (BOOL)::SendMessage(m_hWnd, PSM_INSERTPAGE, (WPARAM)hPageInsertAfter, (LPARAM)hPage);
+        }
+#endif // !_WIN32_WCE
+
+        void RemovePage(int nPageIndex)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ::SendMessage(m_hWnd, PSM_REMOVEPAGE, nPageIndex, 0L);
+        }
+
+        void RemovePage(HPROPSHEETPAGE hPage)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT(hPage != NULL);
+                ::SendMessage(m_hWnd, PSM_REMOVEPAGE, 0, (LPARAM)hPage);
+        }
+
+        BOOL PressButton(int nButton)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                return (BOOL)::SendMessage(m_hWnd, PSM_PRESSBUTTON, nButton, 0L);
+        }
+
+        BOOL Apply()
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                return (BOOL)::SendMessage(m_hWnd, PSM_APPLY, 0, 0L);
+        }
+
+        void CancelToClose()
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ::SendMessage(m_hWnd, PSM_CANCELTOCLOSE, 0, 0L);
+        }
+
+        void SetModified(HWND hWndPage, BOOL bChanged = TRUE)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT(::IsWindow(hWndPage));
+                UINT uMsg = bChanged ? PSM_CHANGED : PSM_UNCHANGED;
+                ::SendMessage(m_hWnd, uMsg, (WPARAM)hWndPage, 0L);
+        }
+
+        LRESULT QuerySiblings(WPARAM wParam, LPARAM lParam)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                return ::SendMessage(m_hWnd, PSM_QUERYSIBLINGS, wParam, lParam);
+        }
+
+        void RebootSystem()
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ::SendMessage(m_hWnd, PSM_REBOOTSYSTEM, 0, 0L);
+        }
+
+        void RestartWindows()
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ::SendMessage(m_hWnd, PSM_RESTARTWINDOWS, 0, 0L);
+        }
+
+        BOOL IsDialogMessage(LPMSG lpMsg)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                return (BOOL)::SendMessage(m_hWnd, PSM_ISDIALOGMESSAGE, 0, (LPARAM)lpMsg);
+        }
+
+#if (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
+        int HwndToIndex(HWND hWnd) const
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                return (int)::SendMessage(m_hWnd, PSM_HWNDTOINDEX, (WPARAM)hWnd, 0L);
+        }
+
+        HWND IndexToHwnd(int nIndex) const
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                return (HWND)::SendMessage(m_hWnd, PSM_INDEXTOHWND, nIndex, 0L);
+        }
+
+        int PageToIndex(HPROPSHEETPAGE hPage) const
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                return (int)::SendMessage(m_hWnd, PSM_PAGETOINDEX, 0, (LPARAM)hPage);
+        }
+
+        HPROPSHEETPAGE IndexToPage(int nIndex) const
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                return (HPROPSHEETPAGE)::SendMessage(m_hWnd, PSM_INDEXTOPAGE, nIndex, 0L);
+        }
+
+        int IdToIndex(int nID) const
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                return (int)::SendMessage(m_hWnd, PSM_IDTOINDEX, 0, nID);
+        }
+
+        int IndexToId(int nIndex) const
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                return (int)::SendMessage(m_hWnd, PSM_INDEXTOID, nIndex, 0L);
+        }
+
+        int GetResult() const
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                return (int)::SendMessage(m_hWnd, PSM_GETRESULT, 0, 0L);
+        }
+
+        BOOL RecalcPageSizes()
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                return (BOOL)::SendMessage(m_hWnd, PSM_RECALCPAGESIZES, 0, 0L);
+        }
+
+        void SetHeaderTitle(int nIndex, LPCTSTR lpstrHeaderTitle)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ::SendMessage(m_hWnd, PSM_SETHEADERTITLE, nIndex, (LPARAM)lpstrHeaderTitle);
+        }
+
+        void SetHeaderSubTitle(int nIndex, LPCTSTR lpstrHeaderSubTitle)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ::SendMessage(m_hWnd, PSM_SETHEADERSUBTITLE, nIndex, (LPARAM)lpstrHeaderSubTitle);
+        }
+#endif // (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
+
+// Implementation - override to prevent usage
+        HWND Create(LPCTSTR, HWND, ATL::_U_RECT = NULL, LPCTSTR = NULL, DWORD = 0, DWORD = 0, ATL::_U_MENUorID = 0U, LPVOID = NULL)
+        {
+                ATLASSERT(FALSE);
+                return NULL;
+        }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// CPropertySheetImpl - implements a property sheet
+
+template <class T, class TBase = CPropertySheetWindow>
+class ATL_NO_VTABLE CPropertySheetImpl : public ATL::CWindowImplBaseT< TBase >
+{
+public:
+        PROPSHEETHEADER m_psh;
+        ATL::CSimpleArray<HPROPSHEETPAGE> m_arrPages;
+
+#if defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__) // PPC specific
+  #ifndef PROPSHEET_LINK_SIZE
+        #define PROPSHEET_LINK_SIZE 128
+  #endif // PROPSHEET_LINK_SIZE
+        TCHAR m_szLink[PROPSHEET_LINK_SIZE];
+        static LPCTSTR m_pszTitle;
+        static LPCTSTR m_pszLink;
+#endif // defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__) 
+
+// Construction/Destruction
+        CPropertySheetImpl(ATL::_U_STRINGorID title = (LPCTSTR)NULL, UINT uStartPage = 0, HWND hWndParent = NULL)
+        {
+                memset(&m_psh, 0, sizeof(PROPSHEETHEADER));
+                m_psh.dwSize = sizeof(PROPSHEETHEADER);
+                m_psh.dwFlags = PSH_USECALLBACK;
+                m_psh.hInstance = ModuleHelper::GetResourceInstance();
+                m_psh.phpage = NULL;   // will be set later
+                m_psh.nPages = 0;      // will be set later
+                m_psh.pszCaption = title.m_lpstr;
+                m_psh.nStartPage = uStartPage;
+                m_psh.hwndParent = hWndParent;   // if NULL, will be set in DoModal/Create
+                m_psh.pfnCallback = T::PropSheetCallback;
+
+#if defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__) // PPC specific 
+                m_psh.dwFlags |= PSH_MAXIMIZE;
+                m_szLink[0] = 0;
+#endif // defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__)
+        }
+
+        ~CPropertySheetImpl()
+        {
+                if(m_arrPages.GetSize() > 0)   // sheet never created, destroy all pages
+                {
+                        for(int i = 0; i < m_arrPages.GetSize(); i++)
+                                ::DestroyPropertySheetPage((HPROPSHEETPAGE)m_arrPages[i]);
+                }
+        }
+
+// Callback function and overrideables
+        static int CALLBACK PropSheetCallback(HWND hWnd, UINT uMsg, LPARAM lParam)
+        {
+                lParam;   // avoid level 4 warning
+                int nRet = 0;
+
+                if(uMsg == PSCB_INITIALIZED)
+                {
+                        ATLASSERT(hWnd != NULL);
+                        T* pT = (T*)ModuleHelper::ExtractCreateWndData();
+                        // subclass the sheet window
+                        pT->SubclassWindow(hWnd);
+                        // remove page handles array
+                        pT->_CleanUpPages();
+
+#if defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__) // PPC specific
+                        m_pszTitle = pT->m_psh.pszCaption;
+                        if(*pT->m_szLink != 0)
+                                m_pszLink = pT->m_szLink;
+#endif  // defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__) // PPC specific
+
+                        pT->OnSheetInitialized();
+                }
+#if defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__) // PPC specific uMsg
+                else
+                {
+                        switch(uMsg)
+                        {
+                        case PSCB_GETVERSION :
+                                nRet = COMCTL32_VERSION;
+                                break;
+                        case PSCB_GETTITLE :
+                                if(m_pszTitle != NULL)
+                                {
+                                        lstrcpy((LPTSTR)lParam, m_pszTitle);
+                                        m_pszTitle = NULL;
+                                }
+                                break;
+                        case PSCB_GETLINKTEXT:
+                                if(m_pszLink != NULL)
+                                {
+                                        lstrcpy((LPTSTR)lParam, m_pszLink);
+                                        m_pszLink = NULL;
+                                }
+                                break;
+                        default:
+                                break;
+                        }
+                }
+#endif // defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__) 
+
+                return nRet;
+        }
+
+        void OnSheetInitialized()
+        {
+        }
+
+// Create method
+        HWND Create(HWND hWndParent = NULL)
+        {
+                ATLASSERT(m_hWnd == NULL);
+
+                m_psh.dwFlags |= PSH_MODELESS;
+                if(m_psh.hwndParent == NULL)
+                        m_psh.hwndParent = hWndParent;
+                m_psh.phpage = (HPROPSHEETPAGE*)m_arrPages.GetData();
+                m_psh.nPages = m_arrPages.GetSize();
+
+                T* pT = static_cast<T*>(this);
+                ModuleHelper::AddCreateWndData(&pT->m_thunk.cd, pT);
+
+                HWND hWnd = (HWND)::PropertySheet(&m_psh);
+                _CleanUpPages();   // ensure clean-up, required if call failed
+
+                ATLASSERT(m_hWnd == hWnd);
+
+                return hWnd;
+        }
+
+        INT_PTR DoModal(HWND hWndParent = ::GetActiveWindow())
+        {
+                ATLASSERT(m_hWnd == NULL);
+
+                m_psh.dwFlags &= ~PSH_MODELESS;
+                if(m_psh.hwndParent == NULL)
+                        m_psh.hwndParent = hWndParent;
+                m_psh.phpage = (HPROPSHEETPAGE*)m_arrPages.GetData();
+                m_psh.nPages = m_arrPages.GetSize();
+
+                T* pT = static_cast<T*>(this);
+                ModuleHelper::AddCreateWndData(&pT->m_thunk.cd, pT);
+
+                INT_PTR nRet = ::PropertySheet(&m_psh);
+                _CleanUpPages();   // ensure clean-up, required if call failed
+
+                return nRet;
+        }
+
+        // implementation helper - clean up pages array
+        void _CleanUpPages()
+        {
+                m_psh.nPages = 0;
+                m_psh.phpage = NULL;
+                m_arrPages.RemoveAll();
+        }
+
+// Attributes (extended overrides of client class methods)
+// These now can be called before the sheet is created
+// Note: Calling these after the sheet is created gives unpredictable results
+        int GetPageCount() const
+        {
+                if(m_hWnd == NULL)   // not created yet
+                        return m_arrPages.GetSize();
+                return TBase::GetPageCount();
+        }
+
+        int GetActiveIndex() const
+        {
+                if(m_hWnd == NULL)   // not created yet
+                        return m_psh.nStartPage;
+                return TBase::GetActiveIndex();
+        }
+
+        HPROPSHEETPAGE GetPage(int nPageIndex) const
+        {
+                ATLASSERT(m_hWnd == NULL);   // can't do this after it's created
+                return (HPROPSHEETPAGE)m_arrPages[nPageIndex];
+        }
+
+        int GetPageIndex(HPROPSHEETPAGE hPage) const
+        {
+                ATLASSERT(m_hWnd == NULL);   // can't do this after it's created
+                return m_arrPages.Find((HPROPSHEETPAGE&)hPage);
+        }
+
+        BOOL SetActivePage(int nPageIndex)
+        {
+                if(m_hWnd == NULL)   // not created yet
+                {
+                        ATLASSERT(nPageIndex >= 0 && nPageIndex < m_arrPages.GetSize());
+                        m_psh.nStartPage = nPageIndex;
+                        return TRUE;
+                }
+                return TBase::SetActivePage(nPageIndex);
+        }
+
+        BOOL SetActivePage(HPROPSHEETPAGE hPage)
+        {
+                ATLASSERT(hPage != NULL);
+                if (m_hWnd == NULL)   // not created yet
+                {
+                        int nPageIndex = GetPageIndex(hPage);
+                        if(nPageIndex == -1)
+                                return FALSE;
+
+                        return SetActivePage(nPageIndex);
+                }
+                return TBase::SetActivePage(hPage);
+
+        }
+
+        void SetTitle(LPCTSTR lpszText, UINT nStyle = 0)
+        {
+                ATLASSERT((nStyle & ~PSH_PROPTITLE) == 0);   // only PSH_PROPTITLE is valid
+                ATLASSERT(lpszText != NULL);
+
+                if(m_hWnd == NULL)
+                {
+                        // set internal state
+                        m_psh.pszCaption = lpszText;   // must exist until sheet is created
+                        m_psh.dwFlags &= ~PSH_PROPTITLE;
+                        m_psh.dwFlags |= nStyle;
+                }
+                else
+                {
+                        // set external state
+                        TBase::SetTitle(lpszText, nStyle);
+                }
+        }
+
+#if defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__) // PPC specific Link field 
+        void SetLinkText(LPCTSTR lpszText)
+        {
+                ATLASSERT(lpszText != NULL);
+                ATLASSERT(lstrlen(lpszText) < PROPSHEET_LINK_SIZE);
+                lstrcpy(m_szLink, lpszText);
+        }
+#endif // defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__) 
+
+        void SetWizardMode()
+        {
+                m_psh.dwFlags |= PSH_WIZARD;
+        }
+
+        void EnableHelp()
+        {
+                m_psh.dwFlags |= PSH_HASHELP;
+        }
+
+// Operations
+        BOOL AddPage(HPROPSHEETPAGE hPage)
+        {
+                ATLASSERT(hPage != NULL);
+                BOOL bRet = FALSE;
+                if(m_hWnd != NULL)
+                        bRet = TBase::AddPage(hPage);
+                else    // sheet not created yet, use internal data
+                        bRet = m_arrPages.Add((HPROPSHEETPAGE&)hPage);
+                return bRet;
+        }
+
+        BOOL AddPage(LPCPROPSHEETPAGE pPage)
+        {
+                ATLASSERT(pPage != NULL);
+                HPROPSHEETPAGE hPage = ::CreatePropertySheetPage(pPage);
+                if(hPage == NULL)
+                        return FALSE;
+                BOOL bRet = AddPage(hPage);
+                if(!bRet)
+                        ::DestroyPropertySheetPage(hPage);
+                return bRet;
+        }
+
+        BOOL RemovePage(HPROPSHEETPAGE hPage)
+        {
+                ATLASSERT(hPage != NULL);
+                if (m_hWnd == NULL)   // not created yet
+                {
+                        int nPage = GetPageIndex(hPage);
+                        if(nPage == -1)
+                                return FALSE;
+                        return RemovePage(nPage);
+                }
+                TBase::RemovePage(hPage);
+                return TRUE;
+
+        }
+
+        BOOL RemovePage(int nPageIndex)
+        {
+                BOOL bRet = TRUE;
+                if(m_hWnd != NULL)
+                        TBase::RemovePage(nPageIndex);
+                else    // sheet not created yet, use internal data
+                        bRet = m_arrPages.RemoveAt(nPageIndex);
+                return bRet;
+        }
+
+#if (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
+        void SetHeader(LPCTSTR szbmHeader)
+        {
+                ATLASSERT(m_hWnd == NULL);   // can't do this after it's created
+
+                m_psh.dwFlags &= ~PSH_WIZARD;
+                m_psh.dwFlags |= (PSH_HEADER | PSH_WIZARD97);
+                m_psh.pszbmHeader = szbmHeader;
+        }
+
+        void SetHeader(HBITMAP hbmHeader)
+        {
+                ATLASSERT(m_hWnd == NULL);   // can't do this after it's created
+
+                m_psh.dwFlags &= ~PSH_WIZARD;
+                m_psh.dwFlags |= (PSH_HEADER | PSH_USEHBMHEADER | PSH_WIZARD97);
+                m_psh.hbmHeader = hbmHeader;
+        }
+
+        void SetWatermark(LPCTSTR szbmWatermark, HPALETTE hplWatermark = NULL)
+        {
+                ATLASSERT(m_hWnd == NULL);   // can't do this after it's created
+
+                m_psh.dwFlags &= ~PSH_WIZARD;
+                m_psh.dwFlags |= PSH_WATERMARK | PSH_WIZARD97;
+                m_psh.pszbmWatermark = szbmWatermark;
+
+                if (hplWatermark != NULL)
+                {
+                        m_psh.dwFlags |= PSH_USEHPLWATERMARK;
+                        m_psh.hplWatermark = hplWatermark;
+                }
+        }
+
+        void SetWatermark(HBITMAP hbmWatermark, HPALETTE hplWatermark = NULL)
+        {
+                ATLASSERT(m_hWnd == NULL);   // can't do this after it's created
+
+                m_psh.dwFlags &= ~PSH_WIZARD;
+                m_psh.dwFlags |= (PSH_WATERMARK | PSH_USEHBMWATERMARK | PSH_WIZARD97);
+                m_psh.hbmWatermark = hbmWatermark;
+
+                if (hplWatermark != NULL)
+                {
+                        m_psh.dwFlags |= PSH_USEHPLWATERMARK;
+                        m_psh.hplWatermark = hplWatermark;
+                }
+        }
+
+        void StretchWatermark(bool bStretchWatermark)
+        {
+                ATLASSERT(m_hWnd == NULL);   // can't do this after it's created
+                if (bStretchWatermark)
+                        m_psh.dwFlags |= PSH_STRETCHWATERMARK;
+                else
+                        m_psh.dwFlags &= ~PSH_STRETCHWATERMARK;
+        }
+#endif // (_WIN32_IE >= 0x0400) && !defined(_WIN32_WCE)
+
+// Message map and handlers
+        BEGIN_MSG_MAP(CPropertySheetImpl)
+                MESSAGE_HANDLER(WM_COMMAND, OnCommand)
+                MESSAGE_HANDLER(WM_SYSCOMMAND, OnSysCommand)
+        END_MSG_MAP()
+
+        LRESULT OnCommand(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& /*bHandled*/)
+        {
+                LRESULT lRet = DefWindowProc(uMsg, wParam, lParam);
+                if(HIWORD(wParam) == BN_CLICKED && (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL) &&
+                   ((m_psh.dwFlags & PSH_MODELESS) != 0) && (GetActivePage() == NULL))
+                        DestroyWindow();
+                return lRet;
+        }
+
+        LRESULT OnSysCommand(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
+        {
+                if(((m_psh.dwFlags & PSH_MODELESS) == PSH_MODELESS) && ((wParam & 0xFFF0) == SC_CLOSE))
+                        SendMessage(WM_CLOSE);
+                else
+                        bHandled = FALSE;
+                return 0;
+        }
+};
+
+#if defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__) // PPC static pointers
+template < class T, class TBase >
+LPCWSTR CPropertySheetImpl<T,TBase>::m_pszTitle = NULL;
+template < class T, class TBase>
+LPCWSTR CPropertySheetImpl<T,TBase>::m_pszLink = NULL;
+#endif // defined(_AYGSHELL_H_) || defined(__AYGSHELL_H__)
+
+// for non-customized sheets
+class CPropertySheet : public CPropertySheetImpl<CPropertySheet>
+{
+public:
+        CPropertySheet(ATL::_U_STRINGorID title = (LPCTSTR)NULL, UINT uStartPage = 0, HWND hWndParent = NULL)
+                : CPropertySheetImpl<CPropertySheet>(title, uStartPage, hWndParent)
+        { }
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CPropertyPageWindow - client side for a property page
+
+class CPropertyPageWindow : public ATL::CWindow
+{
+public:
+// Constructors
+        CPropertyPageWindow(HWND hWnd = NULL) : ATL::CWindow(hWnd)
+        { }
+
+        CPropertyPageWindow& operator =(HWND hWnd)
+        {
+                m_hWnd = hWnd;
+                return *this;
+        }
+
+// Attributes
+        CPropertySheetWindow GetPropertySheet() const
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                return CPropertySheetWindow(GetParent());
+        }
+
+// Operations
+        BOOL Apply()
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT(GetParent() != NULL);
+                return GetPropertySheet().Apply();
+        }
+
+        void CancelToClose()
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT(GetParent() != NULL);
+                GetPropertySheet().CancelToClose();
+        }
+
+        void SetModified(BOOL bChanged = TRUE)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT(GetParent() != NULL);
+                GetPropertySheet().SetModified(m_hWnd, bChanged);
+        }
+
+        LRESULT QuerySiblings(WPARAM wParam, LPARAM lParam)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT(GetParent() != NULL);
+                return GetPropertySheet().QuerySiblings(wParam, lParam);
+        }
+
+        void RebootSystem()
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT(GetParent() != NULL);
+                GetPropertySheet().RebootSystem();
+        }
+
+        void RestartWindows()
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT(GetParent() != NULL);
+                GetPropertySheet().RestartWindows();
+        }
+
+        void SetWizardButtons(DWORD dwFlags)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT(GetParent() != NULL);
+                GetPropertySheet().SetWizardButtons(dwFlags);
+        }
+
+// Implementation - overrides to prevent usage
+        HWND Create(LPCTSTR, HWND, ATL::_U_RECT = NULL, LPCTSTR = NULL, DWORD = 0, DWORD = 0, ATL::_U_MENUorID = 0U, LPVOID = NULL)
+        {
+                ATLASSERT(FALSE);
+                return NULL;
+        }
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// CPropertyPageImpl - implements a property page
+
+template <class T, class TBase = CPropertyPageWindow>
+class ATL_NO_VTABLE CPropertyPageImpl : public ATL::CDialogImplBaseT< TBase >
+{
+public:
+        PROPSHEETPAGE m_psp;
+
+        operator PROPSHEETPAGE*() { return &m_psp; }
+
+// Construction
+        CPropertyPageImpl(ATL::_U_STRINGorID title = (LPCTSTR)NULL)
+        {
+                // initialize PROPSHEETPAGE struct
+                memset(&m_psp, 0, sizeof(PROPSHEETPAGE));
+                m_psp.dwSize = sizeof(PROPSHEETPAGE);
+                m_psp.dwFlags = PSP_USECALLBACK;
+                m_psp.hInstance = ModuleHelper::GetResourceInstance();
+                T* pT = static_cast<T*>(this);
+                m_psp.pszTemplate = MAKEINTRESOURCE(pT->IDD);
+                m_psp.pfnDlgProc = (DLGPROC)T::StartDialogProc;
+                m_psp.pfnCallback = T::PropPageCallback;
+                m_psp.lParam = (LPARAM)pT;
+
+                if(title.m_lpstr != NULL)
+                        SetTitle(title);
+        }
+
+// Callback function and overrideables
+        static UINT CALLBACK PropPageCallback(HWND hWnd, UINT uMsg, LPPROPSHEETPAGE ppsp)
+        {
+                hWnd;   // avoid level 4 warning
+                ATLASSERT(hWnd == NULL);
+                T* pT = (T*)ppsp->lParam;
+                UINT uRet = 0;
+
+                switch(uMsg)
+                {
+                case PSPCB_CREATE:
+                        {
+                                ATL::CDialogImplBaseT< TBase >* pPage = (ATL::CDialogImplBaseT< TBase >*)pT;
+                                ModuleHelper::AddCreateWndData(&pPage->m_thunk.cd, pPage);
+                                uRet = pT->OnPageCreate() ? 1 : 0;
+                        }
+                        break;
+#if (_WIN32_IE >= 0x0500)
+                case PSPCB_ADDREF:
+                        pT->OnPageAddRef();
+                        break;
+#endif // (_WIN32_IE >= 0x0500)
+                case PSPCB_RELEASE:
+                        pT->OnPageRelease();
+                        break;
+                default:
+                        break;
+                }
+
+                return uRet;
+        }
+
+        bool OnPageCreate()
+        {
+                return true;   // true - allow page to be created, false - prevent creation
+        }
+
+#if (_WIN32_IE >= 0x0500)
+        void OnPageAddRef()
+        {
+        }
+#endif // (_WIN32_IE >= 0x0500)
+
+        void OnPageRelease()
+        {
+        }
+
+// Create method
+        HPROPSHEETPAGE Create()
+        {
+                return ::CreatePropertySheetPage(&m_psp);
+        }
+
+// Attributes
+        void SetTitle(ATL::_U_STRINGorID title)
+        {
+                m_psp.pszTitle = title.m_lpstr;
+                m_psp.dwFlags |= PSP_USETITLE;
+        }
+
+#if (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
+        void SetHeaderTitle(LPCTSTR lpstrHeaderTitle)
+        {
+                ATLASSERT(m_hWnd == NULL);   // can't do this after it's created
+                m_psp.dwFlags |= PSP_USEHEADERTITLE;
+                m_psp.pszHeaderTitle = lpstrHeaderTitle;
+        }
+
+        void SetHeaderSubTitle(LPCTSTR lpstrHeaderSubTitle)
+        {
+                ATLASSERT(m_hWnd == NULL);   // can't do this after it's created
+                m_psp.dwFlags |= PSP_USEHEADERSUBTITLE;
+                m_psp.pszHeaderSubTitle = lpstrHeaderSubTitle;
+        }
+#endif // (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
+
+// Operations
+        void EnableHelp()
+        {
+                m_psp.dwFlags |= PSP_HASHELP;
+        }
+
+// Message map and handlers
+        BEGIN_MSG_MAP(CPropertyPageImpl)
+                MESSAGE_HANDLER(WM_NOTIFY, OnNotify)
+        END_MSG_MAP()
+
+        // NOTE: Define _WTL_NEW_PAGE_NOTIFY_HANDLERS to use new notification
+        // handlers that return direct values without any restrictions
+        LRESULT OnNotify(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM lParam, BOOL& bHandled)
+        {
+#ifndef _WIN32_WCE
+                // This notification is sometimes received on Windows CE after the window is already destroyed
+                ATLASSERT(::IsWindow(m_hWnd));
+#endif
+                NMHDR* pNMHDR = (NMHDR*)lParam;
+
+                // don't handle messages not from the page/sheet itself
+                if(pNMHDR->hwndFrom != m_hWnd && pNMHDR->hwndFrom != ::GetParent(m_hWnd))
+                {
+                        bHandled = FALSE;
+                        return 1;
+                }
+#ifdef _WIN32_WCE
+                ATLASSERT(::IsWindow(m_hWnd));
+#endif
+
+                T* pT = static_cast<T*>(this);
+                LRESULT lResult = 0;
+                switch(pNMHDR->code)
+                {
+#ifdef _WTL_NEW_PAGE_NOTIFY_HANDLERS
+                case PSN_SETACTIVE:
+                        lResult = pT->OnSetActive();
+                        break;
+                case PSN_KILLACTIVE:
+                        lResult = pT->OnKillActive();
+                        break;
+                case PSN_APPLY:
+                        lResult = pT->OnApply();
+                        break;
+                case PSN_RESET:
+                        pT->OnReset();
+                        break;
+                case PSN_QUERYCANCEL:
+                        lResult = pT->OnQueryCancel();
+                        break;
+                case PSN_WIZNEXT:
+                        lResult = pT->OnWizardNext();
+                        break;
+                case PSN_WIZBACK:
+                        lResult = pT->OnWizardBack();
+                        break;
+                case PSN_WIZFINISH:
+                        lResult = pT->OnWizardFinish();
+                        break;
+                case PSN_HELP:
+                        pT->OnHelp();
+                        break;
+#ifndef _WIN32_WCE
+#if (_WIN32_IE >= 0x0400)
+                case PSN_GETOBJECT:
+                        if(!pT->OnGetObject((LPNMOBJECTNOTIFY)lParam))
+                                bHandled = FALSE;
+                        break;
+#endif // (_WIN32_IE >= 0x0400)
+#if (_WIN32_IE >= 0x0500)
+                case PSN_TRANSLATEACCELERATOR:
+                        {
+                                LPPSHNOTIFY lpPSHNotify = (LPPSHNOTIFY)lParam;
+                                lResult = pT->OnTranslateAccelerator((LPMSG)lpPSHNotify->lParam);
+                        }
+                        break;
+                case PSN_QUERYINITIALFOCUS:
+                        {
+                                LPPSHNOTIFY lpPSHNotify = (LPPSHNOTIFY)lParam;
+                                lResult = (LRESULT)pT->OnQueryInitialFocus((HWND)lpPSHNotify->lParam);
+                        }
+                        break;
+#endif // (_WIN32_IE >= 0x0500)
+#endif // !_WIN32_WCE
+
+#else // !_WTL_NEW_PAGE_NOTIFY_HANDLERS
+                case PSN_SETACTIVE:
+                        lResult = pT->OnSetActive() ? 0 : -1;
+                        break;
+                case PSN_KILLACTIVE:
+                        lResult = !pT->OnKillActive();
+                        break;
+                case PSN_APPLY:
+                        lResult = pT->OnApply() ? PSNRET_NOERROR : PSNRET_INVALID_NOCHANGEPAGE;
+                        break;
+                case PSN_RESET:
+                        pT->OnReset();
+                        break;
+                case PSN_QUERYCANCEL:
+                        lResult = !pT->OnQueryCancel();
+                        break;
+                case PSN_WIZNEXT:
+                        lResult = pT->OnWizardNext();
+                        break;
+                case PSN_WIZBACK:
+                        lResult = pT->OnWizardBack();
+                        break;
+                case PSN_WIZFINISH:
+                        lResult = !pT->OnWizardFinish();
+                        break;
+                case PSN_HELP:
+                        pT->OnHelp();
+                        break;
+#ifndef _WIN32_WCE
+#if (_WIN32_IE >= 0x0400)
+                case PSN_GETOBJECT:
+                        if(!pT->OnGetObject((LPNMOBJECTNOTIFY)lParam))
+                                bHandled = FALSE;
+                        break;
+#endif // (_WIN32_IE >= 0x0400)
+#if (_WIN32_IE >= 0x0500)
+                case PSN_TRANSLATEACCELERATOR:
+                        {
+                                LPPSHNOTIFY lpPSHNotify = (LPPSHNOTIFY)lParam;
+                                lResult = pT->OnTranslateAccelerator((LPMSG)lpPSHNotify->lParam) ? PSNRET_MESSAGEHANDLED : PSNRET_NOERROR;
+                        }
+                        break;
+                case PSN_QUERYINITIALFOCUS:
+                        {
+                                LPPSHNOTIFY lpPSHNotify = (LPPSHNOTIFY)lParam;
+                                lResult = (LRESULT)pT->OnQueryInitialFocus((HWND)lpPSHNotify->lParam);
+                        }
+                        break;
+#endif // (_WIN32_IE >= 0x0500)
+#endif // !_WIN32_WCE
+
+#endif // !_WTL_NEW_PAGE_NOTIFY_HANDLERS
+                default:
+                        bHandled = FALSE;   // not handled
+                }
+
+                return lResult;
+        }
+
+// Overridables
+        // NOTE: Define _WTL_NEW_PAGE_NOTIFY_HANDLERS to use new notification
+        // handlers that return direct values without any restrictions
+#ifdef _WTL_NEW_PAGE_NOTIFY_HANDLERS
+        int OnSetActive()
+        {
+                // 0 = allow activate
+                // -1 = go back that was active
+                // page ID = jump to page
+                return 0;
+        }
+
+        BOOL OnKillActive()
+        {
+                // FALSE = allow deactivate
+                // TRUE = prevent deactivation
+                return FALSE;
+        }
+
+        int OnApply()
+        {
+                // PSNRET_NOERROR = apply OK
+                // PSNRET_INVALID = apply not OK, return to this page
+                // PSNRET_INVALID_NOCHANGEPAGE = apply not OK, don't change focus
+                return PSNRET_NOERROR;
+        }
+
+        void OnReset()
+        {
+        }
+
+        BOOL OnQueryCancel()
+        {
+                // FALSE = allow cancel
+                // TRUE = prevent cancel
+                return FALSE;
+        }
+
+        int OnWizardBack()
+        {
+                // 0  = goto previous page
+                // -1 = prevent page change
+                // >0 = jump to page by dlg ID
+                return 0;
+        }
+
+        int OnWizardNext()
+        {
+                // 0  = goto next page
+                // -1 = prevent page change
+                // >0 = jump to page by dlg ID
+                return 0;
+        }
+
+        INT_PTR OnWizardFinish()
+        {
+                // FALSE = allow finish
+                // TRUE = prevent finish
+                // HWND = prevent finish and set focus to HWND (CommCtrl 5.80 only)
+                return FALSE;
+        }
+
+        void OnHelp()
+        {
+        }
+
+#ifndef _WIN32_WCE
+#if (_WIN32_IE >= 0x0400)
+        BOOL OnGetObject(LPNMOBJECTNOTIFY /*lpObjectNotify*/)
+        {
+                return FALSE;   // not processed
+        }
+#endif // (_WIN32_IE >= 0x0400)
+
+#if (_WIN32_IE >= 0x0500)
+        int OnTranslateAccelerator(LPMSG /*lpMsg*/)
+        {
+                // PSNRET_NOERROR - message not handled
+                // PSNRET_MESSAGEHANDLED - message handled
+                return PSNRET_NOERROR;
+        }
+
+        HWND OnQueryInitialFocus(HWND /*hWndFocus*/)
+        {
+                // NULL = set focus to default control
+                // HWND = set focus to HWND
+                return NULL;
+        }
+#endif // (_WIN32_IE >= 0x0500)
+#endif // !_WIN32_WCE
+
+#else // !_WTL_NEW_PAGE_NOTIFY_HANDLERS
+        BOOL OnSetActive()
+        {
+                return TRUE;
+        }
+
+        BOOL OnKillActive()
+        {
+                return TRUE;
+        }
+
+        BOOL OnApply()
+        {
+                return TRUE;
+        }
+
+        void OnReset()
+        {
+        }
+
+        BOOL OnQueryCancel()
+        {
+                return TRUE;    // ok to cancel
+        }
+
+        int OnWizardBack()
+        {
+                // 0  = goto previous page
+                // -1 = prevent page change
+                // >0 = jump to page by dlg ID
+                return 0;
+        }
+
+        int OnWizardNext()
+        {
+                // 0  = goto next page
+                // -1 = prevent page change
+                // >0 = jump to page by dlg ID
+                return 0;
+        }
+
+        BOOL OnWizardFinish()
+        {
+                return TRUE;
+        }
+
+        void OnHelp()
+        {
+        }
+
+#ifndef _WIN32_WCE
+#if (_WIN32_IE >= 0x0400)
+        BOOL OnGetObject(LPNMOBJECTNOTIFY /*lpObjectNotify*/)
+        {
+                return FALSE;   // not processed
+        }
+#endif // (_WIN32_IE >= 0x0400)
+
+#if (_WIN32_IE >= 0x0500)
+        BOOL OnTranslateAccelerator(LPMSG /*lpMsg*/)
+        {
+                return FALSE;   // not translated
+        }
+
+        HWND OnQueryInitialFocus(HWND /*hWndFocus*/)
+        {
+                return NULL;   // default
+        }
+#endif // (_WIN32_IE >= 0x0500)
+#endif // !_WIN32_WCE
+
+#endif // !_WTL_NEW_PAGE_NOTIFY_HANDLERS
+};
+
+// for non-customized pages
+template <WORD t_wDlgTemplateID>
+class CPropertyPage : public CPropertyPageImpl<CPropertyPage<t_wDlgTemplateID> >
+{
+public:
+        enum { IDD = t_wDlgTemplateID };
+
+        CPropertyPage(ATL::_U_STRINGorID title = (LPCTSTR)NULL) : CPropertyPageImpl<CPropertyPage>(title)
+        { }
+
+        DECLARE_EMPTY_MSG_MAP()
+};
+
+///////////////////////////////////////////////////////////////////////////////
+// CAxPropertyPageImpl - property page that hosts ActiveX controls
+
+#ifndef _ATL_NO_HOSTING
+
+// Note: You must #include <atlhost.h> to use these classes
+
+template <class T, class TBase = CPropertyPageWindow>
+class ATL_NO_VTABLE CAxPropertyPageImpl : public CPropertyPageImpl< T, TBase >
+{
+public:
+// Data members
+        HGLOBAL m_hInitData;
+        HGLOBAL m_hDlgRes;
+        HGLOBAL m_hDlgResSplit;
+
+// Constructor/destructor
+        CAxPropertyPageImpl(ATL::_U_STRINGorID title = (LPCTSTR)NULL) : 
+                        CPropertyPageImpl< T, TBase >(title),
+                        m_hInitData(NULL), m_hDlgRes(NULL), m_hDlgResSplit(NULL)
+        {
+                T* pT = static_cast<T*>(this);
+                pT;   // avoid level 4 warning
+
+                // initialize ActiveX hosting and modify dialog template
+                ATL::AtlAxWinInit();
+
+                HINSTANCE hInstance = ModuleHelper::GetResourceInstance();
+                LPCTSTR lpTemplateName = MAKEINTRESOURCE(pT->IDD);
+                HRSRC hDlg = ::FindResource(hInstance, lpTemplateName, (LPTSTR)RT_DIALOG);
+                if(hDlg != NULL)
+                {
+                        HRSRC hDlgInit = ::FindResource(hInstance, lpTemplateName, (LPTSTR)_ATL_RT_DLGINIT);
+
+                        BYTE* pInitData = NULL;
+                        if(hDlgInit != NULL)
+                        {
+                                m_hInitData = ::LoadResource(hInstance, hDlgInit);
+                                pInitData = (BYTE*)::LockResource(m_hInitData);
+                        }
+
+                        m_hDlgRes = ::LoadResource(hInstance, hDlg);
+                        DLGTEMPLATE* pDlg = (DLGTEMPLATE*)::LockResource(m_hDlgRes);
+                        LPCDLGTEMPLATE lpDialogTemplate = ATL::_DialogSplitHelper::SplitDialogTemplate(pDlg, pInitData);
+                        if(lpDialogTemplate != pDlg)
+                                m_hDlgResSplit = GlobalHandle(lpDialogTemplate);
+
+                        // set up property page to use in-memory dialog template
+                        if(lpDialogTemplate != NULL)
+                        {
+                                m_psp.dwFlags |= PSP_DLGINDIRECT;
+                                m_psp.pResource = lpDialogTemplate;
+                        }
+                        else
+                        {
+                                ATLASSERT(FALSE && _T("CAxPropertyPageImpl - ActiveX initializtion failed!"));
+                        }
+                }
+                else
+                {
+                        ATLASSERT(FALSE && _T("CAxPropertyPageImpl - Cannot find dialog template!"));
+                }
+        }
+
+        ~CAxPropertyPageImpl()
+        {
+                if(m_hInitData != NULL)
+                {
+                        UnlockResource(m_hInitData);
+                        FreeResource(m_hInitData);
+                }
+                if(m_hDlgRes != NULL)
+                {
+                        UnlockResource(m_hDlgRes);
+                        FreeResource(m_hDlgRes);
+                }
+                if(m_hDlgResSplit != NULL)
+                {
+                        ::GlobalFree(m_hDlgResSplit);
+                }
+        }
+
+// Methods
+        // call this one to handle keyboard message for ActiveX controls
+        BOOL PreTranslateMessage(LPMSG pMsg)
+        {
+                if ((pMsg->message < WM_KEYFIRST || pMsg->message > WM_KEYLAST) &&
+                   (pMsg->message < WM_MOUSEFIRST || pMsg->message > WM_MOUSELAST))
+                        return FALSE;
+                // find a direct child of the dialog from the window that has focus
+                HWND hWndCtl = ::GetFocus();
+                if (IsChild(hWndCtl) && ::GetParent(hWndCtl) != m_hWnd)
+                {
+                        do
+                        {
+                                hWndCtl = ::GetParent(hWndCtl);
+                        }
+                        while (::GetParent(hWndCtl) != m_hWnd);
+                }
+                // give controls a chance to translate this message
+                return (BOOL)::SendMessage(hWndCtl, WM_FORWARDMSG, 0, (LPARAM)pMsg);
+        }
+
+// Overridables
+#if (_WIN32_IE >= 0x0500)
+        // new default implementation for ActiveX hosting pages
+#ifdef _WTL_NEW_PAGE_NOTIFY_HANDLERS
+        int OnTranslateAccelerator(LPMSG lpMsg)
+        {
+                T* pT = static_cast<T*>(this);
+                return (pT->PreTranslateMessage(lpMsg) != FALSE) ? PSNRET_MESSAGEHANDLED : PSNRET_NOERROR;
+        }
+#else // !_WTL_NEW_PAGE_NOTIFY_HANDLERS
+        BOOL OnTranslateAccelerator(LPMSG lpMsg)
+        {
+                T* pT = static_cast<T*>(this);
+                return pT->PreTranslateMessage(lpMsg);
+        }
+#endif // !_WTL_NEW_PAGE_NOTIFY_HANDLERS
+#endif // (_WIN32_IE >= 0x0500)
+
+// Support for new stuff in ATL7
+#if (_ATL_VER >= 0x0700)
+        int GetIDD()
+        {
+                return( static_cast<T*>(this)->IDD );
+        }
+
+        virtual DLGPROC GetDialogProc()
+        {
+                return DialogProc;
+        }
+
+        static INT_PTR CALLBACK DialogProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
+        {
+                CAxPropertyPageImpl< T, TBase >* pThis = (CAxPropertyPageImpl< T, TBase >*)hWnd;
+                if (uMsg == WM_INITDIALOG)
+                {
+                        HRESULT hr;
+                        if (FAILED(hr = pThis->CreateActiveXControls(pThis->GetIDD())))
+                        {
+                                ATLASSERT(FALSE);
+                                return FALSE;
+                        }
+                }
+                return CPropertyPageImpl< T, TBase >::DialogProc(hWnd, uMsg, wParam, lParam);
+        }
+
+// ActiveX controls creation
+        virtual HRESULT CreateActiveXControls(UINT nID)
+        {
+                // Load dialog template and InitData
+                HRSRC hDlgInit = ::FindResource(ATL::_AtlBaseModule.GetResourceInstance(), MAKEINTRESOURCE(nID), (LPTSTR)_ATL_RT_DLGINIT);
+                BYTE* pInitData = NULL;
+                HGLOBAL hData = NULL;
+                HRESULT hr = S_OK;
+                if (hDlgInit != NULL)
+                {
+                        hData = ::LoadResource(ATL::_AtlBaseModule.GetResourceInstance(), hDlgInit);
+                        if (hData != NULL)
+                                pInitData = (BYTE*) ::LockResource(hData);
+                }
+
+                HRSRC hDlg = ::FindResource(ATL::_AtlBaseModule.GetResourceInstance(), MAKEINTRESOURCE(nID), (LPTSTR)RT_DIALOG);
+                if (hDlg != NULL)
+                {
+                        HGLOBAL hResource = ::LoadResource(ATL::_AtlBaseModule.GetResourceInstance(), hDlg);
+                        DLGTEMPLATE* pDlg = NULL;
+                        if (hResource != NULL)
+                        {
+                                pDlg = (DLGTEMPLATE*) ::LockResource(hResource);
+                                if (pDlg != NULL)
+                                {
+                                        // Get first control on the template
+                                        BOOL bDialogEx = ATL::_DialogSplitHelper::IsDialogEx(pDlg);
+                                        WORD nItems = ATL::_DialogSplitHelper::DlgTemplateItemCount(pDlg);
+
+                                        // Get first control on the dialog
+                                        DLGITEMTEMPLATE* pItem = ATL::_DialogSplitHelper::FindFirstDlgItem(pDlg);
+                                        HWND hWndPrev = GetWindow(GW_CHILD);
+
+                                        // Create all ActiveX cotnrols in the dialog template and place them in the correct tab order (z-order)
+                                        for (WORD nItem = 0; nItem < nItems; nItem++)
+                                        {
+                                                DWORD wID = bDialogEx ? ((ATL::_DialogSplitHelper::DLGITEMTEMPLATEEX*)pItem)->id : pItem->id;
+                                                if (ATL::_DialogSplitHelper::IsActiveXControl(pItem, bDialogEx))
+                                                {
+                                                        BYTE* pData = NULL;
+                                                        DWORD dwLen = ATL::_DialogSplitHelper::FindCreateData(wID, pInitData, &pData);
+                                                        ATL::CComPtr<IStream> spStream;
+                                                        if (dwLen != 0)
+                                                        {
+                                                                HGLOBAL h = GlobalAlloc(GHND, dwLen);
+                                                                if (h != NULL)
+                                                                {
+                                                                        BYTE* pBytes = (BYTE*) GlobalLock(h);
+                                                                        BYTE* pSource = pData; 
+                                                                        SecureHelper::memcpy_x(pBytes, dwLen, pSource, dwLen);
+                                                                        GlobalUnlock(h);
+                                                                        CreateStreamOnHGlobal(h, TRUE, &spStream);
+                                                                }
+                                                                else
+                                                                {
+                                                                        hr = E_OUTOFMEMORY;
+                                                                        break;
+                                                                }
+                                                        }
+
+                                                        ATL::CComBSTR bstrLicKey;
+                                                        hr = ATL::_DialogSplitHelper::ParseInitData(spStream, &bstrLicKey.m_str);
+                                                        if (SUCCEEDED(hr))
+                                                        {
+                                                                ATL::CAxWindow2 wnd;
+                                                                // Get control caption.
+                                                                LPWSTR pszClassName = 
+                                                                        bDialogEx ? 
+                                                                                (LPWSTR)(((ATL::_DialogSplitHelper::DLGITEMTEMPLATEEX*)pItem) + 1) :
+                                                                                (LPWSTR)(pItem + 1);
+                                                                // Get control rect.
+                                                                RECT rect;
+                                                                rect.left = 
+                                                                        bDialogEx ? 
+                                                                                ((ATL::_DialogSplitHelper::DLGITEMTEMPLATEEX*)pItem)->x : 
+                                                                                pItem->x;
+                                                                rect.top = 
+                                                                        bDialogEx ? 
+                                                                                ((ATL::_DialogSplitHelper::DLGITEMTEMPLATEEX*)pItem)->y : 
+                                                                                pItem->y;
+                                                                rect.right = rect.left + 
+                                                                        (bDialogEx ? 
+                                                                                ((ATL::_DialogSplitHelper::DLGITEMTEMPLATEEX*)pItem)->cx : 
+                                                                                pItem->cx);
+                                                                rect.bottom = rect.top + 
+                                                                        (bDialogEx ? 
+                                                                                ((ATL::_DialogSplitHelper::DLGITEMTEMPLATEEX*)pItem)->cy : 
+                                                                                pItem->cy);
+
+                                                                // Convert from dialog units to screen units
+                                                                MapDialogRect(&rect);
+
+                                                                // Create AxWindow with a NULL caption.
+                                                                wnd.Create(m_hWnd, 
+                                                                        &rect, 
+                                                                        NULL, 
+                                                                        (bDialogEx ? 
+                                                                                ((ATL::_DialogSplitHelper::DLGITEMTEMPLATEEX*)pItem)->style : 
+                                                                                pItem->style) | WS_TABSTOP, 
+                                                                        bDialogEx ? 
+                                                                                ((ATL::_DialogSplitHelper::DLGITEMTEMPLATEEX*)pItem)->exStyle : 
+                                                                                0,
+                                                                        bDialogEx ? 
+                                                                                ((ATL::_DialogSplitHelper::DLGITEMTEMPLATEEX*)pItem)->id : 
+                                                                                pItem->id,
+                                                                        NULL);
+
+                                                                if (wnd != NULL)
+                                                                {
+#ifndef _WIN32_WCE
+                                                                        // Set the Help ID
+                                                                        if (bDialogEx && ((ATL::_DialogSplitHelper::DLGITEMTEMPLATEEX*)pItem)->helpID != 0)
+                                                                                wnd.SetWindowContextHelpId(((ATL::_DialogSplitHelper::DLGITEMTEMPLATEEX*)pItem)->helpID);
+#endif // !_WIN32_WCE
+                                                                        // Try to create the ActiveX control.
+                                                                        hr = wnd.CreateControlLic(pszClassName, spStream, NULL, bstrLicKey);
+                                                                        if (FAILED(hr))
+                                                                                break;
+                                                                        // Set the correct tab position.
+                                                                        if (nItem == 0)
+                                                                                hWndPrev = HWND_TOP;
+                                                                        wnd.SetWindowPos(hWndPrev, 0,0,0,0,SWP_NOACTIVATE | SWP_NOMOVE | SWP_NOSIZE);
+                                                                        hWndPrev = wnd;
+                                                                }
+                                                                else
+                                                                {
+                                                                        hr = ATL::AtlHresultFromLastError();
+                                                                }
+                                                        }
+                                                }
+                                                else
+                                                {
+                                                        if (nItem != 0)
+                                                                hWndPrev = ::GetWindow(hWndPrev, GW_HWNDNEXT);
+                                                }
+                                                pItem = ATL::_DialogSplitHelper::FindNextDlgItem(pItem, bDialogEx);
+                                        }
+                                }
+                                else
+                                        hr = ATL::AtlHresultFromLastError();
+                        }
+                        else
+                                hr = ATL::AtlHresultFromLastError();
+                }
+                return hr;
+        }
+
+// Event handling support
+        HRESULT AdviseSinkMap(bool bAdvise)
+        {
+                if(!bAdvise && m_hWnd == NULL)
+                {
+                        // window is gone, controls are already unadvised
+                        ATLTRACE2(atlTraceUI, 0, _T("CAxPropertyPageImpl::AdviseSinkMap called after the window was destroyed\n"));
+                        return S_OK;
+                }
+                HRESULT hRet = E_NOTIMPL;
+                __if_exists(T::_GetSinkMapFinder)
+                {
+                        T* pT = static_cast<T*>(this);
+                        hRet = AtlAdviseSinkMap(pT, bAdvise);
+                }
+                return hRet;
+        }
+
+// Message map and handlers
+        typedef CPropertyPageImpl< T, TBase>   _baseClass;
+        BEGIN_MSG_MAP(CAxPropertyPageImpl)
+                MESSAGE_HANDLER(WM_INITDIALOG, OnInitDialog)
+                MESSAGE_HANDLER(WM_DESTROY, OnDestroy)
+                CHAIN_MSG_MAP(_baseClass)
+        END_MSG_MAP()
+
+        LRESULT OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
+        {
+                // initialize controls in dialog with DLGINIT resource section
+                ExecuteDlgInit(static_cast<T*>(this)->IDD);
+                AdviseSinkMap(true);
+                bHandled = FALSE;
+                return 1;
+        }
+
+        LRESULT OnDestroy(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
+        {
+                AdviseSinkMap(false);
+                bHandled = FALSE;
+                return 1;
+        }
+#endif // (_ATL_VER >= 0x0700)
+};
+
+// for non-customized pages
+template <WORD t_wDlgTemplateID>
+class CAxPropertyPage : public CAxPropertyPageImpl<CAxPropertyPage<t_wDlgTemplateID> >
+{
+public:
+        enum { IDD = t_wDlgTemplateID };
+
+        CAxPropertyPage(ATL::_U_STRINGorID title = (LPCTSTR)NULL) : CAxPropertyPageImpl<CAxPropertyPage>(title)
+        { }
+
+#if (_WIN32_IE >= 0x0500) || (_ATL_VER >= 0x0700)
+        // not empty so we handle accelerators/create controls
+        BEGIN_MSG_MAP(CAxPropertyPage)
+                CHAIN_MSG_MAP(CAxPropertyPageImpl<CAxPropertyPage<t_wDlgTemplateID> >)
+        END_MSG_MAP()
+#else // !((_WIN32_IE >= 0x0500) || (_ATL_VER >= 0x0700))
+        DECLARE_EMPTY_MSG_MAP()
+#endif // !((_WIN32_IE >= 0x0500) || (_ATL_VER >= 0x0700))
+};
+
+#endif // _ATL_NO_HOSTING
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Wizard97 Support
+
+#if (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
+
+// Sample wizard dialog resources:
+//
+// IDD_WIZ97_INTERIOR_BLANK DIALOG  0, 0, 317, 143
+// STYLE DS_SETFONT | WS_CHILD | WS_DISABLED | WS_CAPTION
+// CAPTION "Wizard97 Property Page - Interior"
+// FONT 8, "MS Shell Dlg"
+// BEGIN
+// END
+//
+// IDD_WIZ97_EXTERIOR_BLANK DIALOGEX 0, 0, 317, 193
+// STYLE DS_SETFONT | DS_FIXEDSYS | WS_CHILD | WS_DISABLED | WS_CAPTION
+// CAPTION "Wizard97 Property Page - Welcome/Complete"
+// FONT 8, "MS Shell Dlg", 0, 0, 0x0
+// BEGIN
+//    LTEXT           "Welcome to the X Wizard",IDC_WIZ97_EXTERIOR_TITLE,115,8,
+//                    195,24
+//    LTEXT           "Wizard Explanation\r\n(The height of the static text should be in multiples of 8 dlus)",
+//                    IDC_STATIC,115,40,195,16
+//    LTEXT           "h",IDC_WIZ97_BULLET1,118,64,8,8
+//    LTEXT           "List Item 1 (the h is turned into a bullet)",IDC_STATIC,
+//                    127,63,122,8
+//    LTEXT           "h",IDC_WIZ97_BULLET2,118,79,8,8
+//    LTEXT           "List Item 2. Keep 7 dlus between paragraphs",IDC_STATIC,
+//                    127,78,33,8
+//    CONTROL         "&Do not show this Welcome page again",
+//                    IDC_WIZ97_WELCOME_NOTAGAIN,"Button",BS_AUTOCHECKBOX | 
+//                    WS_TABSTOP,115,169,138,10
+// END
+//
+// GUIDELINES DESIGNINFO 
+// BEGIN
+//    IDD_WIZ97_INTERIOR_BLANK, DIALOG
+//    BEGIN
+//        LEFTMARGIN, 7
+//        RIGHTMARGIN, 310
+//        VERTGUIDE, 21
+//        VERTGUIDE, 31
+//        VERTGUIDE, 286
+//        VERTGUIDE, 296
+//        TOPMARGIN, 7
+//        BOTTOMMARGIN, 136
+//        HORZGUIDE, 8
+//    END
+//
+//    IDD_WIZ97_EXTERIOR_BLANK, DIALOG
+//    BEGIN
+//        RIGHTMARGIN, 310
+//        VERTGUIDE, 115
+//        VERTGUIDE, 118
+//        VERTGUIDE, 127
+//        TOPMARGIN, 7
+//        BOTTOMMARGIN, 186
+//        HORZGUIDE, 8
+//        HORZGUIDE, 32
+//        HORZGUIDE, 40
+//        HORZGUIDE, 169
+//    END
+// END
+
+///////////////////////////////////////////////////////////////////////////////
+// CWizard97SheetWindow - client side for a Wizard 97 style wizard sheet
+
+class CWizard97SheetWindow : public CPropertySheetWindow
+{
+public:
+// Constructors
+        CWizard97SheetWindow(HWND hWnd = NULL) : CPropertySheetWindow(hWnd)
+        { }
+
+        CWizard97SheetWindow& operator =(HWND hWnd)
+        {
+                m_hWnd = hWnd;
+                return *this;
+        }
+
+// Operations
+        HFONT GetExteriorPageTitleFont(void)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                return (HFONT)::SendMessage(m_hWnd, GetMessage_GetExteriorPageTitleFont(), 0, 0L);
+        }
+
+        HFONT GetBulletFont(void)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                return (HFONT)::SendMessage(m_hWnd, GetMessage_GetBulletFont(), 0, 0L);
+        }
+
+// Helpers
+        static UINT GetMessage_GetExteriorPageTitleFont()
+        {
+                static UINT uGetExteriorPageTitleFont = 0;
+                if(uGetExteriorPageTitleFont == 0)
+                {
+                        CStaticDataInitCriticalSectionLock lock;
+                        if(FAILED(lock.Lock()))
+                        {
+                                ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to lock critical section in CWizard97SheetWindow::GetMessage_GetExteriorPageTitleFont().\n"));
+                                ATLASSERT(FALSE);
+                                return 0;
+                        }
+
+                        if(uGetExteriorPageTitleFont == 0)
+                                uGetExteriorPageTitleFont = ::RegisterWindowMessage(_T("GetExteriorPageTitleFont_531AF056-B8BE-4c4c-B786-AC608DF0DF12"));
+
+                        lock.Unlock();
+                }
+                ATLASSERT(uGetExteriorPageTitleFont != 0);
+                return uGetExteriorPageTitleFont;
+        }
+
+        static UINT GetMessage_GetBulletFont()
+        {
+                static UINT uGetBulletFont = 0;
+                if(uGetBulletFont == 0)
+                {
+                        CStaticDataInitCriticalSectionLock lock;
+                        if(FAILED(lock.Lock()))
+                        {
+                                ATLTRACE2(atlTraceUI, 0, _T("ERROR : Unable to lock critical section in CWizard97SheetWindow::GetMessage_GetBulletFont().\n"));
+                                ATLASSERT(FALSE);
+                                return 0;
+                        }
+
+                        if(uGetBulletFont == 0)
+                                uGetBulletFont = ::RegisterWindowMessage(_T("GetBulletFont_AD347D08-8F65-45ef-982E-6352E8218AD5"));
+
+                        lock.Unlock();
+                }
+                ATLASSERT(uGetBulletFont != 0);
+                return uGetBulletFont;
+        }
+
+// Implementation - override to prevent usage
+        HWND Create(LPCTSTR, HWND, ATL::_U_RECT = NULL, LPCTSTR = NULL, DWORD = 0, DWORD = 0, ATL::_U_MENUorID = 0U, LPVOID = NULL)
+        {
+                ATLASSERT(FALSE);
+                return NULL;
+        }
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CWizard97SheetImpl - implements a Wizard 97 style wizard sheet
+
+template <class T, class TBase = CWizard97SheetWindow>
+class ATL_NO_VTABLE CWizard97SheetImpl : public CPropertySheetImpl< T, TBase >
+{
+protected:
+// Typedefs
+        typedef CWizard97SheetImpl< T, TBase > thisClass;
+        typedef CPropertySheetImpl< T, TBase > baseClass;
+
+// Member variables
+        CFont m_fontExteriorPageTitle;   // Welcome and Completion page title font
+        CFont m_fontBullet;              // Bullet font (used on static text 'h' to produce a small bullet)
+        bool m_bReceivedFirstSizeMessage;   
+
+public:
+        CWizard97SheetImpl(ATL::_U_STRINGorID title, ATL::_U_STRINGorID headerBitmap, ATL::_U_STRINGorID watermarkBitmap, UINT uStartPage = 0, HWND hWndParent = NULL) :
+                        baseClass(title, uStartPage, hWndParent),
+                        m_bReceivedFirstSizeMessage(false)
+        {
+                m_psh.dwFlags &= ~(PSH_NOCONTEXTHELP);
+                m_psh.dwFlags &= ~(PSH_WIZARD | PSH_WIZARD_LITE);
+
+                m_psh.dwFlags |= (PSH_HASHELP | PSH_WIZARDCONTEXTHELP);
+                m_psh.dwFlags |= PSH_WIZARD97;
+
+                baseClass::SetHeader(headerBitmap.m_lpstr);
+                baseClass::SetWatermark(watermarkBitmap.m_lpstr);
+        }
+
+// Overrides from base class
+        void OnSheetInitialized()
+        {
+                T* pT = static_cast<T*>(this);
+                pT->_InitializeFonts();
+
+                // We'd like to center the wizard here, but its too early.
+                // Instead, we'll do CenterWindow upon our first WM_SIZE message
+        }
+
+// Initialization
+        void _InitializeFonts()
+        {
+                // Setup the Title and Bullet Font
+                // (Property pages can send the "get external page title font" and "get bullet font" messages)
+                // The derived class needs to do the actual SetFont for the dialog items)
+
+                CFontHandle fontThisDialog = this->GetFont();
+                CClientDC dcScreen(NULL);
+
+                LOGFONT titleLogFont = {0};
+                LOGFONT bulletLogFont = {0};
+                fontThisDialog.GetLogFont(&titleLogFont);
+                fontThisDialog.GetLogFont(&bulletLogFont);
+
+                // The Wizard 97 Spec recommends to do the Title Font
+                // as Verdana Bold, 12pt.
+                titleLogFont.lfCharSet = DEFAULT_CHARSET;
+                titleLogFont.lfWeight = FW_BOLD;
+                SecureHelper::strcpy_x(titleLogFont.lfFaceName, _countof(titleLogFont.lfFaceName), _T("Verdana Bold"));
+                INT titleFontPointSize = 12;
+                titleLogFont.lfHeight = -::MulDiv(titleFontPointSize, dcScreen.GetDeviceCaps(LOGPIXELSY), 72);
+                m_fontExteriorPageTitle.CreateFontIndirect(&titleLogFont);
+
+                // The Wizard 97 Spec recommends to do Bullets by having
+                // static text of "h" in the Marlett font.
+                bulletLogFont.lfCharSet = DEFAULT_CHARSET;
+                bulletLogFont.lfWeight = FW_NORMAL;
+                SecureHelper::strcpy_x(bulletLogFont.lfFaceName, _countof(bulletLogFont.lfFaceName), _T("Marlett"));
+                INT bulletFontSize = 8;
+                bulletLogFont.lfHeight = -::MulDiv(bulletFontSize, dcScreen.GetDeviceCaps(LOGPIXELSY), 72);
+                m_fontBullet.CreateFontIndirect(&bulletLogFont);
+        }
+
+// Message Handling
+        BEGIN_MSG_MAP(thisClass)
+                MESSAGE_HANDLER(CWizard97SheetWindow::GetMessage_GetExteriorPageTitleFont(), OnGetExteriorPageTitleFont)
+                MESSAGE_HANDLER(CWizard97SheetWindow::GetMessage_GetBulletFont(), OnGetBulletFont)
+                MESSAGE_HANDLER(WM_SIZE, OnSize)
+                CHAIN_MSG_MAP(baseClass)
+        END_MSG_MAP()
+
+        LRESULT OnGetExteriorPageTitleFont(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
+        {
+                return (LRESULT)(HFONT)m_fontExteriorPageTitle;
+        }
+
+        LRESULT OnGetBulletFont(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
+        {
+                return (LRESULT)(HFONT)m_fontBullet;
+        }
+
+        LRESULT OnSize(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& bHandled)
+        {
+                if(!m_bReceivedFirstSizeMessage)
+                {
+                        m_bReceivedFirstSizeMessage = true;
+                        this->CenterWindow();
+                }
+
+                bHandled = FALSE;
+                return 0;
+        }
+};
+
+// for non-customized sheets
+class CWizard97Sheet : public CWizard97SheetImpl<CWizard97Sheet>
+{
+protected:
+// Typedefs
+        typedef CWizard97Sheet thisClass;
+        typedef CWizard97SheetImpl<CWizard97Sheet> baseClass;
+
+public:
+        CWizard97Sheet(ATL::_U_STRINGorID title, ATL::_U_STRINGorID headerBitmap, ATL::_U_STRINGorID watermarkBitmap, UINT uStartPage = 0, HWND hWndParent = NULL) :
+                baseClass(title, headerBitmap, watermarkBitmap, uStartPage, hWndParent)
+        { }
+
+        BEGIN_MSG_MAP(thisClass)
+                CHAIN_MSG_MAP(baseClass)
+        END_MSG_MAP()
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CWizard97PageWindow - client side for a Wizard 97 style wizard page
+
+#define WIZARD97_EXTERIOR_CXDLG 317
+#define WIZARD97_EXTERIOR_CYDLG 193
+
+#define WIZARD97_INTERIOR_CXDLG 317
+#define WIZARD97_INTERIOR_CYDLG 143
+
+class CWizard97PageWindow : public CPropertyPageWindow
+{
+public:
+// Constructors
+        CWizard97PageWindow(HWND hWnd = NULL) : CPropertyPageWindow(hWnd)
+        { }
+
+        CWizard97PageWindow& operator =(HWND hWnd)
+        {
+                m_hWnd = hWnd;
+                return *this;
+        }
+
+// Attributes
+        CWizard97SheetWindow GetPropertySheet() const
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                return CWizard97SheetWindow(GetParent());
+        }
+
+// Operations
+        HFONT GetExteriorPageTitleFont(void)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                return GetPropertySheet().GetExteriorPageTitleFont();
+        }
+
+        HFONT GetBulletFont(void)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                return GetPropertySheet().GetBulletFont();
+        }
+
+// Implementation - overrides to prevent usage
+        HWND Create(LPCTSTR, HWND, ATL::_U_RECT = NULL, LPCTSTR = NULL, DWORD = 0, DWORD = 0, ATL::_U_MENUorID = 0U, LPVOID = NULL)
+        {
+                ATLASSERT(FALSE);
+                return NULL;
+        }
+
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CWizard97PageImpl - implements a Wizard 97 style wizard page
+
+template <class T, class TBase = CWizard97PageWindow>
+class ATL_NO_VTABLE CWizard97PageImpl : public CPropertyPageImpl< T, TBase >
+{
+protected:
+// Typedefs
+        typedef CWizard97PageImpl< T, TBase > thisClass;
+        typedef CPropertyPageImpl< T, TBase > baseClass;
+
+public:
+        CWizard97PageImpl(ATL::_U_STRINGorID title = (LPCTSTR)NULL) : baseClass(title)
+        { }
+
+// Message Handling
+        BEGIN_MSG_MAP(thisClass)
+                CHAIN_MSG_MAP(baseClass)
+        END_MSG_MAP()
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CWizard97ExteriorPageImpl - implements a Wizard 97 style exterior wizard page
+
+template <class T, class TBase = CWizard97PageWindow>
+class ATL_NO_VTABLE CWizard97ExteriorPageImpl : public CPropertyPageImpl< T, TBase >
+{
+protected:
+// Typedefs
+        typedef CWizard97ExteriorPageImpl< T, TBase > thisClass;
+        typedef CPropertyPageImpl< T, TBase > baseClass;
+
+public:
+// Constructors
+        CWizard97ExteriorPageImpl(ATL::_U_STRINGorID title = (LPCTSTR)NULL) : baseClass(title)
+        {
+                m_psp.dwFlags |= PSP_HASHELP;
+                m_psp.dwFlags |= PSP_HIDEHEADER;
+        }
+
+// Message Handling
+        BEGIN_MSG_MAP(thisClass)
+                CHAIN_MSG_MAP(baseClass)
+        END_MSG_MAP()
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CWizard97InteriorPageImpl - implements a Wizard 97 style interior wizard page
+
+template <class T, class TBase = CWizard97PageWindow>
+class ATL_NO_VTABLE CWizard97InteriorPageImpl : public CPropertyPageImpl< T, TBase >
+{
+protected:
+// Typedefs
+        typedef CWizard97InteriorPageImpl< T, TBase > thisClass;
+        typedef CPropertyPageImpl< T, TBase > baseClass;
+
+public:
+// Constructors
+        CWizard97InteriorPageImpl(ATL::_U_STRINGorID title = (LPCTSTR)NULL) : baseClass(title)
+        {
+                m_psp.dwFlags |= PSP_HASHELP;
+                m_psp.dwFlags &= ~PSP_HIDEHEADER;
+                m_psp.dwFlags |= PSP_USEHEADERTITLE | PSP_USEHEADERSUBTITLE;
+
+                // Be sure to have the derived class define this in the constructor.
+                // We'll default it to something obvious in case its forgotten.
+                baseClass::SetHeaderTitle(_T("Call SetHeaderTitle in Derived Class"));
+                baseClass::SetHeaderSubTitle(_T("Call SetHeaderSubTitle in the constructor of the Derived Class."));
+        }
+
+// Message Handling
+        BEGIN_MSG_MAP(thisClass)
+                CHAIN_MSG_MAP(baseClass)
+        END_MSG_MAP()
+};
+
+#endif // (_WIN32_IE >= 0x0500) && !defined(_WIN32_WCE)
+
+
+///////////////////////////////////////////////////////////////////////////////
+// Aero Wizard support
+
+#if (_WIN32_WINNT >= 0x0600) && !defined(_WIN32_WCE)
+
+///////////////////////////////////////////////////////////////////////////////
+// CAeroWizardFrameWindow - client side for an Aero Wizard frame window
+
+class CAeroWizardFrameWindow : public CPropertySheetWindow
+{
+public:
+// Constructors
+        CAeroWizardFrameWindow(HWND hWnd = NULL) : CPropertySheetWindow(hWnd)
+        { }
+
+        CAeroWizardFrameWindow& operator =(HWND hWnd)
+        {
+                m_hWnd = hWnd;
+                return *this;
+        }
+
+// Operations - new, Aero Wizard only
+        void SetNextText(LPCWSTR lpszText)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ::SendMessage(m_hWnd, PSM_SETNEXTTEXT, 0, (LPARAM)lpszText);
+        }
+
+        void ShowWizardButtons(DWORD dwButtons, DWORD dwStates)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ::PostMessage(m_hWnd, PSM_SHOWWIZBUTTONS, (WPARAM)dwStates, (LPARAM)dwButtons);
+        }
+
+        void EnableWizardButtons(DWORD dwButtons, DWORD dwStates)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ::PostMessage(m_hWnd, PSM_ENABLEWIZBUTTONS, (WPARAM)dwStates, (LPARAM)dwButtons);
+        }
+
+        void SetButtonText(DWORD dwButton, LPCWSTR lpszText)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ::SendMessage(m_hWnd, PSM_SETBUTTONTEXT, (WPARAM)dwButton, (LPARAM)lpszText);
+        }
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CAeroWizardFrameImpl - implements an Aero Wizard frame
+
+template <class T, class TBase = CAeroWizardFrameWindow>
+class ATL_NO_VTABLE CAeroWizardFrameImpl : public CPropertySheetImpl<T, TBase >
+{
+public:
+// Constructor
+        CAeroWizardFrameImpl(ATL::_U_STRINGorID title = (LPCTSTR)NULL, UINT uStartPage = 0, HWND hWndParent = NULL) :
+                CPropertySheetImpl<T, TBase >(title, uStartPage, hWndParent)
+        {
+                m_psh.dwFlags |= PSH_WIZARD | PSH_AEROWIZARD;
+        }
+
+// Operations
+        void EnableResizing()
+        {
+                ATLASSERT(m_hWnd == NULL);   // can't do this after it's created
+                m_psh.dwFlags |= PSH_RESIZABLE;
+        }
+
+        void UseHeaderBitmap()
+        {
+                ATLASSERT(m_hWnd == NULL);   // can't do this after it's created
+                m_psh.dwFlags |= PSH_HEADERBITMAP;
+        }
+
+        void SetNoMargin()
+        {
+                ATLASSERT(m_hWnd == NULL);   // can't do this after it's created
+                m_psh.dwFlags |= PSH_NOMARGIN;
+        }
+
+// Override to prevent use
+        HWND Create(HWND /*hWndParent*/ = NULL)
+        {
+                ATLASSERT(FALSE);   // not supported for Aero Wizard
+                return NULL;
+        }
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CAeroWizardFrame - for non-customized frames
+
+class CAeroWizardFrame : public CAeroWizardFrameImpl<CAeroWizardFrame>
+{
+public:
+        CAeroWizardFrame(ATL::_U_STRINGorID title = (LPCTSTR)NULL, UINT uStartPage = 0, HWND hWndParent = NULL)
+                : CAeroWizardFrameImpl<CAeroWizardFrame>(title, uStartPage, hWndParent)
+        { }
+
+        BEGIN_MSG_MAP(CAeroWizardFrame)
+                MESSAGE_HANDLER(WM_COMMAND, CAeroWizardFrameImpl<CAeroWizardFrame>::OnCommand)
+        END_MSG_MAP()
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CAeroWizardPageWindow - client side for an Aero Wizard page
+
+class CAeroWizardPageWindow : public CPropertyPageWindow
+{
+public:
+// Constructors
+        CAeroWizardPageWindow(HWND hWnd = NULL) : CPropertyPageWindow(hWnd)
+        { }
+
+        CAeroWizardPageWindow& operator =(HWND hWnd)
+        {
+                m_hWnd = hWnd;
+                return *this;
+        }
+
+// Attributes
+        CAeroWizardFrameWindow GetAeroWizardFrame() const
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                // This is not really top-level frame window, but it processes all frame messages
+                return CAeroWizardFrameWindow(GetParent());
+        }
+
+// Operations - new, Aero Wizard only
+        void SetNextText(LPCWSTR lpszText)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT(GetParent() != NULL);
+                GetAeroWizardFrame().SetNextText(lpszText);
+        }
+
+        void ShowWizardButtons(DWORD dwButtons, DWORD dwStates)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT(GetParent() != NULL);
+                GetAeroWizardFrame().ShowWizardButtons(dwButtons, dwStates);
+        }
+
+        void EnableWizardButtons(DWORD dwButtons, DWORD dwStates)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT(GetParent() != NULL);
+                GetAeroWizardFrame().EnableWizardButtons(dwButtons, dwStates);
+        }
+
+        void SetButtonText(DWORD dwButton, LPCWSTR lpszText)
+        {
+                ATLASSERT(::IsWindow(m_hWnd));
+                ATLASSERT(GetParent() != NULL);
+                GetAeroWizardFrame().SetButtonText(dwButton, lpszText);
+        }
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CAeroWizardPageImpl - implements an Aero Wizard page
+
+template <class T, class TBase = CAeroWizardPageWindow>
+class ATL_NO_VTABLE CAeroWizardPageImpl : public CPropertyPageImpl<T, TBase >
+{
+public:
+        CAeroWizardPageImpl(ATL::_U_STRINGorID title = (LPCTSTR)NULL) : CPropertyPageImpl<T, TBase >(title)
+        { }
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CAeroWizardPage - for non-customized pages
+
+template <WORD t_wDlgTemplateID>
+class CAeroWizardPage : public CAeroWizardPageImpl<CAeroWizardPage<t_wDlgTemplateID> >
+{
+public:
+        enum { IDD = t_wDlgTemplateID };
+
+        CAeroWizardPage(ATL::_U_STRINGorID title = (LPCTSTR)NULL) : CAeroWizardPageImpl<CAeroWizardPage>(title)
+        { }
+
+        DECLARE_EMPTY_MSG_MAP()
+};
+
+
+#ifndef _ATL_NO_HOSTING
+
+// Note: You must #include <atlhost.h> to use these classes
+
+///////////////////////////////////////////////////////////////////////////////
+// CAeroWizardAxPageImpl - Aero Wizard page that hosts ActiveX controls
+
+template <class T, class TBase = CAeroWizardPageWindow>
+class ATL_NO_VTABLE CAeroWizardAxPageImpl : public CAxPropertyPageImpl< T, TBase >
+{
+public:
+        CAeroWizardAxPageImpl(ATL::_U_STRINGorID title = (LPCTSTR)NULL) : CAxPropertyPageImpl< T, TBase >(title)
+        { }
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CAeroWizardAxPage - for non-customized pages
+
+template <WORD t_wDlgTemplateID>
+class CAeroWizardAxPage : public CAeroWizardAxPageImpl<CAeroWizardAxPage<t_wDlgTemplateID> >
+{
+public:
+        enum { IDD = t_wDlgTemplateID };
+
+        CAeroWizardAxPage(ATL::_U_STRINGorID title = (LPCTSTR)NULL) : CAeroWizardAxPageImpl<CAeroWizardAxPage>(title)
+        { }
+
+#if (_WIN32_IE >= 0x0500) || (_ATL_VER >= 0x0700)
+        // not empty so we handle accelerators/create controls
+        BEGIN_MSG_MAP(CAeroWizardAxPage)
+                CHAIN_MSG_MAP(CAeroWizardAxPageImpl<CAeroWizardAxPage<t_wDlgTemplateID> >)
+        END_MSG_MAP()
+#else // !((_WIN32_IE >= 0x0500) || (_ATL_VER >= 0x0700))
+        DECLARE_EMPTY_MSG_MAP()
+#endif // !((_WIN32_IE >= 0x0500) || (_ATL_VER >= 0x0700))
+};
+
+#endif // _ATL_NO_HOSTING
+
+#endif // (_WIN32_WINNT >= 0x0600) && !defined(_WIN32_WCE)
+
+
+///////////////////////////////////////////////////////////////////////////////
+// TaskDialog support
+
+#if ((_WIN32_WINNT >= 0x0600) || defined(_WTL_TASKDIALOG)) && !defined(_WIN32_WCE)
+
+///////////////////////////////////////////////////////////////////////////////
+// AtlTaskDialog - support for TaskDialog() function
+
+inline int AtlTaskDialog(HWND hWndParent, 
+                         ATL::_U_STRINGorID WindowTitle, ATL::_U_STRINGorID MainInstructionText, ATL::_U_STRINGorID ContentText, 
+                         TASKDIALOG_COMMON_BUTTON_FLAGS dwCommonButtons = 0U, ATL::_U_STRINGorID Icon = (LPCTSTR)NULL)
+{
+        int nRet = -1;
+
+#ifdef _WTL_TASKDIALOG_DIRECT
+        USES_CONVERSION;
+        HRESULT hRet = ::TaskDialog(hWndParent, ModuleHelper::GetResourceInstance(), T2CW(WindowTitle.m_lpstr), T2CW(MainInstructionText.m_lpstr), T2CW(ContentText.m_lpstr), dwCommonButtons, T2CW(Icon.m_lpstr), &nRet);
+        ATLVERIFY(SUCCEEDED(hRet));
+#else
+        // This allows apps to run on older versions of Windows
+        typedef HRESULT (STDAPICALLTYPE *PFN_TaskDialog)(HWND hwndParent, HINSTANCE hInstance, PCWSTR pszWindowTitle, PCWSTR pszMainInstruction, PCWSTR pszContent, TASKDIALOG_COMMON_BUTTON_FLAGS dwCommonButtons, PCWSTR pszIcon, int* pnButton);
+
+        HMODULE m_hCommCtrlDLL = ::LoadLibrary(_T("comctl32.dll"));
+        if(m_hCommCtrlDLL != NULL)
+        {
+                PFN_TaskDialog pfnTaskDialog = (PFN_TaskDialog)::GetProcAddress(m_hCommCtrlDLL, "TaskDialog");
+                if(pfnTaskDialog != NULL)
+                {
+                        USES_CONVERSION;
+                        HRESULT hRet = pfnTaskDialog(hWndParent, ModuleHelper::GetResourceInstance(), T2CW(WindowTitle.m_lpstr), T2CW(MainInstructionText.m_lpstr), T2CW(ContentText.m_lpstr), dwCommonButtons, T2CW(Icon.m_lpstr), &nRet);
+                        ATLVERIFY(SUCCEEDED(hRet));
+                }
+
+                ::FreeLibrary(m_hCommCtrlDLL);
+        }
+#endif
+
+        return nRet;
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CTaskDialogConfig - TASKDIALOGCONFIG wrapper
+
+class CTaskDialogConfig : public TASKDIALOGCONFIG
+{
+public:
+// Constructor
+        CTaskDialogConfig()
+        {
+                Init();
+        }
+
+        void Init()
+        {
+                memset(this, 0, sizeof(TASKDIALOGCONFIG));   // initialize structure to 0/NULL
+                this->cbSize = sizeof(TASKDIALOGCONFIG);
+                this->hInstance = ModuleHelper::GetResourceInstance();
+        }
+
+// Operations - setting values
+        // common buttons
+        void SetCommonButtons(TASKDIALOG_COMMON_BUTTON_FLAGS dwCommonButtons)
+        {
+                this->dwCommonButtons = dwCommonButtons;
+        }
+
+        // window title text
+        void SetWindowTitle(UINT nID)
+        {
+                this->pszWindowTitle = MAKEINTRESOURCEW(nID);
+        }
+
+        void SetWindowTitle(LPCWSTR lpstrWindowTitle)
+        {
+                this->pszWindowTitle = lpstrWindowTitle;
+        }
+
+        // main icon
+        void SetMainIcon(HICON hIcon)
+        {
+                this->dwFlags |= TDF_USE_HICON_MAIN;
+                this->hMainIcon = hIcon;
+        }
+
+        void SetMainIcon(UINT nID)
+        {
+                this->dwFlags &= ~TDF_USE_HICON_MAIN;
+                this->pszMainIcon = MAKEINTRESOURCEW(nID);
+        }
+
+        void SetMainIcon(LPCWSTR lpstrMainIcon)
+        {
+                this->dwFlags &= ~TDF_USE_HICON_MAIN;
+                this->pszMainIcon = lpstrMainIcon;
+        }
+
+        // main instruction text
+        void SetMainInstructionText(UINT nID)
+        {
+                this->pszMainInstruction = MAKEINTRESOURCEW(nID);
+        }
+
+        void SetMainInstructionText(LPCWSTR lpstrMainInstruction)
+        {
+                this->pszMainInstruction = lpstrMainInstruction;
+        }
+
+        // content text
+        void SetContentText(UINT nID)
+        {
+                this->pszContent = MAKEINTRESOURCEW(nID);
+        }
+
+        void SetContentText(LPCWSTR lpstrContent)
+        {
+                this->pszContent = lpstrContent;
+        }
+
+        // buttons
+        void SetButtons(const TASKDIALOG_BUTTON* pButtons, UINT cButtons, int nDefaultButton = 0)
+        {
+                this->pButtons = pButtons;
+                this->cButtons = cButtons;
+                if(nDefaultButton != 0)
+                        this->nDefaultButton = nDefaultButton;
+        }
+
+        void SetDefaultButton(int nDefaultButton)
+        {
+                this->nDefaultButton = nDefaultButton;
+        }
+
+        // radio buttons
+        void SetRadioButtons(const TASKDIALOG_BUTTON* pRadioButtons, UINT cRadioButtons, int nDefaultRadioButton = 0)
+        {
+                this->pRadioButtons = pRadioButtons;
+                this->cRadioButtons = cRadioButtons;
+                if(nDefaultRadioButton != 0)
+                        this->nDefaultRadioButton = nDefaultRadioButton;
+        }
+
+        void SetDefaultRadioButton(int nDefaultRadioButton)
+        {
+                this->nDefaultRadioButton = nDefaultRadioButton;
+        }
+
+        // verification text
+        void SetVerificationText(UINT nID)
+        {
+                this->pszVerificationText = MAKEINTRESOURCEW(nID);
+        }
+
+        void SetVerificationText(LPCWSTR lpstrVerificationText)
+        {
+                this->pszVerificationText = lpstrVerificationText;
+        }
+
+        // expanded information text
+        void SetExpandedInformationText(UINT nID)
+        {
+                this->pszExpandedInformation = MAKEINTRESOURCEW(nID);
+        }
+
+        void SetExpandedInformationText(LPCWSTR lpstrExpandedInformation)
+        {
+                this->pszExpandedInformation = lpstrExpandedInformation;
+        }
+
+        // expanded control text
+        void SetExpandedControlText(UINT nID)
+        {
+                this->pszExpandedControlText = MAKEINTRESOURCEW(nID);
+        }
+
+        void SetExpandedControlText(LPCWSTR lpstrExpandedControlText)
+        {
+                this->pszExpandedControlText = lpstrExpandedControlText;
+        }
+
+        // collapsed control text
+        void SetCollapsedControlText(UINT nID)
+        {
+                this->pszCollapsedControlText = MAKEINTRESOURCEW(nID);
+        }
+
+        void SetCollapsedControlText(LPCWSTR lpstrCollapsedControlText)
+        {
+                this->pszCollapsedControlText = lpstrCollapsedControlText;
+        }
+
+        // footer icon
+        void SetFooterIcon(HICON hIcon)
+        {
+                this->dwFlags |= TDF_USE_HICON_FOOTER;
+                this->hFooterIcon = hIcon;
+        }
+
+        void SetFooterIcon(UINT nID)
+        {
+                this->dwFlags &= ~TDF_USE_HICON_FOOTER;
+                this->pszFooterIcon = MAKEINTRESOURCEW(nID);
+        }
+
+        void SetFooterIcon(LPCWSTR lpstrFooterIcon)
+        {
+                this->dwFlags &= ~TDF_USE_HICON_FOOTER;
+                this->pszFooterIcon = lpstrFooterIcon;
+        }
+
+        // footer text
+        void SetFooterText(UINT nID)
+        {
+                this->pszFooter = MAKEINTRESOURCEW(nID);
+        }
+
+        void SetFooterText(LPCWSTR lpstrFooterText)
+        {
+                this->pszFooter = lpstrFooterText;
+        }
+
+        // width (in DLUs)
+        void SetWidth(UINT cxWidth)
+        {
+                this->cxWidth = cxWidth;
+        }
+
+        // modify flags
+        void ModifyFlags(DWORD dwRemove, DWORD dwAdd)
+        {
+                this->dwFlags = (this->dwFlags & ~dwRemove) | dwAdd;
+        }
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CTaskDialogImpl - implements a Task Dialog
+
+template <class T>
+class ATL_NO_VTABLE CTaskDialogImpl
+{
+public:
+        CTaskDialogConfig m_tdc;
+        HWND m_hWnd;   // used only in callback functions
+
+// Constructor
+        CTaskDialogImpl(HWND hWndParent = NULL) : m_hWnd(NULL)
+        {
+                m_tdc.hwndParent = hWndParent;
+                m_tdc.pfCallback = T::TaskDialogCallback;
+                m_tdc.lpCallbackData = (LONG_PTR)static_cast<T*>(this);
+        }
+
+// Operations
+        HRESULT DoModal(HWND hWndParent = ::GetActiveWindow(), int* pnButton = NULL, int* pnRadioButton = NULL, BOOL* pfVerificationFlagChecked = NULL)
+        {
+                if(m_tdc.hwndParent == NULL)
+                        m_tdc.hwndParent = hWndParent;
+
+#ifdef _WTL_TASKDIALOG_DIRECT
+                return ::TaskDialogIndirect(&m_tdc, pnButton, pnRadioButton, pfVerificationFlagChecked);
+#else
+
+                // This allows apps to run on older versions of Windows
+                typedef HRESULT (STDAPICALLTYPE *PFN_TaskDialogIndirect)(const TASKDIALOGCONFIG* pTaskConfig, int* pnButton, int* pnRadioButton, BOOL* pfVerificationFlagChecked);
+
+                HRESULT hRet = E_UNEXPECTED;
+                HMODULE m_hCommCtrlDLL = ::LoadLibrary(_T("comctl32.dll"));
+                if(m_hCommCtrlDLL != NULL)
+                {
+                        PFN_TaskDialogIndirect pfnTaskDialogIndirect = (PFN_TaskDialogIndirect)::GetProcAddress(m_hCommCtrlDLL, "TaskDialogIndirect");
+                        if(pfnTaskDialogIndirect != NULL)
+                                hRet = pfnTaskDialogIndirect(&m_tdc, pnButton, pnRadioButton, pfVerificationFlagChecked);
+
+                        ::FreeLibrary(m_hCommCtrlDLL);
+                }
+
+                return hRet;
+#endif
+        }
+
+// Operations - setting values of TASKDIALOGCONFIG
+        // common buttons
+        void SetCommonButtons(TASKDIALOG_COMMON_BUTTON_FLAGS dwCommonButtons)
+        {       m_tdc.SetCommonButtons(dwCommonButtons); }
+        // window title text
+        void SetWindowTitle(UINT nID)
+        {       m_tdc.SetWindowTitle(nID); }
+        void SetWindowTitle(LPCWSTR lpstrWindowTitle)
+        {       m_tdc.SetWindowTitle(lpstrWindowTitle); }
+        // main icon
+        void SetMainIcon(HICON hIcon)
+        {       m_tdc.SetMainIcon(hIcon); }
+        void SetMainIcon(UINT nID)
+        {       m_tdc.SetMainIcon(nID); }
+        void SetMainIcon(LPCWSTR lpstrMainIcon)
+        {       m_tdc.SetMainIcon(lpstrMainIcon); }
+        // main instruction text
+        void SetMainInstructionText(UINT nID)
+        {       m_tdc.SetMainInstructionText(nID); }
+        void SetMainInstructionText(LPCWSTR lpstrMainInstruction)
+        {       m_tdc.SetMainInstructionText(lpstrMainInstruction); }
+        // content text
+        void SetContentText(UINT nID)
+        {       m_tdc.SetContentText(nID); }
+        void SetContentText(LPCWSTR lpstrContent)
+        {       m_tdc.SetContentText(lpstrContent); }
+        // buttons
+        void SetButtons(const TASKDIALOG_BUTTON* pButtons, UINT cButtons, int nDefaultButton = 0)
+        {       m_tdc.SetButtons(pButtons, cButtons, nDefaultButton); }
+        void SetDefaultButton(int nDefaultButton)
+        {       m_tdc.SetDefaultButton(nDefaultButton); }
+        // radio buttons
+        void SetRadioButtons(const TASKDIALOG_BUTTON* pRadioButtons, UINT cRadioButtons, int nDefaultRadioButton = 0)
+        {       m_tdc.SetRadioButtons(pRadioButtons, cRadioButtons, nDefaultRadioButton); }
+        void SetDefaultRadioButton(int nDefaultRadioButton)
+        {       m_tdc.SetDefaultRadioButton(nDefaultRadioButton); }
+        // verification text
+        void SetVerificationText(UINT nID)
+        {       m_tdc.SetVerificationText(nID); }
+        void SetVerificationText(LPCWSTR lpstrVerificationText)
+        {       m_tdc.SetVerificationText(lpstrVerificationText); }
+        // expanded information text
+        void SetExpandedInformationText(UINT nID)
+        {       m_tdc.SetExpandedInformationText(nID); }
+        void SetExpandedInformationText(LPCWSTR lpstrExpandedInformation)
+        {       m_tdc.SetExpandedInformationText(lpstrExpandedInformation); }
+        // expanded control text
+        void SetExpandedControlText(UINT nID)
+        {       m_tdc.SetExpandedControlText(nID); }
+        void SetExpandedControlText(LPCWSTR lpstrExpandedControlText)
+        {       m_tdc.SetExpandedControlText(lpstrExpandedControlText); }
+        // collapsed control text
+        void SetCollapsedControlText(UINT nID)
+        {       m_tdc.SetCollapsedControlText(nID); }
+        void SetCollapsedControlText(LPCWSTR lpstrCollapsedControlText)
+        {       m_tdc.SetCollapsedControlText(lpstrCollapsedControlText); }
+        // footer icon
+        void SetFooterIcon(HICON hIcon)
+        {       m_tdc.SetFooterIcon(hIcon); }
+        void SetFooterIcon(UINT nID)
+        {       m_tdc.SetFooterIcon(nID); }
+        void SetFooterIcon(LPCWSTR lpstrFooterIcon)
+        {       m_tdc.SetFooterIcon(lpstrFooterIcon); }
+        // footer text
+        void SetFooterText(UINT nID)
+        {       m_tdc.SetFooterText(nID); }
+        void SetFooterText(LPCWSTR lpstrFooterText)
+        {       m_tdc.SetFooterText(lpstrFooterText); }
+        // width (in DLUs)
+        void SetWidth(UINT cxWidth)
+        {       m_tdc.SetWidth(cxWidth); }
+        // modify flags
+        void ModifyFlags(DWORD dwRemove, DWORD dwAdd)
+        {       m_tdc.ModifyFlags(dwRemove, dwAdd); }
+
+// Implementation
+        static HRESULT CALLBACK TaskDialogCallback(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam, LONG_PTR lpRefData)
+        {
+                T* pT = (T*)lpRefData;
+                ATLASSERT(pT->m_hWnd == NULL || pT->m_hWnd == hWnd);
+
+                BOOL bRet = FALSE;
+                switch(uMsg)
+                {
+                case TDN_DIALOG_CONSTRUCTED:
+                        pT->m_hWnd = hWnd;
+                        pT->OnDialogConstructed();
+                        break;
+                case TDN_CREATED:
+                        pT->OnCreated();
+                        break;
+                case TDN_BUTTON_CLICKED:
+                        bRet = pT->OnButtonClicked((int)wParam);
+                        break;
+                case TDN_RADIO_BUTTON_CLICKED:
+                        pT->OnRadioButtonClicked((int)wParam);
+                        break;
+                case TDN_HYPERLINK_CLICKED:
+                        pT->OnHyperlinkClicked((LPCWSTR)lParam);
+                        break;
+                case TDN_EXPANDO_BUTTON_CLICKED:
+                        pT->OnExpandoButtonClicked((wParam != 0));
+                        break;
+                case TDN_VERIFICATION_CLICKED:
+                        pT->OnVerificationClicked((wParam != 0));
+                        break;
+                case TDN_HELP:
+                        pT->OnHelp();
+                        break;
+                case TDN_TIMER:
+                        bRet = pT->OnTimer((DWORD)wParam);
+                        break;
+                case TDN_NAVIGATED:
+                        pT->OnNavigated();
+                        break;
+                case TDN_DESTROYED:
+                        pT->OnDestroyed();
+                        pT->m_hWnd = NULL;
+                        break;
+                default:
+                        ATLTRACE2(atlTraceUI, 0, _T("Unknown notification received in CTaskDialogImpl::TaskDialogCallback\n"));
+                        break;
+                }
+
+                return (HRESULT)bRet;
+        }
+
+// Overrideables - notification handlers
+        void OnDialogConstructed()
+        {
+        }
+
+        void OnCreated()
+        {
+        }
+
+        BOOL OnButtonClicked(int /*nButton*/)
+        {
+                return FALSE;   // don't prevent dialog to close
+        }
+
+        void OnRadioButtonClicked(int /*nRadioButton*/)
+        {
+        }
+
+        void OnHyperlinkClicked(LPCWSTR /*pszHREF*/)
+        {
+        }
+
+        void OnExpandoButtonClicked(bool /*bExpanded*/)
+        {
+        }
+
+        void OnVerificationClicked(bool /*bChecked*/)
+        {
+        }
+
+        void OnHelp()
+        {
+        }
+
+        BOOL OnTimer(DWORD /*dwTickCount*/)
+        {
+                return FALSE;   // don't reset counter
+        }
+
+        void OnNavigated()
+        {
+        }
+
+        void OnDestroyed()
+        {
+        }
+
+// Commands - valid to call only from handlers
+        void NavigatePage(TASKDIALOGCONFIG& tdc)
+        {
+                ATLASSERT(m_hWnd != NULL);
+
+                tdc.cbSize = sizeof(TASKDIALOGCONFIG);
+                if(tdc.hwndParent == NULL)
+                        tdc.hwndParent = m_tdc.hwndParent;
+                tdc.pfCallback = m_tdc.pfCallback;
+                tdc.lpCallbackData = m_tdc.lpCallbackData;
+                (TASKDIALOGCONFIG)m_tdc = tdc;
+
+                ::SendMessage(m_hWnd, TDM_NAVIGATE_PAGE, 0, (LPARAM)&tdc);
+        }
+
+        // modify TASKDIALOGCONFIG values, then call this to update task dialog
+        void NavigatePage()
+        {
+                ATLASSERT(m_hWnd != NULL);
+                ::SendMessage(m_hWnd, TDM_NAVIGATE_PAGE, 0, (LPARAM)&m_tdc);
+        }
+
+        void ClickButton(int nButton)
+        {
+                ATLASSERT(m_hWnd != NULL);
+                ::SendMessage(m_hWnd, TDM_CLICK_BUTTON, nButton, 0L);
+        }
+
+        void SetMarqueeProgressBar(BOOL bMarquee)
+        {
+                ATLASSERT(m_hWnd != NULL);
+                ::SendMessage(m_hWnd, TDM_SET_MARQUEE_PROGRESS_BAR, bMarquee, 0L);
+        }
+
+        BOOL SetProgressBarState(int nNewState)
+        {
+                ATLASSERT(m_hWnd != NULL);
+                return (BOOL)::SendMessage(m_hWnd, TDM_SET_PROGRESS_BAR_STATE, nNewState, 0L);
+        }
+
+        DWORD SetProgressBarRange(int nMinRange, int nMaxRange)
+        {
+                ATLASSERT(m_hWnd != NULL);
+                return (DWORD)::SendMessage(m_hWnd, TDM_SET_PROGRESS_BAR_RANGE, 0, MAKELPARAM(nMinRange, nMaxRange));
+        }
+
+        int SetProgressBarPos(int nNewPos)
+        {
+                ATLASSERT(m_hWnd != NULL);
+                return (int)::SendMessage(m_hWnd, TDM_SET_PROGRESS_BAR_POS, nNewPos, 0L);
+        }
+
+        BOOL SetProgressBarMarquee(BOOL bMarquee, UINT uSpeed)
+        {
+                ATLASSERT(m_hWnd != NULL);
+                return (BOOL)::SendMessage(m_hWnd, TDM_SET_PROGRESS_BAR_MARQUEE, bMarquee, uSpeed);
+        }
+
+        void SetElementText(TASKDIALOG_ELEMENTS element, LPCWSTR lpstrText)
+        {
+                ATLASSERT(m_hWnd != NULL);
+                ::SendMessage(m_hWnd, TDM_SET_ELEMENT_TEXT, element, (LPARAM)lpstrText);
+        }
+
+        void ClickRadioButton(int nRadioButton)
+        {
+                ATLASSERT(m_hWnd != NULL);
+                ::SendMessage(m_hWnd, TDM_CLICK_RADIO_BUTTON, nRadioButton, 0L);
+        }
+
+        void EnableButton(int nButton, BOOL bEnable)
+        {
+                ATLASSERT(m_hWnd != NULL);
+                ::SendMessage(m_hWnd, TDM_ENABLE_BUTTON, nButton, bEnable);
+        }
+
+        void EnableRadioButton(int nButton, BOOL bEnable)
+        {
+                ATLASSERT(m_hWnd != NULL);
+                ::SendMessage(m_hWnd, TDM_ENABLE_RADIO_BUTTON, nButton, bEnable);
+        }
+
+        void ClickVerification(BOOL bCheck, BOOL bFocus)
+        {
+                ATLASSERT(m_hWnd != NULL);
+                ::SendMessage(m_hWnd, TDM_CLICK_VERIFICATION, bCheck, bFocus);
+        }
+
+        void UpdateElementText(TASKDIALOG_ELEMENTS element, LPCWSTR lpstrText)
+        {
+                ATLASSERT(m_hWnd != NULL);
+                ::SendMessage(m_hWnd, TDM_UPDATE_ELEMENT_TEXT, element, (LPARAM)lpstrText);
+        }
+
+        void SetButtonElevationRequiredState(int nButton, BOOL bElevation)
+        {
+                ATLASSERT(m_hWnd != NULL);
+                ::SendMessage(m_hWnd, TDM_SET_BUTTON_ELEVATION_REQUIRED_STATE, nButton, bElevation);
+        }
+
+        void UpdateIcon(TASKDIALOG_ICON_ELEMENTS element, HICON hIcon)
+        {
+                ATLASSERT(m_hWnd != NULL);
+#ifdef _DEBUG
+                if(element == TDIE_ICON_MAIN)
+                        ATLASSERT((m_tdc.dwFlags & TDF_USE_HICON_MAIN) != 0);
+                else if(element == TDIE_ICON_FOOTER)
+                        ATLASSERT((m_tdc.dwFlags & TDF_USE_HICON_FOOTER) != 0);
+#endif // _DEBUG
+                ::SendMessage(m_hWnd, TDM_UPDATE_ICON, element, (LPARAM)hIcon);
+        }
+
+        void UpdateIcon(TASKDIALOG_ICON_ELEMENTS element, LPCWSTR lpstrIcon)
+        {
+                ATLASSERT(m_hWnd != NULL);
+#ifdef _DEBUG
+                if(element == TDIE_ICON_MAIN)
+                        ATLASSERT((m_tdc.dwFlags & TDF_USE_HICON_MAIN) == 0);
+                else if(element == TDIE_ICON_FOOTER)
+                        ATLASSERT((m_tdc.dwFlags & TDF_USE_HICON_FOOTER) == 0);
+#endif // _DEBUG
+                ::SendMessage(m_hWnd, TDM_UPDATE_ICON, element, (LPARAM)lpstrIcon);
+        }
+};
+
+
+///////////////////////////////////////////////////////////////////////////////
+// CTaskDialog - for non-customized task dialogs
+
+class CTaskDialog : public CTaskDialogImpl<CTaskDialog>
+{
+public:
+        CTaskDialog(HWND hWndParent = NULL) : CTaskDialogImpl<CTaskDialog>(hWndParent)
+        {
+                m_tdc.pfCallback = NULL;
+        }
+};
+
+#endif // ((_WIN32_WINNT >= 0x0600) || defined(_WTL_TASKDIALOG)) && !defined(_WIN32_WCE)
+
+}; // namespace WTL
+
+#endif // __ATLDLGS_H__