pollymc/mmc_updater/depends/win32cpp/propertysheet.h

// Win32++   Version 7.2
// Released: 5th AUgust 2011
//
//      David Nash
//      email: dnash@bigpond.net.au
//      url: https://sourceforge.net/projects/win32-framework
//
//
// Copyright (c) 2005-2011  David Nash
//
// Permission is hereby granted, free of charge, to
// any person obtaining a copy of this software and
// associated documentation files (the "Software"),
// to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify,
// merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom
// the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice
// shall be included in all copies or substantial portions
// of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
// ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
// TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
// PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
// SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
// ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
// OR OTHER DEALINGS IN THE SOFTWARE.
//
////////////////////////////////////////////////////////


///////////////////////////////////////////////////////
// propertysheet.h
//  Declaration of the following classes:
//  CPropertyPage and CPropertySheet

// These classes add support for property sheets to Win32++. A property sheet
// will have one or more property pages. These pages are much like dialogs
// which are presented within a tabbed dialog or within a wizard. The data
// on a property page can be validated before the next page is presented.
// Property sheets have three modes of use: Modal, Modeless, and Wizard.
//
// Refer to the PropertySheet demo program for an example of how propert sheets
// can be used.


#ifndef _WIN32XX_PROPERTYSHEET_H_
#define _WIN32XX_PROPERTYSHEET_H_

#include "dialog.h"

#define ID_APPLY_NOW   0x3021
#define ID_WIZBACK     0x3023
#define ID_WIZNEXT     0x3024
#define ID_WIZFINISH   0x3025
#define ID_HELP        0xE146

#ifndef PROPSHEETHEADER_V1_SIZE
 #define PROPSHEETHEADER_V1_SIZE 40
#endif

namespace Win32xx
{
    class CPropertyPage;
	typedef Shared_Ptr<CPropertyPage> PropertyPagePtr;

	class CPropertyPage : public CWnd
	{
	public:
		CPropertyPage (UINT nIDTemplate, LPCTSTR szTitle = NULL);
		virtual ~CPropertyPage() {}

		virtual INT_PTR DialogProc(UINT uMsg, WPARAM wParam, LPARAM lParam);
		virtual INT_PTR DialogProcDefault(UINT uMsg, WPARAM wParam, LPARAM lParam);
		virtual int  OnApply();
		virtual void OnCancel();
		virtual void OnHelp();
		virtual BOOL OnInitDialog();
		virtual BOOL OnKillActive();
		virtual LRESULT OnNotify(WPARAM wParam, LPARAM lParam);
		virtual int  OnOK();
		virtual BOOL OnQueryCancel();
		virtual BOOL OnQuerySiblings(WPARAM wParam, LPARAM lParam);
		virtual int  OnSetActive();
		virtual int  OnWizardBack();
		virtual INT_PTR OnWizardFinish();
		virtual int  OnWizardNext();
		virtual	BOOL PreTranslateMessage(MSG* pMsg);

		static UINT CALLBACK StaticPropSheetPageProc(HWND hwnd, UINT uMsg, LPPROPSHEETPAGE ppsp);
		static INT_PTR CALLBACK StaticDialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);

		void CancelToClose() const;
		PROPSHEETPAGE GetPSP() const {return m_PSP;}
		BOOL IsButtonEnabled(int iButton) const;
		LRESULT QuerySiblings(WPARAM wParam, LPARAM lParam) const;
		void SetModified(BOOL bChanged) const;
		void SetTitle(LPCTSTR szTitle);
		void SetWizardButtons(DWORD dwFlags) const;

	protected:
		PROPSHEETPAGE m_PSP;

	private:
		CPropertyPage(const CPropertyPage&);				// Disable copy construction
		CPropertyPage& operator = (const CPropertyPage&);	// Disable assignment operator

