home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Internet 2000 May / MICD_2000_05.iso / CBuilder5 / INSTALL / DATA1.CAB / Program_Built_Files / Include / Atl / atlconv.h < prev    next >
Encoding:
C/C++ Source or Header  |  2000-02-01  |  13.7 KB  |  386 lines
  1. // This is a part of the Active Template Library.
  2. // Copyright (C) 1996-1998 Microsoft Corporation
  3. // All rights reserved.
  4. //
  5. // This source code is only intended as a supplement to the
  6. // Active Template Library Reference and related
  7. // electronic documentation provided with the library.
  8. // See these sources for detailed information regarding the
  9. // Active Template Library product.
  10.  
  11. #ifndef __ATLCONV_H__
  12. #define __ATLCONV_H__
  13.  
  14. #ifndef __cplusplus
  15.     #error ATL requires C++ compilation (use a .cpp suffix)
  16. #endif
  17.  
  18. #include "atldef.h"
  19.  
  20. #ifndef _INC_MALLOC
  21. #include <malloc.h>
  22. #endif // _INC_MALLOC
  23.  
  24. #pragma pack(push,8)
  25.  
  26. #ifndef __BORLANDC__
  27. #ifdef _CONVERSION_USES_THREAD_LOCALE
  28.     #ifndef _DEBUG
  29.         #define USES_CONVERSION int _convert; _convert; UINT _acp = GetACP(); _acp; LPCWSTR _lpw; _lpw; LPCSTR _lpa; _lpa
  30.     #else
  31.         #define USES_CONVERSION int _convert = 0; _convert; UINT _acp = GetACP(); _acp; LPCWSTR _lpw = NULL; _lpw; LPCSTR _lpa = NULL; _lpa
  32.     #endif
  33. #else
  34.     #ifndef _DEBUG
  35.         #define USES_CONVERSION int _convert; _convert; UINT _acp = CP_ACP; _acp; LPCWSTR _lpw; _lpw; LPCSTR _lpa; _lpa
  36.     #else
  37.         #define USES_CONVERSION int _convert = 0; _convert; UINT _acp = CP_ACP; _acp; LPCWSTR _lpw = NULL; _lpw; LPCSTR _lpa = NULL; _lpa
  38.     #endif
  39. #endif
  40. #else
  41. #ifdef _CONVERSION_USES_THREAD_LOCALE
  42.     #ifndef _DEBUG
  43.         #define USES_CONVERSION int _convert; &_convert; UINT _acp = GetACP(); &_acp; LPCWSTR &_lpw; _lpw; LPCSTR _lpa; &_lpa
  44.     #else
  45.         #define USES_CONVERSION int _convert = 0; &_convert; UINT _acp = GetACP(); &_acp; LPCWSTR _lpw = NULL; &_lpw; LPCSTR _lpa = NULL; &_lpa
  46.     #endif
  47. #else
  48.     #ifndef _DEBUG
  49.         #define USES_CONVERSION int _convert; &_convert; UINT _acp = CP_ACP; &_acp; LPCWSTR _lpw; &_lpw; LPCSTR _lpa; &_lpa
  50.     #else
  51.         #define USES_CONVERSION int _convert = 0; &_convert; UINT _acp = CP_ACP; &_acp; LPCWSTR _lpw = NULL; &_lpw; LPCSTR _lpa = NULL; &_lpa
  52.     #endif
  53. #endif
  54. #endif __BORLANDC__
  55.  
  56. #ifdef _WINGDI_
  57.     ATLAPI_(LPDEVMODEA) AtlDevModeW2A(LPDEVMODEA lpDevModeA, LPDEVMODEW lpDevModeW);
  58. #endif
  59.  
  60. /////////////////////////////////////////////////////////////////////////////
  61. // Global UNICODE<>ANSI translation helpers
  62. inline LPWSTR WINAPI AtlA2WHelper(LPWSTR lpw, LPCSTR lpa, int nChars, UINT acp)
  63. {
  64.     ATLASSERT(lpa != NULL);
  65.     ATLASSERT(lpw != NULL);
  66.     // verify that no illegal character present
  67.     // since lpw was allocated based on the size of lpa
  68.     // don't worry about the number of chars
  69.     lpw[0] = '\0';
  70.     MultiByteToWideChar(acp, 0, lpa, -1, lpw, nChars);
  71.     return lpw;
  72. }
  73.  
  74. inline LPSTR WINAPI AtlW2AHelper(LPSTR lpa, LPCWSTR lpw, int nChars, UINT acp)
  75. {
  76.     ATLASSERT(lpw != NULL);
  77.     ATLASSERT(lpa != NULL);
  78.     // verify that no illegal character present
  79.     // since lpa was allocated based on the size of lpw
  80.     // don't worry about the number of chars
  81.     lpa[0] = '\0';
  82.     WideCharToMultiByte(acp, 0, lpw, -1, lpa, nChars, NULL, NULL);
  83.     return lpa;
  84. }
  85. inline LPWSTR WINAPI AtlA2WHelper(LPWSTR lpw, LPCSTR lpa, int nChars)
  86. {
  87.     return AtlA2WHelper(lpw, lpa, nChars, CP_ACP);
  88. }
  89.  
  90. inline LPSTR WINAPI AtlW2AHelper(LPSTR lpa, LPCWSTR lpw, int nChars)
  91. {
  92.     return AtlW2AHelper(lpa, lpw, nChars, CP_ACP);
  93. }
  94.  
  95. #ifdef _CONVERSION_USES_THREAD_LOCALE
  96.     #ifdef ATLA2WHELPER
  97.         #undef ATLA2WHELPER
  98.         #undef ATLW2AHELPER
  99.     #endif
  100.     #define ATLA2WHELPER AtlA2WHelper
  101.     #define ATLW2AHELPER AtlW2AHelper
  102. #else
  103.     #ifndef ATLA2WHELPER
  104.         #define ATLA2WHELPER AtlA2WHelper
  105.         #define ATLW2AHELPER AtlW2AHelper
  106.     #endif
  107. #endif
  108.  
  109. #ifdef _CONVERSION_USES_THREAD_LOCALE
  110.     #define A2W(lpa) (\
  111.         ((_lpa = lpa) == NULL) ? NULL : (\
  112.             _convert = (lstrlenA(_lpa)+1),\
  113.             ATLA2WHELPER((LPWSTR) alloca(_convert*2), _lpa, _convert, _acp)))
  114. #else
  115.     #define A2W(lpa) (\
  116.         ((_lpa = lpa) == NULL) ? NULL : (\
  117.             _convert = (lstrlenA(_lpa)+1),\
  118.             ATLA2WHELPER((LPWSTR) alloca(_convert*2), _lpa, _convert)))
  119. #endif
  120.  
  121. #ifdef _CONVERSION_USES_THREAD_LOCALE
  122.     #define W2A(lpw) (\
  123.         ((_lpw = lpw) == NULL) ? NULL : (\
  124.             _convert = (lstrlenW(_lpw)+1)*2,\
  125.             ATLW2AHELPER((LPSTR) alloca(_convert), _lpw, _convert, _acp)))
  126. #else
  127.     #define W2A(lpw) (\
  128.         ((_lpw = lpw) == NULL) ? NULL : (\
  129.             _convert = (lstrlenW(_lpw)+1)*2,\
  130.             ATLW2AHELPER((LPSTR) alloca(_convert), _lpw, _convert)))
  131. #endif
  132.  
  133. #define A2CW(lpa) ((LPCWSTR)A2W(lpa))
  134. #define W2CA(lpw) ((LPCSTR)W2A(lpw))
  135.  
  136. #if defined(_UNICODE)
  137. // in these cases the default (TCHAR) is the same as OLECHAR
  138.     inline size_t ocslen(LPCOLESTR x) { return lstrlenW(x); }
  139.     inline OLECHAR* ocscpy(LPOLESTR dest, LPCOLESTR src) { return lstrcpyW(dest, src); }
  140.     inline OLECHAR* ocscat(LPOLESTR dest, LPCOLESTR src) { return lstrcatW(dest, src); }
  141.     inline LPCOLESTR T2COLE(LPCTSTR lp) { return lp; }
  142.     inline LPCTSTR OLE2CT(LPCOLESTR lp) { return lp; }
  143.     inline LPOLESTR T2OLE(LPTSTR lp) { return lp; }
  144.     inline LPTSTR OLE2T(LPOLESTR lp) { return lp; }
  145.     inline LPOLESTR CharNextO(LPCOLESTR lp) {return CharNextW(lp);}
  146. #elif defined(OLE2ANSI)
  147. // in these cases the default (TCHAR) is the same as OLECHAR
  148.     inline size_t ocslen(LPCOLESTR x) { return lstrlen(x); }
  149.     inline OLECHAR* ocscpy(LPOLESTR dest, LPCOLESTR src) { return lstrcpy(dest, src); }
  150.     inline OLECHAR* ocscat(LPOLESTR dest, LPCOLESTR src) { return ocscpy(dest+ocslen(dest), src); }
  151.     inline LPCOLESTR T2COLE(LPCTSTR lp) { return lp; }
  152.     inline LPCTSTR OLE2CT(LPCOLESTR lp) { return lp; }
  153.     inline LPOLESTR T2OLE(LPTSTR lp) { return lp; }
  154.     inline LPTSTR OLE2T(LPOLESTR lp) { return lp; }
  155.     inline LPOLESTR CharNextO(LPCOLESTR lp) {return CharNext(lp);}
  156. #else
  157.     inline size_t ocslen(LPCOLESTR x) { return lstrlenW(x); }
  158.     //lstrcpyW doesn't work on Win95, so we do this
  159.     inline OLECHAR* ocscpy(LPOLESTR dest, LPCOLESTR src)
  160.     {return (LPOLESTR) memcpy(dest, src, (lstrlenW(src)+1)*sizeof(WCHAR));}
  161.     inline OLECHAR* ocscat(LPOLESTR dest, LPCOLESTR src) { return ocscpy(dest+ocslen(dest), src); }
  162.     //CharNextW doesn't work on Win95 so we use this
  163.     #define T2COLE(lpa) A2CW(lpa)
  164.     #define T2OLE(lpa) A2W(lpa)
  165.     #define OLE2CT(lpo) W2CA(lpo)
  166.     #define OLE2T(lpo) W2A(lpo)
  167.     inline LPOLESTR CharNextO(LPCOLESTR lp) {return (LPOLESTR) ((*lp) ? (lp+1) : lp);}
  168. #endif
  169.  
  170. #ifdef OLE2ANSI
  171.     inline LPOLESTR A2OLE(LPSTR lp) { return lp;}
  172.     inline LPSTR OLE2A(LPOLESTR lp) { return lp;}
  173.     #define W2OLE W2A
  174.     #define OLE2W A2W
  175.     inline LPCOLESTR A2COLE(LPCSTR lp) { return lp;}
  176.     inline LPCSTR OLE2CA(LPCOLESTR lp) { return lp;}
  177.     #define W2COLE W2CA
  178.     #define OLE2CW A2CW
  179. #else
  180.     inline LPOLESTR W2OLE(LPWSTR lp) { return lp; }
  181.     inline LPWSTR OLE2W(LPOLESTR lp) { return lp; }
  182.     #define A2OLE A2W
  183.     #define OLE2A W2A
  184.     inline LPCOLESTR W2COLE(LPCWSTR lp) { return lp; }
  185.     inline LPCWSTR OLE2CW(LPCOLESTR lp) { return lp; }
  186.     #define A2COLE A2CW
  187.     #define OLE2CA W2CA
  188. #endif
  189.  
  190. #ifdef _UNICODE
  191.     #define T2A W2A
  192.     #define A2T A2W
  193.     inline LPWSTR T2W(LPTSTR lp) { return lp; }
  194.     inline LPTSTR W2T(LPWSTR lp) { return lp; }
  195.     #define T2CA W2CA
  196.     #define A2CT A2CW
  197.     inline LPCWSTR T2CW(LPCTSTR lp) { return lp; }
  198.     inline LPCTSTR W2CT(LPCWSTR lp) { return lp; }
  199. #else
  200.     #define T2W A2W
  201.     #define W2T W2A
  202.     inline LPSTR T2A(LPTSTR lp) { return lp; }
  203.     inline LPTSTR A2T(LPSTR lp) { return lp; }
  204.     #define T2CW A2CW
  205.     #define W2CT W2CA
  206.     inline LPCSTR T2CA(LPCTSTR lp) { return lp; }
  207.     inline LPCTSTR A2CT(LPCSTR lp) { return lp; }
  208. #endif
  209.  
  210. inline BSTR A2WBSTR(LPCSTR lp, int nLen = -1)
  211. {
  212.     USES_CONVERSION;
  213.     BSTR str = NULL;
  214.     int nConvertedLen = MultiByteToWideChar(_acp, 0, lp,
  215.         nLen, NULL, NULL)-1;
  216.  
  217.   if (nLen==-1)
  218.      nConvertedLen = nConvertedLen -1;
  219.  
  220.     str = ::SysAllocStringLen(NULL, nConvertedLen);
  221.     if (str != NULL)
  222.     {
  223.         MultiByteToWideChar(_acp, 0, lp, -1,
  224.             str, nConvertedLen);
  225.     }
  226.     return str;
  227. }
  228.  
  229. inline BSTR OLE2BSTR(LPCOLESTR lp) {return ::SysAllocString(lp);}
  230. #if defined(_UNICODE)
  231. // in these cases the default (TCHAR) is the same as OLECHAR
  232.     inline BSTR T2BSTR(LPCTSTR lp) {return ::SysAllocString(lp);}
  233.     inline BSTR A2BSTR(LPCSTR lp) {USES_CONVERSION; return A2WBSTR(lp);}
  234.     inline BSTR W2BSTR(LPCWSTR lp) {return ::SysAllocString(lp);}
  235. #elif defined(OLE2ANSI)
  236. // in these cases the default (TCHAR) is the same as OLECHAR
  237.     inline BSTR T2BSTR(LPCTSTR lp) {return ::SysAllocString(lp);}
  238.     inline BSTR A2BSTR(LPCSTR lp) {return ::SysAllocString(lp);}
  239.     inline BSTR W2BSTR(LPCWSTR lp) {USES_CONVERSION; return ::SysAllocString(W2COLE(lp));}
  240. #else
  241.     inline BSTR T2BSTR(LPCTSTR lp) {USES_CONVERSION; return A2WBSTR(lp);}
  242.     inline BSTR A2BSTR(LPCSTR lp) {USES_CONVERSION; return A2WBSTR(lp);}
  243.     inline BSTR W2BSTR(LPCWSTR lp) {return ::SysAllocString(lp);}
  244. #endif
  245.  
  246. #ifdef _WINGDI_
  247. /////////////////////////////////////////////////////////////////////////////
  248. // Global UNICODE<>ANSI translation helpers
  249. inline LPDEVMODEW AtlDevModeA2W(LPDEVMODEW lpDevModeW, LPDEVMODEA lpDevModeA)
  250. {
  251.     USES_CONVERSION;
  252.     if (lpDevModeA == NULL)
  253.         return NULL;
  254.     ATLASSERT(lpDevModeW != NULL);
  255.     AtlA2WHelper(lpDevModeW->dmDeviceName, (LPCSTR)lpDevModeA->dmDeviceName, 32*sizeof(WCHAR), _acp);
  256.     memcpy(&lpDevModeW->dmSpecVersion, &lpDevModeA->dmSpecVersion,
  257.         offsetof(DEVMODEW, dmFormName) - offsetof(DEVMODEW, dmSpecVersion));
  258.     AtlA2WHelper(lpDevModeW->dmFormName, (LPCSTR)lpDevModeA->dmFormName, 32*sizeof(WCHAR), _acp);
  259.     memcpy(&lpDevModeW->dmLogPixels, &lpDevModeA->dmLogPixels,
  260.         sizeof(DEVMODEW) - offsetof(DEVMODEW, dmLogPixels));
  261.     if (lpDevModeA->dmDriverExtra != 0)
  262.         memcpy(lpDevModeW+1, lpDevModeA+1, lpDevModeA->dmDriverExtra);
  263.     lpDevModeW->dmSize = sizeof(DEVMODEW);
  264.     return lpDevModeW;
  265. }
  266.  
  267. inline LPTEXTMETRICW AtlTextMetricA2W(LPTEXTMETRICW lptmW, LPTEXTMETRICA lptmA)
  268. {
  269.     USES_CONVERSION;
  270.     if (lptmA == NULL)
  271.         return NULL;
  272.     ATLASSERT(lptmW != NULL);
  273.     memcpy(lptmW, lptmA, sizeof(LONG) * 11);
  274.     memcpy(&lptmW->tmItalic, &lptmA->tmItalic, sizeof(BYTE) * 5);
  275.     MultiByteToWideChar(_acp, 0, (LPCSTR)&lptmA->tmFirstChar, 1, &lptmW->tmFirstChar, 1);
  276.     MultiByteToWideChar(_acp, 0, (LPCSTR)&lptmA->tmLastChar, 1, &lptmW->tmLastChar, 1);
  277.     MultiByteToWideChar(_acp, 0, (LPCSTR)&lptmA->tmDefaultChar, 1, &lptmW->tmDefaultChar, 1);
  278.     MultiByteToWideChar(_acp, 0, (LPCSTR)&lptmA->tmBreakChar, 1, &lptmW->tmBreakChar, 1);
  279.     return lptmW;
  280. }
  281.  
  282. inline LPTEXTMETRICA AtlTextMetricW2A(LPTEXTMETRICA lptmA, LPTEXTMETRICW lptmW)
  283. {
  284.     USES_CONVERSION;
  285.     if (lptmW == NULL)
  286.         return NULL;
  287.     ATLASSERT(lptmA != NULL);
  288.     memcpy(lptmA, lptmW, sizeof(LONG) * 11);
  289.     memcpy(&lptmA->tmItalic, &lptmW->tmItalic, sizeof(BYTE) * 5);
  290.     WideCharToMultiByte(_acp, 0, &lptmW->tmFirstChar, 1, (LPSTR)&lptmA->tmFirstChar, 1, NULL, NULL);
  291.     WideCharToMultiByte(_acp, 0, &lptmW->tmLastChar, 1, (LPSTR)&lptmA->tmLastChar, 1, NULL, NULL);
  292.     WideCharToMultiByte(_acp, 0, &lptmW->tmDefaultChar, 1, (LPSTR)&lptmA->tmDefaultChar, 1, NULL, NULL);
  293.     WideCharToMultiByte(_acp, 0, &lptmW->tmBreakChar, 1, (LPSTR)&lptmA->tmBreakChar, 1, NULL, NULL);
  294.     return lptmA;
  295. }
  296.  
  297. #ifndef ATLDEVMODEA2W
  298. #define ATLDEVMODEA2W AtlDevModeA2W
  299. #define ATLDEVMODEW2A AtlDevModeW2A
  300. #define ATLTEXTMETRICA2W AtlTextMetricA2W
  301. #define ATLTEXTMETRICW2A AtlTextMetricW2A
  302. #endif
  303.  
  304. #define DEVMODEW2A(lpw)\
  305.     ((lpw == NULL) ? NULL : ATLDEVMODEW2A((LPDEVMODEA)alloca(sizeof(DEVMODEA)+lpw->dmDriverExtra), lpw))
  306. #define DEVMODEA2W(lpa)\
  307.     ((lpa == NULL) ? NULL : ATLDEVMODEA2W((LPDEVMODEW)alloca(sizeof(DEVMODEW)+lpa->dmDriverExtra), lpa))
  308. #define TEXTMETRICW2A(lptmw)\
  309.     ((lptmw == NULL) ? NULL : ATLTEXTMETRICW2A((LPTEXTMETRICA)alloca(sizeof(TEXTMETRICA)), lptmw))
  310. #define TEXTMETRICA2W(lptma)\
  311.     ((lptma == NULL) ? NULL : ATLTEXTMETRICA2W((LPTEXTMETRICW)alloca(sizeof(TEXTMETRICW)), lptma))
  312.  
  313. #ifdef OLE2ANSI
  314.     #define DEVMODEOLE DEVMODEA
  315.     #define LPDEVMODEOLE LPDEVMODEA
  316.     #define TEXTMETRICOLE TEXTMETRICA
  317.     #define LPTEXTMETRICOLE LPTEXTMETRICA
  318. #else
  319.     #define DEVMODEOLE DEVMODEW
  320.     #define LPDEVMODEOLE LPDEVMODEW
  321.     #define TEXTMETRICOLE TEXTMETRICW
  322.     #define LPTEXTMETRICOLE LPTEXTMETRICW
  323. #endif
  324.  
  325. #if defined(_UNICODE)
  326. // in these cases the default (TCHAR) is the same as OLECHAR
  327.     inline LPDEVMODEW DEVMODEOLE2T(LPDEVMODEOLE lp) { return lp; }
  328.     inline LPDEVMODEOLE DEVMODET2OLE(LPDEVMODEW lp) { return lp; }
  329.     inline LPTEXTMETRICW TEXTMETRICOLE2T(LPTEXTMETRICOLE lp) { return lp; }
  330.     inline LPTEXTMETRICOLE TEXTMETRICT2OLE(LPTEXTMETRICW lp) { return lp; }
  331. #elif defined(OLE2ANSI)
  332. // in these cases the default (TCHAR) is the same as OLECHAR
  333.     inline LPDEVMODE DEVMODEOLE2T(LPDEVMODEOLE lp) { return lp; }
  334.     inline LPDEVMODEOLE DEVMODET2OLE(LPDEVMODE lp) { return lp; }
  335.     inline LPTEXTMETRIC TEXTMETRICOLE2T(LPTEXTMETRICOLE lp) { return lp; }
  336.     inline LPTEXTMETRICOLE TEXTMETRICT2OLE(LPTEXTMETRIC lp) { return lp; }
  337. #else
  338.     #define DEVMODEOLE2T(lpo) DEVMODEW2A(lpo)
  339.     #define DEVMODET2OLE(lpa) DEVMODEA2W(lpa)
  340.     #define TEXTMETRICOLE2T(lptmw) TEXTMETRICW2A(lptmw)
  341.     #define TEXTMETRICT2OLE(lptma) TEXTMETRICA2W(lptma)
  342. #endif
  343.  
  344. #endif //_WINGDI_
  345.  
  346. #pragma pack(pop)
  347.  
  348. #ifndef _ATL_DLL_IMPL
  349. #ifndef _ATL_DLL
  350. #define _ATLCONV_IMPL
  351. #endif
  352. #endif
  353.  
  354. #endif // __ATLCONV_H__
  355.  
  356. /////////////////////////////////////////////////////////////////////////////
  357.  
  358. #ifdef _ATLCONV_IMPL
  359.  
  360. #ifdef _WINGDI_
  361.  
  362. ATLINLINE ATLAPI_(LPDEVMODEA) AtlDevModeW2A(LPDEVMODEA lpDevModeA, LPDEVMODEW lpDevModeW)
  363. {
  364.     USES_CONVERSION;
  365.     if (lpDevModeW == NULL)
  366.         return NULL;
  367.     ATLASSERT(lpDevModeA != NULL);
  368.     AtlW2AHelper((LPSTR)lpDevModeA->dmDeviceName, lpDevModeW->dmDeviceName, 32*sizeof(char), _acp);
  369.     memcpy(&lpDevModeA->dmSpecVersion, &lpDevModeW->dmSpecVersion,
  370.         offsetof(DEVMODEA, dmFormName) - offsetof(DEVMODEA, dmSpecVersion));
  371.     AtlW2AHelper((LPSTR)lpDevModeA->dmFormName, lpDevModeW->dmFormName, 32*sizeof(char), _acp);
  372.     memcpy(&lpDevModeA->dmLogPixels, &lpDevModeW->dmLogPixels,
  373.         sizeof(DEVMODEA) - offsetof(DEVMODEA, dmLogPixels));
  374.     if (lpDevModeW->dmDriverExtra != 0)
  375.         memcpy(lpDevModeA+1, lpDevModeW+1, lpDevModeW->dmDriverExtra);
  376.     lpDevModeA->dmSize = sizeof(DEVMODEA);
  377.     return lpDevModeA;
  378. }
  379.  
  380. #endif //_WINGDI
  381.  
  382. //Prevent pulling in second time
  383. #undef _ATLCONV_IMPL
  384.  
  385. #endif // _ATLCONV_IMPL
  386.