mimeintl.c File Reference

#include <stdarg.h>
#include <stdio.h>
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "winnls.h"
#include "objbase.h"
#include "ole2.h"
#include "mimeole.h"
#include "mlang.h"
#include "wine/list.h"
#include "wine/debug.h"
#include "inetcomm_private.h"

Include dependency graph for mimeintl.c:

Go to the source code of this file.

Classes
struct	charset_entry
struct	internat_impl

Macros
#define	COBJMACROS

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (inetcomm)
static internat_impl *	impl_from_IMimeInternational (IMimeInternational *iface)
static HRESULT	get_mlang (IMultiLanguage **ml)
static HRESULT WINAPI	MimeInternat_QueryInterface (IMimeInternational *iface, REFIID riid, LPVOID *ppobj)
static ULONG WINAPI	MimeInternat_AddRef (IMimeInternational *iface)
static ULONG WINAPI	MimeInternat_Release (IMimeInternational *iface)
static HRESULT WINAPI	MimeInternat_SetDefaultCharset (IMimeInternational *iface, HCHARSET hCharset)
static HRESULT WINAPI	MimeInternat_GetDefaultCharset (IMimeInternational *iface, LPHCHARSET phCharset)
static HRESULT	mlang_getcodepageinfo (UINT cp, MIMECPINFO *mlang_cp_info)
static HRESULT WINAPI	MimeInternat_GetCodePageCharset (IMimeInternational *iface, CODEPAGEID cpiCodePage, CHARSETTYPE ctCsetType, LPHCHARSET phCharset)
static HRESULT	mlang_getcsetinfo (const char *charset, MIMECSETINFO *mlang_info)
static HCHARSET	add_charset (struct list *list, MIMECSETINFO *mlang_info, HCHARSET handle)
static HRESULT WINAPI	MimeInternat_FindCharset (IMimeInternational *iface, LPCSTR pszCharset, LPHCHARSET phCharset)
static HRESULT WINAPI	MimeInternat_GetCharsetInfo (IMimeInternational *iface, HCHARSET hCharset, LPINETCSETINFO pCsetInfo)
static HRESULT WINAPI	MimeInternat_GetCodePageInfo (IMimeInternational *iface, CODEPAGEID cpiCodePage, LPCODEPAGEINFO pCodePageInfo)
static HRESULT WINAPI	MimeInternat_CanConvertCodePages (IMimeInternational *iface, CODEPAGEID cpiSource, CODEPAGEID cpiDest)
static HRESULT WINAPI	MimeInternat_DecodeHeader (IMimeInternational *iface, HCHARSET hCharset, LPCSTR pszData, LPPROPVARIANT pDecoded, LPRFC1522INFO pRfc1522Info)
static HRESULT WINAPI	MimeInternat_EncodeHeader (IMimeInternational *iface, HCHARSET hCharset, LPPROPVARIANT pData, LPSTR *ppszEncoded, LPRFC1522INFO pRfc1522Info)
static HRESULT WINAPI	MimeInternat_ConvertBuffer (IMimeInternational *iface, CODEPAGEID cpiSource, CODEPAGEID cpiDest, LPBLOB pIn, LPBLOB pOut, ULONG *pcbRead)
static HRESULT WINAPI	MimeInternat_ConvertString (IMimeInternational *iface, CODEPAGEID cpiSource, CODEPAGEID cpiDest, LPPROPVARIANT pIn, LPPROPVARIANT pOut)
static HRESULT WINAPI	MimeInternat_MLANG_ConvertInetReset (IMimeInternational *iface)
static HRESULT WINAPI	MimeInternat_MLANG_ConvertInetString (IMimeInternational *iface, CODEPAGEID cpiSource, CODEPAGEID cpiDest, LPCSTR pSource, int *pnSizeOfSource, LPSTR pDestination, int *pnDstSize)
static HRESULT WINAPI	MimeInternat_Rfc1522Decode (IMimeInternational *iface, LPCSTR pszValue, LPSTR pszCharset, ULONG cchmax, LPSTR *ppszDecoded)
static HRESULT WINAPI	MimeInternat_Rfc1522Encode (IMimeInternational *iface, LPCSTR pszValue, HCHARSET hCharset, LPSTR *ppszEncoded)
HRESULT	MimeInternational_Construct (IMimeInternational **internat)
HRESULT WINAPI	MimeOleGetInternat (IMimeInternational **internat)
HRESULT WINAPI	MimeOleFindCharset (LPCSTR name, LPHCHARSET charset)
HRESULT WINAPI	MimeOleGetCharsetInfo (HCHARSET hCharset, LPINETCSETINFO pCsetInfo)
HRESULT WINAPI	MimeOleGetDefaultCharset (LPHCHARSET charset)

