home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / com / inole2 / inole / ansi.cpp next >
C/C++ Source or Header  |  1996-05-23  |  9KB  |  397 lines
  1. /*
  2.  * ANSI.CPP
  3.  *
  4.  * Utility functions for dealing with OLE APIs that need
  5.  * Unicode strings.  These are only defined when UNICODE
  6.  * is not defined, otherwise INOLE.H simply redefines them
  7.  * as macro pass-throughs to the original OLE functions.
  8.  *
  9.  * Copyright (c)1993-1995 Microsoft Corporation, All Rights Reserved
  10.  *
  11.  * Kraig Brockschmidt, Microsoft
  12.  * Internet  :  kraigb@microsoft.com
  13.  * Compuserve:  >INTERNET:kraigb@microsoft.com
  14.  */
  15.  
  16.  
  17. #define NOMACROREDIRECT
  18. #include "inoledll.h"
  19.  
  20.  
  21. #ifdef WIN32ANSI
  22.  
  23. /*
  24.  * ConvertStringAlloc
  25.  *
  26.  * Purpose:
  27.  *  Allocates memory using the task allocator.  Used internally
  28.  *  in this file.
  29.  */
  30.  
  31. HRESULT ConvertStringAlloc(ULONG ulSize, void **ppv)
  32.     {
  33.     HRESULT     hr;
  34.     IMalloc    *pIMalloc;
  35.  
  36.     if (NULL==ppv)
  37.         return ResultFromScode(E_INVALIDARG);
  38.  
  39.     hr=CoGetMalloc(MEMCTX_TASK, &pIMalloc);
  40.  
  41.     if (FAILED(hr))
  42.         return hr;
  43.  
  44.     *ppv=pIMalloc->Alloc(ulSize);
  45.     pIMalloc->Release();
  46.  
  47.     return (NULL==*ppv) ? ResultFromScode(E_OUTOFMEMORY) : NOERROR;
  48.     }
  49.  
  50.  
  51.  
  52. /*
  53.  * INOLE_ConvertStringToANSI
  54.  *
  55.  * Purpose:
  56.  *  Converts the string in pszW to ANSI, allocating the
  57.  *  output buffer pointed to by *ppszA on output.  The
  58.  *  string is allocated with COM's task allocator.
  59.  *
  60.  */
  61.  
  62. STDAPI INOLE_ConvertStringToANSI(LPCWSTR pszW, LPSTR *ppszA)
  63.     {
  64.     ULONG   cch;
  65.     HRESULT hr;
  66.  
  67.     //If input is NULL then just return the same
  68.     if (NULL==pszW)
  69.         {
  70.         *ppszA=NULL;
  71.         return NOERROR;
  72.         }
  73.  
  74.     //This calculates the number of MBCS characters we'll need
  75.     cch=1+WideCharToMultiByte(CP_ACP, 0, pszW, -1, NULL, 0, NULL, NULL);
  76.  
  77.     hr=ConvertStringAlloc(cch, (void **)ppszA);
  78.  
  79.     if (FAILED(hr))
  80.         return hr;
  81.  
  82.     WideCharToMultiByte(CP_ACP, 0, pszW, -1, *ppszA, cch, NULL, NULL);
  83.     return NOERROR;
  84.     }
  85.  
  86.  
  87.  
  88.  
  89. /*
  90.  * INOLE_StringFromCLSID
  91.  */
  92.  
  93. STDAPI INOLE_StringFromCLSID(REFCLSID clsID, LPSTR *ppszCLSID)
  94.     {
  95.     LPWSTR  psz;
  96.     HRESULT hr;
  97.  
  98.     if (NULL==ppszCLSID)
  99.         return ResultFromScode(E_INVALIDARG);
  100.  
  101.     hr=StringFromCLSID(clsID, &psz);
  102.  
  103.     if (FAILED(hr))
  104.         return hr;
  105.  
  106.     hr=INOLE_ConvertStringToANSI(psz, ppszCLSID);
  107.     CoTaskMemFree((void *)psz);
  108.     return hr;
  109.     }
  110.  
  111.  
  112.  
  113. /*
  114.  * INOLE_StringFromGUID2
  115.  */
  116.  
  117. STDAPI INOLE_StringFromGUID2(REFGUID guid, LPSTR pszGUID, int cch)
  118.     {
  119.     LPSTR   psz;
  120.     HRESULT hr;
  121.  
  122.     if (NULL==pszGUID)
  123.         return ResultFromScode(E_INVALIDARG);
  124.  
  125.     hr=INOLE_StringFromCLSID(guid, &psz);
  126.  
  127.     if (FAILED(hr))
  128.         return hr;
  129.  
  130.     lstrcpyn(pszGUID, psz, cch);
  131.     CoTaskMemFree((void *)psz);
  132.     return hr;
  133.     }
  134.  
  135.  
  136.  
  137.  
  138.  
  139. /*
  140.  * INOLE_ProgIDFromCLSID
  141.  */
  142.  
  143. STDAPI INOLE_ProgIDFromCLSID(REFCLSID clsID, LPSTR *ppszProgID)
  144.     {
  145.     LPWSTR  psz;
  146.     HRESULT hr;
  147.  
  148.     if (NULL==ppszProgID)
  149.         return ResultFromScode(E_INVALIDARG);
  150.  
  151.     hr=ProgIDFromCLSID(clsID, &psz);
  152.  
  153.     if (FAILED(hr))
  154.         return hr;
  155.  
  156.     hr=INOLE_ConvertStringToANSI(psz, ppszProgID);
  157.     CoTaskMemFree(psz);
  158.     return hr;
  159.     }
  160.  
  161.  
  162.  
  163.  
  164. /*
  165.  * INOLE_ReadFmtUserTypeStg
  166.  * INOLE_WriteFmtUserTypeStg
  167.  */
  168.  
  169. STDAPI INOLE_ReadFmtUserTypeStg(IStorage *pIStorage
  170.     , CLIPFORMAT *pcf, LPSTR *ppszUserType)
  171.     {
  172.     HRESULT     hr;
  173.     LPOLESTR    pszUserType;
  174.  
  175.     if (NULL==ppszUserType)
  176.         return ResultFromScode(E_INVALIDARG);
  177.  
  178.     hr=ReadFmtUserTypeStg(pIStorage, pcf, &pszUserType);
  179.  
  180.     if (FAILED(hr))
  181.         return hr;
  182.  
  183.     if (ppszUserType)
  184.         {
  185.         hr=INOLE_ConvertStringToANSI(pszUserType, ppszUserType);
  186.         CoTaskMemFree(pszUserType);
  187.         }
  188.  
  189.     return hr;
  190.     }
  191.  
  192.  
  193. STDAPI INOLE_WriteFmtUserTypeStg(IStorage *pIStorage, CLIPFORMAT cf
  194.     , LPSTR pszUserType)
  195.     {
  196.     OLECHAR     szType[512];
  197.     HRESULT     hr;
  198.  
  199.     if (NULL==pszUserType)
  200.         return ResultFromScode(E_INVALIDARG);
  201.  
  202.     MultiByteToWideChar(CP_ACP, 0, pszUserType, -1, szType, 512);
  203.     hr=WriteFmtUserTypeStg(pIStorage, cf, szType);
  204.  
  205.     return hr;
  206.     }
  207.  
  208.  
  209.  
  210. /*
  211.  * INOLE_StgIsStorageFile
  212.  * INOLE_StgCreateDocfile
  213.  * INOLE_StgOpenStorage
  214.  */
  215.  
  216. STDAPI INOLE_StgIsStorageFile(LPCSTR pszName)
  217.     {
  218.     OLECHAR     szTemp[MAX_PATH];
  219.  
  220.     MultiByteToWideChar(CP_ACP, 0, pszName, -1
  221.         , szTemp, MAX_PATH);
  222.     return StgIsStorageFile(szTemp);
  223.     }
  224.  
  225.  
  226.  
  227. STDAPI INOLE_StgCreateDocfile(LPCSTR pszNameA, DWORD grfMode
  228.     , DWORD reserved, IStorage **ppIStorage)
  229.     {
  230.     OLECHAR     szTemp[MAX_PATH];
  231.     LPOLESTR    pszName;
  232.  
  233.     *ppIStorage=NULL;
  234.  
  235.     if (NULL!=pszNameA)
  236.         {
  237.         MultiByteToWideChar(CP_ACP, 0, pszNameA, -1
  238.             , szTemp, MAX_PATH);
  239.         pszName=szTemp;
  240.         }
  241.     else
  242.         pszName=NULL;
  243.  
  244.     return StgCreateDocfile(pszName, grfMode, reserved
  245.         , ppIStorage);
  246.     }
  247.  
  248.  
  249.  
  250. STDAPI INOLE_StgOpenStorage(LPCSTR pszNameA, IStorage *pStgPri
  251.     , DWORD grfMode, SNB snbEx, DWORD reserved
  252.     , IStorage * *ppIStorage)
  253.     {
  254.     OLECHAR   szTemp[MAX_PATH];
  255.     LPOLESTR  pszName;
  256.  
  257.     *ppIStorage=NULL;
  258.  
  259.     if (NULL!=pszNameA)
  260.         {
  261.         MultiByteToWideChar(CP_ACP, 0, pszNameA, -1
  262.             , szTemp, MAX_PATH);
  263.         pszName= szTemp;
  264.         }
  265.     else
  266.         pszName=NULL;
  267.  
  268.     return StgOpenStorage(pszName, pStgPri, grfMode, snbEx
  269.         , reserved, ppIStorage);
  270.     }
  271.  
  272.  
  273.  
  274.  
  275. /*
  276.  * INOLE_CreateFileMoniker
  277.  * INOLE_CreateItemMoniker
  278.  * INOLE_MkParseDisplayName
  279.  */
  280.  
  281. STDAPI INOLE_CreateFileMoniker(LPCSTR pszPathNameA, LPMONIKER *ppmk)
  282.     {
  283.     OLECHAR     szTemp[MAX_PATH];
  284.  
  285.     if (NULL==ppmk)
  286.         return ResultFromScode(E_INVALIDARG);
  287.  
  288.     *ppmk=NULL;
  289.  
  290.     MultiByteToWideChar(CP_ACP, 0, pszPathNameA, -1
  291.         , szTemp, MAX_PATH);
  292.  
  293.     return CreateFileMoniker(szTemp, ppmk);
  294.     }
  295.  
  296.  
  297. STDAPI INOLE_CreateItemMoniker(LPCSTR pszDelimA, LPCSTR pszItemA
  298.     , LPMONIKER *ppmk)
  299.     {
  300.     OLECHAR     szItem[MAX_PATH];   //Some assumptions about string length
  301.     OLECHAR     szDelim[20];
  302.  
  303.     if (NULL==ppmk)
  304.         return ResultFromScode(E_INVALIDARG);
  305.  
  306.     *ppmk=NULL;
  307.  
  308.     MultiByteToWideChar(CP_ACP, 0, pszItemA, -1
  309.         , szItem, MAX_PATH);
  310.     MultiByteToWideChar(CP_ACP, 0, pszDelimA, -1
  311.         , szDelim, 20);
  312.  
  313.     return CreateItemMoniker(szDelim, szItem, ppmk);
  314.     }
  315.  
  316.  
  317. STDAPI INOLE_MkParseDisplayName(LPBC pbc, LPCSTR pszUserNameA
  318.     , ULONG *pchEaten, LPMONIKER *ppmk)
  319.     {
  320.     OLECHAR     szTemp[512];    //Assumption on string length
  321.  
  322.     if (NULL==ppmk)
  323.         return ResultFromScode(E_INVALIDARG);
  324.  
  325.     *ppmk=NULL;
  326.  
  327.     MultiByteToWideChar(CP_ACP, 0, pszUserNameA, -1
  328.         , szTemp, 512);
  329.  
  330.     return MkParseDisplayName(pbc, szTemp, pchEaten, ppmk);
  331.     }
  332.  
  333.  
  334.  
  335. /*
  336.  * INOLE_OleCreateLinkToFile
  337.  * INOLE_OleCreateFromFile
  338.  */
  339.  
  340. STDAPI INOLE_OleCreateLinkToFile(LPCSTR lpszFileName, REFIID riid
  341.     , DWORD renderopt, LPFORMATETC lpFormatEtc
  342.     , LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID *ppvObj)
  343.     {
  344.     OLECHAR     szFile[512];    //Assumption on string length
  345.  
  346.     MultiByteToWideChar(CP_ACP, 0, lpszFileName, -1, szFile, 512);
  347.     return OleCreateLinkToFile(szFile, riid, renderopt, lpFormatEtc
  348.         , pClientSite, pStg, ppvObj);
  349.     }
  350.  
  351.  
  352.  
  353. STDAPI INOLE_OleCreateFromFile(REFCLSID rclsid, LPCSTR lpszFileName
  354.     , REFIID riid, DWORD renderopt, LPFORMATETC lpFormatEtc
  355.     , LPOLECLIENTSITE pClientSite, LPSTORAGE pStg, LPVOID *ppvObj)
  356.     {
  357.     OLECHAR     szFile[512];    //Assumption on string length
  358.  
  359.     MultiByteToWideChar(CP_ACP, 0, lpszFileName, -1, szFile, 512);
  360.     return OleCreateFromFile(rclsid, szFile, riid, renderopt, lpFormatEtc
  361.         , pClientSite, pStg, ppvObj);
  362.     }
  363.  
  364. #else
  365.  
  366. //Do-nothing functions so we can at least export them.
  367.  
  368. #ifndef WIN32
  369. STDAPI INOLE_ConvertStringToANSI(LPCSTR a, LPSTR *b) {return NOERROR;}
  370. #else
  371. STDAPI INOLE_ConvertStringToANSI(LPCWSTR a, LPSTR *b) {return NOERROR;}
  372. #endif
  373. STDAPI INOLE_StringFromCLSID(REFCLSID a, LPSTR *b) {return NOERROR;}
  374. STDAPI INOLE_StringFromGUID2(REFGUID a, LPSTR b, int c) {return NOERROR;}
  375. STDAPI INOLE_ProgIDFromCLSID(REFCLSID a, LPSTR *b) {return NOERROR;}
  376.  
  377. STDAPI INOLE_ReadFmtUserTypeStg(IStorage *a, CLIPFORMAT *b, LPSTR *c) {return NOERROR;}
  378. STDAPI INOLE_WriteFmtUserTypeStg(IStorage *a, CLIPFORMAT b, LPSTR c) {return NOERROR;}
  379.  
  380. STDAPI INOLE_StgIsStorageFile(LPCSTR a) {return NOERROR;}
  381. STDAPI INOLE_StgCreateDocfile(LPCSTR a, DWORD b, DWORD c, IStorage ** d) {return NOERROR;}
  382. STDAPI INOLE_StgOpenStorage(LPCSTR a, IStorage *b, DWORD c, SNB d
  383.            , DWORD e, IStorage **f) {return NOERROR;}
  384.  
  385. STDAPI INOLE_CreateFileMoniker(LPCSTR, LPMONIKER *) {return NOERROR;}
  386. STDAPI INOLE_CreateItemMoniker(LPCSTR, LPCSTR, LPMONIKER *) {return NOERROR;}
  387. STDAPI INOLE_MkParseDisplayName(LPBC, LPCSTR, ULONG *, LPMONIKER *) {return NOERROR;}
  388.  
  389. STDAPI INOLE_OleCreateLinkToFile(LPCOLESTR, REFIID, DWORD, LPFORMATETC
  390.     , LPOLECLIENTSITE, LPSTORAGE, LPVOID *) {return NOERROR;}
  391.  
  392. STDAPI INOLE_OleCreateFromFile(REFCLSID, LPCOLESTR, REFIID
  393.     , DWORD, LPFORMATETC, LPOLECLIENTSITE, LPSTORAGE, LPVOID *) {return NOERROR;}
  394.  
  395.  
  396. #endif
  397.