ATLCONV.H

// This is a part of the Active Template Library. 
// Copyright (C) 1996-1997 Microsoft Corporation 
// All rights reserved. 
// 
// This source code is only intended as a supplement to the 
// Active Template Library Reference and related 
// electronic documentation provided with the library. 
// See these sources for detailed information regarding the 
// Active Template Library product. 
 
#ifndef __ATLCONV_H__ 
#define __ATLCONV_H__ 
 
#ifndef __cplusplus 
#error ATL requires C++ compilation (use a .cpp suffix) 
#endif 
 
#ifndef _INC_MALLOC 
#include <malloc.h> 
#endif // _INC_MALLOC 
 
#pragma pack(push,8) 
 
// Make sure MFC's afxconv.h hasn't already been loaded to do this 
#ifndef USES_CONVERSION 
 
#ifndef _DEBUG 
#define USES_CONVERSION int _convert; _convert 
#else 
#define USES_CONVERSION int _convert = 0 
#endif 
 
///////////////////////////////////////////////////////////////////////////// 
// Global UNICODE<>ANSI translation helpers 
LPWSTR WINAPI AtlA2WHelper(LPWSTR lpw, LPCSTR lpa, int nChars); 
LPSTR WINAPI AtlW2AHelper(LPSTR lpa, LPCWSTR lpw, int nChars); 
 
#ifndef ATLA2WHELPER 
#define ATLA2WHELPER AtlA2WHelper 
#define ATLW2AHELPER AtlW2AHelper 
#endif 
 
#define A2W(lpa) (\ 
((LPCSTR)lpa == NULL) ? NULL : (\ 
_convert = (lstrlenA(lpa)+1),\ 
ATLA2WHELPER((LPWSTR) alloca(_convert*2), lpa, _convert))) 
 
#define W2A(lpw) (\ 
((LPCWSTR)lpw == NULL) ? NULL : (\ 
_convert = (lstrlenW(lpw)+1)*2,\ 
ATLW2AHELPER((LPSTR) alloca(_convert), lpw, _convert))) 
 
#define A2CW(lpa) ((LPCWSTR)A2W(lpa)) 
#define W2CA(lpw) ((LPCSTR)W2A(lpw)) 
 
#if defined(_UNICODE) 
// in these cases the default (TCHAR) is the same as OLECHAR 
inline size_t ocslen(LPCOLESTR x) { return lstrlenW(x); } 
inline OLECHAR* ocscpy(LPOLESTR dest, LPCOLESTR src) { return lstrcpyW(dest, src); } 
inline LPCOLESTR T2COLE(LPCTSTR lp) { return lp; } 
inline LPCTSTR OLE2CT(LPCOLESTR lp) { return lp; } 
inline LPOLESTR T2OLE(LPTSTR lp) { return lp; } 
inline LPTSTR OLE2T(LPOLESTR lp) { return lp; } 
#elif defined(OLE2ANSI) 
// in these cases the default (TCHAR) is the same as OLECHAR 
inline size_t ocslen(LPCOLESTR x) { return lstrlen(x); } 
inline OLECHAR* ocscpy(LPOLESTR dest, LPCOLESTR src) { return lstrcpy(dest, src); } 
inline LPCOLESTR T2COLE(LPCTSTR lp) { return lp; } 
inline LPCTSTR OLE2CT(LPCOLESTR lp) { return lp; } 
inline LPOLESTR T2OLE(LPTSTR lp) { return lp; } 
inline LPTSTR OLE2T(LPOLESTR lp) { return lp; } 
#else 
inline size_t ocslen(LPCOLESTR x) { return lstrlenW(x); } 
//lstrcpyW doesn't work on Win95, so we do this 
inline OLECHAR* ocscpy(LPOLESTR dest, LPCOLESTR src) 
{return (LPOLESTR) memcpy(dest, src, (lstrlenW(src)+1)*sizeof(WCHAR));} 
//CharNextW doesn't work on Win95 so we use this 
#define T2COLE(lpa) A2CW(lpa) 
#define T2OLE(lpa) A2W(lpa) 
#define OLE2CT(lpo) W2CA(lpo) 
#define OLE2T(lpo) W2A(lpo) 
#endif 
 