Variables
static IMimeInternationalVtbl	mime_internat_vtbl
static internat_impl *	global_internat

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 21 of file mimeintl.c.

Function Documentation

add_charset()

static HCHARSET add_charset ( struct list *  list, MIMECSETINFO *  mlang_info, HCHARSET  handle  )

static

Definition at line 223 of file mimeintl.c.

{
    charset_entry *charset = HeapAlloc(GetProcessHeap(), 0, sizeof(*charset));
 
    WideCharToMultiByte(CP_ACP, 0, mlang_info->wszCharset, -1,
                        charset->cs_info.szName, sizeof(charset->cs_info.szName), NULL, NULL);
    charset->cs_info.cpiWindows = mlang_info->uiCodePage;
    charset->cs_info.cpiInternet = mlang_info->uiInternetEncoding;
    charset->cs_info.hCharset = handle;
    charset->cs_info.dwReserved1 = 0;
    list_add_head(list, &charset->entry);
 
    return charset->cs_info.hCharset;
}

Referenced by MimeInternat_FindCharset().

get_mlang()

static HRESULT get_mlang ( IMultiLanguage **  ml )

inlinestatic

Definition at line 64 of file mimeintl.c.

{
    return CoCreateInstance(&CLSID_CMultiLanguage, NULL,  CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER,
                            &IID_IMultiLanguage, (void **)ml);
}

Referenced by MimeInternat_CanConvertCodePages(), MimeInternat_ConvertBuffer(), MimeInternat_ConvertString(), mlang_getcodepageinfo(), mlang_getcsetinfo(), and mlang_getcsetinfo_from_cp().

impl_from_IMimeInternational()

static internat_impl * impl_from_IMimeInternational ( IMimeInternational *  iface )

inlinestatic

Definition at line 59 of file mimeintl.c.

{
    return CONTAINING_RECORD(iface, internat_impl, IMimeInternational_iface);
}

Referenced by MimeInternat_AddRef(), MimeInternat_FindCharset(), MimeInternat_GetCharsetInfo(), MimeInternat_GetDefaultCharset(), MimeInternat_Release(), and MimeInternat_SetDefaultCharset().

MimeInternat_AddRef()

static ULONG WINAPI MimeInternat_AddRef ( IMimeInternational *  iface )

static

Definition at line 84 of file mimeintl.c.

{
    internat_impl *This = impl_from_IMimeInternational( iface );
    return InterlockedIncrement(&This->refs);
}

MimeInternat_CanConvertCodePages()

static HRESULT WINAPI MimeInternat_CanConvertCodePages ( IMimeInternational *  iface, CODEPAGEID  cpiSource, CODEPAGEID  cpiDest  )

static

Definition at line 311 of file mimeintl.c.

{
    HRESULT hr;
    IMultiLanguage *ml;
 
    TRACE("(%p)->(%ld, %ld)\n", iface, cpiSource, cpiDest);
 
    /* Could call mlang.IsConvertINetStringAvailable() to avoid the COM overhead if need be. */
 
    hr = get_mlang(&ml);
    if(SUCCEEDED(hr))
    {
        hr = IMultiLanguage_IsConvertible(ml, cpiSource, cpiDest);
        IMultiLanguage_Release(ml);
    }
 
    return hr;
}

MimeInternat_ConvertBuffer()

