/*** Autogenerated by WIDL 0.9.22 from mlang.idl - Do not edit ***/
#include <rpc.h>
#include <rpcndr.h>

#ifndef __WIDL_MLANG_H
#define __WIDL_MLANG_H
#ifdef __cplusplus
extern "C" {
#endif
#include <unknwn.h>
#ifndef __IStream_FWD_DEFINED__
#define __IStream_FWD_DEFINED__
typedef interface IStream IStream;
#endif

#ifndef _WINNT_
typedef WORD LANGID;
#endif
#ifndef __IMLangCodePages_FWD_DEFINED__
#define __IMLangCodePages_FWD_DEFINED__
typedef interface IMLangCodePages IMLangCodePages;
#endif

/*****************************************************************************
 * IMLangCodePages interface
 */
#ifndef __IMLangCodePages_INTERFACE_DEFINED__
#define __IMLangCodePages_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMLangCodePages, 0x359f3443, 0xbd4a, 0x11d0, 0xb1,0x88, 0x00,0xaa,0x00,0x38,0xc9,0x69);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IMLangCodePages : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetCharCodePages(
        WCHAR chSrc,
        DWORD* pdwCodePages) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetStrCodePages(
        const WCHAR* pszSrc,
        long cchSrc,
        DWORD dwPriorityCodePages,
        DWORD* pdwCodePages,
        long* pcchCodePages) = 0;

    virtual HRESULT STDMETHODCALLTYPE CodePageToCodePages(
        UINT uCodePage,
        DWORD* pdwCodePages) = 0;

    virtual HRESULT STDMETHODCALLTYPE CodePagesToCodePage(
        DWORD dwCodePages,
        UINT uDefaultCodePage,
        UINT* puCodePage) = 0;

};
#else
typedef struct IMLangCodePagesVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IMLangCodePages* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IMLangCodePages* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IMLangCodePages* This);

    /*** IMLangCodePages methods ***/
    HRESULT (STDMETHODCALLTYPE *GetCharCodePages)(
        IMLangCodePages* This,
        WCHAR chSrc,
        DWORD* pdwCodePages);

    HRESULT (STDMETHODCALLTYPE *GetStrCodePages)(
        IMLangCodePages* This,
        const WCHAR* pszSrc,
        long cchSrc,
        DWORD dwPriorityCodePages,
        DWORD* pdwCodePages,
        long* pcchCodePages);

    HRESULT (STDMETHODCALLTYPE *CodePageToCodePages)(
        IMLangCodePages* This,
        UINT uCodePage,
        DWORD* pdwCodePages);

    HRESULT (STDMETHODCALLTYPE *CodePagesToCodePage)(
        IMLangCodePages* This,
        DWORD dwCodePages,
        UINT uDefaultCodePage,
        UINT* puCodePage);

    END_INTERFACE
} IMLangCodePagesVtbl;
interface IMLangCodePages {
    const IMLangCodePagesVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IMLangCodePages_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IMLangCodePages_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IMLangCodePages_Release(p) (p)->lpVtbl->Release(p)
/*** IMLangCodePages methods ***/
#define IMLangCodePages_GetCharCodePages(p,a,b) (p)->lpVtbl->GetCharCodePages(p,a,b)
#define IMLangCodePages_GetStrCodePages(p,a,b,c,d,e) (p)->lpVtbl->GetStrCodePages(p,a,b,c,d,e)
#define IMLangCodePages_CodePageToCodePages(p,a,b) (p)->lpVtbl->CodePageToCodePages(p,a,b)
#define IMLangCodePages_CodePagesToCodePage(p,a,b,c) (p)->lpVtbl->CodePagesToCodePage(p,a,b,c)
#endif

#endif

HRESULT CALLBACK IMLangCodePages_GetCharCodePages_Proxy(
    IMLangCodePages* This,
    WCHAR chSrc,
    DWORD* pdwCodePages);
void __RPC_STUB IMLangCodePages_GetCharCodePages_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMLangCodePages_GetStrCodePages_Proxy(
    IMLangCodePages* This,
    const WCHAR* pszSrc,
    long cchSrc,
    DWORD dwPriorityCodePages,
    DWORD* pdwCodePages,
    long* pcchCodePages);
void __RPC_STUB IMLangCodePages_GetStrCodePages_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMLangCodePages_CodePageToCodePages_Proxy(
    IMLangCodePages* This,
    UINT uCodePage,
    DWORD* pdwCodePages);
void __RPC_STUB IMLangCodePages_CodePageToCodePages_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMLangCodePages_CodePagesToCodePage_Proxy(
    IMLangCodePages* This,
    DWORD dwCodePages,
    UINT uDefaultCodePage,
    UINT* puCodePage);
void __RPC_STUB IMLangCodePages_CodePagesToCodePage_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMLangCodePages_INTERFACE_DEFINED__ */

#ifndef __IMLangFontLink_FWD_DEFINED__
#define __IMLangFontLink_FWD_DEFINED__
typedef interface IMLangFontLink IMLangFontLink;
#endif

/*****************************************************************************
 * IMLangFontLink interface
 */
#ifndef __IMLangFontLink_INTERFACE_DEFINED__
#define __IMLangFontLink_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMLangFontLink, 0x359f3441, 0xbd4a, 0x11d0, 0xb1,0x88, 0x00,0xaa,0x00,0x38,0xc9,0x69);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IMLangFontLink : public IMLangCodePages
{
    virtual HRESULT STDMETHODCALLTYPE GetFontCodePages(
        HDC hDC,
        HFONT hFont,
        DWORD* pdwCodePages) = 0;

    virtual HRESULT STDMETHODCALLTYPE MapFont(
        HDC hDC,
        DWORD dwCodePages,
        HFONT hSrcFont,
        HFONT* phDestFont) = 0;

    virtual HRESULT STDMETHODCALLTYPE ReleaseFont(
        HFONT hFont) = 0;

    virtual HRESULT STDMETHODCALLTYPE ResetFontMapping(
        ) = 0;

};
#else
typedef struct IMLangFontLinkVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IMLangFontLink* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IMLangFontLink* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IMLangFontLink* This);

    /*** IMLangCodePages methods ***/
    HRESULT (STDMETHODCALLTYPE *GetCharCodePages)(
        IMLangFontLink* This,
        WCHAR chSrc,
        DWORD* pdwCodePages);

    HRESULT (STDMETHODCALLTYPE *GetStrCodePages)(
        IMLangFontLink* This,
        const WCHAR* pszSrc,
        long cchSrc,
        DWORD dwPriorityCodePages,
        DWORD* pdwCodePages,
        long* pcchCodePages);

    HRESULT (STDMETHODCALLTYPE *CodePageToCodePages)(
        IMLangFontLink* This,
        UINT uCodePage,
        DWORD* pdwCodePages);

    HRESULT (STDMETHODCALLTYPE *CodePagesToCodePage)(
        IMLangFontLink* This,
        DWORD dwCodePages,
        UINT uDefaultCodePage,
        UINT* puCodePage);

    /*** IMLangFontLink methods ***/
    HRESULT (STDMETHODCALLTYPE *GetFontCodePages)(
        IMLangFontLink* This,
        HDC hDC,
        HFONT hFont,
        DWORD* pdwCodePages);

    HRESULT (STDMETHODCALLTYPE *MapFont)(
        IMLangFontLink* This,
        HDC hDC,
        DWORD dwCodePages,
        HFONT hSrcFont,
        HFONT* phDestFont);

    HRESULT (STDMETHODCALLTYPE *ReleaseFont)(
        IMLangFontLink* This,
        HFONT hFont);

    HRESULT (STDMETHODCALLTYPE *ResetFontMapping)(
        IMLangFontLink* This);

    END_INTERFACE
} IMLangFontLinkVtbl;
interface IMLangFontLink {
    const IMLangFontLinkVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IMLangFontLink_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IMLangFontLink_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IMLangFontLink_Release(p) (p)->lpVtbl->Release(p)
/*** IMLangCodePages methods ***/
#define IMLangFontLink_GetCharCodePages(p,a,b) (p)->lpVtbl->GetCharCodePages(p,a,b)
#define IMLangFontLink_GetStrCodePages(p,a,b,c,d,e) (p)->lpVtbl->GetStrCodePages(p,a,b,c,d,e)
#define IMLangFontLink_CodePageToCodePages(p,a,b) (p)->lpVtbl->CodePageToCodePages(p,a,b)
#define IMLangFontLink_CodePagesToCodePage(p,a,b,c) (p)->lpVtbl->CodePagesToCodePage(p,a,b,c)
/*** IMLangFontLink methods ***/
#define IMLangFontLink_GetFontCodePages(p,a,b,c) (p)->lpVtbl->GetFontCodePages(p,a,b,c)
#define IMLangFontLink_MapFont(p,a,b,c,d) (p)->lpVtbl->MapFont(p,a,b,c,d)
#define IMLangFontLink_ReleaseFont(p,a) (p)->lpVtbl->ReleaseFont(p,a)
#define IMLangFontLink_ResetFontMapping(p) (p)->lpVtbl->ResetFontMapping(p)
#endif

#endif

HRESULT CALLBACK IMLangFontLink_GetFontCodePages_Proxy(
    IMLangFontLink* This,
    HDC hDC,
    HFONT hFont,
    DWORD* pdwCodePages);
void __RPC_STUB IMLangFontLink_GetFontCodePages_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMLangFontLink_MapFont_Proxy(
    IMLangFontLink* This,
    HDC hDC,
    DWORD dwCodePages,
    HFONT hSrcFont,
    HFONT* phDestFont);
void __RPC_STUB IMLangFontLink_MapFont_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMLangFontLink_ReleaseFont_Proxy(
    IMLangFontLink* This,
    HFONT hFont);
void __RPC_STUB IMLangFontLink_ReleaseFont_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMLangFontLink_ResetFontMapping_Proxy(
    IMLangFontLink* This);
void __RPC_STUB IMLangFontLink_ResetFontMapping_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMLangFontLink_INTERFACE_DEFINED__ */

#ifndef __IEnumScript_FWD_DEFINED__
#define __IEnumScript_FWD_DEFINED__
typedef interface IEnumScript IEnumScript;
#endif

#define MAX_SCRIPT_NAME (48)

#define MAX_MIMEFACE_NAME (32)

typedef BYTE SCRIPT_ID;
typedef __int64 SCRIPT_IDS;
typedef enum tagSCRIPTCONTF {
    sidDefault = 0,
    sidMerge = sidDefault + 1,
    sidAsciiSym = sidMerge + 1,
    sidAsciiLatin = sidAsciiSym + 1,
    sidLatin = sidAsciiLatin + 1,
    sidGreek = sidLatin + 1,
    sidCyrillic = sidGreek + 1,
    sidArmenian = sidCyrillic + 1,
    sidHebrew = sidArmenian + 1,
    sidArabic = sidHebrew + 1,
    sidDevanagari = sidArabic + 1,
    sidBengali = sidDevanagari + 1,
    sidGurmukhi = sidBengali + 1,
    sidGujarati = sidGurmukhi + 1,
    sidOriya = sidGujarati + 1,
    sidTamil = sidOriya + 1,
    sidTelugu = sidTamil + 1,
    sidKannada = sidTelugu + 1,
    sidMalayalam = sidKannada + 1,
    sidThai = sidMalayalam + 1,
    sidLao = sidThai + 1,
    sidTibetan = sidLao + 1,
    sidGeorgian = sidTibetan + 1,
    sidHangul = sidGeorgian + 1,
    sidKana = sidHangul + 1,
    sidBopomofo = sidKana + 1,
    sidHan = sidBopomofo + 1,
    sidEthiopic = sidHan + 1,
    sidCanSyllabic = sidEthiopic + 1,
    sidCherokee = sidCanSyllabic + 1,
    sidYi = sidCherokee + 1,
    sidBraille = sidYi + 1,
    sidRunic = sidBraille + 1,
    sidOgham = sidRunic + 1,
    sidSinhala = sidOgham + 1,
    sidSyriac = sidSinhala + 1,
    sidBurmese = sidSyriac + 1,
    sidKhmer = sidBurmese + 1,
    sidThaana = sidKhmer + 1,
    sidMongolian = sidThaana + 1,
    sidUserDefined = sidMongolian + 1,
    sidLim = sidUserDefined + 1,
    sidFEFirst = sidHangul,
    sidFELast = sidHan
} SCRIPTCONTF;
typedef enum tagSCRIPTFONTCONTF {
    SCRIPTCONTF_FIXED_FONT = 0x1,
    SCRIPTCONTF_PROPORTIONAL_FONT = 0x2,
    SCRIPTCONTF_SCRIPT_USER = 0x10000,
    SCRIPTCONTF_SCRIPT_HIDE = 0x20000,
    SCRIPTCONTF_SCRIPT_SYSTEM = 0x40000
} SCRIPTFONTCONTF;
typedef struct tagSCRIPFONTINFO {
    SCRIPT_IDS scripts;
    WCHAR wszFont[32];
} SCRIPTFONTINFO;
typedef struct tagSCRIPFONTINFO *PSCRIPTFONTINFO;
typedef struct tagSCRIPTINFO {
    SCRIPT_ID ScriptId;
    UINT uiCodePage;
    WCHAR wszDescription[48];
    WCHAR wszFixedWidthFont[32];
    WCHAR wszProportionalFont[32];
} SCRIPTINFO;
typedef struct tagSCRIPTINFO *PSCRIPTINFO;
/*****************************************************************************
 * IEnumScript interface
 */
#ifndef __IEnumScript_INTERFACE_DEFINED__
#define __IEnumScript_INTERFACE_DEFINED__

DEFINE_GUID(IID_IEnumScript, 0xae5f1430, 0x388b, 0x11d2, 0x83,0x80, 0x00,0xc0,0x4f,0x8f,0x5d,0xa1);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IEnumScript : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE Clone(
        IEnumScript** ppEnum) = 0;