		tString m_Title;
	};

	class CPropertySheet : public CWnd
	{
	public:
		CPropertySheet(UINT nIDCaption, CWnd* pParent = NULL);
		CPropertySheet(LPCTSTR pszCaption = NULL, CWnd* pParent = NULL);
		virtual ~CPropertySheet() {}

		// Operations
		virtual CPropertyPage* AddPage(CPropertyPage* pPage);
		virtual HWND Create(CWnd* pParent = 0);
		virtual INT_PTR CreatePropertySheet(LPCPROPSHEETHEADER ppsph);
		virtual void DestroyButton(int iButton);
		virtual void Destroy();
		virtual int DoModal();
		virtual void RemovePage(CPropertyPage* pPage);

		// State functions
		BOOL IsModeless() const;
		BOOL IsWizard() const;

		//Attributes
		CPropertyPage* GetActivePage() const;
		int GetPageCount() const;
		int GetPageIndex(CPropertyPage* pPage) const;
		HWND GetTabControl() const;
		virtual BOOL SetActivePage(int nPage);
		virtual BOOL SetActivePage(CPropertyPage* pPage);
		virtual void SetIcon(UINT idIcon);
		virtual void SetTitle(LPCTSTR szTitle);
		virtual void SetWizardMode(BOOL bWizard);

	protected:
		virtual BOOL PreTranslateMessage(MSG* pMsg);
		virtual LRESULT WndProcDefault(UINT uMsg, WPARAM wParam, LPARAM lParam);

	private:
		CPropertySheet(const CPropertySheet&);				// Disable copy construction
		CPropertySheet& operator = (const CPropertySheet&); // Disable assignment operator
		void BuildPageArray();
		static void CALLBACK Callback(HWND hwnd, UINT uMsg, LPARAM lParam);

		tString m_Title;
		std::vector<PropertyPagePtr> m_vPages;	// vector of CPropertyPage
		std::vector<PROPSHEETPAGE> m_vPSP;		// vector of PROPSHEETPAGE
		BOOL m_bInitialUpdate;
		PROPSHEETHEADER m_PSH;
	};

}

//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//

namespace Win32xx
{

	//////////////////////////////////////////
	// Definitions for the CPropertyPage class
	//
	inline CPropertyPage::CPropertyPage(UINT nIDTemplate, LPCTSTR szTitle /* = NULL*/)
	{
		ZeroMemory(&m_PSP, sizeof(PROPSHEETPAGE));
		SetTitle(szTitle);

		m_PSP.dwSize        = sizeof(PROPSHEETPAGE);
		m_PSP.dwFlags       |= PSP_USECALLBACK;
		m_PSP.hInstance     = GetApp()->GetResourceHandle();
		m_PSP.pszTemplate   = MAKEINTRESOURCE(nIDTemplate);
		m_PSP.pszTitle      = m_Title.c_str();
		m_PSP.pfnDlgProc    = (DLGPROC)CPropertyPage::StaticDialogProc;
		m_PSP.lParam        = (LPARAM)this;
		m_PSP.pfnCallback   = CPropertyPage::StaticPropSheetPageProc;
	}

	inline void CPropertyPage::CancelToClose() const
	// Disables the Cancel button and changes the text of the OK button to "Close."
	{
		assert(::IsWindow(m_hWnd));
		SendMessage(PSM_CANCELTOCLOSE, 0L, 0L);
	}


	inline INT_PTR CPropertyPage::DialogProc(UINT uMsg, WPARAM wParam, LPARAM lParam)
	{
		// Override this function in your class derrived from CPropertyPage if you wish to handle messages
		// A typical function might look like this:

		//	switch (uMsg)
		//	{
		//	case MESSAGE1:		// Some Win32 API message
		//		OnMessage1();	// A user defined function
		//		break;			// Also do default processing
		//	case MESSAGE2:
		//		OnMessage2();
		//		return x;		// Don't do default processing, but instead return
		//						//  a value recommended by the Win32 API documentation
		//	}

		// Always pass unhandled messages on to DialogProcDefault
		return DialogProcDefault(uMsg, wParam, lParam);
	}