static HRESULT WINAPI MimeInternat_ConvertBuffer ( IMimeInternational *  iface, CODEPAGEID  cpiSource, CODEPAGEID  cpiDest, LPBLOB  pIn, LPBLOB  pOut, ULONG *  pcbRead  )

static

Definition at line 349 of file mimeintl.c.

{
    HRESULT hr;
    IMultiLanguage *ml;
 
    TRACE("(%p)->(%ld, %ld, %p, %p, %p)\n", iface, cpiSource, cpiDest, pIn, pOut, pcbRead);
 
    *pcbRead = 0;
    pOut->cbSize = 0;
 
    /* Could call mlang.ConvertINetString() to avoid the COM overhead if need be. */
 
    hr = get_mlang(&ml);
    if(SUCCEEDED(hr))
    {
        DWORD mode = 0;
        UINT in_size = pIn->cbSize, out_size;
 
        hr = IMultiLanguage_ConvertString(ml, &mode, cpiSource, cpiDest, pIn->pBlobData, &in_size,
                                          NULL, &out_size);
        if(hr == S_OK) /* S_FALSE means the conversion could not be performed */
        {
            pOut->pBlobData = CoTaskMemAlloc(out_size);
            if(!pOut->pBlobData)
                hr = E_OUTOFMEMORY;
            else
            {
                mode = 0;
                in_size = pIn->cbSize;
                hr = IMultiLanguage_ConvertString(ml, &mode, cpiSource, cpiDest, pIn->pBlobData, &in_size,
                                                  pOut->pBlobData, &out_size);
 
                if(hr == S_OK)
                {
                    *pcbRead = in_size;
                    pOut->cbSize = out_size;
                }
                else
                    CoTaskMemFree(pOut->pBlobData);
            }
        }
        IMultiLanguage_Release(ml);
    }
 
    return hr;
}

MimeInternat_ConvertString()

static HRESULT WINAPI MimeInternat_ConvertString ( IMimeInternational *  iface, CODEPAGEID  cpiSource, CODEPAGEID  cpiDest, LPPROPVARIANT  pIn, LPPROPVARIANT  pOut  )

static

Definition at line 398 of file mimeintl.c.

{
    HRESULT hr;
    int src_len;
    IMultiLanguage *ml;
 
    TRACE("(%p)->(%ld, %ld, %p %p)\n", iface, cpiSource, cpiDest, pIn, pOut);
 
    switch(pIn->vt)
    {
    case VT_LPSTR:
        if(cpiSource == CP_UNICODE) cpiSource = GetACP();
        src_len = strlen(pIn->pszVal);
        break;
    case VT_LPWSTR:
        cpiSource = CP_UNICODE;
        src_len = lstrlenW(pIn->pwszVal) * sizeof(WCHAR);
        break;
    default:
        return E_INVALIDARG;
    }
 
    hr = get_mlang(&ml);
    if(SUCCEEDED(hr))
    {
        DWORD mode = 0;
        UINT in_size = src_len, out_size;
 
        hr = IMultiLanguage_ConvertString(ml, &mode, cpiSource, cpiDest, (BYTE*)pIn->pszVal, &in_size,
                                          NULL, &out_size);
        if(hr == S_OK) /* S_FALSE means the conversion could not be performed */
        {
            out_size += (cpiDest == CP_UNICODE) ? sizeof(WCHAR) : sizeof(char);
 
            pOut->pszVal = CoTaskMemAlloc(out_size);
            if(!pOut->pszVal)
                hr = E_OUTOFMEMORY;
            else
            {
                mode = 0;
                in_size = src_len;
                hr = IMultiLanguage_ConvertString(ml, &mode, cpiSource, cpiDest, (BYTE*)pIn->pszVal, &in_size,
                                                  (BYTE*)pOut->pszVal, &out_size);
 
                if(hr == S_OK)
                {
                    if(cpiDest == CP_UNICODE)
                    {
                        pOut->pwszVal[out_size / sizeof(WCHAR)] = 0;
                        pOut->vt = VT_LPWSTR;
                    }
                    else
                    {
                        pOut->pszVal[out_size] = '\0';
                        pOut->vt = VT_LPSTR;
                    }
                }
                else
                    CoTaskMemFree(pOut->pszVal);
            }
        }
        IMultiLanguage_Release(ml);
    }
    return hr;
}