    virtual HRESULT STDMETHODCALLTYPE Next(
        ULONG celt,
        PSCRIPTINFO rgelt,
        ULONG* pceltFetched) = 0;

    virtual HRESULT STDMETHODCALLTYPE Reset(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE Skip(
        ULONG celt) = 0;

};
#else
typedef struct IEnumScriptVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IEnumScript* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IEnumScript* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IEnumScript* This);

    /*** IEnumScript methods ***/
    HRESULT (STDMETHODCALLTYPE *Clone)(
        IEnumScript* This,
        IEnumScript** ppEnum);

    HRESULT (STDMETHODCALLTYPE *Next)(
        IEnumScript* This,
        ULONG celt,
        PSCRIPTINFO rgelt,
        ULONG* pceltFetched);

    HRESULT (STDMETHODCALLTYPE *Reset)(
        IEnumScript* This);

    HRESULT (STDMETHODCALLTYPE *Skip)(
        IEnumScript* This,
        ULONG celt);

    END_INTERFACE
} IEnumScriptVtbl;
interface IEnumScript {
    const IEnumScriptVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IEnumScript_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IEnumScript_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IEnumScript_Release(p) (p)->lpVtbl->Release(p)
/*** IEnumScript methods ***/
#define IEnumScript_Clone(p,a) (p)->lpVtbl->Clone(p,a)
#define IEnumScript_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c)
#define IEnumScript_Reset(p) (p)->lpVtbl->Reset(p)
#define IEnumScript_Skip(p,a) (p)->lpVtbl->Skip(p,a)
#endif

#endif

HRESULT CALLBACK IEnumScript_Clone_Proxy(
    IEnumScript* This,
    IEnumScript** ppEnum);
void __RPC_STUB IEnumScript_Clone_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumScript_Next_Proxy(
    IEnumScript* This,
    ULONG celt,
    PSCRIPTINFO rgelt,
    ULONG* pceltFetched);
void __RPC_STUB IEnumScript_Next_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumScript_Reset_Proxy(
    IEnumScript* This);
void __RPC_STUB IEnumScript_Reset_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumScript_Skip_Proxy(
    IEnumScript* This,
    ULONG celt);
void __RPC_STUB IEnumScript_Skip_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IEnumScript_INTERFACE_DEFINED__ */

#ifndef __IEnumCodePage_FWD_DEFINED__
#define __IEnumCodePage_FWD_DEFINED__
typedef interface IEnumCodePage IEnumCodePage;
#endif

#define MAX_MIMECP_NAME (64)

#define MAX_MIMECSET_NAME (50)

typedef enum tagMIMECONTF {
    MIMECONTF_MAILNEWS = 0x1,
    MIMECONTF_BROWSER = 0x2,
    MIMECONTF_MINIMAL = 0x4,
    MIMECONTF_IMPORT = 0x8,
    MIMECONTF_SAVABLE_MAILNEWS = 0x100,
    MIMECONTF_SAVABLE_BROWSER = 0x200,
    MIMECONTF_EXPORT = 0x400,
    MIMECONTF_PRIVCONVERTER = 0x10000,
    MIMECONTF_VALID = 0x20000,
    MIMECONTF_VALID_NLS = 0x40000,
    MIMECONTF_MIME_IE4 = 0x10000000,
    MIMECONTF_MIME_LATEST = 0x20000000,
    MIMECONTF_MIME_REGISTRY = 0x40000000
} MIMECONTF;
typedef struct tagMIMECPINFO {
    DWORD dwFlags;
    UINT uiCodePage;
    UINT uiFamilyCodePage;
    WCHAR wszDescription[64];
    WCHAR wszWebCharset[50];
    WCHAR wszHeaderCharset[50];
    WCHAR wszBodyCharset[50];
    WCHAR wszFixedWidthFont[32];
    WCHAR wszProportionalFont[32];
    BYTE bGDICharset;
} MIMECPINFO;
typedef struct tagMIMECPINFO *PMIMECPINFO;
typedef struct tagMIMECSETINFO {
    UINT uiCodePage;
    UINT uiInternetEncoding;
    WCHAR wszCharset[50];
} MIMECSETINFO;
typedef struct tagMIMECSETINFO *PMIMECSETINFO;
/*****************************************************************************
 * IEnumCodePage interface
 */
#ifndef __IEnumCodePage_INTERFACE_DEFINED__
#define __IEnumCodePage_INTERFACE_DEFINED__

DEFINE_GUID(IID_IEnumCodePage, 0x275c23e3, 0x3747, 0x11d0, 0x9f,0xea, 0x00,0xaa,0x00,0x3f,0x86,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IEnumCodePage : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE Clone(
        IEnumCodePage** ppEnum) = 0;

    virtual HRESULT STDMETHODCALLTYPE Next(
        ULONG celt,
        PMIMECPINFO rgelt,
        ULONG* pceltFetched) = 0;

    virtual HRESULT STDMETHODCALLTYPE Reset(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE Skip(
        ULONG celt) = 0;

};
#else
typedef struct IEnumCodePageVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IEnumCodePage* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IEnumCodePage* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IEnumCodePage* This);

    /*** IEnumCodePage methods ***/
    HRESULT (STDMETHODCALLTYPE *Clone)(
        IEnumCodePage* This,
        IEnumCodePage** ppEnum);

    HRESULT (STDMETHODCALLTYPE *Next)(
        IEnumCodePage* This,
        ULONG celt,
        PMIMECPINFO rgelt,
        ULONG* pceltFetched);

    HRESULT (STDMETHODCALLTYPE *Reset)(
        IEnumCodePage* This);

    HRESULT (STDMETHODCALLTYPE *Skip)(
        IEnumCodePage* This,
        ULONG celt);