#ifdef OLE2ANSI 
inline LPOLESTR A2OLE(LPSTR lp) { return lp;} 
inline LPSTR OLE2A(LPOLESTR lp) { return lp;} 
#define W2OLE W2A 
#define OLE2W A2W 
inline LPCOLESTR A2COLE(LPCSTR lp) { return lp;} 
inline LPCSTR OLE2CA(LPCOLESTR lp) { return lp;} 
#define W2COLE W2CA 
#define OLE2CW A2CW 
#else 
inline LPOLESTR W2OLE(LPWSTR lp) { return lp; } 
inline LPWSTR OLE2W(LPOLESTR lp) { return lp; } 
#define A2OLE A2W 
#define OLE2A W2A 
inline LPCOLESTR W2COLE(LPCWSTR lp) { return lp; } 
inline LPCWSTR OLE2CW(LPCOLESTR lp) { return lp; } 
#define A2COLE A2CW 
#define OLE2CA W2CA 
#endif 
 
#ifdef _UNICODE 
#define T2A W2A 
#define A2T A2W 
inline LPWSTR T2W(LPTSTR lp) { return lp; } 
inline LPTSTR W2T(LPWSTR lp) { return lp; } 
#define T2CA W2CA 
#define A2CT A2CW 
inline LPCWSTR T2CW(LPCTSTR lp) { return lp; } 
inline LPCTSTR W2CT(LPCWSTR lp) { return lp; } 
#else 
#define T2W A2W 
#define W2T W2A 
inline LPSTR T2A(LPTSTR lp) { return lp; } 
inline LPTSTR A2T(LPSTR lp) { return lp; } 
#define T2CW A2CW 
#define W2CT W2CA 
inline LPCSTR T2CA(LPCTSTR lp) { return lp; } 
inline LPCTSTR A2CT(LPCSTR lp) { return lp; } 
#endif 
 
inline BSTR OLE2BSTR(LPCOLESTR lp) {return ::SysAllocString(lp);} 
#if defined(_UNICODE) 
// in these cases the default (TCHAR) is the same as OLECHAR 
inline BSTR T2BSTR(LPCTSTR lp) {return ::SysAllocString(lp);} 
inline BSTR A2BSTR(LPCSTR lp) {USES_CONVERSION; return ::SysAllocString(A2COLE(lp));} 
inline BSTR W2BSTR(LPCWSTR lp) {return ::SysAllocString(lp);} 
#elif defined(OLE2ANSI) 
// in these cases the default (TCHAR) is the same as OLECHAR 
inline BSTR T2BSTR(LPCTSTR lp) {return ::SysAllocString(lp);} 
inline BSTR A2BSTR(LPCSTR lp) {return ::SysAllocString(lp);} 
inline BSTR W2BSTR(LPCWSTR lp) {USES_CONVERSION; return ::SysAllocString(W2COLE(lp));} 
#else 
inline BSTR T2BSTR(LPCTSTR lp) {USES_CONVERSION; return ::SysAllocString(T2COLE(lp));} 
inline BSTR A2BSTR(LPCSTR lp) {USES_CONVERSION; return ::SysAllocString(A2COLE(lp));} 
inline BSTR W2BSTR(LPCWSTR lp) {return ::SysAllocString(lp);} 
#endif 
 
#ifdef _WINGDI_ 
///////////////////////////////////////////////////////////////////////////// 
// Global UNICODE<>ANSI translation helpers 
LPDEVMODEW AtlDevModeA2W(LPDEVMODEW lpDevModeW, LPDEVMODEA lpDevModeA); 
LPDEVMODEA AtlDevModeW2A(LPDEVMODEA lpDevModeA, LPDEVMODEW lpDevModeW); 
LPTEXTMETRICW AtlTextMetricA2W(LPTEXTMETRICW lptmW, LPTEXTMETRICA pltmA); 
LPTEXTMETRICA AtlTextMetricW2A(LPTEXTMETRICA lptmA, LPTEXTMETRICW pltmW); 
 
#ifndef ATLDEVMODEA2W 
#define ATLDEVMODEA2W AtlDevModeA2W 
#define ATLDEVMODEW2A AtlDevModeW2A 
#define ATLTEXTMETRICA2W AtlTextMetricA2W 
#define ATLTEXTMETRICW2A AtlTextMetricW2A 
#endif 
 