	inline INT_PTR CPropertyPage::DialogProcDefault(UINT uMsg, WPARAM wParam, LPARAM lParam)
	// All DialogProc functions should pass unhandled messages to this function
	{
		LRESULT lr = 0L;

		switch (uMsg)
	    {
		case UWM_CLEANUPTEMPS:
			{
				TLSData* pTLSData = (TLSData*)TlsGetValue(GetApp()->GetTlsIndex());
				pTLSData->vTmpWnds.clear();
			}
			break;

	    case WM_INITDIALOG:
		    return OnInitDialog();

		case PSM_QUERYSIBLINGS:
			return (BOOL)OnQuerySiblings(wParam, lParam);

		case WM_COMMAND:
			{
				// Refelect this message if it's from a control
				CWnd* pWnd = GetApp()->GetCWndFromMap((HWND)lParam);
				if (pWnd != NULL)
					lr = pWnd->OnCommand(wParam, lParam);

				// Handle user commands
				if (!lr)
					lr =  OnCommand(wParam, lParam);

				if (lr) return 0L;
			}
			break;

		case WM_NOTIFY:
			{
				// Do Notification reflection if it came from a CWnd object
				HWND hwndFrom = ((LPNMHDR)lParam)->hwndFrom;
				CWnd* pWndFrom = GetApp()->GetCWndFromMap(hwndFrom);

				if (pWndFrom != NULL)
					lr = pWndFrom->OnNotifyReflect(wParam, lParam);
				else
				{
					// Some controls (eg ListView) have child windows.
					// Reflect those notifications too.
					CWnd* pWndFromParent = GetApp()->GetCWndFromMap(::GetParent(hwndFrom));
					if (pWndFromParent != NULL)
						lr = pWndFromParent->OnNotifyReflect(wParam, lParam);
				}

				// Handle user notifications
				if (!lr) lr = OnNotify(wParam, lParam);

				// Set the return code for notifications
				if (IsWindow())
					SetWindowLongPtr(DWLP_MSGRESULT, (LONG_PTR)lr);

				return (BOOL)lr;
			}

		case WM_PAINT:
			{
				if (::GetUpdateRect(m_hWnd, NULL, FALSE))
				{
					CPaintDC dc(this);
					OnDraw(&dc);
				}
				else
				// RedrawWindow can require repainting without an update rect
				{
					CClientDC dc(this);
					OnDraw(&dc);
				}

				break;
			}
			
		case WM_ERASEBKGND:
			{
				CDC dc((HDC)wParam);
				BOOL bResult = OnEraseBkgnd(&dc);
				dc.Detach();
				if (bResult) return TRUE;
			}
			break;

		// A set of messages to be reflected back to the control that generated them
		case WM_CTLCOLORBTN:
		case WM_CTLCOLOREDIT:
		case WM_CTLCOLORDLG:
		case WM_CTLCOLORLISTBOX:
		case WM_CTLCOLORSCROLLBAR:
		case WM_CTLCOLORSTATIC:
		case WM_DRAWITEM:
		case WM_MEASUREITEM:
		case WM_DELETEITEM:
		case WM_COMPAREITEM:
		case WM_CHARTOITEM:
		case WM_VKEYTOITEM:
		case WM_HSCROLL:
		case WM_VSCROLL:
		case WM_PARENTNOTIFY:
			return MessageReflect(m_hWnd, uMsg, wParam, lParam);

	    } // switch(uMsg)
	    return FALSE;

	} // INT_PTR CALLBACK CPropertyPage::DialogProc(...)

	inline BOOL CPropertyPage::IsButtonEnabled(int iButton) const
	{
		assert(::IsWindow(m_hWnd));
		return GetParent()->GetDlgItem(iButton)->IsWindowEnabled();
	}

	inline int CPropertyPage::OnApply()
	{
		// This function is called for each page when the Apply button is pressed
		// Override this function in your derived class if required.

		// The possible return values are:
		// PSNRET_NOERROR. The changes made to this page are valid and have been applied
		// PSNRET_INVALID. The property sheet will not be destroyed, and focus will be returned to this page.
		// PSNRET_INVALID_NOCHANGEPAGE. The property sheet will not be destroyed, and focus will be returned;

		return PSNRET_NOERROR;
	}

	inline void CPropertyPage::OnCancel()
	{
		// This function is called for each page when the Cancel button is pressed
		// Override this function in your derived class if required.
	}

	inline void CPropertyPage::OnHelp()
	{
		// This function is called in response to the PSN_HELP notification.
		SendMessage(m_hWnd, WM_COMMAND, ID_HELP, 0L);
	}