    END_INTERFACE
} IEnumCodePageVtbl;
interface IEnumCodePage {
    const IEnumCodePageVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IEnumCodePage_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IEnumCodePage_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IEnumCodePage_Release(p) (p)->lpVtbl->Release(p)
/*** IEnumCodePage methods ***/
#define IEnumCodePage_Clone(p,a) (p)->lpVtbl->Clone(p,a)
#define IEnumCodePage_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c)
#define IEnumCodePage_Reset(p) (p)->lpVtbl->Reset(p)
#define IEnumCodePage_Skip(p,a) (p)->lpVtbl->Skip(p,a)
#endif

#endif

HRESULT CALLBACK IEnumCodePage_Clone_Proxy(
    IEnumCodePage* This,
    IEnumCodePage** ppEnum);
void __RPC_STUB IEnumCodePage_Clone_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumCodePage_Next_Proxy(
    IEnumCodePage* This,
    ULONG celt,
    PMIMECPINFO rgelt,
    ULONG* pceltFetched);
void __RPC_STUB IEnumCodePage_Next_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumCodePage_Reset_Proxy(
    IEnumCodePage* This);
void __RPC_STUB IEnumCodePage_Reset_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumCodePage_Skip_Proxy(
    IEnumCodePage* This,
    ULONG celt);
void __RPC_STUB IEnumCodePage_Skip_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IEnumCodePage_INTERFACE_DEFINED__ */

#ifndef __IMLangConvertCharset_FWD_DEFINED__
#define __IMLangConvertCharset_FWD_DEFINED__
typedef interface IMLangConvertCharset IMLangConvertCharset;
#endif

/*****************************************************************************
 * IMLangConvertCharset interface
 */
#ifndef __IMLangConvertCharset_INTERFACE_DEFINED__
#define __IMLangConvertCharset_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMLangConvertCharset, 0xd66d6f98, 0xcdaa, 0x11d0, 0xb8,0x22, 0x00,0xc0,0x4f,0xc9,0xb3,0x1f);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IMLangConvertCharset : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE Initialize(
        UINT uiSrcCodePage,
        UINT uiDstCodePage,
        DWORD dwProperty) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetSourceCodePage(
        UINT* puiSrcCodePage) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetDestinationCodePage(
        UINT* puiDstCodePage) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetProperty(
        DWORD* pdwProperty) = 0;

    virtual HRESULT STDMETHODCALLTYPE DoConversion(
        BYTE* pSrcStr,
        UINT* pcSrcSize,
        BYTE* pDstStr,
        UINT* pcDstSize) = 0;

    virtual HRESULT STDMETHODCALLTYPE DoConversionToUnicode(
        CHAR* pSrcStr,
        UINT* pcSrcSize,
        WCHAR* pDstStr,
        UINT* pcDstSize) = 0;

    virtual HRESULT STDMETHODCALLTYPE DoConversionFromUnicode(
        WCHAR* pSrcStr,
        UINT* pcSrcSize,
        CHAR* pDstStr,
        UINT* pcDstSize) = 0;

};
#else
typedef struct IMLangConvertCharsetVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IMLangConvertCharset* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IMLangConvertCharset* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IMLangConvertCharset* This);

    /*** IMLangConvertCharset methods ***/
    HRESULT (STDMETHODCALLTYPE *Initialize)(
        IMLangConvertCharset* This,
        UINT uiSrcCodePage,
        UINT uiDstCodePage,
        DWORD dwProperty);

    HRESULT (STDMETHODCALLTYPE *GetSourceCodePage)(
        IMLangConvertCharset* This,
        UINT* puiSrcCodePage);

    HRESULT (STDMETHODCALLTYPE *GetDestinationCodePage)(
        IMLangConvertCharset* This,
        UINT* puiDstCodePage);

    HRESULT (STDMETHODCALLTYPE *GetProperty)(
        IMLangConvertCharset* This,
        DWORD* pdwProperty);

    HRESULT (STDMETHODCALLTYPE *DoConversion)(
        IMLangConvertCharset* This,
        BYTE* pSrcStr,
        UINT* pcSrcSize,
        BYTE* pDstStr,
        UINT* pcDstSize);

    HRESULT (STDMETHODCALLTYPE *DoConversionToUnicode)(
        IMLangConvertCharset* This,
        CHAR* pSrcStr,
        UINT* pcSrcSize,
        WCHAR* pDstStr,
        UINT* pcDstSize);

    HRESULT (STDMETHODCALLTYPE *DoConversionFromUnicode)(
        IMLangConvertCharset* This,
        WCHAR* pSrcStr,
        UINT* pcSrcSize,
        CHAR* pDstStr,
        UINT* pcDstSize);

    END_INTERFACE
} IMLangConvertCharsetVtbl;
interface IMLangConvertCharset {
    const IMLangConvertCharsetVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IMLangConvertCharset_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IMLangConvertCharset_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IMLangConvertCharset_Release(p) (p)->lpVtbl->Release(p)
/*** IMLangConvertCharset methods ***/
#define IMLangConvertCharset_Initialize(p,a,b,c) (p)->lpVtbl->Initialize(p,a,b,c)
#define IMLangConvertCharset_GetSourceCodePage(p,a) (p)->lpVtbl->GetSourceCodePage(p,a)
#define IMLangConvertCharset_GetDestinationCodePage(p,a) (p)->lpVtbl->GetDestinationCodePage(p,a)
#define IMLangConvertCharset_GetProperty(p,a) (p)->lpVtbl->GetProperty(p,a)
#define IMLangConvertCharset_DoConversion(p,a,b,c,d) (p)->lpVtbl->DoConversion(p,a,b,c,d)
#define IMLangConvertCharset_DoConversionToUnicode(p,a,b,c,d) (p)->lpVtbl->DoConversionToUnicode(p,a,b,c,d)
#define IMLangConvertCharset_DoConversionFromUnicode(p,a,b,c,d) (p)->lpVtbl->DoConversionFromUnicode(p,a,b,c,d)
#endif

#endif

HRESULT CALLBACK IMLangConvertCharset_Initialize_Proxy(
    IMLangConvertCharset* This,
    UINT uiSrcCodePage,
    UINT uiDstCodePage,
    DWORD dwProperty);
void __RPC_STUB IMLangConvertCharset_Initialize_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMLangConvertCharset_GetSourceCodePage_Proxy(
    IMLangConvertCharset* This,
    UINT* puiSrcCodePage);
void __RPC_STUB IMLangConvertCharset_GetSourceCodePage_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMLangConvertCharset_GetDestinationCodePage_Proxy(
    IMLangConvertCharset* This,
    UINT* puiDstCodePage);
void __RPC_STUB IMLangConvertCharset_GetDestinationCodePage_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMLangConvertCharset_GetProperty_Proxy(
    IMLangConvertCharset* This,
    DWORD* pdwProperty);
void __RPC_STUB IMLangConvertCharset_GetProperty_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMLangConvertCharset_DoConversion_Proxy(
    IMLangConvertCharset* This,
    BYTE* pSrcStr,
    UINT* pcSrcSize,
    BYTE* pDstStr,
    UINT* pcDstSize);
void __RPC_STUB IMLangConvertCharset_DoConversion_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMLangConvertCharset_DoConversionToUnicode_Proxy(
    IMLangConvertCharset* This,
    CHAR* pSrcStr,
    UINT* pcSrcSize,
    WCHAR* pDstStr,
    UINT* pcDstSize);
void __RPC_STUB IMLangConvertCharset_DoConversionToUnicode_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMLangConvertCharset_DoConversionFromUnicode_Proxy(
    IMLangConvertCharset* This,
    WCHAR* pSrcStr,
    UINT* pcSrcSize,
    CHAR* pDstStr,
    UINT* pcDstSize);
void __RPC_STUB IMLangConvertCharset_DoConversionFromUnicode_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMLangConvertCharset_INTERFACE_DEFINED__ */

/*****************************************************************************
 * CMLangConvertCharset coclass
 */

DEFINE_GUID(CLSID_CMLangConvertCharset, 0xd66d6f99, 0xcdaa, 0x11d0, 0xb8,0x22, 0x00,0xc0,0x4f,0xc9,0xb3,0x1f);

#ifndef __CMLangConvertCharset_FWD_DEFINED__
#define __CMLangConvertCharset_FWD_DEFINED__
typedef struct CMLangConvertCharset CMLangConvertCharset;
#endif /* defined __CMLangConvertCharset_FWD_DEFINED__ */

#ifndef __IEnumRfc1766_FWD_DEFINED__
#define __IEnumRfc1766_FWD_DEFINED__
typedef interface IEnumRfc1766 IEnumRfc1766;
#endif

#define MAX_RFC1766_NAME (6)

#define MAX_LOCALE_NAME (32)

typedef struct tagRFC1766INFO {
    LCID lcid;
    WCHAR wszRfc1766[6];
    WCHAR wszLocaleName[32];
} RFC1766INFO;
typedef struct tagRFC1766INFO *PRFC1766INFO;
/*****************************************************************************
 * IEnumRfc1766 interface
 */
#ifndef __IEnumRfc1766_INTERFACE_DEFINED__
#define __IEnumRfc1766_INTERFACE_DEFINED__

DEFINE_GUID(IID_IEnumRfc1766, 0x3dc39d1d, 0xc030, 0x11d0, 0xb8,0x1b, 0x00,0xc0,0x4f,0xc9,0xb3,0x1f);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IEnumRfc1766 : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE Clone(
        IEnumRfc1766** ppEnum) = 0;

    virtual HRESULT STDMETHODCALLTYPE Next(
        ULONG celt,
        PRFC1766INFO rgelt,
        ULONG* pceltFetched) = 0;