#define DEVMODEW2A(lpw)\ 
((lpw == NULL) ? NULL : ATLDEVMODEW2A((LPDEVMODEA)alloca(sizeof(DEVMODEA)+lpw->dmDriverExtra), lpw)) 
#define DEVMODEA2W(lpa)\ 
((lpa == NULL) ? NULL : ATLDEVMODEA2W((LPDEVMODEW)alloca(sizeof(DEVMODEW)+lpa->dmDriverExtra), lpa)) 
#define TEXTMETRICW2A(lptmw)\ 
((lptmw == NULL) ? NULL : ATLTEXTMETRICW2A((LPTEXTMETRICA)alloca(sizeof(TEXTMETRICA)), lptmw)) 
#define TEXTMETRICA2W(lptma)\ 
((lptma == NULL) ? NULL : ATLTEXTMETRICA2W((LPTEXTMETRICW)alloca(sizeof(TEXTMETRICW)), lptma)) 
 
#ifdef OLE2ANSI 
#define DEVMODEOLE DEVMODEA 
#define LPDEVMODEOLE LPDEVMODEA 
#define TEXTMETRICOLE TEXTMETRICA 
#define LPTEXTMETRICOLE LPTEXTMETRICA 
#else 
#define DEVMODEOLE DEVMODEW 
#define LPDEVMODEOLE LPDEVMODEW 
#define TEXTMETRICOLE TEXTMETRICW 
#define LPTEXTMETRICOLE LPTEXTMETRICW 
#endif 
 
#if defined(_UNICODE) 
// in these cases the default (TCHAR) is the same as OLECHAR 
inline LPDEVMODEW DEVMODEOLE2T(LPDEVMODEOLE lp) { return lp; } 
inline LPDEVMODEOLE DEVMODET2OLE(LPDEVMODEW lp) { return lp; } 
inline LPTEXTMETRICW TEXTMETRICOLE2T(LPTEXTMETRICOLE lp) { return lp; } 
inline LPTEXTMETRICOLE TEXTMETRICT2OLE(LPTEXTMETRICW lp) { return lp; } 
#elif defined(OLE2ANSI) 
// in these cases the default (TCHAR) is the same as OLECHAR 
inline LPDEVMODE DEVMODEOLE2T(LPDEVMODEOLE lp) { return lp; } 
inline LPDEVMODEOLE DEVMODET2OLE(LPDEVMODE lp) { return lp; } 
inline LPTEXTMETRIC TEXTMETRICOLE2T(LPTEXTMETRICOLE lp) { return lp; } 
inline LPTEXTMETRICOLE TEXTMETRICT2OLE(LPTEXTMETRIC lp) { return lp; } 
#else 
#define DEVMODEOLE2T(lpo) DEVMODEW2A(lpo) 
#define DEVMODET2OLE(lpa) DEVMODEA2W(lpa) 
#define TEXTMETRICOLE2T(lptmw) TEXTMETRICW2A(lptmw) 
#define TEXTMETRICT2OLE(lptma) TEXTMETRICA2W(lptma) 
#endif 
 
#endif //_WINGDI_ 
 
#else //!USES_CONVERSION 
 
// if USES_CONVERSION already defined (i.e. MFC_VER < 4.21 ) 
// flip this switch to avoid atlconv.cpp 
#define _ATL_NO_CONVERSIONS 
 
#endif //!USES_CONVERSION 
 
// Define these even if MFC already included 
#if defined(_UNICODE) 
// in these cases the default (TCHAR) is the same as OLECHAR 
inline LPOLESTR CharNextO(LPCOLESTR lp) {return CharNextW(lp);} 
#elif defined(OLE2ANSI) 
// in these cases the default (TCHAR) is the same as OLECHAR 
inline LPOLESTR CharNextO(LPCOLESTR lp) {return CharNext(lp);} 
#else 
inline LPOLESTR CharNextO(LPCOLESTR lp) {return (LPOLESTR)(lp+1);} 
#endif 
 
#pragma pack(pop) 
 
#endif // __ATLCONV_H__ 
 
/////////////////////////////////////////////////////////////////////////////