	inline BOOL CPropertyPage::OnQueryCancel()
	{
		// Called when the cancel button is pressed, and before the cancel has taken place
		// Returns TRUE to prevent the cancel operation, or FALSE to allow it.

		return FALSE;    // Allow cancel to proceed
	}

	inline BOOL CPropertyPage::OnQuerySiblings(WPARAM wParam, LPARAM lParam)
	{
		UNREFERENCED_PARAMETER(wParam);
		UNREFERENCED_PARAMETER(lParam);

		// Responds to a query request from the Property Sheet.
		// The values for wParam and lParam are the ones set by
		// the CPropertySheet::QuerySiblings call

		// return FALSE to allow other siblings to be queried, or
		// return TRUE to stop query at this page.

		return FALSE;
	}

	inline BOOL CPropertyPage::OnInitDialog()
	{
		// Called when the property page is created
		// Override this function in your derived class if required.

		return TRUE; // Pass Keyboard control to handle in WPARAM
	}

	inline BOOL CPropertyPage::OnKillActive()
	{
		// This is called in response to a PSN_KILLACTIVE notification, which
		// is sent whenever the OK or Apply button is pressed.
		// It provides an opportunity to validate the page contents before it's closed.
		// Return TRUE to prevent the page from losing the activation, or FALSE to allow it.

		return FALSE;
	}

	inline int CPropertyPage::OnOK()
	{
		// Called for each page when the OK button is pressed
		// Override this function in your derived class if required.

		// The possible return values are:
		// PSNRET_NOERROR. The changes made to this page are valid and have been applied
		// PSNRET_INVALID. The property sheet will not be destroyed, and focus will be returned to this page.
		// PSNRET_INVALID_NOCHANGEPAGE. The property sheet will not be destroyed, and focus will be returned;

		return PSNRET_NOERROR;
	}

	inline LRESULT CPropertyPage::OnNotify(WPARAM wParam, LPARAM lParam)
	{
		UNREFERENCED_PARAMETER(wParam);

		LPPSHNOTIFY pNotify = (LPPSHNOTIFY)lParam;
		switch(pNotify->hdr.code)
		{
		case PSN_SETACTIVE:
			return OnSetActive();
		case PSN_KILLACTIVE:
			return OnKillActive();
		case PSN_APPLY:
			if (pNotify->lParam)
				return OnOK();
			else
				return OnApply();
		case PSN_RESET:
			OnCancel();
			return FALSE;
		case PSN_QUERYCANCEL:
			return OnQueryCancel();
		case PSN_WIZNEXT:
			return OnWizardNext();
		case PSN_WIZBACK:
			return OnWizardBack();
		case PSN_WIZFINISH:
			return OnWizardFinish();
		case PSN_HELP:
			OnHelp();
			return TRUE;
		}
		return FALSE;
	}

	inline int CPropertyPage::OnSetActive()
	{
		// Called when a page becomes active
		// Override this function in your derived class if required.

		// Returns zero to accept the activation, or -1 to activate the next or the previous page (depending
		// on whether the user clicked the Next or Back button). To set the activation to a particular page,
		// return the resource identifier of the page.

		return 0;
	}

	inline int CPropertyPage::OnWizardBack()
	{
		// This function is called when the Back button is pressed on a wizard page
		// Override this function in your derived class if required.

		// Returns 0 to allow the wizard to go to the previous page. Returns -1 to prevent the wizard
		// from changing pages. To display a particular page, return its dialog resource identifier.

		return 0;
	}

	inline INT_PTR CPropertyPage::OnWizardFinish()
	{
		// This function is called when the Finish button is pressed on a wizard page
		// Override this function in your derived class if required.

		// Return Value:
		// Return non-zero to prevent the wizard from finishing.
		// Version 5.80. and later. Return a window handle to prevent the wizard from finishing. The wizard will set the focus to that window. The window must be owned by the wizard page.
		// Return 0 to allow the wizard to finish.

		return 0; // Allow wizard to finish
	}