    virtual HRESULT STDMETHODCALLTYPE Reset(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE Skip(
        ULONG celt) = 0;

};
#else
typedef struct IEnumRfc1766Vtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IEnumRfc1766* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IEnumRfc1766* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IEnumRfc1766* This);

    /*** IEnumRfc1766 methods ***/
    HRESULT (STDMETHODCALLTYPE *Clone)(
        IEnumRfc1766* This,
        IEnumRfc1766** ppEnum);

    HRESULT (STDMETHODCALLTYPE *Next)(
        IEnumRfc1766* This,
        ULONG celt,
        PRFC1766INFO rgelt,
        ULONG* pceltFetched);

    HRESULT (STDMETHODCALLTYPE *Reset)(
        IEnumRfc1766* This);

    HRESULT (STDMETHODCALLTYPE *Skip)(
        IEnumRfc1766* This,
        ULONG celt);

    END_INTERFACE
} IEnumRfc1766Vtbl;
interface IEnumRfc1766 {
    const IEnumRfc1766Vtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IEnumRfc1766_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IEnumRfc1766_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IEnumRfc1766_Release(p) (p)->lpVtbl->Release(p)
/*** IEnumRfc1766 methods ***/
#define IEnumRfc1766_Clone(p,a) (p)->lpVtbl->Clone(p,a)
#define IEnumRfc1766_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c)
#define IEnumRfc1766_Reset(p) (p)->lpVtbl->Reset(p)
#define IEnumRfc1766_Skip(p,a) (p)->lpVtbl->Skip(p,a)
#endif

#endif

HRESULT CALLBACK IEnumRfc1766_Clone_Proxy(
    IEnumRfc1766* This,
    IEnumRfc1766** ppEnum);
void __RPC_STUB IEnumRfc1766_Clone_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumRfc1766_Next_Proxy(
    IEnumRfc1766* This,
    ULONG celt,
    PRFC1766INFO rgelt,
    ULONG* pceltFetched);
void __RPC_STUB IEnumRfc1766_Next_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumRfc1766_Reset_Proxy(
    IEnumRfc1766* This);
void __RPC_STUB IEnumRfc1766_Reset_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IEnumRfc1766_Skip_Proxy(
    IEnumRfc1766* This,
    ULONG celt);
void __RPC_STUB IEnumRfc1766_Skip_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IEnumRfc1766_INTERFACE_DEFINED__ */

#ifndef __IMultiLanguage_FWD_DEFINED__
#define __IMultiLanguage_FWD_DEFINED__
typedef interface IMultiLanguage IMultiLanguage;
#endif

/*****************************************************************************
 * IMultiLanguage interface
 */
#ifndef __IMultiLanguage_INTERFACE_DEFINED__
#define __IMultiLanguage_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMultiLanguage, 0x275c23e1, 0x3747, 0x11d0, 0x9f,0xea, 0x00,0xaa,0x00,0x3f,0x86,0x46);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IMultiLanguage : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetNumberOfCodePageInfo(
        UINT* pcCodePage) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetCodePageInfo(
        UINT uiCodePage,
        PMIMECPINFO pCodePageInfo) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetFamilyCodePage(
        UINT uiCodePage,
        UINT* puiFamilyCodePage) = 0;

    virtual HRESULT STDMETHODCALLTYPE EnumCodePages(
        DWORD grfFlags,
        IEnumCodePage** ppEnumCodePage) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetCharsetInfo(
        BSTR Charset,
        PMIMECSETINFO pCharsetInfo) = 0;

    virtual HRESULT STDMETHODCALLTYPE IsConvertible(
        DWORD dwSrcEncoding,
        DWORD dwDstEncoding) = 0;

    virtual HRESULT STDMETHODCALLTYPE ConvertString(
        DWORD* pdwMode,
        DWORD dwSrcEncoding,
        DWORD dwDstEncoding,
        BYTE* pSrcStr,
        UINT* pcSrcSize,
        BYTE* pDstStr,
        UINT* pcDstSize) = 0;

    virtual HRESULT STDMETHODCALLTYPE ConvertStringToUnicode(
        DWORD* pdwMode,
        DWORD dwEncoding,
        CHAR* pSrcStr,
        UINT* pcSrcSize,
        WCHAR* pDstStr,
        UINT* pcDstSize) = 0;

    virtual HRESULT STDMETHODCALLTYPE ConvertStringFromUnicode(
        DWORD* pdwMode,
        DWORD dwEncoding,
        WCHAR* pSrcStr,
        UINT* pcSrcSize,
        CHAR* pDstStr,
        UINT* pcDstSize) = 0;

    virtual HRESULT STDMETHODCALLTYPE ConvertStringReset(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetRfc1766FromLcid(
        LCID Locale,
        BSTR* pbstrRfc1766) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetLcidFromRfc1766(
        LCID* pLocale,
        BSTR bstrRfc1766) = 0;

    virtual HRESULT STDMETHODCALLTYPE EnumRfc1766(
        IEnumRfc1766** ppEnumRfc1766) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetRfc1766Info(
        LCID Locale,
        PRFC1766INFO pRfc1766Info) = 0;

    virtual HRESULT STDMETHODCALLTYPE CreateConvertCharset(
        UINT uiSrcCodePage,
        UINT uiDstCodePage,
        DWORD dwProperty,
        IMLangConvertCharset** ppMLangConvertCharset) = 0;

};
#else
typedef struct IMultiLanguageVtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IMultiLanguage* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IMultiLanguage* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IMultiLanguage* This);

    /*** IMultiLanguage methods ***/
    HRESULT (STDMETHODCALLTYPE *GetNumberOfCodePageInfo)(
        IMultiLanguage* This,
        UINT* pcCodePage);

    HRESULT (STDMETHODCALLTYPE *GetCodePageInfo)(
        IMultiLanguage* This,
        UINT uiCodePage,
        PMIMECPINFO pCodePageInfo);

    HRESULT (STDMETHODCALLTYPE *GetFamilyCodePage)(
        IMultiLanguage* This,
        UINT uiCodePage,
        UINT* puiFamilyCodePage);

    HRESULT (STDMETHODCALLTYPE *EnumCodePages)(
        IMultiLanguage* This,
        DWORD grfFlags,
        IEnumCodePage** ppEnumCodePage);

    HRESULT (STDMETHODCALLTYPE *GetCharsetInfo)(
        IMultiLanguage* This,
        BSTR Charset,
        PMIMECSETINFO pCharsetInfo);

    HRESULT (STDMETHODCALLTYPE *IsConvertible)(
        IMultiLanguage* This,
        DWORD dwSrcEncoding,
        DWORD dwDstEncoding);

    HRESULT (STDMETHODCALLTYPE *ConvertString)(
        IMultiLanguage* This,
        DWORD* pdwMode,
        DWORD dwSrcEncoding,
        DWORD dwDstEncoding,
        BYTE* pSrcStr,
        UINT* pcSrcSize,
        BYTE* pDstStr,
        UINT* pcDstSize);

    HRESULT (STDMETHODCALLTYPE *ConvertStringToUnicode)(
        IMultiLanguage* This,
        DWORD* pdwMode,
        DWORD dwEncoding,
        CHAR* pSrcStr,
        UINT* pcSrcSize,
        WCHAR* pDstStr,
        UINT* pcDstSize);

    HRESULT (STDMETHODCALLTYPE *ConvertStringFromUnicode)(
        IMultiLanguage* This,
        DWORD* pdwMode,
        DWORD dwEncoding,
        WCHAR* pSrcStr,
        UINT* pcSrcSize,
        CHAR* pDstStr,
        UINT* pcDstSize);

    HRESULT (STDMETHODCALLTYPE *ConvertStringReset)(
        IMultiLanguage* This);

    HRESULT (STDMETHODCALLTYPE *GetRfc1766FromLcid)(
        IMultiLanguage* This,
        LCID Locale,
        BSTR* pbstrRfc1766);

    HRESULT (STDMETHODCALLTYPE *GetLcidFromRfc1766)(
        IMultiLanguage* This,
        LCID* pLocale,
        BSTR bstrRfc1766);

    HRESULT (STDMETHODCALLTYPE *EnumRfc1766)(
        IMultiLanguage* This,
        IEnumRfc1766** ppEnumRfc1766);

    HRESULT (STDMETHODCALLTYPE *GetRfc1766Info)(
        IMultiLanguage* This,
        LCID Locale,
        PRFC1766INFO pRfc1766Info);

    HRESULT (STDMETHODCALLTYPE *CreateConvertCharset)(
        IMultiLanguage* This,
        UINT uiSrcCodePage,
        UINT uiDstCodePage,
        DWORD dwProperty,
        IMLangConvertCharset** ppMLangConvertCharset);

    END_INTERFACE
} IMultiLanguageVtbl;
interface IMultiLanguage {
    const IMultiLanguageVtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IMultiLanguage_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IMultiLanguage_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IMultiLanguage_Release(p) (p)->lpVtbl->Release(p)
/*** IMultiLanguage methods ***/
#define IMultiLanguage_GetNumberOfCodePageInfo(p,a) (p)->lpVtbl->GetNumberOfCodePageInfo(p,a)
#define IMultiLanguage_GetCodePageInfo(p,a,b) (p)->lpVtbl->GetCodePageInfo(p,a,b)
#define IMultiLanguage_GetFamilyCodePage(p,a,b) (p)->lpVtbl->GetFamilyCodePage(p,a,b)
#define IMultiLanguage_EnumCodePages(p,a,b) (p)->lpVtbl->EnumCodePages(p,a,b)
#define IMultiLanguage_GetCharsetInfo(p,a,b) (p)->lpVtbl->GetCharsetInfo(p,a,b)
#define IMultiLanguage_IsConvertible(p,a,b) (p)->lpVtbl->IsConvertible(p,a,b)
#define IMultiLanguage_ConvertString(p,a,b,c,d,e,f,g) (p)->lpVtbl->ConvertString(p,a,b,c,d,e,f,g)
#define IMultiLanguage_ConvertStringToUnicode(p,a,b,c,d,e,f) (p)->lpVtbl->ConvertStringToUnicode(p,a,b,c,d,e,f)
#define IMultiLanguage_ConvertStringFromUnicode(p,a,b,c,d,e,f) (p)->lpVtbl->ConvertStringFromUnicode(p,a,b,c,d,e,f)
#define IMultiLanguage_ConvertStringReset(p) (p)->lpVtbl->ConvertStringReset(p)
#define IMultiLanguage_GetRfc1766FromLcid(p,a,b) (p)->lpVtbl->GetRfc1766FromLcid(p,a,b)
#define IMultiLanguage_GetLcidFromRfc1766(p,a,b) (p)->lpVtbl->GetLcidFromRfc1766(p,a,b)
#define IMultiLanguage_EnumRfc1766(p,a) (p)->lpVtbl->EnumRfc1766(p,a)
#define IMultiLanguage_GetRfc1766Info(p,a,b) (p)->lpVtbl->GetRfc1766Info(p,a,b)
#define IMultiLanguage_CreateConvertCharset(p,a,b,c,d) (p)->lpVtbl->CreateConvertCharset(p,a,b,c,d)
#endif

#endif

HRESULT CALLBACK IMultiLanguage_GetNumberOfCodePageInfo_Proxy(
    IMultiLanguage* This,
    UINT* pcCodePage);
void __RPC_STUB IMultiLanguage_GetNumberOfCodePageInfo_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage_GetCodePageInfo_Proxy(
    IMultiLanguage* This,
    UINT uiCodePage,
    PMIMECPINFO pCodePageInfo);
void __RPC_STUB IMultiLanguage_GetCodePageInfo_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage_GetFamilyCodePage_Proxy(
    IMultiLanguage* This,
    UINT uiCodePage,
    UINT* puiFamilyCodePage);
void __RPC_STUB IMultiLanguage_GetFamilyCodePage_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage_EnumCodePages_Proxy(
    IMultiLanguage* This,
    DWORD grfFlags,
    IEnumCodePage** ppEnumCodePage);
void __RPC_STUB IMultiLanguage_EnumCodePages_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage_GetCharsetInfo_Proxy(
    IMultiLanguage* This,
    BSTR Charset,
    PMIMECSETINFO pCharsetInfo);
void __RPC_STUB IMultiLanguage_GetCharsetInfo_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage_IsConvertible_Proxy(
    IMultiLanguage* This,
    DWORD dwSrcEncoding,
    DWORD dwDstEncoding);
void __RPC_STUB IMultiLanguage_IsConvertible_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage_ConvertString_Proxy(
    IMultiLanguage* This,
    DWORD* pdwMode,
    DWORD dwSrcEncoding,
    DWORD dwDstEncoding,
    BYTE* pSrcStr,
    UINT* pcSrcSize,
    BYTE* pDstStr,
    UINT* pcDstSize);
void __RPC_STUB IMultiLanguage_ConvertString_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage_ConvertStringToUnicode_Proxy(
    IMultiLanguage* This,
    DWORD* pdwMode,
    DWORD dwEncoding,
    CHAR* pSrcStr,
    UINT* pcSrcSize,
    WCHAR* pDstStr,
    UINT* pcDstSize);
void __RPC_STUB IMultiLanguage_ConvertStringToUnicode_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage_ConvertStringFromUnicode_Proxy(
    IMultiLanguage* This,
    DWORD* pdwMode,
    DWORD dwEncoding,
    WCHAR* pSrcStr,
    UINT* pcSrcSize,
    CHAR* pDstStr,
    UINT* pcDstSize);
void __RPC_STUB IMultiLanguage_ConvertStringFromUnicode_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage_ConvertStringReset_Proxy(
    IMultiLanguage* This);
void __RPC_STUB IMultiLanguage_ConvertStringReset_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage_GetRfc1766FromLcid_Proxy(
    IMultiLanguage* This,
    LCID Locale,
    BSTR* pbstrRfc1766);
void __RPC_STUB IMultiLanguage_GetRfc1766FromLcid_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage_GetLcidFromRfc1766_Proxy(
    IMultiLanguage* This,
    LCID* pLocale,
    BSTR bstrRfc1766);
void __RPC_STUB IMultiLanguage_GetLcidFromRfc1766_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage_EnumRfc1766_Proxy(
    IMultiLanguage* This,
    IEnumRfc1766** ppEnumRfc1766);
void __RPC_STUB IMultiLanguage_EnumRfc1766_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage_GetRfc1766Info_Proxy(
    IMultiLanguage* This,
    LCID Locale,
    PRFC1766INFO pRfc1766Info);
void __RPC_STUB IMultiLanguage_GetRfc1766Info_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage_CreateConvertCharset_Proxy(
    IMultiLanguage* This,
    UINT uiSrcCodePage,
    UINT uiDstCodePage,
    DWORD dwProperty,
    IMLangConvertCharset** ppMLangConvertCharset);
void __RPC_STUB IMultiLanguage_CreateConvertCharset_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMultiLanguage_INTERFACE_DEFINED__ */

#ifndef __IMultiLanguage2_FWD_DEFINED__
#define __IMultiLanguage2_FWD_DEFINED__
typedef interface IMultiLanguage2 IMultiLanguage2;
#endif

typedef struct tagDetectEncodingInfo {
    UINT nLangID;
    UINT nCodePage;
    INT nDocPercent;
    INT nConfidence;
} DetectEncodingInfo;
typedef struct tagDetectEncodingInfo *pDetectEncodingInfo;
/*****************************************************************************
 * IMultiLanguage2 interface
 */
#ifndef __IMultiLanguage2_INTERFACE_DEFINED__
#define __IMultiLanguage2_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMultiLanguage2, 0xdccfc164, 0x2b38, 0x11d2, 0xb7,0xec, 0x00,0xc0,0x4f,0x8f,0x5d,0x9a);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IMultiLanguage2 : public IUnknown
{
    virtual HRESULT STDMETHODCALLTYPE GetNumberOfCodePageInfo(
        UINT* pcCodePage) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetCodePageInfo(
        UINT uiCodePage,
        LANGID LangId,
        PMIMECPINFO pCodePageInfo) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetFamilyCodePage(
        UINT uiCodePage,
        UINT* puiFamilyCodePage) = 0;

    virtual HRESULT STDMETHODCALLTYPE EnumCodePages(
        DWORD grfFlags,
        LANGID LangId,
        IEnumCodePage** ppEnumCodePage) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetCharsetInfo(
        BSTR Charset,
        PMIMECSETINFO pCharsetInfo) = 0;

    virtual HRESULT STDMETHODCALLTYPE IsConvertible(
        DWORD dwSrcEncoding,
        DWORD dwDstEncoding) = 0;

    virtual HRESULT STDMETHODCALLTYPE ConvertString(
        DWORD* pdwMode,
        DWORD dwSrcEncoding,
        DWORD dwDstEncoding,
        BYTE* pSrcStr,
        UINT* pcSrcSize,
        BYTE* pDstStr,
        UINT* pcDstSize) = 0;

    virtual HRESULT STDMETHODCALLTYPE ConvertStringToUnicode(
        DWORD* pdwMode,
        DWORD dwEncoding,
        CHAR* pSrcStr,
        UINT* pcSrcSize,
        WCHAR* pDstStr,
        UINT* pcDstSize) = 0;

    virtual HRESULT STDMETHODCALLTYPE ConvertStringFromUnicode(
        DWORD* pdwMode,
        DWORD dwEncoding,
        WCHAR* pSrcStr,
        UINT* pcSrcSize,
        CHAR* pDstStr,
        UINT* pcDstSize) = 0;

    virtual HRESULT STDMETHODCALLTYPE ConvertStringReset(
        ) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetRfc1766FromLcid(
        LCID Locale,
        BSTR* pbstrRfc1766) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetLcidFromRfc1766(
        LCID* pLocale,
        BSTR bstrRfc1766) = 0;

    virtual HRESULT STDMETHODCALLTYPE EnumRfc1766(
        LANGID LangId,
        IEnumRfc1766** ppEnumRfc1766) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetRfc1766Info(
        LCID Locale,
        LANGID LangId,
        PRFC1766INFO pRfc1766Info) = 0;

    virtual HRESULT STDMETHODCALLTYPE CreateConvertCharset(
        UINT uiSrcCodePage,
        UINT uiDstCodePage,
        DWORD dwProperty,
        IMLangConvertCharset** ppMLangConvertCharset) = 0;

    virtual HRESULT STDMETHODCALLTYPE ConvertStringInIStream(
        DWORD* pdwMode,
        DWORD dwFlag,
        WCHAR* lpFallBack,
        DWORD dwSrcEncoding,
        DWORD dwDstEncoding,
        IStream* pstmIn,
        IStream* pstmOut) = 0;

    virtual HRESULT STDMETHODCALLTYPE ConvertStringToUnicodeEx(
        DWORD* pdwMode,
        DWORD dwEncoding,
        CHAR* pSrcStr,
        UINT* pcSrcSize,
        WCHAR* pDstStr,
        UINT* pcDstSize,
        DWORD dwFlag,
        WCHAR* lpFallBack) = 0;

    virtual HRESULT STDMETHODCALLTYPE ConvertStringFromUnicodeEx(
        DWORD* pdwMode,
        DWORD dwEncoding,
        WCHAR* pSrcStr,
        UINT* pcSrcSize,
        CHAR* pDstStr,
        UINT* pcDstSize,
        DWORD dwFlag,
        WCHAR* lpFallBack) = 0;

    virtual HRESULT STDMETHODCALLTYPE DetectCodepageInIStream(
        DWORD dwFlag,
        DWORD dwPrefWinCodePage,
        IStream* pstmIn,
        DetectEncodingInfo* lpEncoding,
        INT* pnScores) = 0;

    virtual HRESULT STDMETHODCALLTYPE DetectInputCodepage(
        DWORD dwFlag,
        DWORD dwPrefWinCodePage,
        CHAR* pSrcStr,
        INT* pcSrcSize,
        DetectEncodingInfo* lpEncoding,
        INT* pnScores) = 0;

    virtual HRESULT STDMETHODCALLTYPE ValidateCodePage(
        UINT uiCodePage,
        HWND hwnd) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetCodePageDescription(
        UINT uiCodePage,
        LCID lcid,
        LPWSTR lpWideCharStr,
        int cchWideChar) = 0;

    virtual HRESULT STDMETHODCALLTYPE IsCodePageInstallable(
        UINT uiCodePage) = 0;

    virtual HRESULT STDMETHODCALLTYPE SetMimeDBSource(
        MIMECONTF dwSource) = 0;

    virtual HRESULT STDMETHODCALLTYPE GetNumberOfScripts(
        UINT* pnScripts) = 0;

    virtual HRESULT STDMETHODCALLTYPE EnumScripts(
        DWORD dwFlags,
        LANGID LangId,
        IEnumScript** ppEnumScript) = 0;

    virtual HRESULT STDMETHODCALLTYPE ValidateCodePageEx(
        UINT uiCodePage,
        HWND hwnd,
        DWORD dwfIODControl) = 0;

};
#else
typedef struct IMultiLanguage2Vtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IMultiLanguage2* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IMultiLanguage2* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IMultiLanguage2* This);

    /*** IMultiLanguage2 methods ***/
    HRESULT (STDMETHODCALLTYPE *GetNumberOfCodePageInfo)(
        IMultiLanguage2* This,
        UINT* pcCodePage);

    HRESULT (STDMETHODCALLTYPE *GetCodePageInfo)(
        IMultiLanguage2* This,
        UINT uiCodePage,
        LANGID LangId,
        PMIMECPINFO pCodePageInfo);

    HRESULT (STDMETHODCALLTYPE *GetFamilyCodePage)(
        IMultiLanguage2* This,
        UINT uiCodePage,
        UINT* puiFamilyCodePage);

    HRESULT (STDMETHODCALLTYPE *EnumCodePages)(
        IMultiLanguage2* This,
        DWORD grfFlags,
        LANGID LangId,
        IEnumCodePage** ppEnumCodePage);

    HRESULT (STDMETHODCALLTYPE *GetCharsetInfo)(
        IMultiLanguage2* This,
        BSTR Charset,
        PMIMECSETINFO pCharsetInfo);

    HRESULT (STDMETHODCALLTYPE *IsConvertible)(
        IMultiLanguage2* This,
        DWORD dwSrcEncoding,
        DWORD dwDstEncoding);

    HRESULT (STDMETHODCALLTYPE *ConvertString)(
        IMultiLanguage2* This,
        DWORD* pdwMode,
        DWORD dwSrcEncoding,
        DWORD dwDstEncoding,
        BYTE* pSrcStr,
        UINT* pcSrcSize,
        BYTE* pDstStr,
        UINT* pcDstSize);

    HRESULT (STDMETHODCALLTYPE *ConvertStringToUnicode)(
        IMultiLanguage2* This,
        DWORD* pdwMode,
        DWORD dwEncoding,
        CHAR* pSrcStr,
        UINT* pcSrcSize,
        WCHAR* pDstStr,
        UINT* pcDstSize);

    HRESULT (STDMETHODCALLTYPE *ConvertStringFromUnicode)(
        IMultiLanguage2* This,
        DWORD* pdwMode,
        DWORD dwEncoding,
        WCHAR* pSrcStr,
        UINT* pcSrcSize,
        CHAR* pDstStr,
        UINT* pcDstSize);

    HRESULT (STDMETHODCALLTYPE *ConvertStringReset)(
        IMultiLanguage2* This);

    HRESULT (STDMETHODCALLTYPE *GetRfc1766FromLcid)(
        IMultiLanguage2* This,
        LCID Locale,
        BSTR* pbstrRfc1766);

    HRESULT (STDMETHODCALLTYPE *GetLcidFromRfc1766)(
        IMultiLanguage2* This,
        LCID* pLocale,
        BSTR bstrRfc1766);

    HRESULT (STDMETHODCALLTYPE *EnumRfc1766)(
        IMultiLanguage2* This,
        LANGID LangId,
        IEnumRfc1766** ppEnumRfc1766);

    HRESULT (STDMETHODCALLTYPE *GetRfc1766Info)(
        IMultiLanguage2* This,
        LCID Locale,
        LANGID LangId,
        PRFC1766INFO pRfc1766Info);

    HRESULT (STDMETHODCALLTYPE *CreateConvertCharset)(
        IMultiLanguage2* This,
        UINT uiSrcCodePage,
        UINT uiDstCodePage,
        DWORD dwProperty,
        IMLangConvertCharset** ppMLangConvertCharset);

    HRESULT (STDMETHODCALLTYPE *ConvertStringInIStream)(
        IMultiLanguage2* This,
        DWORD* pdwMode,
        DWORD dwFlag,
        WCHAR* lpFallBack,
        DWORD dwSrcEncoding,
        DWORD dwDstEncoding,
        IStream* pstmIn,
        IStream* pstmOut);

    HRESULT (STDMETHODCALLTYPE *ConvertStringToUnicodeEx)(
        IMultiLanguage2* This,
        DWORD* pdwMode,
        DWORD dwEncoding,
        CHAR* pSrcStr,
        UINT* pcSrcSize,
        WCHAR* pDstStr,
        UINT* pcDstSize,
        DWORD dwFlag,
        WCHAR* lpFallBack);

    HRESULT (STDMETHODCALLTYPE *ConvertStringFromUnicodeEx)(
        IMultiLanguage2* This,
        DWORD* pdwMode,
        DWORD dwEncoding,
        WCHAR* pSrcStr,
        UINT* pcSrcSize,
        CHAR* pDstStr,
        UINT* pcDstSize,
        DWORD dwFlag,
        WCHAR* lpFallBack);

    HRESULT (STDMETHODCALLTYPE *DetectCodepageInIStream)(
        IMultiLanguage2* This,
        DWORD dwFlag,
        DWORD dwPrefWinCodePage,
        IStream* pstmIn,
        DetectEncodingInfo* lpEncoding,
        INT* pnScores);

    HRESULT (STDMETHODCALLTYPE *DetectInputCodepage)(
        IMultiLanguage2* This,
        DWORD dwFlag,
        DWORD dwPrefWinCodePage,
        CHAR* pSrcStr,
        INT* pcSrcSize,
        DetectEncodingInfo* lpEncoding,
        INT* pnScores);

    HRESULT (STDMETHODCALLTYPE *ValidateCodePage)(
        IMultiLanguage2* This,
        UINT uiCodePage,
        HWND hwnd);

    HRESULT (STDMETHODCALLTYPE *GetCodePageDescription)(
        IMultiLanguage2* This,
        UINT uiCodePage,
        LCID lcid,
        LPWSTR lpWideCharStr,
        int cchWideChar);

    HRESULT (STDMETHODCALLTYPE *IsCodePageInstallable)(
        IMultiLanguage2* This,
        UINT uiCodePage);

    HRESULT (STDMETHODCALLTYPE *SetMimeDBSource)(
        IMultiLanguage2* This,
        MIMECONTF dwSource);

    HRESULT (STDMETHODCALLTYPE *GetNumberOfScripts)(
        IMultiLanguage2* This,
        UINT* pnScripts);

    HRESULT (STDMETHODCALLTYPE *EnumScripts)(
        IMultiLanguage2* This,
        DWORD dwFlags,
        LANGID LangId,
        IEnumScript** ppEnumScript);

    HRESULT (STDMETHODCALLTYPE *ValidateCodePageEx)(
        IMultiLanguage2* This,
        UINT uiCodePage,
        HWND hwnd,
        DWORD dwfIODControl);

    END_INTERFACE
} IMultiLanguage2Vtbl;
interface IMultiLanguage2 {
    const IMultiLanguage2Vtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IMultiLanguage2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IMultiLanguage2_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IMultiLanguage2_Release(p) (p)->lpVtbl->Release(p)
/*** IMultiLanguage2 methods ***/
#define IMultiLanguage2_GetNumberOfCodePageInfo(p,a) (p)->lpVtbl->GetNumberOfCodePageInfo(p,a)
#define IMultiLanguage2_GetCodePageInfo(p,a,b,c) (p)->lpVtbl->GetCodePageInfo(p,a,b,c)
#define IMultiLanguage2_GetFamilyCodePage(p,a,b) (p)->lpVtbl->GetFamilyCodePage(p,a,b)
#define IMultiLanguage2_EnumCodePages(p,a,b,c) (p)->lpVtbl->EnumCodePages(p,a,b,c)
#define IMultiLanguage2_GetCharsetInfo(p,a,b) (p)->lpVtbl->GetCharsetInfo(p,a,b)
#define IMultiLanguage2_IsConvertible(p,a,b) (p)->lpVtbl->IsConvertible(p,a,b)
#define IMultiLanguage2_ConvertString(p,a,b,c,d,e,f,g) (p)->lpVtbl->ConvertString(p,a,b,c,d,e,f,g)
#define IMultiLanguage2_ConvertStringToUnicode(p,a,b,c,d,e,f) (p)->lpVtbl->ConvertStringToUnicode(p,a,b,c,d,e,f)
#define IMultiLanguage2_ConvertStringFromUnicode(p,a,b,c,d,e,f) (p)->lpVtbl->ConvertStringFromUnicode(p,a,b,c,d,e,f)
#define IMultiLanguage2_ConvertStringReset(p) (p)->lpVtbl->ConvertStringReset(p)
#define IMultiLanguage2_GetRfc1766FromLcid(p,a,b) (p)->lpVtbl->GetRfc1766FromLcid(p,a,b)
#define IMultiLanguage2_GetLcidFromRfc1766(p,a,b) (p)->lpVtbl->GetLcidFromRfc1766(p,a,b)
#define IMultiLanguage2_EnumRfc1766(p,a,b) (p)->lpVtbl->EnumRfc1766(p,a,b)
#define IMultiLanguage2_GetRfc1766Info(p,a,b,c) (p)->lpVtbl->GetRfc1766Info(p,a,b,c)
#define IMultiLanguage2_CreateConvertCharset(p,a,b,c,d) (p)->lpVtbl->CreateConvertCharset(p,a,b,c,d)
#define IMultiLanguage2_ConvertStringInIStream(p,a,b,c,d,e,f,g) (p)->lpVtbl->ConvertStringInIStream(p,a,b,c,d,e,f,g)
#define IMultiLanguage2_ConvertStringToUnicodeEx(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->ConvertStringToUnicodeEx(p,a,b,c,d,e,f,g,h)
#define IMultiLanguage2_ConvertStringFromUnicodeEx(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->ConvertStringFromUnicodeEx(p,a,b,c,d,e,f,g,h)
#define IMultiLanguage2_DetectCodepageInIStream(p,a,b,c,d,e) (p)->lpVtbl->DetectCodepageInIStream(p,a,b,c,d,e)
#define IMultiLanguage2_DetectInputCodepage(p,a,b,c,d,e,f) (p)->lpVtbl->DetectInputCodepage(p,a,b,c,d,e,f)
#define IMultiLanguage2_ValidateCodePage(p,a,b) (p)->lpVtbl->ValidateCodePage(p,a,b)
#define IMultiLanguage2_GetCodePageDescription(p,a,b,c,d) (p)->lpVtbl->GetCodePageDescription(p,a,b,c,d)
#define IMultiLanguage2_IsCodePageInstallable(p,a) (p)->lpVtbl->IsCodePageInstallable(p,a)
#define IMultiLanguage2_SetMimeDBSource(p,a) (p)->lpVtbl->SetMimeDBSource(p,a)
#define IMultiLanguage2_GetNumberOfScripts(p,a) (p)->lpVtbl->GetNumberOfScripts(p,a)
#define IMultiLanguage2_EnumScripts(p,a,b,c) (p)->lpVtbl->EnumScripts(p,a,b,c)
#define IMultiLanguage2_ValidateCodePageEx(p,a,b,c) (p)->lpVtbl->ValidateCodePageEx(p,a,b,c)
#endif

#endif

HRESULT CALLBACK IMultiLanguage2_GetNumberOfCodePageInfo_Proxy(
    IMultiLanguage2* This,
    UINT* pcCodePage);
void __RPC_STUB IMultiLanguage2_GetNumberOfCodePageInfo_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage2_GetCodePageInfo_Proxy(
    IMultiLanguage2* This,
    UINT uiCodePage,
    LANGID LangId,
    PMIMECPINFO pCodePageInfo);
void __RPC_STUB IMultiLanguage2_GetCodePageInfo_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage2_GetFamilyCodePage_Proxy(
    IMultiLanguage2* This,
    UINT uiCodePage,
    UINT* puiFamilyCodePage);
void __RPC_STUB IMultiLanguage2_GetFamilyCodePage_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage2_EnumCodePages_Proxy(
    IMultiLanguage2* This,
    DWORD grfFlags,
    LANGID LangId,
    IEnumCodePage** ppEnumCodePage);
void __RPC_STUB IMultiLanguage2_EnumCodePages_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage2_GetCharsetInfo_Proxy(
    IMultiLanguage2* This,
    BSTR Charset,
    PMIMECSETINFO pCharsetInfo);
void __RPC_STUB IMultiLanguage2_GetCharsetInfo_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage2_IsConvertible_Proxy(
    IMultiLanguage2* This,
    DWORD dwSrcEncoding,
    DWORD dwDstEncoding);
void __RPC_STUB IMultiLanguage2_IsConvertible_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage2_ConvertString_Proxy(
    IMultiLanguage2* This,
    DWORD* pdwMode,
    DWORD dwSrcEncoding,
    DWORD dwDstEncoding,
    BYTE* pSrcStr,
    UINT* pcSrcSize,
    BYTE* pDstStr,
    UINT* pcDstSize);
void __RPC_STUB IMultiLanguage2_ConvertString_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage2_ConvertStringToUnicode_Proxy(
    IMultiLanguage2* This,
    DWORD* pdwMode,
    DWORD dwEncoding,
    CHAR* pSrcStr,
    UINT* pcSrcSize,
    WCHAR* pDstStr,
    UINT* pcDstSize);
void __RPC_STUB IMultiLanguage2_ConvertStringToUnicode_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage2_ConvertStringFromUnicode_Proxy(
    IMultiLanguage2* This,
    DWORD* pdwMode,
    DWORD dwEncoding,
    WCHAR* pSrcStr,
    UINT* pcSrcSize,
    CHAR* pDstStr,
    UINT* pcDstSize);
void __RPC_STUB IMultiLanguage2_ConvertStringFromUnicode_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage2_ConvertStringReset_Proxy(
    IMultiLanguage2* This);
void __RPC_STUB IMultiLanguage2_ConvertStringReset_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage2_GetRfc1766FromLcid_Proxy(
    IMultiLanguage2* This,
    LCID Locale,
    BSTR* pbstrRfc1766);
void __RPC_STUB IMultiLanguage2_GetRfc1766FromLcid_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage2_GetLcidFromRfc1766_Proxy(
    IMultiLanguage2* This,
    LCID* pLocale,
    BSTR bstrRfc1766);
void __RPC_STUB IMultiLanguage2_GetLcidFromRfc1766_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage2_EnumRfc1766_Proxy(
    IMultiLanguage2* This,
    LANGID LangId,
    IEnumRfc1766** ppEnumRfc1766);
void __RPC_STUB IMultiLanguage2_EnumRfc1766_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage2_GetRfc1766Info_Proxy(
    IMultiLanguage2* This,
    LCID Locale,
    LANGID LangId,
    PRFC1766INFO pRfc1766Info);
void __RPC_STUB IMultiLanguage2_GetRfc1766Info_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage2_CreateConvertCharset_Proxy(
    IMultiLanguage2* This,
    UINT uiSrcCodePage,
    UINT uiDstCodePage,
    DWORD dwProperty,
    IMLangConvertCharset** ppMLangConvertCharset);
void __RPC_STUB IMultiLanguage2_CreateConvertCharset_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage2_ConvertStringInIStream_Proxy(
    IMultiLanguage2* This,
    DWORD* pdwMode,
    DWORD dwFlag,
    WCHAR* lpFallBack,
    DWORD dwSrcEncoding,
    DWORD dwDstEncoding,
    IStream* pstmIn,
    IStream* pstmOut);
void __RPC_STUB IMultiLanguage2_ConvertStringInIStream_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage2_ConvertStringToUnicodeEx_Proxy(
    IMultiLanguage2* This,
    DWORD* pdwMode,
    DWORD dwEncoding,
    CHAR* pSrcStr,
    UINT* pcSrcSize,
    WCHAR* pDstStr,
    UINT* pcDstSize,
    DWORD dwFlag,
    WCHAR* lpFallBack);
void __RPC_STUB IMultiLanguage2_ConvertStringToUnicodeEx_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage2_ConvertStringFromUnicodeEx_Proxy(
    IMultiLanguage2* This,
    DWORD* pdwMode,
    DWORD dwEncoding,
    WCHAR* pSrcStr,
    UINT* pcSrcSize,
    CHAR* pDstStr,
    UINT* pcDstSize,
    DWORD dwFlag,
    WCHAR* lpFallBack);
void __RPC_STUB IMultiLanguage2_ConvertStringFromUnicodeEx_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage2_DetectCodepageInIStream_Proxy(
    IMultiLanguage2* This,
    DWORD dwFlag,
    DWORD dwPrefWinCodePage,
    IStream* pstmIn,
    DetectEncodingInfo* lpEncoding,
    INT* pnScores);
void __RPC_STUB IMultiLanguage2_DetectCodepageInIStream_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage2_DetectInputCodepage_Proxy(
    IMultiLanguage2* This,
    DWORD dwFlag,
    DWORD dwPrefWinCodePage,
    CHAR* pSrcStr,
    INT* pcSrcSize,
    DetectEncodingInfo* lpEncoding,
    INT* pnScores);
void __RPC_STUB IMultiLanguage2_DetectInputCodepage_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage2_ValidateCodePage_Proxy(
    IMultiLanguage2* This,
    UINT uiCodePage,
    HWND hwnd);
void __RPC_STUB IMultiLanguage2_ValidateCodePage_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage2_GetCodePageDescription_Proxy(
    IMultiLanguage2* This,
    UINT uiCodePage,
    LCID lcid,
    LPWSTR lpWideCharStr,
    int cchWideChar);
void __RPC_STUB IMultiLanguage2_GetCodePageDescription_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage2_IsCodePageInstallable_Proxy(
    IMultiLanguage2* This,
    UINT uiCodePage);
void __RPC_STUB IMultiLanguage2_IsCodePageInstallable_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage2_SetMimeDBSource_Proxy(
    IMultiLanguage2* This,
    MIMECONTF dwSource);
void __RPC_STUB IMultiLanguage2_SetMimeDBSource_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage2_GetNumberOfScripts_Proxy(
    IMultiLanguage2* This,
    UINT* pnScripts);
void __RPC_STUB IMultiLanguage2_GetNumberOfScripts_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage2_EnumScripts_Proxy(
    IMultiLanguage2* This,
    DWORD dwFlags,
    LANGID LangId,
    IEnumScript** ppEnumScript);
void __RPC_STUB IMultiLanguage2_EnumScripts_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage2_ValidateCodePageEx_Proxy(
    IMultiLanguage2* This,
    UINT uiCodePage,
    HWND hwnd,
    DWORD dwfIODControl);
void __RPC_STUB IMultiLanguage2_ValidateCodePageEx_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMultiLanguage2_INTERFACE_DEFINED__ */

#ifndef __IMultiLanguage3_FWD_DEFINED__
#define __IMultiLanguage3_FWD_DEFINED__
typedef interface IMultiLanguage3 IMultiLanguage3;
#endif

typedef IMultiLanguage3 *LPMULTILANGUAGE3;
/*****************************************************************************
 * IMultiLanguage3 interface
 */
#ifndef __IMultiLanguage3_INTERFACE_DEFINED__
#define __IMultiLanguage3_INTERFACE_DEFINED__

DEFINE_GUID(IID_IMultiLanguage3, 0x4e5868ab, 0xb157, 0x4623, 0x9a,0xcc, 0x6a,0x1d,0x9c,0xae,0xbe,0x04);
#if defined(__cplusplus) && !defined(CINTERFACE)
interface IMultiLanguage3 : public IMultiLanguage2
{
    virtual HRESULT STDMETHODCALLTYPE DetectOutboundCodePage(
        DWORD dwFlags,
        LPCWSTR lpWideCharStr,
        UINT cchWideChar,
        UINT* puiPreferredCodePages,
        UINT nPreferredCodePages,
        UINT* puiDetectedCodePages,
        UINT* pnDetectedCodePages,
        WCHAR* lpSpecialChar) = 0;