MimeInternat_DecodeHeader()

static HRESULT WINAPI MimeInternat_DecodeHeader ( IMimeInternational *  iface, HCHARSET  hCharset, LPCSTR  pszData, LPPROPVARIANT  pDecoded, LPRFC1522INFO  pRfc1522Info  )

static

Definition at line 331 of file mimeintl.c.

{
    FIXME("stub\n");
    return E_NOTIMPL;
}

MimeInternat_EncodeHeader()

static HRESULT WINAPI MimeInternat_EncodeHeader ( IMimeInternational *  iface, HCHARSET  hCharset, LPPROPVARIANT  pData, LPSTR *  ppszEncoded, LPRFC1522INFO  pRfc1522Info  )

static

Definition at line 340 of file mimeintl.c.

{
    FIXME("stub\n");
    return E_NOTIMPL;
}

MimeInternat_FindCharset()

static HRESULT WINAPI MimeInternat_FindCharset ( IMimeInternational *  iface, LPCSTR  pszCharset, LPHCHARSET  phCharset  )

static

Definition at line 238 of file mimeintl.c.

{
    internat_impl *This = impl_from_IMimeInternational( iface );
    HRESULT hr = MIME_E_NOT_FOUND;
    charset_entry *charset;
 
    TRACE("(%p)->(%s, %p)\n", iface, debugstr_a(pszCharset), phCharset);
 
    *phCharset = NULL;
 
    EnterCriticalSection(&This->cs);
 
    LIST_FOR_EACH_ENTRY(charset, &This->charsets, charset_entry, entry)
    {
        if(!lstrcmpiA(charset->cs_info.szName, pszCharset))
        {
            *phCharset = charset->cs_info.hCharset;
            hr = S_OK;
            break;
        }
    }
 
    if(hr == MIME_E_NOT_FOUND)
    {
        MIMECSETINFO mlang_info;
 
        LeaveCriticalSection(&This->cs);
        hr = mlang_getcsetinfo(pszCharset, &mlang_info);
        EnterCriticalSection(&This->cs);
 
        if(SUCCEEDED(hr))
            *phCharset = add_charset(&This->charsets, &mlang_info,
                                     UlongToHandle(InterlockedIncrement(&This->next_charset_handle)));
    }
 
    LeaveCriticalSection(&This->cs);
    return hr;
}

MimeInternat_GetCharsetInfo()

static HRESULT WINAPI MimeInternat_GetCharsetInfo ( IMimeInternational *  iface, HCHARSET  hCharset, LPINETCSETINFO  pCsetInfo  )

static

Definition at line 278 of file mimeintl.c.

{
    internat_impl *This = impl_from_IMimeInternational( iface );
    HRESULT hr = MIME_E_INVALID_HANDLE;
    charset_entry *charset;
 
    TRACE("(%p)->(%p, %p)\n", iface, hCharset, pCsetInfo);
 
    EnterCriticalSection(&This->cs);
 
    LIST_FOR_EACH_ENTRY(charset, &This->charsets, charset_entry, entry)
    {
        if(charset->cs_info.hCharset ==  hCharset)
        {
            *pCsetInfo = charset->cs_info;
            hr = S_OK;
            break;
        }
    }
 
    LeaveCriticalSection(&This->cs);
 
    return hr;
}

MimeInternat_GetCodePageCharset()

static HRESULT WINAPI MimeInternat_GetCodePageCharset ( IMimeInternational *  iface, CODEPAGEID  cpiCodePage, CHARSETTYPE  ctCsetType, LPHCHARSET  phCharset  )

static

Definition at line 161 of file mimeintl.c.