	inline int CPropertyPage::OnWizardNext()
	{
		// This function is called when the Next button is pressed on a wizard page
		// Override this function in your derived class if required.

		// Return 0 to allow the wizard to go to the next page. Return -1 to prevent the wizard from
		// changing pages. To display a particular page, return its dialog resource identifier.

		return 0;
	}

	inline BOOL CPropertyPage::PreTranslateMessage(MSG* pMsg)
	{
		// allow the tab control to translate keyboard input
		if (pMsg->message == WM_KEYDOWN && GetAsyncKeyState(VK_CONTROL) < 0 &&
			(pMsg->wParam == VK_TAB || pMsg->wParam == VK_PRIOR || pMsg->wParam == VK_NEXT))
		{
			CWnd* pWndParent = GetParent();
			if (pWndParent->SendMessage(PSM_ISDIALOGMESSAGE, 0L, (LPARAM)pMsg))
				return TRUE;
		}

		// allow the dialog to translate keyboard input
		if ((pMsg->message >= WM_KEYFIRST) && (pMsg->message <= WM_KEYLAST))
		{
			if (IsDialogMessage(pMsg))
				return TRUE;
		}

		return CWnd::PreTranslateMessage(pMsg);
	}

	inline LRESULT CPropertyPage::QuerySiblings(WPARAM wParam, LPARAM lParam) const
	{
		// Sent to a property sheet, which then forwards the message to each of its pages.
		// Set wParam and lParam to values you want passed to the property pages.
		// Returns the nonzero value from a page in the property sheet, or zero if no page returns a nonzero value.

		assert(::IsWindow(m_hWnd));
		return GetParent()->SendMessage(PSM_QUERYSIBLINGS, wParam, lParam);
	}

	inline void CPropertyPage::SetModified(BOOL bChanged) const
	{
		// The property sheet will enable the Apply button if bChanged is TRUE.

		assert(::IsWindow(m_hWnd));

		if (bChanged)
			GetParent()->SendMessage(PSM_CHANGED, (WPARAM)m_hWnd, 0L);
		else
			GetParent()->SendMessage(PSM_UNCHANGED, (WPARAM)m_hWnd, 0L);
	}

	inline void CPropertyPage::SetTitle(LPCTSTR szTitle)
	{
		if (szTitle)
		{
			m_Title = szTitle;
			m_PSP.dwFlags |= PSP_USETITLE;
		}
		else
		{
			m_Title.erase();
			m_PSP.dwFlags &= ~PSP_USETITLE;
		}

		m_PSP.pszTitle = m_Title.c_str();
	}

	inline void CPropertyPage::SetWizardButtons(DWORD dwFlags) const
	{
		// dwFlags:  A value that specifies which wizard buttons are enabled. You can combine one or more of the following flags.
		//	PSWIZB_BACK				Enable the Back button. If this flag is not set, the Back button is displayed as disabled.
		//	PSWIZB_DISABLEDFINISH	Display a disabled Finish button.
		//	PSWIZB_FINISH			Display an enabled Finish button.
		//	PSWIZB_NEXT				Enable the Next button. If this flag is not set, the Next button is displayed as disabled.

		assert (::IsWindow(m_hWnd));
		PropSheet_SetWizButtons(::GetParent(m_hWnd), dwFlags);
	}

	inline UINT CALLBACK CPropertyPage::StaticPropSheetPageProc(HWND hwnd, UINT uMsg, LPPROPSHEETPAGE ppsp)
	{
		assert( GetApp() );
		UNREFERENCED_PARAMETER(hwnd);

		// Note: the hwnd is always NULL

		switch (uMsg)
		{
		case PSPCB_CREATE:
			{
				TLSData* pTLSData = (TLSData*)TlsGetValue(GetApp()->GetTlsIndex());
				assert(pTLSData);

				// Store the CPropertyPage pointer in Thread Local Storage
				pTLSData->pCWnd = (CWnd*)ppsp->lParam;
			}
			break;
		}

		return TRUE;
	}