    virtual HRESULT STDMETHODCALLTYPE DetectOutboundCodePageInIStream(
        DWORD dwFlags,
        IStream* pStrIn,
        UINT* puiPreferredCodePages,
        UINT nPreferredCodePages,
        UINT* puiDetectedCodePages,
        UINT* pnDetectedCodePages,
        WCHAR* lpSpecialChar) = 0;

};
#else
typedef struct IMultiLanguage3Vtbl {
    BEGIN_INTERFACE

    /*** IUnknown methods ***/
    HRESULT (STDMETHODCALLTYPE *QueryInterface)(
        IMultiLanguage3* This,
        REFIID riid,
        void** ppvObject);

    ULONG (STDMETHODCALLTYPE *AddRef)(
        IMultiLanguage3* This);

    ULONG (STDMETHODCALLTYPE *Release)(
        IMultiLanguage3* This);

    /*** IMultiLanguage2 methods ***/
    HRESULT (STDMETHODCALLTYPE *GetNumberOfCodePageInfo)(
        IMultiLanguage3* This,
        UINT* pcCodePage);

    HRESULT (STDMETHODCALLTYPE *GetCodePageInfo)(
        IMultiLanguage3* This,
        UINT uiCodePage,
        LANGID LangId,
        PMIMECPINFO pCodePageInfo);

    HRESULT (STDMETHODCALLTYPE *GetFamilyCodePage)(
        IMultiLanguage3* This,
        UINT uiCodePage,
        UINT* puiFamilyCodePage);

    HRESULT (STDMETHODCALLTYPE *EnumCodePages)(
        IMultiLanguage3* This,
        DWORD grfFlags,
        LANGID LangId,
        IEnumCodePage** ppEnumCodePage);

    HRESULT (STDMETHODCALLTYPE *GetCharsetInfo)(
        IMultiLanguage3* This,
        BSTR Charset,
        PMIMECSETINFO pCharsetInfo);

    HRESULT (STDMETHODCALLTYPE *IsConvertible)(
        IMultiLanguage3* This,
        DWORD dwSrcEncoding,
        DWORD dwDstEncoding);

    HRESULT (STDMETHODCALLTYPE *ConvertString)(
        IMultiLanguage3* This,
        DWORD* pdwMode,
        DWORD dwSrcEncoding,
        DWORD dwDstEncoding,
        BYTE* pSrcStr,
        UINT* pcSrcSize,
        BYTE* pDstStr,
        UINT* pcDstSize);

    HRESULT (STDMETHODCALLTYPE *ConvertStringToUnicode)(
        IMultiLanguage3* This,
        DWORD* pdwMode,
        DWORD dwEncoding,
        CHAR* pSrcStr,
        UINT* pcSrcSize,
        WCHAR* pDstStr,
        UINT* pcDstSize);

    HRESULT (STDMETHODCALLTYPE *ConvertStringFromUnicode)(
        IMultiLanguage3* This,
        DWORD* pdwMode,
        DWORD dwEncoding,
        WCHAR* pSrcStr,
        UINT* pcSrcSize,
        CHAR* pDstStr,
        UINT* pcDstSize);

    HRESULT (STDMETHODCALLTYPE *ConvertStringReset)(
        IMultiLanguage3* This);

    HRESULT (STDMETHODCALLTYPE *GetRfc1766FromLcid)(
        IMultiLanguage3* This,
        LCID Locale,
        BSTR* pbstrRfc1766);

    HRESULT (STDMETHODCALLTYPE *GetLcidFromRfc1766)(
        IMultiLanguage3* This,
        LCID* pLocale,
        BSTR bstrRfc1766);

    HRESULT (STDMETHODCALLTYPE *EnumRfc1766)(
        IMultiLanguage3* This,
        LANGID LangId,
        IEnumRfc1766** ppEnumRfc1766);

    HRESULT (STDMETHODCALLTYPE *GetRfc1766Info)(
        IMultiLanguage3* This,
        LCID Locale,
        LANGID LangId,
        PRFC1766INFO pRfc1766Info);

    HRESULT (STDMETHODCALLTYPE *CreateConvertCharset)(
        IMultiLanguage3* This,
        UINT uiSrcCodePage,
        UINT uiDstCodePage,
        DWORD dwProperty,
        IMLangConvertCharset** ppMLangConvertCharset);

    HRESULT (STDMETHODCALLTYPE *ConvertStringInIStream)(
        IMultiLanguage3* This,
        DWORD* pdwMode,
        DWORD dwFlag,
        WCHAR* lpFallBack,
        DWORD dwSrcEncoding,
        DWORD dwDstEncoding,
        IStream* pstmIn,
        IStream* pstmOut);

    HRESULT (STDMETHODCALLTYPE *ConvertStringToUnicodeEx)(
        IMultiLanguage3* This,
        DWORD* pdwMode,
        DWORD dwEncoding,
        CHAR* pSrcStr,
        UINT* pcSrcSize,
        WCHAR* pDstStr,
        UINT* pcDstSize,
        DWORD dwFlag,
        WCHAR* lpFallBack);

    HRESULT (STDMETHODCALLTYPE *ConvertStringFromUnicodeEx)(
        IMultiLanguage3* This,
        DWORD* pdwMode,
        DWORD dwEncoding,
        WCHAR* pSrcStr,
        UINT* pcSrcSize,
        CHAR* pDstStr,
        UINT* pcDstSize,
        DWORD dwFlag,
        WCHAR* lpFallBack);

    HRESULT (STDMETHODCALLTYPE *DetectCodepageInIStream)(
        IMultiLanguage3* This,
        DWORD dwFlag,
        DWORD dwPrefWinCodePage,
        IStream* pstmIn,
        DetectEncodingInfo* lpEncoding,
        INT* pnScores);

    HRESULT (STDMETHODCALLTYPE *DetectInputCodepage)(
        IMultiLanguage3* This,
        DWORD dwFlag,
        DWORD dwPrefWinCodePage,
        CHAR* pSrcStr,
        INT* pcSrcSize,
        DetectEncodingInfo* lpEncoding,
        INT* pnScores);

    HRESULT (STDMETHODCALLTYPE *ValidateCodePage)(
        IMultiLanguage3* This,
        UINT uiCodePage,
        HWND hwnd);

    HRESULT (STDMETHODCALLTYPE *GetCodePageDescription)(
        IMultiLanguage3* This,
        UINT uiCodePage,
        LCID lcid,
        LPWSTR lpWideCharStr,
        int cchWideChar);

    HRESULT (STDMETHODCALLTYPE *IsCodePageInstallable)(
        IMultiLanguage3* This,
        UINT uiCodePage);

    HRESULT (STDMETHODCALLTYPE *SetMimeDBSource)(
        IMultiLanguage3* This,
        MIMECONTF dwSource);

    HRESULT (STDMETHODCALLTYPE *GetNumberOfScripts)(
        IMultiLanguage3* This,
        UINT* pnScripts);

    HRESULT (STDMETHODCALLTYPE *EnumScripts)(
        IMultiLanguage3* This,
        DWORD dwFlags,
        LANGID LangId,
        IEnumScript** ppEnumScript);

    HRESULT (STDMETHODCALLTYPE *ValidateCodePageEx)(
        IMultiLanguage3* This,
        UINT uiCodePage,
        HWND hwnd,
        DWORD dwfIODControl);

    /*** IMultiLanguage3 methods ***/
    HRESULT (STDMETHODCALLTYPE *DetectOutboundCodePage)(
        IMultiLanguage3* This,
        DWORD dwFlags,
        LPCWSTR lpWideCharStr,
        UINT cchWideChar,
        UINT* puiPreferredCodePages,
        UINT nPreferredCodePages,
        UINT* puiDetectedCodePages,
        UINT* pnDetectedCodePages,
        WCHAR* lpSpecialChar);

    HRESULT (STDMETHODCALLTYPE *DetectOutboundCodePageInIStream)(
        IMultiLanguage3* This,
        DWORD dwFlags,
        IStream* pStrIn,
        UINT* puiPreferredCodePages,
        UINT nPreferredCodePages,
        UINT* puiDetectedCodePages,
        UINT* pnDetectedCodePages,
        WCHAR* lpSpecialChar);

    END_INTERFACE
} IMultiLanguage3Vtbl;
interface IMultiLanguage3 {
    const IMultiLanguage3Vtbl* lpVtbl;
};

#ifdef COBJMACROS
/*** IUnknown methods ***/
#define IMultiLanguage3_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
#define IMultiLanguage3_AddRef(p) (p)->lpVtbl->AddRef(p)
#define IMultiLanguage3_Release(p) (p)->lpVtbl->Release(p)
/*** IMultiLanguage2 methods ***/
#define IMultiLanguage3_GetNumberOfCodePageInfo(p,a) (p)->lpVtbl->GetNumberOfCodePageInfo(p,a)
#define IMultiLanguage3_GetCodePageInfo(p,a,b,c) (p)->lpVtbl->GetCodePageInfo(p,a,b,c)
#define IMultiLanguage3_GetFamilyCodePage(p,a,b) (p)->lpVtbl->GetFamilyCodePage(p,a,b)
#define IMultiLanguage3_EnumCodePages(p,a,b,c) (p)->lpVtbl->EnumCodePages(p,a,b,c)
#define IMultiLanguage3_GetCharsetInfo(p,a,b) (p)->lpVtbl->GetCharsetInfo(p,a,b)
#define IMultiLanguage3_IsConvertible(p,a,b) (p)->lpVtbl->IsConvertible(p,a,b)
#define IMultiLanguage3_ConvertString(p,a,b,c,d,e,f,g) (p)->lpVtbl->ConvertString(p,a,b,c,d,e,f,g)
#define IMultiLanguage3_ConvertStringToUnicode(p,a,b,c,d,e,f) (p)->lpVtbl->ConvertStringToUnicode(p,a,b,c,d,e,f)
#define IMultiLanguage3_ConvertStringFromUnicode(p,a,b,c,d,e,f) (p)->lpVtbl->ConvertStringFromUnicode(p,a,b,c,d,e,f)
#define IMultiLanguage3_ConvertStringReset(p) (p)->lpVtbl->ConvertStringReset(p)
#define IMultiLanguage3_GetRfc1766FromLcid(p,a,b) (p)->lpVtbl->GetRfc1766FromLcid(p,a,b)
#define IMultiLanguage3_GetLcidFromRfc1766(p,a,b) (p)->lpVtbl->GetLcidFromRfc1766(p,a,b)
#define IMultiLanguage3_EnumRfc1766(p,a,b) (p)->lpVtbl->EnumRfc1766(p,a,b)
#define IMultiLanguage3_GetRfc1766Info(p,a,b,c) (p)->lpVtbl->GetRfc1766Info(p,a,b,c)
#define IMultiLanguage3_CreateConvertCharset(p,a,b,c,d) (p)->lpVtbl->CreateConvertCharset(p,a,b,c,d)
#define IMultiLanguage3_ConvertStringInIStream(p,a,b,c,d,e,f,g) (p)->lpVtbl->ConvertStringInIStream(p,a,b,c,d,e,f,g)
#define IMultiLanguage3_ConvertStringToUnicodeEx(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->ConvertStringToUnicodeEx(p,a,b,c,d,e,f,g,h)
#define IMultiLanguage3_ConvertStringFromUnicodeEx(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->ConvertStringFromUnicodeEx(p,a,b,c,d,e,f,g,h)
#define IMultiLanguage3_DetectCodepageInIStream(p,a,b,c,d,e) (p)->lpVtbl->DetectCodepageInIStream(p,a,b,c,d,e)
#define IMultiLanguage3_DetectInputCodepage(p,a,b,c,d,e,f) (p)->lpVtbl->DetectInputCodepage(p,a,b,c,d,e,f)
#define IMultiLanguage3_ValidateCodePage(p,a,b) (p)->lpVtbl->ValidateCodePage(p,a,b)
#define IMultiLanguage3_GetCodePageDescription(p,a,b,c,d) (p)->lpVtbl->GetCodePageDescription(p,a,b,c,d)
#define IMultiLanguage3_IsCodePageInstallable(p,a) (p)->lpVtbl->IsCodePageInstallable(p,a)
#define IMultiLanguage3_SetMimeDBSource(p,a) (p)->lpVtbl->SetMimeDBSource(p,a)
#define IMultiLanguage3_GetNumberOfScripts(p,a) (p)->lpVtbl->GetNumberOfScripts(p,a)
#define IMultiLanguage3_EnumScripts(p,a,b,c) (p)->lpVtbl->EnumScripts(p,a,b,c)
#define IMultiLanguage3_ValidateCodePageEx(p,a,b,c) (p)->lpVtbl->ValidateCodePageEx(p,a,b,c)
/*** IMultiLanguage3 methods ***/
#define IMultiLanguage3_DetectOutboundCodePage(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->DetectOutboundCodePage(p,a,b,c,d,e,f,g,h)
#define IMultiLanguage3_DetectOutboundCodePageInIStream(p,a,b,c,d,e,f,g) (p)->lpVtbl->DetectOutboundCodePageInIStream(p,a,b,c,d,e,f,g)
#endif

#endif

HRESULT CALLBACK IMultiLanguage3_DetectOutboundCodePage_Proxy(
    IMultiLanguage3* This,
    DWORD dwFlags,
    LPCWSTR lpWideCharStr,
    UINT cchWideChar,
    UINT* puiPreferredCodePages,
    UINT nPreferredCodePages,
    UINT* puiDetectedCodePages,
    UINT* pnDetectedCodePages,
    WCHAR* lpSpecialChar);
void __RPC_STUB IMultiLanguage3_DetectOutboundCodePage_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);
HRESULT CALLBACK IMultiLanguage3_DetectOutboundCodePageInIStream_Proxy(
    IMultiLanguage3* This,
    DWORD dwFlags,
    IStream* pStrIn,
    UINT* puiPreferredCodePages,
    UINT nPreferredCodePages,
    UINT* puiDetectedCodePages,
    UINT* pnDetectedCodePages,
    WCHAR* lpSpecialChar);