{
    HRESULT hr;
    MIMECPINFO mlang_cp_info;
 
    TRACE("(%p)->(%ld, %d, %p)\n", iface, cpiCodePage, ctCsetType, phCharset);
 
    *phCharset = NULL;
 
    hr = mlang_getcodepageinfo(cpiCodePage, &mlang_cp_info);
    if(SUCCEEDED(hr))
    {
        const WCHAR *charset_nameW = NULL;
        char *charset_name;
        DWORD len;
 
        switch(ctCsetType)
        {
        case CHARSET_BODY:
            charset_nameW = mlang_cp_info.wszBodyCharset;
            break;
        case CHARSET_HEADER:
            charset_nameW = mlang_cp_info.wszHeaderCharset;
            break;
        case CHARSET_WEB:
            charset_nameW = mlang_cp_info.wszWebCharset;
            break;
        default:
            return MIME_E_INVALID_CHARSET_TYPE;
        }
        len = WideCharToMultiByte(CP_ACP, 0, charset_nameW, -1, NULL, 0, NULL, NULL);
        charset_name = HeapAlloc(GetProcessHeap(), 0, len);
        WideCharToMultiByte(CP_ACP, 0, charset_nameW, -1, charset_name, len, NULL, NULL);
        hr = IMimeInternational_FindCharset(iface, charset_name, phCharset);
        HeapFree(GetProcessHeap(), 0, charset_name);
    }
    return hr;
}

MimeInternat_GetCodePageInfo()

static HRESULT WINAPI MimeInternat_GetCodePageInfo ( IMimeInternational *  iface, CODEPAGEID  cpiCodePage, LPCODEPAGEINFO  pCodePageInfo  )

static

Definition at line 304 of file mimeintl.c.

{
    FIXME("stub\n");
    return E_NOTIMPL;
}

MimeInternat_GetDefaultCharset()

static HRESULT WINAPI MimeInternat_GetDefaultCharset ( IMimeInternational *  iface, LPHCHARSET  phCharset  )

static

Definition at line 127 of file mimeintl.c.

{
    internat_impl *This = impl_from_IMimeInternational( iface );
    HRESULT hr = S_OK;
 
    TRACE("(%p)->(%p)\n", iface, phCharset);
 
    if(This->default_charset == NULL)
    {
        HCHARSET hcs;
        hr = IMimeInternational_GetCodePageCharset(iface, GetACP(), CHARSET_BODY, &hcs);
        if(SUCCEEDED(hr))
            InterlockedCompareExchangePointer(&This->default_charset, hcs, NULL);
    }
    *phCharset = This->default_charset;
 
    return hr;
}

MimeInternat_MLANG_ConvertInetReset()

static HRESULT WINAPI MimeInternat_MLANG_ConvertInetReset ( IMimeInternational *  iface )

static

Definition at line 466 of file mimeintl.c.

{
    FIXME("stub\n");
    return E_NOTIMPL;
}

MimeInternat_MLANG_ConvertInetString()

static HRESULT WINAPI MimeInternat_MLANG_ConvertInetString ( IMimeInternational *  iface, CODEPAGEID  cpiSource, CODEPAGEID  cpiDest, LPCSTR  pSource, int *  pnSizeOfSource, LPSTR  pDestination, int *  pnDstSize  )

static

Definition at line 472 of file mimeintl.c.

{
    FIXME("stub\n");
    return E_NOTIMPL;
}

MimeInternat_QueryInterface()

static HRESULT WINAPI MimeInternat_QueryInterface ( IMimeInternational *  iface, REFIID  riid, LPVOID *  ppobj  )

static

Definition at line 70 of file mimeintl.c.

{
    if (IsEqualGUID(riid, &IID_IUnknown) ||
        IsEqualGUID(riid, &IID_IMimeInternational))
    {
        IMimeInternational_AddRef( iface );
        *ppobj = iface;
        return S_OK;
    }
 
    FIXME("interface %s not implemented\n", debugstr_guid(riid));
    return E_NOINTERFACE;
}

MimeInternat_Release()

static ULONG WINAPI MimeInternat_Release ( IMimeInternational *  iface )

static