	inline INT_PTR CALLBACK CPropertyPage::StaticDialogProc(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
	{
		assert( GetApp() );

		// Find matching CWnd pointer for this HWND
		CPropertyPage* pPage = (CPropertyPage*)GetApp()->GetCWndFromMap(hwndDlg);
		if (0 == pPage)
		{
			// matching CWnd pointer not found, so add it to HWNDMap now
			TLSData* pTLSData = (TLSData*)TlsGetValue(GetApp()->GetTlsIndex());
			pPage = (CPropertyPage*)pTLSData->pCWnd;

			// Set the hWnd members and call DialogProc for this message
			pPage->m_hWnd = hwndDlg;
			pPage->AddToMap();
		}

		return pPage->DialogProc(uMsg, wParam, lParam);
	}


	///////////////////////////////////////////
	// Definitions for the CPropertySheet class
	//
	inline CPropertySheet::CPropertySheet(UINT nIDCaption, CWnd* pParent /* = NULL*/)
	{
		ZeroMemory(&m_PSH, sizeof (PROPSHEETHEADER));
		SetTitle(LoadString(nIDCaption));
		m_bInitialUpdate = FALSE;

#ifdef _WIN32_WCE
		m_PSH.dwSize = sizeof(PROPSHEETHEADER);
#else
		if (GetComCtlVersion() >= 471)
			m_PSH.dwSize = sizeof(PROPSHEETHEADER);
		else
			m_PSH.dwSize = PROPSHEETHEADER_V1_SIZE;
#endif

		m_PSH.dwFlags          = PSH_PROPSHEETPAGE | PSH_USECALLBACK;
		m_PSH.hwndParent       = pParent? pParent->GetHwnd() : 0;
		m_PSH.hInstance        = GetApp()->GetInstanceHandle();
		m_PSH.pfnCallback      = (PFNPROPSHEETCALLBACK)CPropertySheet::Callback;
	}

	inline CPropertySheet::CPropertySheet(LPCTSTR pszCaption /*= NULL*/, CWnd* pParent /* = NULL*/)
	{
		ZeroMemory(&m_PSH, sizeof (PROPSHEETHEADER));
		SetTitle(pszCaption);
		m_bInitialUpdate = FALSE;

#ifdef _WIN32_WCE
		m_PSH.dwSize = PROPSHEETHEADER_V1_SIZE;
#else
		if (GetComCtlVersion() >= 471)
			m_PSH.dwSize = sizeof(PROPSHEETHEADER);
		else
			m_PSH.dwSize = PROPSHEETHEADER_V1_SIZE;
#endif

		m_PSH.dwFlags          = PSH_PROPSHEETPAGE | PSH_USECALLBACK;
		m_PSH.hwndParent       = pParent? pParent->GetHwnd() : 0;;
		m_PSH.hInstance        = GetApp()->GetInstanceHandle();
		m_PSH.pfnCallback      = (PFNPROPSHEETCALLBACK)CPropertySheet::Callback;
	}

	inline CPropertyPage* CPropertySheet::AddPage(CPropertyPage* pPage)
	// Adds a Property Page to the Property Sheet
	{
		assert(NULL != pPage);

		m_vPages.push_back(PropertyPagePtr(pPage));

		if (m_hWnd)
		{
			// property sheet already exists, so add page to it
			PROPSHEETPAGE psp = pPage->GetPSP();
			HPROPSHEETPAGE hpsp = ::CreatePropertySheetPage(&psp);
			PropSheet_AddPage(m_hWnd, hpsp);
		}

		m_PSH.nPages = (int)m_vPages.size();

		return pPage;
	}

	inline void CPropertySheet::BuildPageArray()
	// Builds the PROPSHEETPAGE array
	{
		m_vPSP.clear();
		std::vector<PropertyPagePtr>::iterator iter;
		for (iter = m_vPages.begin(); iter < m_vPages.end(); ++iter)
			m_vPSP.push_back((*iter)->GetPSP());

		PROPSHEETPAGE* pPSPArray = &m_vPSP.front();	// Array of PROPSHEETPAGE
		m_PSH.ppsp = pPSPArray;
	}

	inline void CALLBACK CPropertySheet::Callback(HWND hwnd, UINT uMsg, LPARAM lParam)
	{
		assert( GetApp() );

		switch(uMsg)
		{
		//called before the dialog is created, hwnd = NULL, lParam points to dialog resource
		case PSCB_PRECREATE:
			{
				LPDLGTEMPLATE  lpTemplate = (LPDLGTEMPLATE)lParam;

				if(!(lpTemplate->style & WS_SYSMENU))
				{
					lpTemplate->style |= WS_SYSMENU;
				}
			}
			break;

		//called after the dialog is created
		case PSCB_INITIALIZED:
			{
				// Retrieve pointer to CWnd object from Thread Local Storage
				TLSData* pTLSData = (TLSData*)TlsGetValue(GetApp()->GetTlsIndex());
				assert(pTLSData);

				CPropertySheet* w = (CPropertySheet*)pTLSData->pCWnd;
				assert(w);

				w->Attach(hwnd);
				w->OnCreate();
			}
			break;
		}
	}


	inline HWND CPropertySheet::Create(CWnd* pParent /*= 0*/)
	// Creates a modeless Property Sheet
	{
		assert( GetApp() );

		if (pParent)
		{
			m_PSH.hwndParent = pParent->GetHwnd();
		}

		BuildPageArray();
		PROPSHEETPAGE* pPSPArray = &m_vPSP.front();
		m_PSH.ppsp = pPSPArray;

		// Create a modeless Property Sheet
		m_PSH.dwFlags &= ~PSH_WIZARD;
		m_PSH.dwFlags |= PSH_MODELESS;
		HWND hWnd = (HWND)CreatePropertySheet(&m_PSH);

		return hWnd;
	}

	inline INT_PTR CPropertySheet::CreatePropertySheet(LPCPROPSHEETHEADER ppsph)
	{
		assert( GetApp() );

		INT_PTR ipResult = 0;

		// Only one window per CWnd instance allowed
		assert(!::IsWindow(m_hWnd));

		// Ensure this thread has the TLS index set
		TLSData* pTLSData = GetApp()->SetTlsIndex();

		// Store the 'this' pointer in Thread Local Storage
		pTLSData->pCWnd = this;

		// Create the property sheet
		ipResult = PropertySheet(ppsph);

		return ipResult;
	}

	inline void CPropertySheet::DestroyButton(int IDButton)
	{
		assert(::IsWindow(m_hWnd));

		HWND hwndButton = ::GetDlgItem(m_hWnd, IDButton);
		if (hwndButton != NULL)
		{
			// Hide and disable the button
			::ShowWindow(hwndButton, SW_HIDE);
			::EnableWindow(hwndButton, FALSE);
		}
	}

	inline void CPropertySheet::Destroy()
	{
		CWnd::Destroy();
		m_vPages.clear();
	}

	inline int CPropertySheet::DoModal()
	{
		assert( GetApp() );

		BuildPageArray();
		PROPSHEETPAGE* pPSPArray = &m_vPSP.front();
		m_PSH.ppsp = pPSPArray;

		// Create the Property Sheet
		int nResult = (int)CreatePropertySheet(&m_PSH);

		m_vPages.clear();

		return nResult;
	}

	inline CPropertyPage* CPropertySheet::GetActivePage() const
	{
		assert(::IsWindow(m_hWnd));

		CPropertyPage* pPage = NULL;
		if (m_hWnd != NULL)
		{
			HWND hPage = (HWND)SendMessage(PSM_GETCURRENTPAGEHWND, 0L, 0L);
			pPage = (CPropertyPage*)FromHandle(hPage);
		}

		return pPage;
	}

	inline int CPropertySheet::GetPageCount() const
	// Returns the number of Property Pages in this Property Sheet
	{
		assert(::IsWindow(m_hWnd));
		return (int)m_vPages.size();
	}

	inline int CPropertySheet::GetPageIndex(CPropertyPage* pPage) const
	{
		assert(::IsWindow(m_hWnd));

		for (int i = 0; i < GetPageCount(); i++)
		{
			if (m_vPages[i].get() == pPage)
				return i;
		}
		return -1;
	}

	inline HWND CPropertySheet::GetTabControl() const
	// Returns the handle to the Property Sheet's tab control
	{
		assert(::IsWindow(m_hWnd));
		return (HWND)SendMessage(PSM_GETTABCONTROL, 0L, 0L);
	}

	inline BOOL CPropertySheet::IsModeless() const
	{
		return (m_PSH.dwFlags & PSH_MODELESS);
	}

	inline BOOL CPropertySheet::IsWizard() const
	{
		return (m_PSH.dwFlags & PSH_WIZARD);
	}

	inline void CPropertySheet::RemovePage(CPropertyPage* pPage)
	// Removes a Property Page from the Property Sheet
	{
		assert(::IsWindow(m_hWnd));

		int nPage = GetPageIndex(pPage);
		if (m_hWnd != NULL)
			SendMessage(m_hWnd, PSM_REMOVEPAGE, nPage, 0L);

		m_vPages.erase(m_vPages.begin() + nPage, m_vPages.begin() + nPage+1);
		m_PSH.nPages = (int)m_vPages.size();
	}

	inline BOOL CPropertySheet::PreTranslateMessage(MSG* pMsg)
	{
		// allow sheet to translate Ctrl+Tab, Shift+Ctrl+Tab, Ctrl+PageUp, and Ctrl+PageDown
		if (pMsg->message == WM_KEYDOWN && GetAsyncKeyState(VK_CONTROL) < 0 &&
			(pMsg->wParam == VK_TAB || pMsg->wParam == VK_PRIOR || pMsg->wParam == VK_NEXT))
		{
			if (SendMessage(PSM_ISDIALOGMESSAGE, 0L, (LPARAM)pMsg))
				return TRUE;
		}

		// allow the dialog to translate keyboard input
		if ((pMsg->message >= WM_KEYFIRST) && (pMsg->message <= WM_KEYLAST))
		{
			return GetActivePage()->PreTranslateMessage(pMsg);
		}

		return CWnd::PreTranslateMessage(pMsg);
	}

	inline BOOL CPropertySheet::SetActivePage(int nPage)
	{
		assert(::IsWindow(m_hWnd));
		return (BOOL)SendMessage(m_hWnd, PSM_SETCURSEL, nPage, 0L);
	}

	inline BOOL CPropertySheet::SetActivePage(CPropertyPage* pPage)
	{
		assert(::IsWindow(m_hWnd));
		int nPage = GetPageIndex(pPage);
		if ((nPage >= 0))
			return SetActivePage(nPage);

		return FALSE;
	}

	inline void CPropertySheet::SetIcon(UINT idIcon)
	{
		m_PSH.pszIcon = MAKEINTRESOURCE(idIcon);
		m_PSH.dwFlags |= PSH_USEICONID;
	}

	inline void CPropertySheet::SetTitle(LPCTSTR szTitle)
	{
		if (szTitle)
			m_Title = szTitle;
		else
			m_Title.erase();

		m_PSH.pszCaption = m_Title.c_str();
	}

	inline void CPropertySheet::SetWizardMode(BOOL bWizard)
	{
		if (bWizard)
			m_PSH.dwFlags |= PSH_WIZARD;
		else
			m_PSH.dwFlags &= ~PSH_WIZARD;
	}

	inline LRESULT CPropertySheet::WndProcDefault(UINT uMsg, WPARAM wParam, LPARAM lParam)
	{
		switch (uMsg)
		{

		case WM_WINDOWPOSCHANGED:
			{
				LPWINDOWPOS lpWinPos = (LPWINDOWPOS)lParam;
				if (lpWinPos->flags & SWP_SHOWWINDOW)
				{
					if (!m_bInitialUpdate)
						// The first window positioning with the window visible
						OnInitialUpdate();
					m_bInitialUpdate = TRUE;
				}
			}
			break;

		case WM_DESTROY:
			m_bInitialUpdate = FALSE;
			break;

		case WM_SYSCOMMAND:
			if ((SC_CLOSE == wParam) && (m_PSH.dwFlags &  PSH_MODELESS))
			{
				Destroy();
				return 0L;
			}
			break;
		}

		// pass unhandled messages on for default processing
		return CWnd::WndProcDefault(uMsg, wParam, lParam);
	}

}

#endif // _WIN32XX_PROPERTYSHEET_H_