void __RPC_STUB IMultiLanguage3_DetectOutboundCodePageInIStream_Stub(
    IRpcStubBuffer* This,
    IRpcChannelBuffer* pRpcChannelBuffer,
    PRPC_MESSAGE pRpcMessage,
    DWORD* pdwStubPhase);

#endif  /* __IMultiLanguage3_INTERFACE_DEFINED__ */

/*****************************************************************************
 * CMultiLanguage coclass
 */

DEFINE_GUID(CLSID_CMultiLanguage, 0x275c23e2, 0x3747, 0x11d0, 0x9f,0xea, 0x00,0xaa,0x00,0x3f,0x86,0x46);

#ifndef __CMultiLanguage_FWD_DEFINED__
#define __CMultiLanguage_FWD_DEFINED__
typedef struct CMultiLanguage CMultiLanguage;
#endif /* defined __CMultiLanguage_FWD_DEFINED__ */

STDAPI LcidToRfc1766A(LCID, LPSTR, INT);
STDAPI LcidToRfc1766W(LCID, LPWSTR, INT);
#define LcidToRfc1766 WINELIB_NAME_AW(LcidToRfc1766)
STDAPI Rfc1766ToLcidA(LCID *, LPCSTR);
STDAPI Rfc1766ToLcidW(LCID *, LPCWSTR);
#define Rfc1766ToLcid WINELIB_NAME_AW(Rfc1766ToLcid)
STDAPI GetGlobalFontLinkObject(void);
STDAPI IsConvertINetStringAvailable(DWORD, DWORD);
STDAPI ConvertINetString(LPDWORD, DWORD, DWORD, LPCSTR, LPINT, LPSTR, LPINT);
STDAPI ConvertINetMultiByteToUnicode(LPDWORD, DWORD, LPCSTR, LPINT, LPWSTR, LPINT);
STDAPI ConvertINetUnicodeToMultiByte(LPDWORD, DWORD, LPCWSTR, LPINT, LPSTR, LPINT);
/* Begin additional prototypes for all interfaces */

