third_party/wtl/include/atlddx.h - chromium/src - Git at Google

 // 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 __ATLDDX_H__
 #define __ATLDDX_H__

 #pragma once

 #ifndef __cplusplus
 	#error ATL requires C++ compilation (use a .cpp suffix)
 #endif

 #ifndef __ATLAPP_H__
 	#error atlddx.h requires atlapp.h to be included first
 #endif

 #if defined(_ATL_USE_DDX_FLOAT) && defined(_ATL_MIN_CRT)
 	#error Cannot use floating point DDX with _ATL_MIN_CRT defined
 #endif // defined(_ATL_USE_DDX_FLOAT) && defined(_ATL_MIN_CRT)

 #ifdef _ATL_USE_DDX_FLOAT
   #include <float.h>
 #endif // _ATL_USE_DDX_FLOAT


 ///////////////////////////////////////////////////////////////////////////////
 // Classes in this file:
 //
 // CWinDataExchange<T>


 namespace WTL
 {

 // Constants
 #define DDX_LOAD	FALSE
 #define DDX_SAVE	TRUE

 // DDX map macros
 #define BEGIN_DDX_MAP(thisClass) \
 	BOOL DoDataExchange(BOOL bSaveAndValidate = FALSE, UINT nCtlID = (UINT)-1) \
 	{ \
 		bSaveAndValidate; \
 		nCtlID;

 #define DDX_TEXT(nID, var) \
 		if(nCtlID == (UINT)-1 || nCtlID == nID) \
 		{ \
 			if(!DDX_Text(nID, var, sizeof(var), bSaveAndValidate)) \
 				return FALSE; \
 		}

 #define DDX_TEXT_LEN(nID, var, len) \
 		if(nCtlID == (UINT)-1 || nCtlID == nID) \
 		{ \
 			if(!DDX_Text(nID, var, sizeof(var), bSaveAndValidate, TRUE, len)) \
 				return FALSE; \
 		}

 #define DDX_INT(nID, var) \
 		if(nCtlID == (UINT)-1 || nCtlID == nID) \
 		{ \
 			if(!DDX_Int(nID, var, TRUE, bSaveAndValidate)) \
 				return FALSE; \
 		}

 #define DDX_INT_RANGE(nID, var, min, max) \
 		if(nCtlID == (UINT)-1 || nCtlID == nID) \
 		{ \
 			if(!DDX_Int(nID, var, TRUE, bSaveAndValidate, TRUE, min, max)) \
 				return FALSE; \
 		}

 #define DDX_UINT(nID, var) \
 		if(nCtlID == (UINT)-1 || nCtlID == nID) \
 		{ \
 			if(!DDX_Int(nID, var, FALSE, bSaveAndValidate)) \
 				return FALSE; \
 		}

 #define DDX_UINT_RANGE(nID, var, min, max) \
 		if(nCtlID == (UINT)-1 || nCtlID == nID) \
 		{ \
 			if(!DDX_Int(nID, var, FALSE, bSaveAndValidate, TRUE, min, max)) \
 				return FALSE; \
 		}

 #ifdef _ATL_USE_DDX_FLOAT
 #define DDX_FLOAT(nID, var) \
 		if(nCtlID == (UINT)-1 || nCtlID == nID) \
 		{ \
 			if(!DDX_Float(nID, var, bSaveAndValidate)) \
 				return FALSE; \
 		}

 #define DDX_FLOAT_RANGE(nID, var, min, max) \
 		if(nCtlID == (UINT)-1 || nCtlID == nID) \
 		{ \
 			if(!DDX_Float(nID, var, bSaveAndValidate, TRUE, min, max)) \
 				return FALSE; \
 		}
 #define DDX_FLOAT_P(nID, var, precision) \
 		if(nCtlID == (UINT)-1 || nCtlID == nID) \
 		{ \
 			if(!DDX_Float(nID, var, bSaveAndValidate, FALSE, 0, 0, precision)) \
 				return FALSE; \
 		}

 #define DDX_FLOAT_P_RANGE(nID, var, min, max, precision) \
 		if(nCtlID == (UINT)-1 || nCtlID == nID) \
 		{ \
 			if(!DDX_Float(nID, var, bSaveAndValidate, TRUE, min, max, precision)) \
 				return FALSE; \
 		}
 #endif // _ATL_USE_DDX_FLOAT

 #define DDX_CONTROL(nID, obj) \
 		if(nCtlID == (UINT)-1 || nCtlID == nID) \
 			DDX_Control(nID, obj, bSaveAndValidate);

 #define DDX_CONTROL_HANDLE(nID, obj) \
 		if(nCtlID == (UINT)-1 || nCtlID == nID) \
 			DDX_Control_Handle(nID, obj, bSaveAndValidate);

 #define DDX_CHECK(nID, var) \
 		if(nCtlID == (UINT)-1 || nCtlID == nID) \
 			DDX_Check(nID, var, bSaveAndValidate);

 #define DDX_RADIO(nID, var) \
 		if(nCtlID == (UINT)-1 || nCtlID == nID) \
 			DDX_Radio(nID, var, bSaveAndValidate);

 #define END_DDX_MAP() \
 		return TRUE; \
 	}


 ///////////////////////////////////////////////////////////////////////////////
 // CWinDataExchange - provides support for DDX

 template <class T>
 class CWinDataExchange
 {
 public:
 // Data exchange method - override in your derived class
 	BOOL DoDataExchange(BOOL /*bSaveAndValidate*/ = FALSE, UINT /*nCtlID*/ = (UINT)-1)
 	{
 		// this one should never be called, override it in
 		// your derived class by implementing DDX map
 		ATLASSERT(FALSE);
 		return FALSE;
 	}

 // Helpers for validation error reporting
 	enum _XDataType
 	{
 		ddxDataNull = 0,
 		ddxDataText = 1,
 		ddxDataInt = 2,
 		ddxDataFloat = 3,
 		ddxDataDouble = 4
 	};

 	struct _XTextData
 	{
 		int nLength;
 		int nMaxLength;
 	};

 	struct _XIntData
 	{
 		long nVal;
 		long nMin;
 		long nMax;
 	};

 	struct _XFloatData
 	{
 		double nVal;
 		double nMin;
 		double nMax;
 	};

 	struct _XData
 	{
 		_XDataType nDataType;
 		union
 		{
 			_XTextData textData;
 			_XIntData intData;
 			_XFloatData floatData;
 		};
 	};

 // Text exchange
 	BOOL DDX_Text(UINT nID, LPTSTR lpstrText, int cbSize, BOOL bSave, BOOL bValidate = FALSE, int nLength = 0)
 	{
 		T* pT = static_cast<T*>(this);
 		BOOL bSuccess = TRUE;

 		if(bSave)
 		{
 			HWND hWndCtrl = pT->GetDlgItem(nID);
 			int nRetLen = ::GetWindowText(hWndCtrl, lpstrText, cbSize / sizeof(TCHAR));
 			if(nRetLen < ::GetWindowTextLength(hWndCtrl))
 				bSuccess = FALSE;
 		}
 		else
 		{
 			ATLASSERT(!bValidate || lstrlen(lpstrText) <= nLength);
 			bSuccess = pT->SetDlgItemText(nID, lpstrText);
 		}

 		if(!bSuccess)
 		{
 			pT->OnDataExchangeError(nID, bSave);
 		}
 		else if(bSave && bValidate)   // validation
 		{
 			ATLASSERT(nLength > 0);
 			if(lstrlen(lpstrText) > nLength)
 			{
 				_XData data = { ddxDataText };
 				data.textData.nLength = lstrlen(lpstrText);
 				data.textData.nMaxLength = nLength;
 				pT->OnDataValidateError(nID, bSave, data);
 				bSuccess = FALSE;
 			}
 		}
 		return bSuccess;
 	}

 	BOOL DDX_Text(UINT nID, BSTR& bstrText, int /*cbSize*/, BOOL bSave, BOOL bValidate = FALSE, int nLength = 0)
 	{
 		T* pT = static_cast<T*>(this);
 		BOOL bSuccess = TRUE;

 		if(bSave)
 		{
 			bSuccess = pT->GetDlgItemText(nID, bstrText);
 		}
 		else
 		{
 			USES_CONVERSION;
 			LPTSTR lpstrText = OLE2T(bstrText);
 			ATLASSERT(!bValidate || lstrlen(lpstrText) <= nLength);
 			bSuccess = pT->SetDlgItemText(nID, lpstrText);
 		}

 		if(!bSuccess)
 		{
 			pT->OnDataExchangeError(nID, bSave);
 		}
 		else if(bSave && bValidate)   // validation
 		{
 			ATLASSERT(nLength > 0);
 			if((int)::SysStringLen(bstrText) > nLength)
 			{
 				_XData data = { ddxDataText };
 				data.textData.nLength = (int)::SysStringLen(bstrText);
 				data.textData.nMaxLength = nLength;
 				pT->OnDataValidateError(nID, bSave, data);
 				bSuccess = FALSE;
 			}
 		}
 		return bSuccess;
 	}

 	BOOL DDX_Text(UINT nID, ATL::CComBSTR& bstrText, int /*cbSize*/, BOOL bSave, BOOL bValidate = FALSE, int nLength = 0)
 	{
 		T* pT = static_cast<T*>(this);
 		BOOL bSuccess = TRUE;

 		if(bSave)
 		{
 			bSuccess = pT->GetDlgItemText(nID, (BSTR&)bstrText);
 		}
 		else
 		{
 			USES_CONVERSION;
 			LPTSTR lpstrText = OLE2T(bstrText);
 			ATLASSERT(!bValidate || lstrlen(lpstrText) <= nLength);
 			bSuccess = pT->SetDlgItemText(nID, lpstrText);
 		}

 		if(!bSuccess)
 		{
 			pT->OnDataExchangeError(nID, bSave);
 		}
 		else if(bSave && bValidate)   // validation
 		{
 			ATLASSERT(nLength > 0);
 			if((int)bstrText.Length() > nLength)
 			{
 				_XData data = { ddxDataText };
 				data.textData.nLength = (int)bstrText.Length();
 				data.textData.nMaxLength = nLength;
 				pT->OnDataValidateError(nID, bSave, data);
 				bSuccess = FALSE;
 			}
 		}
 		return bSuccess;
 	}

 #if defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)
 	BOOL DDX_Text(UINT nID, _CSTRING_NS::CString& strText, int /*cbSize*/, BOOL bSave, BOOL bValidate = FALSE, int nLength = 0)
 	{
 		T* pT = static_cast<T*>(this);
 		BOOL bSuccess = TRUE;

 		if(bSave)
 		{
 			HWND hWndCtrl = pT->GetDlgItem(nID);
 			int nLen = ::GetWindowTextLength(hWndCtrl);
 			int nRetLen = -1;
 			LPTSTR lpstr = strText.GetBufferSetLength(nLen);
 			if(lpstr != NULL)
 			{
 				nRetLen = ::GetWindowText(hWndCtrl, lpstr, nLen + 1);
 				strText.ReleaseBuffer();
 			}
 			if(nRetLen < nLen)
 				bSuccess = FALSE;
 		}
 		else
 		{
 			bSuccess = pT->SetDlgItemText(nID, strText);
 		}

 		if(!bSuccess)
 		{
 			pT->OnDataExchangeError(nID, bSave);
 		}
 		else if(bSave && bValidate)   // validation
 		{
 			ATLASSERT(nLength > 0);
 			if(strText.GetLength() > nLength)
 			{
 				_XData data = { ddxDataText };
 				data.textData.nLength = strText.GetLength();
 				data.textData.nMaxLength = nLength;
 				pT->OnDataValidateError(nID, bSave, data);
 				bSuccess = FALSE;
 			}
 		}
 		return bSuccess;
 	}
 #endif // defined(_WTL_USE_CSTRING) || defined(__ATLSTR_H__)

 // Numeric exchange
 	template <class Type>
 	BOOL DDX_Int(UINT nID, Type& nVal, BOOL bSigned, BOOL bSave, BOOL bValidate = FALSE, Type nMin = 0, Type nMax = 0)
 	{
 		T* pT = static_cast<T*>(this);
 		BOOL bSuccess = TRUE;

 		if(bSave)
 		{
 			nVal = (Type)pT->GetDlgItemInt(nID, &bSuccess, bSigned);
 		}
 		else
 		{
 			ATLASSERT(!bValidate || nVal >= nMin && nVal <= nMax);
 			bSuccess = pT->SetDlgItemInt(nID, nVal, bSigned);
 		}

 		if(!bSuccess)
 		{
 			pT->OnDataExchangeError(nID, bSave);
 		}
 		else if(bSave && bValidate)   // validation
 		{
 			ATLASSERT(nMin != nMax);
 			if(nVal < nMin || nVal > nMax)
 			{
 				_XData data = { ddxDataInt };
 				data.intData.nVal = (long)nVal;
 				data.intData.nMin = (long)nMin;
 				data.intData.nMax = (long)nMax;
 				pT->OnDataValidateError(nID, bSave, data);
 				bSuccess = FALSE;
 			}
 		}
 		return bSuccess;
 	}

 // Float exchange
 #ifdef _ATL_USE_DDX_FLOAT
 	static BOOL _AtlSimpleFloatParse(LPCTSTR lpszText, double& d)
 	{
 		ATLASSERT(lpszText != NULL);
 		while (*lpszText == _T(' ') || *lpszText == _T('\t'))
 			lpszText++;

 		TCHAR chFirst = lpszText[0];
 		d = _tcstod(lpszText, (LPTSTR*)&lpszText);
 		if (d == 0.0 && chFirst != _T('0'))
 			return FALSE;   // could not convert
 		while (*lpszText == _T(' ') || *lpszText == _T('\t'))
 			lpszText++;

 		if (*lpszText != _T('\0'))
 			return FALSE;   // not terminated properly

 		return TRUE;
 	}

 	BOOL DDX_Float(UINT nID, float& nVal, BOOL bSave, BOOL bValidate = FALSE, float nMin = 0.F, float nMax = 0.F, int nPrecision = FLT_DIG)
 	{
 		T* pT = static_cast<T*>(this);
 		BOOL bSuccess = TRUE;
 		const int cchBuff = 32;
 		TCHAR szBuff[cchBuff] = { 0 };

 		if(bSave)
 		{
 			pT->GetDlgItemText(nID, szBuff, cchBuff);
 			double d = 0;
 			if(_AtlSimpleFloatParse(szBuff, d))
 				nVal = (float)d;
 			else
 				bSuccess = FALSE;
 		}
 		else
 		{
 			ATLASSERT(!bValidate || nVal >= nMin && nVal <= nMax);
 			SecureHelper::sprintf_x(szBuff, cchBuff, _T("%.*g"), nPrecision, nVal);
 			bSuccess = pT->SetDlgItemText(nID, szBuff);
 		}

 		if(!bSuccess)
 		{
 			pT->OnDataExchangeError(nID, bSave);
 		}
 		else if(bSave && bValidate)   // validation
 		{
 			ATLASSERT(nMin != nMax);
 			if(nVal < nMin || nVal > nMax)
 			{
 				_XData data = { ddxDataFloat };
 				data.floatData.nVal = (double)nVal;
 				data.floatData.nMin = (double)nMin;
 				data.floatData.nMax = (double)nMax;
 				pT->OnDataValidateError(nID, bSave, data);
 				bSuccess = FALSE;
 			}
 		}
 		return bSuccess;
 	}

 	BOOL DDX_Float(UINT nID, double& nVal, BOOL bSave, BOOL bValidate = FALSE, double nMin = 0., double nMax = 0., int nPrecision = DBL_DIG)
 	{
 		T* pT = static_cast<T*>(this);
 		BOOL bSuccess = TRUE;
 		const int cchBuff = 32;
 		TCHAR szBuff[cchBuff] = { 0 };

 		if(bSave)
 		{
 			pT->GetDlgItemText(nID, szBuff, cchBuff);
 			double d = 0;
 			if(_AtlSimpleFloatParse(szBuff, d))
 				nVal = d;
 			else
 				bSuccess = FALSE;
 		}
 		else
 		{
 			ATLASSERT(!bValidate || nVal >= nMin && nVal <= nMax);
 			SecureHelper::sprintf_x(szBuff, cchBuff, _T("%.*g"), nPrecision, nVal);
 			bSuccess = pT->SetDlgItemText(nID, szBuff);
 		}

 		if(!bSuccess)
 		{
 			pT->OnDataExchangeError(nID, bSave);
 		}
 		else if(bSave && bValidate)   // validation
 		{
 			ATLASSERT(nMin != nMax);
 			if(nVal < nMin || nVal > nMax)
 			{
 				_XData data = { ddxDataFloat };
 				data.floatData.nVal = nVal;
 				data.floatData.nMin = nMin;
 				data.floatData.nMax = nMax;
 				pT->OnDataValidateError(nID, bSave, data);
 				bSuccess = FALSE;
 			}
 		}
 		return bSuccess;
 	}
 #endif // _ATL_USE_DDX_FLOAT

 // Full control subclassing (for CWindowImpl derived controls)
 	template <class TControl>
 	void DDX_Control(UINT nID, TControl& ctrl, BOOL bSave)
 	{
 		if(!bSave && ctrl.m_hWnd == NULL)
 		{
 			T* pT = static_cast<T*>(this);
 			ctrl.SubclassWindow(pT->GetDlgItem(nID));
 		}
 	}

 // Simple control attaching (for HWND wrapper controls)
 	template <class TControl>
 	void DDX_Control_Handle(UINT nID, TControl& ctrl, BOOL bSave)
 	{
 		if(!bSave && ctrl.m_hWnd == NULL)
 		{
 			T* pT = static_cast<T*>(this);
 			ctrl = pT->GetDlgItem(nID);
 		}
 	}

 // Control state
 	void DDX_Check(UINT nID, int& nValue, BOOL bSave)
 	{
 		T* pT = static_cast<T*>(this);
 		HWND hWndCtrl = pT->GetDlgItem(nID);
 		if(bSave)
 		{
 			nValue = (int)::SendMessage(hWndCtrl, BM_GETCHECK, 0, 0L);
 			ATLASSERT(nValue >= 0 && nValue <= 2);
 		}
 		else
 		{
 			if(nValue < 0 || nValue > 2)
 			{
 				ATLTRACE2(atlTraceUI, 0, _T("ATL: Warning - dialog data checkbox value (%d) out of range.\n"), nValue);
 				nValue = 0;  // default to off
 			}
 			::SendMessage(hWndCtrl, BM_SETCHECK, nValue, 0L);
 		}
 	}

 	// variant that supports bool (checked/not-checked, no intermediate state)
 	void DDX_Check(UINT nID, bool& bCheck, BOOL bSave)
 	{
 		int nValue = bCheck ? 1 : 0;
 		DDX_Check(nID, nValue, bSave);

 		if(bSave)
 		{
 			if(nValue == 2)
 				ATLTRACE2(atlTraceUI, 0, _T("ATL: Warning - checkbox state (%d) out of supported range.\n"), nValue);
 			bCheck = (nValue == 1);
 		}
 	}

 	void DDX_Radio(UINT nID, int& nValue, BOOL bSave)
 	{
 		T* pT = static_cast<T*>(this);
 		HWND hWndCtrl = pT->GetDlgItem(nID);
 		ATLASSERT(hWndCtrl != NULL);

 		// must be first in a group of auto radio buttons
 		ATLASSERT(::GetWindowLong(hWndCtrl, GWL_STYLE) & WS_GROUP);
 		ATLASSERT(::SendMessage(hWndCtrl, WM_GETDLGCODE, 0, 0L) & DLGC_RADIOBUTTON);

 		if(bSave)
 			nValue = -1;     // value if none found

 		// walk all children in group
 		int nButton = 0;
 		do
 		{
 			if(::SendMessage(hWndCtrl, WM_GETDLGCODE, 0, 0L) & DLGC_RADIOBUTTON)
 			{
 				// control in group is a radio button
 				if(bSave)
 				{
 					if(::SendMessage(hWndCtrl, BM_GETCHECK, 0, 0L) != 0)
 					{
 						ATLASSERT(nValue == -1);    // only set once
 						nValue = nButton;
 					}
 				}
 				else
 				{
 					// select button
 					::SendMessage(hWndCtrl, BM_SETCHECK, (nButton == nValue), 0L);
 				}
 				nButton++;
 			}
 			else
 			{
 				ATLTRACE2(atlTraceUI, 0, _T("ATL: Warning - skipping non-radio button in group.\n"));
 			}
 			hWndCtrl = ::GetWindow(hWndCtrl, GW_HWNDNEXT);
 		}
 		while (hWndCtrl != NULL && !(GetWindowLong(hWndCtrl, GWL_STYLE) & WS_GROUP));
 	}

 // Overrideables
 	void OnDataExchangeError(UINT nCtrlID, BOOL /*bSave*/)
 	{
 		// Override to display an error message
 		::MessageBeep((UINT)-1);
 		T* pT = static_cast<T*>(this);
 		::SetFocus(pT->GetDlgItem(nCtrlID));
 	}

 	void OnDataValidateError(UINT nCtrlID, BOOL /*bSave*/, _XData& /*data*/)
 	{
 		// Override to display an error message
 		::MessageBeep((UINT)-1);
 		T* pT = static_cast<T*>(this);
 		::SetFocus(pT->GetDlgItem(nCtrlID));
 	}
 };

 }; // namespace WTL

 #endif // __ATLDDX_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 __ATLDDX_H__
	#define __ATLDDX_H__

	#pragma once

	#ifndef __cplusplus
	#error ATL requires C++ compilation (use a .cpp suffix)
	#endif

	#ifndef __ATLAPP_H__
	#error atlddx.h requires atlapp.h to be included first
	#endif

	#if defined(_ATL_USE_DDX_FLOAT) && defined(_ATL_MIN_CRT)
	#error Cannot use floating point DDX with _ATL_MIN_CRT defined
	#endif // defined(_ATL_USE_DDX_FLOAT) && defined(_ATL_MIN_CRT)

	#ifdef _ATL_USE_DDX_FLOAT
	#include <float.h>
	#endif // _ATL_USE_DDX_FLOAT


	///////////////////////////////////////////////////////////////////////////////
	// Classes in this file:
	//
	// CWinDataExchange<T>


	namespace WTL
	{

	// Constants
	#define DDX_LOAD FALSE
	#define DDX_SAVE TRUE

	// DDX map macros
	#define BEGIN_DDX_MAP(thisClass) \
	BOOL DoDataExchange(BOOL bSaveAndValidate = FALSE, UINT nCtlID = (UINT)-1) \
	{ \
	bSaveAndValidate; \
	nCtlID;

	#define DDX_TEXT(nID, var) \
	if(nCtlID == (UINT)-1 \|\| nCtlID == nID) \
	{ \
	if(!DDX_Text(nID, var, sizeof(var), bSaveAndValidate)) \
	return FALSE; \
	}

	#define DDX_TEXT_LEN(nID, var, len) \
	if(nCtlID == (UINT)-1 \|\| nCtlID == nID) \
	{ \
	if(!DDX_Text(nID, var, sizeof(var), bSaveAndValidate, TRUE, len)) \
	return FALSE; \
	}

	#define DDX_INT(nID, var) \
	if(nCtlID == (UINT)-1 \|\| nCtlID == nID) \
	{ \
	if(!DDX_Int(nID, var, TRUE, bSaveAndValidate)) \
	return FALSE; \
	}

	#define DDX_INT_RANGE(nID, var, min, max) \
	if(nCtlID == (UINT)-1 \|\| nCtlID == nID) \
	{ \
	if(!DDX_Int(nID, var, TRUE, bSaveAndValidate, TRUE, min, max)) \
	return FALSE; \
	}

	#define DDX_UINT(nID, var) \
	if(nCtlID == (UINT)-1 \|\| nCtlID == nID) \
	{ \
	if(!DDX_Int(nID, var, FALSE, bSaveAndValidate)) \
	return FALSE; \
	}

	#define DDX_UINT_RANGE(nID, var, min, max) \
	if(nCtlID == (UINT)-1 \|\| nCtlID == nID) \
	{ \
	if(!DDX_Int(nID, var, FALSE, bSaveAndValidate, TRUE, min, max)) \
	return FALSE; \
	}

	#ifdef _ATL_USE_DDX_FLOAT
	#define DDX_FLOAT(nID, var) \
	if(nCtlID == (UINT)-1 \|\| nCtlID == nID) \
	{ \
	if(!DDX_Float(nID, var, bSaveAndValidate)) \
	return FALSE; \
	}

	#define DDX_FLOAT_RANGE(nID, var, min, max) \
	if(nCtlID == (UINT)-1 \|\| nCtlID == nID) \
	{ \
	if(!DDX_Float(nID, var, bSaveAndValidate, TRUE, min, max)) \
	return FALSE; \
	}
	#define DDX_FLOAT_P(nID, var, precision) \
	if(nCtlID == (UINT)-1 \|\| nCtlID == nID) \
	{ \
	if(!DDX_Float(nID, var, bSaveAndValidate, FALSE, 0, 0, precision)) \
	return FALSE; \
	}

	#define DDX_FLOAT_P_RANGE(nID, var, min, max, precision) \
	if(nCtlID == (UINT)-1 \|\| nCtlID == nID) \
	{ \
	if(!DDX_Float(nID, var, bSaveAndValidate, TRUE, min, max, precision)) \
	return FALSE; \
	}
	#endif // _ATL_USE_DDX_FLOAT

	#define DDX_CONTROL(nID, obj) \
	if(nCtlID == (UINT)-1 \|\| nCtlID == nID) \
	DDX_Control(nID, obj, bSaveAndValidate);

	#define DDX_CONTROL_HANDLE(nID, obj) \
	if(nCtlID == (UINT)-1 \|\| nCtlID == nID) \
	DDX_Control_Handle(nID, obj, bSaveAndValidate);

	#define DDX_CHECK(nID, var) \
	if(nCtlID == (UINT)-1 \|\| nCtlID == nID) \
	DDX_Check(nID, var, bSaveAndValidate);

	#define DDX_RADIO(nID, var) \
	if(nCtlID == (UINT)-1 \|\| nCtlID == nID) \
	DDX_Radio(nID, var, bSaveAndValidate);

	#define END_DDX_MAP() \
	return TRUE; \
	}


	///////////////////////////////////////////////////////////////////////////////
	// CWinDataExchange - provides support for DDX

	template <class T>
	class CWinDataExchange
	{
	public:
	// Data exchange method - override in your derived class
	BOOL DoDataExchange(BOOL /bSaveAndValidate/ = FALSE, UINT /nCtlID/ = (UINT)-1)
	{
	// this one should never be called, override it in
	// your derived class by implementing DDX map
	ATLASSERT(FALSE);
	return FALSE;
	}

	// Helpers for validation error reporting
	enum _XDataType
	{
	ddxDataNull = 0,
	ddxDataText = 1,
	ddxDataInt = 2,
	ddxDataFloat = 3,
	ddxDataDouble = 4
	};

	struct _XTextData
	{
	int nLength;
	int nMaxLength;
	};

	struct _XIntData
	{
	long nVal;
	long nMin;
	long nMax;
	};

	struct _XFloatData
	{
	double nVal;
	double nMin;
	double nMax;
	};

	struct _XData
	{
	_XDataType nDataType;
	union
	{
	_XTextData textData;
	_XIntData intData;
	_XFloatData floatData;
	};
	};

	// Text exchange
	BOOL DDX_Text(UINT nID, LPTSTR lpstrText, int cbSize, BOOL bSave, BOOL bValidate = FALSE, int nLength = 0)
	{
	T* pT = static_cast<T*>(this);
	BOOL bSuccess = TRUE;

	if(bSave)
	{
	HWND hWndCtrl = pT->GetDlgItem(nID);
	int nRetLen = ::GetWindowText(hWndCtrl, lpstrText, cbSize / sizeof(TCHAR));
	if(nRetLen < ::GetWindowTextLength(hWndCtrl))
	bSuccess = FALSE;
	}
	else
	{
	ATLASSERT(!bValidate \|\| lstrlen(lpstrText) <= nLength);
	bSuccess = pT->SetDlgItemText(nID, lpstrText);
	}

	if(!bSuccess)
	{
	pT->OnDataExchangeError(nID, bSave);
	}
	else if(bSave && bValidate) // validation
	{
	ATLASSERT(nLength > 0);
	if(lstrlen(lpstrText) > nLength)
	{
	_XData data = { ddxDataText };
	data.textData.nLength = lstrlen(lpstrText);
	data.textData.nMaxLength = nLength;
	pT->OnDataValidateError(nID, bSave, data);
	bSuccess = FALSE;
	}
	}
	return bSuccess;
	}

	BOOL DDX_Text(UINT nID, BSTR& bstrText, int /cbSize/, BOOL bSave, BOOL bValidate = FALSE, int nLength = 0)
	{
	T* pT = static_cast<T*>(this);
	BOOL bSuccess = TRUE;

	if(bSave)
	{
	bSuccess = pT->GetDlgItemText(nID, bstrText);
	}
	else
	{
	USES_CONVERSION;
	LPTSTR lpstrText = OLE2T(bstrText);
	ATLASSERT(!bValidate \|\| lstrlen(lpstrText) <= nLength);
	bSuccess = pT->SetDlgItemText(nID, lpstrText);
	}

	if(!bSuccess)
	{
	pT->OnDataExchangeError(nID, bSave);
	}
	else if(bSave && bValidate) // validation
	{
	ATLASSERT(nLength > 0);
	if((int)::SysStringLen(bstrText) > nLength)
	{
	_XData data = { ddxDataText };
	data.textData.nLength = (int)::SysStringLen(bstrText);
	data.textData.nMaxLength = nLength;
	pT->OnDataValidateError(nID, bSave, data);
	bSuccess = FALSE;
	}
	}
	return bSuccess;
	}

	BOOL DDX_Text(UINT nID, ATL::CComBSTR& bstrText, int /cbSize/, BOOL bSave, BOOL bValidate = FALSE, int nLength = 0)
	{
	T* pT = static_cast<T*>(this);
	BOOL bSuccess = TRUE;

	if(bSave)
	{
	bSuccess = pT->GetDlgItemText(nID, (BSTR&)bstrText);
	}
	else
	{
	USES_CONVERSION;
	LPTSTR lpstrText = OLE2T(bstrText);
	ATLASSERT(!bValidate \|\| lstrlen(lpstrText) <= nLength);
	bSuccess = pT->SetDlgItemText(nID, lpstrText);
	}

	if(!bSuccess)
	{
	pT->OnDataExchangeError(nID, bSave);
	}
	else if(bSave && bValidate) // validation
	{
	ATLASSERT(nLength > 0);
	if((int)bstrText.Length() > nLength)
	{
	_XData data = { ddxDataText };
	data.textData.nLength = (int)bstrText.Length();
	data.textData.nMaxLength = nLength;
	pT->OnDataValidateError(nID, bSave, data);
	bSuccess = FALSE;
	}
	}
	return bSuccess;
	}

	#if defined(_WTL_USE_CSTRING) \|\| defined(__ATLSTR_H__)
	BOOL DDX_Text(UINT nID, _CSTRING_NS::CString& strText, int /cbSize/, BOOL bSave, BOOL bValidate = FALSE, int nLength = 0)
	{
	T* pT = static_cast<T*>(this);
	BOOL bSuccess = TRUE;

	if(bSave)
	{
	HWND hWndCtrl = pT->GetDlgItem(nID);
	int nLen = ::GetWindowTextLength(hWndCtrl);
	int nRetLen = -1;
	LPTSTR lpstr = strText.GetBufferSetLength(nLen);
	if(lpstr != NULL)
	{
	nRetLen = ::GetWindowText(hWndCtrl, lpstr, nLen + 1);
	strText.ReleaseBuffer();
	}
	if(nRetLen < nLen)
	bSuccess = FALSE;
	}
	else
	{
	bSuccess = pT->SetDlgItemText(nID, strText);
	}

	if(!bSuccess)
	{
	pT->OnDataExchangeError(nID, bSave);
	}
	else if(bSave && bValidate) // validation
	{
	ATLASSERT(nLength > 0);
	if(strText.GetLength() > nLength)
	{
	_XData data = { ddxDataText };
	data.textData.nLength = strText.GetLength();
	data.textData.nMaxLength = nLength;
	pT->OnDataValidateError(nID, bSave, data);
	bSuccess = FALSE;
	}
	}
	return bSuccess;
	}
	#endif // defined(_WTL_USE_CSTRING) \|\| defined(__ATLSTR_H__)

	// Numeric exchange
	template <class Type>
	BOOL DDX_Int(UINT nID, Type& nVal, BOOL bSigned, BOOL bSave, BOOL bValidate = FALSE, Type nMin = 0, Type nMax = 0)
	{
	T* pT = static_cast<T*>(this);
	BOOL bSuccess = TRUE;

	if(bSave)
	{
	nVal = (Type)pT->GetDlgItemInt(nID, &bSuccess, bSigned);
	}
	else
	{
	ATLASSERT(!bValidate \|\| nVal >= nMin && nVal <= nMax);
	bSuccess = pT->SetDlgItemInt(nID, nVal, bSigned);
	}

	if(!bSuccess)
	{
	pT->OnDataExchangeError(nID, bSave);
	}
	else if(bSave && bValidate) // validation
	{
	ATLASSERT(nMin != nMax);
	if(nVal < nMin \|\| nVal > nMax)
	{
	_XData data = { ddxDataInt };
	data.intData.nVal = (long)nVal;
	data.intData.nMin = (long)nMin;
	data.intData.nMax = (long)nMax;
	pT->OnDataValidateError(nID, bSave, data);
	bSuccess = FALSE;
	}
	}
	return bSuccess;
	}

	// Float exchange
	#ifdef _ATL_USE_DDX_FLOAT
	static BOOL _AtlSimpleFloatParse(LPCTSTR lpszText, double& d)
	{
	ATLASSERT(lpszText != NULL);
	while (lpszText == _T(' ') \|\| lpszText == _T('\t'))
	lpszText++;

	TCHAR chFirst = lpszText[0];
	d = _tcstod(lpszText, (LPTSTR*)&lpszText);
	if (d == 0.0 && chFirst != _T('0'))
	return FALSE; // could not convert
	while (lpszText == _T(' ') \|\| lpszText == _T('\t'))
	lpszText++;

	if (*lpszText != _T('\0'))
	return FALSE; // not terminated properly

	return TRUE;
	}

	BOOL DDX_Float(UINT nID, float& nVal, BOOL bSave, BOOL bValidate = FALSE, float nMin = 0.F, float nMax = 0.F, int nPrecision = FLT_DIG)
	{
	T* pT = static_cast<T*>(this);
	BOOL bSuccess = TRUE;
	const int cchBuff = 32;
	TCHAR szBuff[cchBuff] = { 0 };

	if(bSave)
	{
	pT->GetDlgItemText(nID, szBuff, cchBuff);
	double d = 0;
	if(_AtlSimpleFloatParse(szBuff, d))
	nVal = (float)d;
	else
	bSuccess = FALSE;
	}
	else
	{
	ATLASSERT(!bValidate \|\| nVal >= nMin && nVal <= nMax);
	SecureHelper::sprintf_x(szBuff, cchBuff, _T("%.*g"), nPrecision, nVal);
	bSuccess = pT->SetDlgItemText(nID, szBuff);
	}

	if(!bSuccess)
	{
	pT->OnDataExchangeError(nID, bSave);
	}
	else if(bSave && bValidate) // validation
	{
	ATLASSERT(nMin != nMax);
	if(nVal < nMin \|\| nVal > nMax)
	{
	_XData data = { ddxDataFloat };
	data.floatData.nVal = (double)nVal;
	data.floatData.nMin = (double)nMin;
	data.floatData.nMax = (double)nMax;
	pT->OnDataValidateError(nID, bSave, data);
	bSuccess = FALSE;
	}
	}
	return bSuccess;
	}

	BOOL DDX_Float(UINT nID, double& nVal, BOOL bSave, BOOL bValidate = FALSE, double nMin = 0., double nMax = 0., int nPrecision = DBL_DIG)
	{
	T* pT = static_cast<T*>(this);
	BOOL bSuccess = TRUE;
	const int cchBuff = 32;
	TCHAR szBuff[cchBuff] = { 0 };

	if(bSave)
	{
	pT->GetDlgItemText(nID, szBuff, cchBuff);
	double d = 0;
	if(_AtlSimpleFloatParse(szBuff, d))
	nVal = d;
	else
	bSuccess = FALSE;
	}
	else
	{
	ATLASSERT(!bValidate \|\| nVal >= nMin && nVal <= nMax);
	SecureHelper::sprintf_x(szBuff, cchBuff, _T("%.*g"), nPrecision, nVal);
	bSuccess = pT->SetDlgItemText(nID, szBuff);
	}

	if(!bSuccess)
	{
	pT->OnDataExchangeError(nID, bSave);
	}
	else if(bSave && bValidate) // validation
	{
	ATLASSERT(nMin != nMax);
	if(nVal < nMin \|\| nVal > nMax)
	{
	_XData data = { ddxDataFloat };
	data.floatData.nVal = nVal;
	data.floatData.nMin = nMin;
	data.floatData.nMax = nMax;
	pT->OnDataValidateError(nID, bSave, data);
	bSuccess = FALSE;
	}
	}
	return bSuccess;
	}
	#endif // _ATL_USE_DDX_FLOAT

	// Full control subclassing (for CWindowImpl derived controls)
	template <class TControl>
	void DDX_Control(UINT nID, TControl& ctrl, BOOL bSave)
	{
	if(!bSave && ctrl.m_hWnd == NULL)
	{
	T* pT = static_cast<T*>(this);
	ctrl.SubclassWindow(pT->GetDlgItem(nID));
	}
	}

	// Simple control attaching (for HWND wrapper controls)
	template <class TControl>
	void DDX_Control_Handle(UINT nID, TControl& ctrl, BOOL bSave)
	{
	if(!bSave && ctrl.m_hWnd == NULL)
	{
	T* pT = static_cast<T*>(this);
	ctrl = pT->GetDlgItem(nID);
	}
	}

	// Control state
	void DDX_Check(UINT nID, int& nValue, BOOL bSave)
	{
	T* pT = static_cast<T*>(this);
	HWND hWndCtrl = pT->GetDlgItem(nID);
	if(bSave)
	{
	nValue = (int)::SendMessage(hWndCtrl, BM_GETCHECK, 0, 0L);
	ATLASSERT(nValue >= 0 && nValue <= 2);
	}
	else
	{
	if(nValue < 0 \|\| nValue > 2)
	{
	ATLTRACE2(atlTraceUI, 0, _T("ATL: Warning - dialog data checkbox value (%d) out of range.\n"), nValue);
	nValue = 0; // default to off
	}
	::SendMessage(hWndCtrl, BM_SETCHECK, nValue, 0L);
	}
	}

	// variant that supports bool (checked/not-checked, no intermediate state)
	void DDX_Check(UINT nID, bool& bCheck, BOOL bSave)
	{
	int nValue = bCheck ? 1 : 0;
	DDX_Check(nID, nValue, bSave);

	if(bSave)
	{
	if(nValue == 2)
	ATLTRACE2(atlTraceUI, 0, _T("ATL: Warning - checkbox state (%d) out of supported range.\n"), nValue);
	bCheck = (nValue == 1);
	}
	}

	void DDX_Radio(UINT nID, int& nValue, BOOL bSave)
	{
	T* pT = static_cast<T*>(this);
	HWND hWndCtrl = pT->GetDlgItem(nID);
	ATLASSERT(hWndCtrl != NULL);

	// must be first in a group of auto radio buttons
	ATLASSERT(::GetWindowLong(hWndCtrl, GWL_STYLE) & WS_GROUP);
	ATLASSERT(::SendMessage(hWndCtrl, WM_GETDLGCODE, 0, 0L) & DLGC_RADIOBUTTON);

	if(bSave)
	nValue = -1; // value if none found

	// walk all children in group
	int nButton = 0;
	do
	{
	if(::SendMessage(hWndCtrl, WM_GETDLGCODE, 0, 0L) & DLGC_RADIOBUTTON)
	{
	// control in group is a radio button
	if(bSave)
	{
	if(::SendMessage(hWndCtrl, BM_GETCHECK, 0, 0L) != 0)
	{
	ATLASSERT(nValue == -1); // only set once
	nValue = nButton;
	}
	}
	else
	{
	// select button
	::SendMessage(hWndCtrl, BM_SETCHECK, (nButton == nValue), 0L);
	}
	nButton++;
	}
	else
	{
	ATLTRACE2(atlTraceUI, 0, _T("ATL: Warning - skipping non-radio button in group.\n"));
	}
	hWndCtrl = ::GetWindow(hWndCtrl, GW_HWNDNEXT);
	}
	while (hWndCtrl != NULL && !(GetWindowLong(hWndCtrl, GWL_STYLE) & WS_GROUP));
	}

	// Overrideables
	void OnDataExchangeError(UINT nCtrlID, BOOL /bSave/)
	{
	// Override to display an error message
	::MessageBeep((UINT)-1);
	T* pT = static_cast<T*>(this);
	::SetFocus(pT->GetDlgItem(nCtrlID));
	}

	void OnDataValidateError(UINT nCtrlID, BOOL /bSave/, _XData& /data/)
	{
	// Override to display an error message
	::MessageBeep((UINT)-1);
	T* pT = static_cast<T*>(this);
	::SetFocus(pT->GetDlgItem(nCtrlID));
	}
	};

	}; // namespace WTL

	#endif // __ATLDDX_H__