Definition at line 90 of file mimeintl.c.

{
    internat_impl *This = impl_from_IMimeInternational( iface );
    ULONG refs;
 
    refs = InterlockedDecrement(&This->refs);
    if (!refs)
    {
        charset_entry *charset, *cursor2;
 
        LIST_FOR_EACH_ENTRY_SAFE(charset, cursor2, &This->charsets, charset_entry, entry)
        {
            list_remove(&charset->entry);
            HeapFree(GetProcessHeap(), 0, charset);
        }
        This->cs.DebugInfo->Spare[0] = 0;
        DeleteCriticalSection(&This->cs);
        HeapFree(GetProcessHeap(), 0, This);
    }
 
    return refs;
}

MimeInternat_Rfc1522Decode()

static HRESULT WINAPI MimeInternat_Rfc1522Decode ( IMimeInternational *  iface, LPCSTR  pszValue, LPSTR  pszCharset, ULONG  cchmax, LPSTR *  ppszDecoded  )

static

Definition at line 483 of file mimeintl.c.

{
    FIXME("stub\n");
    return E_NOTIMPL;
}

MimeInternat_Rfc1522Encode()

static HRESULT WINAPI MimeInternat_Rfc1522Encode ( IMimeInternational *  iface, LPCSTR  pszValue, HCHARSET  hCharset, LPSTR *  ppszEncoded  )

static

Definition at line 492 of file mimeintl.c.

{
    FIXME("stub\n");
    return E_NOTIMPL;
}

MimeInternat_SetDefaultCharset()

static HRESULT WINAPI MimeInternat_SetDefaultCharset ( IMimeInternational *  iface, HCHARSET  hCharset  )

static

Definition at line 113 of file mimeintl.c.

{
    internat_impl *This = impl_from_IMimeInternational( iface );
 
    TRACE("(%p)->(%p)\n", iface, hCharset);
 
    if(hCharset == NULL) return E_INVALIDARG;
    /* FIXME check hCharset is valid */
 
    InterlockedExchangePointer(&This->default_charset, hCharset);
 
    return S_OK;
}

MimeInternational_Construct()

HRESULT MimeInternational_Construct

(

IMimeInternational **

internat

)

Definition at line 524 of file mimeintl.c.

{
    global_internat = HeapAlloc(GetProcessHeap(), 0, sizeof(*global_internat));
    global_internat->IMimeInternational_iface.lpVtbl = &mime_internat_vtbl;
    global_internat->refs = 0;
    InitializeCriticalSectionEx(&global_internat->cs, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO);
    global_internat->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": global_internat.cs");
 
    list_init(&global_internat->charsets);
    global_internat->next_charset_handle = 0;
    global_internat->default_charset = NULL;
 
    *internat = &global_internat->IMimeInternational_iface;
 
    IMimeInternational_AddRef(*internat);
    return S_OK;
}

Referenced by DllMain().

MimeOleFindCharset()

HRESULT WINAPI MimeOleFindCharset	(	LPCSTR	name,
		LPHCHARSET	charset
	)

Definition at line 551 of file mimeintl.c.

{
    IMimeInternational *internat;
    HRESULT hr;
 
    TRACE("(%s, %p)\n", debugstr_a(name), charset);
 
    hr = MimeOleGetInternat(&internat);
    if(SUCCEEDED(hr))
    {
        hr = IMimeInternational_FindCharset(internat, name, charset);
        IMimeInternational_Release(internat);
    }
    return hr;
}

MimeOleGetCharsetInfo()

HRESULT WINAPI MimeOleGetCharsetInfo	(	HCHARSET	hCharset,
		LPINETCSETINFO	pCsetInfo
	)

Definition at line 567 of file mimeintl.c.

{
    IMimeInternational *internat;
    HRESULT hr;
 
    TRACE("(%p, %p)\n", hCharset, pCsetInfo);
 
    hr = MimeOleGetInternat(&internat);
    if(SUCCEEDED(hr))
    {
        hr = IMimeInternational_GetCharsetInfo(internat, hCharset, pCsetInfo);
        IMimeInternational_Release(internat);
    }
    return hr;
}