unsigned long   __RPC_USER HWND_UserSize     (unsigned long *, unsigned long,   HWND *);
unsigned char * __RPC_USER HWND_UserMarshal  (unsigned long *, unsigned char *, HWND *);
unsigned char * __RPC_USER HWND_UserUnmarshal(unsigned long *, unsigned char *, HWND *);
void            __RPC_USER HWND_UserFree     (unsigned long *, HWND *);
unsigned long   __RPC_USER BSTR_UserSize     (unsigned long *, unsigned long,   BSTR *);
unsigned char * __RPC_USER BSTR_UserMarshal  (unsigned long *, unsigned char *, BSTR *);
unsigned char * __RPC_USER BSTR_UserUnmarshal(unsigned long *, unsigned char *, BSTR *);
void            __RPC_USER BSTR_UserFree     (unsigned long *, BSTR *);
unsigned long   __RPC_USER HFONT_UserSize     (unsigned long *, unsigned long,   HFONT *);
unsigned char * __RPC_USER HFONT_UserMarshal  (unsigned long *, unsigned char *, HFONT *);
unsigned char * __RPC_USER HFONT_UserUnmarshal(unsigned long *, unsigned char *, HFONT *);
void            __RPC_USER HFONT_UserFree     (unsigned long *, HFONT *);
unsigned long   __RPC_USER HDC_UserSize     (unsigned long *, unsigned long,   HDC *);
unsigned char * __RPC_USER HDC_UserMarshal  (unsigned long *, unsigned char *, HDC *);
unsigned char * __RPC_USER HDC_UserUnmarshal(unsigned long *, unsigned char *, HDC *);
void            __RPC_USER HDC_UserFree     (unsigned long *, HDC *);

/* End additional prototypes */

#ifdef __cplusplus
}
#endif
#endif /* __WIDL_MLANG_H */