MimeOleGetDefaultCharset()

HRESULT WINAPI MimeOleGetDefaultCharset

(

LPHCHARSET

charset

)

Definition at line 583 of file mimeintl.c.

{
    IMimeInternational *internat;
    HRESULT hr;
 
    TRACE("(%p)\n", charset);
 
    hr = MimeOleGetInternat(&internat);
    if(SUCCEEDED(hr))
    {
        hr = IMimeInternational_GetDefaultCharset(internat, charset);
        IMimeInternational_Release(internat);
    }
    return hr;
}

MimeOleGetInternat()

HRESULT WINAPI MimeOleGetInternat

(

IMimeInternational **

internat

)

Definition at line 542 of file mimeintl.c.

{
    TRACE("(%p)\n", internat);
 
    *internat = &global_internat->IMimeInternational_iface;
    IMimeInternational_AddRef(*internat);
    return S_OK;
}

Referenced by MimeOleFindCharset(), MimeOleGetCharsetInfo(), MimeOleGetDefaultCharset(), test_charset(), test_convert(), test_create(), and test_defaultcharset().

mlang_getcodepageinfo()

static HRESULT mlang_getcodepageinfo ( UINT  cp, MIMECPINFO *  mlang_cp_info  )

static

Definition at line 146 of file mimeintl.c.

{
    HRESULT hr;
    IMultiLanguage *ml;
 
    hr = get_mlang(&ml);
 
    if(SUCCEEDED(hr))
    {
        hr = IMultiLanguage_GetCodePageInfo(ml, cp, mlang_cp_info);
        IMultiLanguage_Release(ml);
    }
    return hr;
}

Referenced by MimeInternat_GetCodePageCharset(), and mlang_getcsetinfo_from_cp().

mlang_getcsetinfo()

static HRESULT mlang_getcsetinfo ( const char *  charset, MIMECSETINFO *  mlang_info  )

static

Definition at line 202 of file mimeintl.c.

{
    DWORD len = MultiByteToWideChar(CP_ACP, 0, charset, -1, NULL, 0);
    BSTR bstr = SysAllocStringLen(NULL, len - 1);
    HRESULT hr;
    IMultiLanguage *ml;
 
    MultiByteToWideChar(CP_ACP, 0, charset, -1, bstr, len);
 
    hr = get_mlang(&ml);
 
    if(SUCCEEDED(hr))
    {
        hr = IMultiLanguage_GetCharsetInfo(ml, bstr, mlang_info);
        IMultiLanguage_Release(ml);
    }
    SysFreeString(bstr);
    if(FAILED(hr)) hr = MIME_E_NOT_FOUND;
    return hr;
}

Referenced by MimeInternat_FindCharset(), and test_charset().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

inetcomm

)

Variable Documentation

global_internat

internat_impl* global_internat

static

Definition at line 522 of file mimeintl.c.

Referenced by MimeInternational_Construct(), and MimeOleGetInternat().

mime_internat_vtbl

IMimeInternationalVtbl mime_internat_vtbl

static

Initial value:

=
{
    MimeInternat_QueryInterface,
    MimeInternat_AddRef,
    MimeInternat_Release,
    MimeInternat_SetDefaultCharset,
    MimeInternat_GetDefaultCharset,
    MimeInternat_GetCodePageCharset,
    MimeInternat_FindCharset,
    MimeInternat_GetCharsetInfo,
    MimeInternat_GetCodePageInfo,
    MimeInternat_CanConvertCodePages,
    MimeInternat_DecodeHeader,
    MimeInternat_EncodeHeader,
    MimeInternat_ConvertBuffer,
    MimeInternat_ConvertString,
    MimeInternat_MLANG_ConvertInetReset,
    MimeInternat_MLANG_ConvertInetString,
    MimeInternat_Rfc1522Decode,
    MimeInternat_Rfc1522Encode
}

Definition at line 500 of file mimeintl.c.

Referenced by MimeInternational_Construct().