typedef struct
{
const IStreamVtbl *lpVtbl;
- ULONG ref;
+ LONG ref;
HANDLE hFile;
DWORD dwMode;
LPOLESTR lpszPath;
extern DWORD SHLWAPI_ThreadRef_index;
-/* following is GUID for IObjectWithSite::SetSite -- see _174 */
-static DWORD id1[4] = {0xfc4801a3, 0x11cf2ba9, 0xaa0029a2, 0x52733d00};
-/* following is GUID for IPersistMoniker::GetClassID -- see _174 */
-static DWORD id2[4] = {0x79eac9ee, 0x11cebaf9, 0xaa00828c, 0x0ba94b00};
-
/* Function pointers for GET_FUNC macro; these need to be global because of gcc bug */
typedef LPITEMIDLIST (WINAPI *fnpSHBrowseForFolderW)(LPBROWSEINFOW);
static fnpSHBrowseForFolderW pSHBrowseForFolderW;
/*************************************************************************
* @ [SHLWAPI.174]
*
- * Call either IObjectWithSite_SetSite() or IPersistMoniker_GetClassID() on
- * an interface.
+ * Call either IObjectWithSite_SetSite() or IInternetSecurityManager_SetSecuritySite() on
+ * an object.
*
- * RETURNS
- * Success: S_OK.
- * Failure: E_FAIL, if p1 is NULL.
- * E_NOINTERFACE If p1 does not support the IPersist interface,
- * Or an HRESULT error code.
*/
-DWORD WINAPI IUnknown_SetSite(
- IUnknown *p1, /* [in] OLE object */
- LPVOID *p2) /* [out] ptr for call results */
+HRESULT WINAPI IUnknown_SetSite(
+ IUnknown *obj, /* [in] OLE object */
+ IUnknown *site) /* [in] Site interface */
{
- DWORD ret, aa;
- IUnknown *iobjectwithsite;
-
- if (!p1) return E_FAIL;
+ HRESULT hr;
+ IObjectWithSite *iobjwithsite;
+ IInternetSecurityManager *isecmgr;
- /* see if SetSite interface exists for IObjectWithSite object */
- ret = IUnknown_QueryInterface((IUnknown *)p1, (REFIID)id1, (LPVOID *)&iobjectwithsite);
- TRACE("first IU_QI ret=%08lx, iobjectwithsite=%p\n", ret, iobjectwithsite);
- if (ret) {
+ if (!obj) return E_FAIL;
- /* see if GetClassId interface exists for IPersistMoniker object */
- ret = IUnknown_QueryInterface(p1, (REFIID)id2, (LPVOID *)&aa);
- TRACE("second IU_QI ret=%08lx, aa=%08lx\n", ret, aa);
- if (ret) return ret;
-
- /* fake a GetClassId call */
- ret = IOleWindow_GetWindow((IOleWindow *)aa, (HWND*)p2);
- TRACE("second IU_QI doing 0x0c ret=%08lx, *p2=%08lx\n", ret,
- *(LPDWORD)p2);
- IUnknown_Release((IUnknown *)aa);
+ hr = IUnknown_QueryInterface(obj, &IID_IObjectWithSite, (LPVOID *)&iobjwithsite);
+ TRACE("IID_IObjectWithSite QI ret=%08lx, %p\n", hr, iobjwithsite);
+ if (SUCCEEDED(hr))
+ {
+ hr = IObjectWithSite_SetSite(iobjwithsite, site);
+ TRACE("done IObjectWithSite_SetSite ret=%08lx\n", hr);
+ IUnknown_Release(iobjwithsite);
}
- else {
- /* fake a SetSite call */
- ret = IOleWindow_GetWindow((IOleWindow *)iobjectwithsite, (HWND*)p2);
- TRACE("first IU_QI doing 0x0c ret=%08lx, *p2=%08lx\n", ret,
- *(LPDWORD)p2);
- IUnknown_Release((IUnknown *)iobjectwithsite);
+ else
+ {
+ hr = IUnknown_QueryInterface(obj, &IID_IInternetSecurityManager, (LPVOID *)&isecmgr);
+ TRACE("IID_IInternetSecurityManager QI ret=%08lx, %p\n", hr, isecmgr);
+ if (FAILED(hr)) return hr;
+
+ hr = IInternetSecurityManager_SetSecuritySite(isecmgr, (IInternetSecurityMgrSite *)site);
+ TRACE("done IInternetSecurityManager_SetSecuritySite ret=%08lx\n", hr);
+ IUnknown_Release(isecmgr);
}
- return ret;
+ return hr;
}
/*************************************************************************
*/
HMENU WINAPI SHGetMenuFromID(HMENU hMenu, UINT uID)
{
- MENUITEMINFOA mi;
+ MENUITEMINFOW mi;
- TRACE("(%p,%uld)\n", hMenu, uID);
+ TRACE("(%p,%u)\n", hMenu, uID);
- mi.cbSize = sizeof(MENUITEMINFOA);
+ mi.cbSize = sizeof(mi);
mi.fMask = MIIM_SUBMENU;
- if (!GetMenuItemInfoA(hMenu, uID, 0, &mi))
+ if (!GetMenuItemInfoW(hMenu, uID, FALSE, &mi))
return NULL;
return mi.hSubMenu;
return !IsChild(hParent, hChild);
}
+/*************************************************************************
+ * FDSA functions. Manage a dynamic array of fixed size memory blocks.
+ */
+
+typedef struct
+{
+ DWORD num_items; /* Number of elements inserted */
+ void *mem; /* Ptr to array */
+ DWORD blocks_alloced; /* Number of elements allocated */
+ BYTE inc; /* Number of elements to grow by when we need to expand */
+ BYTE block_size; /* Size in bytes of an element */
+ BYTE flags; /* Flags */
+} FDSA_info;
+
+#define FDSA_FLAG_INTERNAL_ALLOC 0x01 /* When set we have allocated mem internally */
+
/*************************************************************************
* @ [SHLWAPI.208]
*
- * Some sort of memory management process.
+ * Initialize an FDSA arrary.
*/
-DWORD WINAPI FDSA_Initialize(
- DWORD a,
- DWORD b,
- LPVOID c,
- LPVOID d,
- DWORD e)
+BOOL WINAPI FDSA_Initialize(DWORD block_size, DWORD inc, FDSA_info *info, void *mem,
+ DWORD init_blocks)
{
- FIXME("(0x%08lx 0x%08lx %p %p 0x%08lx) stub\n",
- a, b, c, d, e);
- return 1;
+ TRACE("(0x%08lx 0x%08lx %p %p 0x%08lx)\n", block_size, inc, info, mem, init_blocks);
+
+ if(inc == 0)
+ inc = 1;
+
+ if(mem)
+ memset(mem, 0, block_size * init_blocks);
+
+ info->num_items = 0;
+ info->inc = inc;
+ info->mem = mem;
+ info->blocks_alloced = init_blocks;
+ info->block_size = block_size;
+ info->flags = 0;
+
+ return TRUE;
}
/*************************************************************************
* @ [SHLWAPI.209]
*
- * Some sort of memory management process.
+ * Destroy an FDSA array
*/
-DWORD WINAPI FDSA_Destroy(
- LPVOID a)
+BOOL WINAPI FDSA_Destroy(FDSA_info *info)
{
- FIXME("(%p) stub\n",
- a);
- return 1;
+ TRACE("(%p)\n", info);
+
+ if(info->flags & FDSA_FLAG_INTERNAL_ALLOC)
+ {
+ HeapFree(GetProcessHeap(), 0, info->mem);
+ return FALSE;
+ }
+
+ return TRUE;
}
/*************************************************************************
* @ [SHLWAPI.210]
*
- * Some sort of memory management process.
+ * Insert element into an FDSA array
*/
-DWORD WINAPI FDSA_InsertItem(
- LPVOID a,
- DWORD b,
- LPVOID c)
+DWORD WINAPI FDSA_InsertItem(FDSA_info *info, DWORD where, void *block)
{
- FIXME("(%p 0x%08lx %p) stub\n",
- a, b, c);
- return 0;
+ TRACE("(%p 0x%08lx %p)\n", info, where, block);
+ if(where > info->num_items)
+ where = info->num_items;
+
+ if(info->num_items >= info->blocks_alloced)
+ {
+ DWORD size = (info->blocks_alloced + info->inc) * info->block_size;
+ if(info->flags & 0x1)
+ info->mem = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, info->mem, size);
+ else
+ {
+ void *old_mem = info->mem;
+ info->mem = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
+ memcpy(info->mem, old_mem, info->blocks_alloced * info->block_size);
+ }
+ info->blocks_alloced += info->inc;
+ info->flags |= 0x1;
+ }
+
+ if(where < info->num_items)
+ {
+ memmove((char*)info->mem + (where + 1) * info->block_size,
+ (char*)info->mem + where * info->block_size,
+ (info->num_items - where) * info->block_size);
+ }
+ memcpy((char*)info->mem + where * info->block_size, block, info->block_size);
+
+ info->num_items++;
+ return where;
}
/*************************************************************************
* @ [SHLWAPI.211]
+ *
+ * Delete an element from an FDSA array.
*/
-DWORD WINAPI FDSA_DeleteItem(
- LPVOID a,
- DWORD b)
+BOOL WINAPI FDSA_DeleteItem(FDSA_info *info, DWORD where)
{
- FIXME("(%p 0x%08lx) stub\n",
- a, b);
- return 1;
+ TRACE("(%p 0x%08lx)\n", info, where);
+
+ if(where >= info->num_items)
+ return FALSE;
+
+ if(where < info->num_items - 1)
+ {
+ memmove((char*)info->mem + where * info->block_size,
+ (char*)info->mem + (where + 1) * info->block_size,
+ (info->num_items - where - 1) * info->block_size);
+ }
+ memset((char*)info->mem + (info->num_items - 1) * info->block_size,
+ 0, info->block_size);
+ info->num_items--;
+ return TRUE;
}
+
typedef struct {
REFIID refid;
DWORD indx;
return pGetOpenFileNameW(ofn);
}
+/*************************************************************************
+ * @ [SHLWAPI.404]
+ */
+HRESULT WINAPI IUnknown_EnumObjects(LPSHELLFOLDER lpFolder, HWND hwnd, SHCONTF flags, IEnumIDList **ppenum)
+{
+ IPersist *persist;
+ HRESULT hr;
+
+ hr = IShellFolder_QueryInterface(lpFolder, &IID_IPersist, (LPVOID)&persist);
+ if(SUCCEEDED(hr))
+ {
+ CLSID clsid;
+ hr = IPersist_GetClassID(persist, &clsid);
+ if(SUCCEEDED(hr))
+ {
+ if(IsEqualCLSID(&clsid, &CLSID_ShellFSFolder))
+ hr = IShellFolder_EnumObjects(lpFolder, hwnd, flags, ppenum);
+ else
+ hr = E_FAIL;
+ }
+ IPersist_Release(persist);
+ }
+ return hr;
+}
+
/* INTERNAL: Map from HLS color space to RGB */
static WORD WINAPI ConvertHue(int wHue, WORD wMid1, WORD wMid2)
{
return TRUE;
}
+/*************************************************************************
+ * @ [SHLWAPI.425]
+ */
+BOOL WINAPI DeleteMenuWrap(HMENU hmenu, UINT pos, UINT flags)
+{
+ /* FIXME: This should do more than simply call DeleteMenu */
+ FIXME("%p %08x %08x): semi-stub\n", hmenu, pos, flags);
+ return DeleteMenu(hmenu, pos, flags);
+}
+
/*************************************************************************
* @ [SHLWAPI.429]
* FIXME I have no idea what this function does or what its arguments are.
return FALSE;
}
+/*************************************************************************
+ * @ [SHLWAPI.439]
+ */
+HRESULT WINAPI SHLoadRegUIStringW(HKEY hkey, LPCWSTR value, LPWSTR buf, DWORD size)
+{
+ DWORD type, sz = size;
+
+ if(RegQueryValueExW(hkey, value, NULL, &type, (LPBYTE)buf, &sz) != ERROR_SUCCESS)
+ return E_FAIL;
+
+ return SHLoadIndirectString(buf, buf, size, NULL);
+}
+
/*************************************************************************
* @ [SHLWAPI.478]
*
*/
INT WINAPI GetMenuPosFromID(HMENU hMenu, UINT wID)
{
- MENUITEMINFOA mi;
+ MENUITEMINFOW mi;
INT nCount = GetMenuItemCount(hMenu), nIter = 0;
while (nIter < nCount)
{
- mi.wID = 0;
- if (!GetMenuItemInfoA(hMenu, nIter, TRUE, &mi) && mi.wID == wID)
+ mi.cbSize = sizeof(mi);
+ mi.fMask = MIIM_ID;
+ if (GetMenuItemInfoW(hMenu, nIter, TRUE, &mi) && mi.wID == wID)
return nIter;
nIter++;
}
{
DWORD dwRet = ERROR_SUCCESS, dwDummy;
HKEY hSubKey;
- static const char szEmpty[] = { '\0' };
TRACE("(hkey=%p,%s,%s,%ld,%p,%ld)\n", hKey, debugstr_a(lpszSubKey),
debugstr_a(lpszValue), dwType, pvData, cbData);
if (lpszSubKey && *lpszSubKey)
- dwRet = RegCreateKeyExA(hKey, lpszSubKey, 0, (LPSTR)szEmpty,
+ dwRet = RegCreateKeyExA(hKey, lpszSubKey, 0, NULL,
0, KEY_SET_VALUE, NULL, &hSubKey, &dwDummy);
else
hSubKey = hKey;
{
DWORD dwRet = ERROR_SUCCESS, dwDummy;
HKEY hSubKey;
- static const WCHAR szEmpty[] = { '\0' };
TRACE("(hkey=%p,%s,%s,%ld,%p,%ld)\n", hKey, debugstr_w(lpszSubKey),
debugstr_w(lpszValue), dwType, pvData, cbData);
if (lpszSubKey && *lpszSubKey)
- dwRet = RegCreateKeyExW(hKey, lpszSubKey, 0, (LPWSTR)szEmpty,
+ dwRet = RegCreateKeyExW(hKey, lpszSubKey, 0, NULL,
0, KEY_SET_VALUE, NULL, &hSubKey, &dwDummy);
else
hSubKey = hKey;
typedef struct
{
const IStreamVtbl *lpVtbl;
- DWORD ref;
+ LONG ref;
HKEY hKey;
LPBYTE pbBuffer;
DWORD dwLength;
353 stub -noname SHFormatDateTimeA
354 stub -noname SHFormatDateTimeW
355 stdcall -noname IUnknown_EnableModeless(ptr long)
-356 stdcall -noname _CreateAllAccessSecurityAttributes(ptr ptr)
+356 stdcall -noname _CreateAllAccessSecurityAttributes(ptr ptr long)
357 stdcall -noname SHGetNewLinkInfoWrapW(wstr wstr wstr long long)
358 stdcall -noname SHDefExtractIconWrapW(wstr long long ptr ptr long)
359 stdcall @(long long wstr) kernel32.OpenEventW
401 stdcall -noname PageSetupDlgWrapW(ptr)
402 stdcall -noname PrintDlgWrapW(ptr)
403 stdcall -noname GetOpenFileNameWrapW(ptr)
-404 stub -noname IShellFolder_EnumObjects
+404 stdcall -noname IUnknown_EnumObjects(ptr ptr long ptr)
405 stdcall -noname MLBuildResURLA(str ptr long str ptr long)
406 stdcall -noname MLBuildResURLW(wstr ptr long wstr ptr long)
407 stub -noname AssocMakeProgid
422 stdcall -noname _SHGlobalCounterCreateNamedA(str long)
423 stdcall -noname _SHGlobalCounterCreateNamedW(wstr long)
424 stdcall -noname _SHGlobalCounterDecrement(long)
-425 stub -noname DeleteMenuWrap
+425 stdcall -noname DeleteMenuWrap(ptr long long)
426 stub -noname DestroyMenuWrap
427 stub -noname TrackPopupMenuWrap
428 stdcall @(long long long long long ptr) user32.TrackPopupMenuEx
436 stdcall -noname CLSIDFromStringWrap(wstr ptr)
437 stdcall -noname IsOS(long)
438 stub -noname SHLoadRegUIStringA
-439 stub -noname SHLoadRegUIStringW
+439 stdcall -noname SHLoadRegUIStringW(ptr wstr ptr long)
440 stdcall -noname SHGetWebFolderFilePathA(str ptr long)
441 stdcall -noname SHGetWebFolderFilePathW(wstr ptr long)
442 stdcall @(wstr ptr long) kernel32.GetEnvironmentVariableW
454 stub -noname CharLowerNoDBCSW
455 stdcall -noname PathIsValidCharA(long long)
456 stdcall -noname PathIsValidCharW(long long)
-457 stub -noname GetLongPathNameWrapW
-458 stub -noname GetLongPathNameWrapA
+457 stdcall @(wstr ptr long) kernel32.GetLongPathNameW
+458 stdcall @(str ptr long) kernel32.GetLongPathNameA
459 stdcall -noname SHExpandEnvironmentStringsA(str ptr long) kernel32.ExpandEnvironmentStringsA
460 stdcall -noname SHExpandEnvironmentStringsW(wstr ptr long) kernel32.ExpandEnvironmentStringsW
461 stdcall -noname SHGetAppCompatFlags(long)
@ stdcall ColorAdjustLuma(long long long)
@ stdcall ColorHLSToRGB(long long long)
@ stdcall ColorRGBToHLS(long ptr ptr ptr)
-@ stdcall DllGetVersion (ptr) SHLWAPI_DllGetVersion
+@ stdcall -private DllGetVersion(ptr)
@ stdcall GetMenuPosFromID(ptr long)
@ stdcall HashData (ptr long ptr long)
@ stdcall IntlStrEqWorkerA(long str str long) StrIsIntlEqualA
@ stdcall SHGetValueA ( long str str ptr ptr ptr )
@ stdcall SHGetValueW ( long wstr wstr ptr ptr ptr )
@ stdcall SHIsLowMemoryMachine(long)
+@ stdcall SHLoadIndirectString(wstr ptr long ptr)
@ stdcall SHOpenRegStream2A(long str str long)
@ stdcall SHOpenRegStream2W(long wstr str long)
@ stdcall SHOpenRegStreamA(long str str long)
* as pdvi, provided that the size is set correctly.
* Returns version as shlwapi.dll from IE5.01.
*/
-HRESULT WINAPI SHLWAPI_DllGetVersion (DLLVERSIONINFO *pdvi)
+HRESULT WINAPI DllGetVersion (DLLVERSIONINFO *pdvi)
{
DLLVERSIONINFO2 *pdvi2 = (DLLVERSIONINFO2*)pdvi;
SHAnsiToUnicode(lpDst, szBuff, MAX_PATH);
return !strcmpW(lpSrcStr, szBuff);
}
+
+/*************************************************************************
+ * SHLoadIndirectString [SHLWAPI.@]
+ *
+ * If passed a string that begins with a '@' extract the string from the
+ * appropriate resource, otherwise do a straight copy.
+ *
+ */
+HRESULT WINAPI SHLoadIndirectString(LPCWSTR src, LPWSTR dst, UINT dst_len, void **reserved)
+{
+ WCHAR *dllname = NULL;
+ HMODULE hmod = NULL;
+ HRESULT hr = E_FAIL;
+
+ TRACE("(%s %p %08x %p)\n", debugstr_w(src), dst, dst_len, reserved);
+
+ if(src[0] == '@')
+ {
+ WCHAR *index_str;
+ int index;
+
+ dst[0] = 0;
+ dllname = StrDupW(src + 1);
+ index_str = strchrW(dllname, ',');
+
+ if(!index_str) goto end;
+
+ *index_str = 0;
+ index_str++;
+ index = atoiW(index_str);
+
+ hmod = LoadLibraryW(dllname);
+ if(!hmod) goto end;
+
+ if(index < 0)
+ {
+ if(LoadStringW(hmod, -index, dst, dst_len))
+ hr = S_OK;
+ }
+ else
+ FIXME("can't handle non-negative indicies (%d)\n", index);
+ }
+ else
+ {
+ if(dst != src)
+ lstrcpynW(dst, src, dst_len);
+ hr = S_OK;
+ }
+
+ TRACE("returing %s\n", debugstr_w(dst));
+end:
+ if(hmod) FreeLibrary(hmod);
+ HeapFree(GetProcessHeap(), 0, dllname);
+ return hr;
+}
*/
LPSECURITY_ATTRIBUTES WINAPI _CreateAllAccessSecurityAttributes(
LPSECURITY_ATTRIBUTES lpAttr,
- PSECURITY_DESCRIPTOR lpSec)
+ PSECURITY_DESCRIPTOR lpSec,
+ DWORD p3)
{
/* This function is used within SHLWAPI only to create security attributes
* for shell semaphores. */
- TRACE("(%p,%p)\n", lpAttr, lpSec);
+ TRACE("(%p,%p,%08lx)\n", lpAttr, lpSec, p3);
if (!(GetVersion() & 0x80000000)) /* NT */
{
StrCpyNW(szBuff + iPrefixLen, lpszName, iBuffLen - iPrefixLen);
/* Initialise security attributes */
- pSecAttr = _CreateAllAccessSecurityAttributes(&sAttr, &sd);
+ pSecAttr = _CreateAllAccessSecurityAttributes(&sAttr, &sd, 0);
if (!(hRet = CreateSemaphoreW(pSecAttr , iInitial, MAXLONG, szBuff)))
hRet = OpenSemaphoreW(SYNCHRONIZE|SEMAPHORE_MODIFY_STATE, 0, szBuff);
--- /dev/null
+/*** Autogenerated by WIDL 0.1 from msxml.idl - Do not edit ***/
+#include <rpc.h>
+#include <rpcndr.h>
+
+#ifndef __WIDL_MSXML_H
+#define __WIDL_MSXML_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include <unknwn.h>
+#include <wtypes.h>
+#include <objidl.h>
+#include <oaidl.h>
+#ifndef __IXMLElementCollection_FWD_DEFINED__
+#define __IXMLElementCollection_FWD_DEFINED__
+typedef struct IXMLElementCollection IXMLElementCollection;
+#endif
+
+/*****************************************************************************
+ * IXMLElementCollection interface
+ */
+#ifndef __IXMLElementCollection_INTERFACE_DEFINED__
+#define __IXMLElementCollection_INTERFACE_DEFINED__
+
+DEFINE_GUID(IID_IXMLElementCollection, 0x65725580, 0x9b5d, 0x11d0, 0x9b,0xfe, 0x00,0xc0,0x4f,0xc9,0x9c,0x8e);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IXMLElementCollection : public IDispatch
+{
+ virtual HRESULT STDMETHODCALLTYPE put_length(
+ long v) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get_length(
+ long* p) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get__newEnum(
+ IUnknown** ppUnk) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE item(
+ VARIANT var1,
+ VARIANT var2,
+ IDispatch** ppDisp) = 0;
+
+};
+#else
+typedef struct IXMLElementCollectionVtbl IXMLElementCollectionVtbl;
+struct IXMLElementCollection {
+ const IXMLElementCollectionVtbl* lpVtbl;
+};
+struct IXMLElementCollectionVtbl {
+ BEGIN_INTERFACE
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IXMLElementCollection* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IXMLElementCollection* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IXMLElementCollection* This);
+
+ /*** IDispatch methods ***/
+ HRESULT (STDMETHODCALLTYPE *GetTypeInfoCount)(
+ IXMLElementCollection* This,
+ UINT* pctinfo);
+
+ HRESULT (STDMETHODCALLTYPE *GetTypeInfo)(
+ IXMLElementCollection* This,
+ UINT iTInfo,
+ LCID lcid,
+ ITypeInfo** ppTInfo);
+
+ HRESULT (STDMETHODCALLTYPE *GetIDsOfNames)(
+ IXMLElementCollection* This,
+ REFIID riid,
+ LPOLESTR* rgszNames,
+ UINT cNames,
+ LCID lcid,
+ DISPID* rgDispId);
+
+ HRESULT (STDMETHODCALLTYPE *Invoke)(
+ IXMLElementCollection* This,
+ DISPID dispIdMember,
+ REFIID riid,
+ LCID lcid,
+ WORD wFlags,
+ DISPPARAMS* pDispParams,
+ VARIANT* pVarResult,
+ EXCEPINFO* pExcepInfo,
+ UINT* puArgErr);
+
+ /*** IXMLElementCollection methods ***/
+ HRESULT (STDMETHODCALLTYPE *put_length)(
+ IXMLElementCollection* This,
+ long v);
+
+ HRESULT (STDMETHODCALLTYPE *get_length)(
+ IXMLElementCollection* This,
+ long* p);
+
+ HRESULT (STDMETHODCALLTYPE *get__newEnum)(
+ IXMLElementCollection* This,
+ IUnknown** ppUnk);
+
+ HRESULT (STDMETHODCALLTYPE *item)(
+ IXMLElementCollection* This,
+ VARIANT var1,
+ VARIANT var2,
+ IDispatch** ppDisp);
+
+ END_INTERFACE
+};
+
+#ifdef COBJMACROS
+/*** IUnknown methods ***/
+#define IXMLElementCollection_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IXMLElementCollection_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IXMLElementCollection_Release(p) (p)->lpVtbl->Release(p)
+/*** IDispatch methods ***/
+#define IXMLElementCollection_GetTypeInfoCount(p,a) (p)->lpVtbl->GetTypeInfoCount(p,a)
+#define IXMLElementCollection_GetTypeInfo(p,a,b,c) (p)->lpVtbl->GetTypeInfo(p,a,b,c)
+#define IXMLElementCollection_GetIDsOfNames(p,a,b,c,d,e) (p)->lpVtbl->GetIDsOfNames(p,a,b,c,d,e)
+#define IXMLElementCollection_Invoke(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g,h)
+/*** IXMLElementCollection methods ***/
+#define IXMLElementCollection_put_length(p,a) (p)->lpVtbl->put_length(p,a)
+#define IXMLElementCollection_get_length(p,a) (p)->lpVtbl->get_length(p,a)
+#define IXMLElementCollection_get__newEnum(p,a) (p)->lpVtbl->get__newEnum(p,a)
+#define IXMLElementCollection_item(p,a,b,c) (p)->lpVtbl->item(p,a,b,c)
+#endif
+
+#endif
+
+HRESULT CALLBACK IXMLElementCollection_put_length_Proxy(
+ IXMLElementCollection* This,
+ long v);
+void __RPC_STUB IXMLElementCollection_put_length_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLElementCollection_get_length_Proxy(
+ IXMLElementCollection* This,
+ long* p);
+void __RPC_STUB IXMLElementCollection_get_length_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLElementCollection_get__newEnum_Proxy(
+ IXMLElementCollection* This,
+ IUnknown** ppUnk);
+void __RPC_STUB IXMLElementCollection_get__newEnum_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLElementCollection_item_Proxy(
+ IXMLElementCollection* This,
+ VARIANT var1,
+ VARIANT var2,
+ IDispatch** ppDisp);
+void __RPC_STUB IXMLElementCollection_item_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+#endif /* __IXMLElementCollection_INTERFACE_DEFINED__ */
+
+#ifndef __IXMLElement_FWD_DEFINED__
+#define __IXMLElement_FWD_DEFINED__
+typedef struct IXMLElement IXMLElement;
+#endif
+
+/*****************************************************************************
+ * IXMLElement interface
+ */
+#ifndef __IXMLElement_INTERFACE_DEFINED__
+#define __IXMLElement_INTERFACE_DEFINED__
+
+DEFINE_GUID(IID_IXMLElement, 0x3f7f31ac, 0xe15f, 0x11d0, 0x9c,0x25, 0x00,0xc0,0x4f,0xc9,0x9c,0x8e);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IXMLElement : public IDispatch
+{
+ virtual HRESULT STDMETHODCALLTYPE get_tagName(
+ BSTR* p) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE put_tagName(
+ BSTR p) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get_parent(
+ IXMLElement** parent) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE setAttribute(
+ BSTR strPropertyName,
+ VARIANT PropertyValue) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE getAttribute(
+ BSTR strPropertyName,
+ VARIANT* PropertyValue) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE removeAttribute(
+ BSTR strPropertyName) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get_children(
+ IXMLElementCollection** p) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get_type(
+ long* p) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get_text(
+ BSTR* p) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE put_text(
+ BSTR p) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE addChild(
+ IXMLElement* pChildElem,
+ long lIndex,
+ long lreserved) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE removeChild(
+ IXMLElement* pChildElem) = 0;
+
+};
+#else
+typedef struct IXMLElementVtbl IXMLElementVtbl;
+struct IXMLElement {
+ const IXMLElementVtbl* lpVtbl;
+};
+struct IXMLElementVtbl {
+ BEGIN_INTERFACE
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IXMLElement* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IXMLElement* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IXMLElement* This);
+
+ /*** IDispatch methods ***/
+ HRESULT (STDMETHODCALLTYPE *GetTypeInfoCount)(
+ IXMLElement* This,
+ UINT* pctinfo);
+
+ HRESULT (STDMETHODCALLTYPE *GetTypeInfo)(
+ IXMLElement* This,
+ UINT iTInfo,
+ LCID lcid,
+ ITypeInfo** ppTInfo);
+
+ HRESULT (STDMETHODCALLTYPE *GetIDsOfNames)(
+ IXMLElement* This,
+ REFIID riid,
+ LPOLESTR* rgszNames,
+ UINT cNames,
+ LCID lcid,
+ DISPID* rgDispId);
+
+ HRESULT (STDMETHODCALLTYPE *Invoke)(
+ IXMLElement* This,
+ DISPID dispIdMember,
+ REFIID riid,
+ LCID lcid,
+ WORD wFlags,
+ DISPPARAMS* pDispParams,
+ VARIANT* pVarResult,
+ EXCEPINFO* pExcepInfo,
+ UINT* puArgErr);
+
+ /*** IXMLElement methods ***/
+ HRESULT (STDMETHODCALLTYPE *get_tagName)(
+ IXMLElement* This,
+ BSTR* p);
+
+ HRESULT (STDMETHODCALLTYPE *put_tagName)(
+ IXMLElement* This,
+ BSTR p);
+
+ HRESULT (STDMETHODCALLTYPE *get_parent)(
+ IXMLElement* This,
+ IXMLElement** parent);
+
+ HRESULT (STDMETHODCALLTYPE *setAttribute)(
+ IXMLElement* This,
+ BSTR strPropertyName,
+ VARIANT PropertyValue);
+
+ HRESULT (STDMETHODCALLTYPE *getAttribute)(
+ IXMLElement* This,
+ BSTR strPropertyName,
+ VARIANT* PropertyValue);
+
+ HRESULT (STDMETHODCALLTYPE *removeAttribute)(
+ IXMLElement* This,
+ BSTR strPropertyName);
+
+ HRESULT (STDMETHODCALLTYPE *get_children)(
+ IXMLElement* This,
+ IXMLElementCollection** p);
+
+ HRESULT (STDMETHODCALLTYPE *get_type)(
+ IXMLElement* This,
+ long* p);
+
+ HRESULT (STDMETHODCALLTYPE *get_text)(
+ IXMLElement* This,
+ BSTR* p);
+
+ HRESULT (STDMETHODCALLTYPE *put_text)(
+ IXMLElement* This,
+ BSTR p);
+
+ HRESULT (STDMETHODCALLTYPE *addChild)(
+ IXMLElement* This,
+ IXMLElement* pChildElem,
+ long lIndex,
+ long lreserved);
+
+ HRESULT (STDMETHODCALLTYPE *removeChild)(
+ IXMLElement* This,
+ IXMLElement* pChildElem);
+
+ END_INTERFACE
+};
+
+#ifdef COBJMACROS
+/*** IUnknown methods ***/
+#define IXMLElement_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IXMLElement_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IXMLElement_Release(p) (p)->lpVtbl->Release(p)
+/*** IDispatch methods ***/
+#define IXMLElement_GetTypeInfoCount(p,a) (p)->lpVtbl->GetTypeInfoCount(p,a)
+#define IXMLElement_GetTypeInfo(p,a,b,c) (p)->lpVtbl->GetTypeInfo(p,a,b,c)
+#define IXMLElement_GetIDsOfNames(p,a,b,c,d,e) (p)->lpVtbl->GetIDsOfNames(p,a,b,c,d,e)
+#define IXMLElement_Invoke(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g,h)
+/*** IXMLElement methods ***/
+#define IXMLElement_get_tagName(p,a) (p)->lpVtbl->get_tagName(p,a)
+#define IXMLElement_put_tagName(p,a) (p)->lpVtbl->put_tagName(p,a)
+#define IXMLElement_get_parent(p,a) (p)->lpVtbl->get_parent(p,a)
+#define IXMLElement_setAttribute(p,a,b) (p)->lpVtbl->setAttribute(p,a,b)
+#define IXMLElement_getAttribute(p,a,b) (p)->lpVtbl->getAttribute(p,a,b)
+#define IXMLElement_removeAttribute(p,a) (p)->lpVtbl->removeAttribute(p,a)
+#define IXMLElement_get_children(p,a) (p)->lpVtbl->get_children(p,a)
+#define IXMLElement_get_type(p,a) (p)->lpVtbl->get_type(p,a)
+#define IXMLElement_get_text(p,a) (p)->lpVtbl->get_text(p,a)
+#define IXMLElement_put_text(p,a) (p)->lpVtbl->put_text(p,a)
+#define IXMLElement_addChild(p,a,b,c) (p)->lpVtbl->addChild(p,a,b,c)
+#define IXMLElement_removeChild(p,a) (p)->lpVtbl->removeChild(p,a)
+#endif
+
+#endif
+
+HRESULT CALLBACK IXMLElement_get_tagName_Proxy(
+ IXMLElement* This,
+ BSTR* p);
+void __RPC_STUB IXMLElement_get_tagName_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLElement_put_tagName_Proxy(
+ IXMLElement* This,
+ BSTR p);
+void __RPC_STUB IXMLElement_put_tagName_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLElement_get_parent_Proxy(
+ IXMLElement* This,
+ IXMLElement** parent);
+void __RPC_STUB IXMLElement_get_parent_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLElement_setAttribute_Proxy(
+ IXMLElement* This,
+ BSTR strPropertyName,
+ VARIANT PropertyValue);
+void __RPC_STUB IXMLElement_setAttribute_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLElement_getAttribute_Proxy(
+ IXMLElement* This,
+ BSTR strPropertyName,
+ VARIANT* PropertyValue);
+void __RPC_STUB IXMLElement_getAttribute_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLElement_removeAttribute_Proxy(
+ IXMLElement* This,
+ BSTR strPropertyName);
+void __RPC_STUB IXMLElement_removeAttribute_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLElement_get_children_Proxy(
+ IXMLElement* This,
+ IXMLElementCollection** p);
+void __RPC_STUB IXMLElement_get_children_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLElement_get_type_Proxy(
+ IXMLElement* This,
+ long* p);
+void __RPC_STUB IXMLElement_get_type_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLElement_get_text_Proxy(
+ IXMLElement* This,
+ BSTR* p);
+void __RPC_STUB IXMLElement_get_text_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLElement_put_text_Proxy(
+ IXMLElement* This,
+ BSTR p);
+void __RPC_STUB IXMLElement_put_text_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLElement_addChild_Proxy(
+ IXMLElement* This,
+ IXMLElement* pChildElem,
+ long lIndex,
+ long lreserved);
+void __RPC_STUB IXMLElement_addChild_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLElement_removeChild_Proxy(
+ IXMLElement* This,
+ IXMLElement* pChildElem);
+void __RPC_STUB IXMLElement_removeChild_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+#endif /* __IXMLElement_INTERFACE_DEFINED__ */
+
+#ifndef __IXMLDocument_FWD_DEFINED__
+#define __IXMLDocument_FWD_DEFINED__
+typedef struct IXMLDocument IXMLDocument;
+#endif
+
+/*****************************************************************************
+ * IXMLDocument interface
+ */
+#ifndef __IXMLDocument_INTERFACE_DEFINED__
+#define __IXMLDocument_INTERFACE_DEFINED__
+
+DEFINE_GUID(IID_IXMLDocument, 0xf52e2b61, 0x18a1, 0x11d1, 0xb1,0x05, 0x00,0x80,0x5f,0x49,0x91,0x6b);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IXMLDocument : public IDispatch
+{
+ virtual HRESULT STDMETHODCALLTYPE get_root(
+ IXMLElement** p) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get_fileSize(
+ BSTR* p) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get_fileModifiedDate(
+ BSTR* p) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get_fileUpdatedDate(
+ BSTR* p) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get_URL(
+ BSTR* p) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE put_URL(
+ BSTR p) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get_mimeType(
+ BSTR* p) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get_readyState(
+ long* p) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get_charset(
+ BSTR* p) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE put_charset(
+ BSTR p) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get_version(
+ BSTR* p) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get_doctype(
+ BSTR* p) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get_dtdURl(
+ BSTR* p) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE createElement(
+ VARIANT vType,
+ VARIANT var1,
+ IXMLElement** ppElem) = 0;
+
+};
+#else
+typedef struct IXMLDocumentVtbl IXMLDocumentVtbl;
+struct IXMLDocument {
+ const IXMLDocumentVtbl* lpVtbl;
+};
+struct IXMLDocumentVtbl {
+ BEGIN_INTERFACE
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IXMLDocument* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IXMLDocument* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IXMLDocument* This);
+
+ /*** IDispatch methods ***/
+ HRESULT (STDMETHODCALLTYPE *GetTypeInfoCount)(
+ IXMLDocument* This,
+ UINT* pctinfo);
+
+ HRESULT (STDMETHODCALLTYPE *GetTypeInfo)(
+ IXMLDocument* This,
+ UINT iTInfo,
+ LCID lcid,
+ ITypeInfo** ppTInfo);
+
+ HRESULT (STDMETHODCALLTYPE *GetIDsOfNames)(
+ IXMLDocument* This,
+ REFIID riid,
+ LPOLESTR* rgszNames,
+ UINT cNames,
+ LCID lcid,
+ DISPID* rgDispId);
+
+ HRESULT (STDMETHODCALLTYPE *Invoke)(
+ IXMLDocument* This,
+ DISPID dispIdMember,
+ REFIID riid,
+ LCID lcid,
+ WORD wFlags,
+ DISPPARAMS* pDispParams,
+ VARIANT* pVarResult,
+ EXCEPINFO* pExcepInfo,
+ UINT* puArgErr);
+
+ /*** IXMLDocument methods ***/
+ HRESULT (STDMETHODCALLTYPE *get_root)(
+ IXMLDocument* This,
+ IXMLElement** p);
+
+ HRESULT (STDMETHODCALLTYPE *get_fileSize)(
+ IXMLDocument* This,
+ BSTR* p);
+
+ HRESULT (STDMETHODCALLTYPE *get_fileModifiedDate)(
+ IXMLDocument* This,
+ BSTR* p);
+
+ HRESULT (STDMETHODCALLTYPE *get_fileUpdatedDate)(
+ IXMLDocument* This,
+ BSTR* p);
+
+ HRESULT (STDMETHODCALLTYPE *get_URL)(
+ IXMLDocument* This,
+ BSTR* p);
+
+ HRESULT (STDMETHODCALLTYPE *put_URL)(
+ IXMLDocument* This,
+ BSTR p);
+
+ HRESULT (STDMETHODCALLTYPE *get_mimeType)(
+ IXMLDocument* This,
+ BSTR* p);
+
+ HRESULT (STDMETHODCALLTYPE *get_readyState)(
+ IXMLDocument* This,
+ long* p);
+
+ HRESULT (STDMETHODCALLTYPE *get_charset)(
+ IXMLDocument* This,
+ BSTR* p);
+
+ HRESULT (STDMETHODCALLTYPE *put_charset)(
+ IXMLDocument* This,
+ BSTR p);
+
+ HRESULT (STDMETHODCALLTYPE *get_version)(
+ IXMLDocument* This,
+ BSTR* p);
+
+ HRESULT (STDMETHODCALLTYPE *get_doctype)(
+ IXMLDocument* This,
+ BSTR* p);
+
+ HRESULT (STDMETHODCALLTYPE *get_dtdURl)(
+ IXMLDocument* This,
+ BSTR* p);
+
+ HRESULT (STDMETHODCALLTYPE *createElement)(
+ IXMLDocument* This,
+ VARIANT vType,
+ VARIANT var1,
+ IXMLElement** ppElem);
+
+ END_INTERFACE
+};
+
+#ifdef COBJMACROS
+/*** IUnknown methods ***/
+#define IXMLDocument_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IXMLDocument_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IXMLDocument_Release(p) (p)->lpVtbl->Release(p)
+/*** IDispatch methods ***/
+#define IXMLDocument_GetTypeInfoCount(p,a) (p)->lpVtbl->GetTypeInfoCount(p,a)
+#define IXMLDocument_GetTypeInfo(p,a,b,c) (p)->lpVtbl->GetTypeInfo(p,a,b,c)
+#define IXMLDocument_GetIDsOfNames(p,a,b,c,d,e) (p)->lpVtbl->GetIDsOfNames(p,a,b,c,d,e)
+#define IXMLDocument_Invoke(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g,h)
+/*** IXMLDocument methods ***/
+#define IXMLDocument_get_root(p,a) (p)->lpVtbl->get_root(p,a)
+#define IXMLDocument_get_fileSize(p,a) (p)->lpVtbl->get_fileSize(p,a)
+#define IXMLDocument_get_fileModifiedDate(p,a) (p)->lpVtbl->get_fileModifiedDate(p,a)
+#define IXMLDocument_get_fileUpdatedDate(p,a) (p)->lpVtbl->get_fileUpdatedDate(p,a)
+#define IXMLDocument_get_URL(p,a) (p)->lpVtbl->get_URL(p,a)
+#define IXMLDocument_put_URL(p,a) (p)->lpVtbl->put_URL(p,a)
+#define IXMLDocument_get_mimeType(p,a) (p)->lpVtbl->get_mimeType(p,a)
+#define IXMLDocument_get_readyState(p,a) (p)->lpVtbl->get_readyState(p,a)
+#define IXMLDocument_get_charset(p,a) (p)->lpVtbl->get_charset(p,a)
+#define IXMLDocument_put_charset(p,a) (p)->lpVtbl->put_charset(p,a)
+#define IXMLDocument_get_version(p,a) (p)->lpVtbl->get_version(p,a)
+#define IXMLDocument_get_doctype(p,a) (p)->lpVtbl->get_doctype(p,a)
+#define IXMLDocument_get_dtdURl(p,a) (p)->lpVtbl->get_dtdURl(p,a)
+#define IXMLDocument_createElement(p,a,b,c) (p)->lpVtbl->createElement(p,a,b,c)
+#endif
+
+#endif
+
+HRESULT CALLBACK IXMLDocument_get_root_Proxy(
+ IXMLDocument* This,
+ IXMLElement** p);
+void __RPC_STUB IXMLDocument_get_root_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLDocument_get_fileSize_Proxy(
+ IXMLDocument* This,
+ BSTR* p);
+void __RPC_STUB IXMLDocument_get_fileSize_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLDocument_get_fileModifiedDate_Proxy(
+ IXMLDocument* This,
+ BSTR* p);
+void __RPC_STUB IXMLDocument_get_fileModifiedDate_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLDocument_get_fileUpdatedDate_Proxy(
+ IXMLDocument* This,
+ BSTR* p);
+void __RPC_STUB IXMLDocument_get_fileUpdatedDate_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLDocument_get_URL_Proxy(
+ IXMLDocument* This,
+ BSTR* p);
+void __RPC_STUB IXMLDocument_get_URL_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLDocument_put_URL_Proxy(
+ IXMLDocument* This,
+ BSTR p);
+void __RPC_STUB IXMLDocument_put_URL_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLDocument_get_mimeType_Proxy(
+ IXMLDocument* This,
+ BSTR* p);
+void __RPC_STUB IXMLDocument_get_mimeType_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLDocument_get_readyState_Proxy(
+ IXMLDocument* This,
+ long* p);
+void __RPC_STUB IXMLDocument_get_readyState_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLDocument_get_charset_Proxy(
+ IXMLDocument* This,
+ BSTR* p);
+void __RPC_STUB IXMLDocument_get_charset_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLDocument_put_charset_Proxy(
+ IXMLDocument* This,
+ BSTR p);
+void __RPC_STUB IXMLDocument_put_charset_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLDocument_get_version_Proxy(
+ IXMLDocument* This,
+ BSTR* p);
+void __RPC_STUB IXMLDocument_get_version_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLDocument_get_doctype_Proxy(
+ IXMLDocument* This,
+ BSTR* p);
+void __RPC_STUB IXMLDocument_get_doctype_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLDocument_get_dtdURl_Proxy(
+ IXMLDocument* This,
+ BSTR* p);
+void __RPC_STUB IXMLDocument_get_dtdURl_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLDocument_createElement_Proxy(
+ IXMLDocument* This,
+ VARIANT vType,
+ VARIANT var1,
+ IXMLElement** ppElem);
+void __RPC_STUB IXMLDocument_createElement_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+#endif /* __IXMLDocument_INTERFACE_DEFINED__ */
+
+#ifndef __IXMLElement2_FWD_DEFINED__
+#define __IXMLElement2_FWD_DEFINED__
+typedef struct IXMLElement2 IXMLElement2;
+#endif
+
+/*****************************************************************************
+ * IXMLElement2 interface
+ */
+#ifndef __IXMLElement2_INTERFACE_DEFINED__
+#define __IXMLElement2_INTERFACE_DEFINED__
+
+DEFINE_GUID(IID_IXMLElement2, 0x2b8de2ff, 0x8d2d, 0x11d1, 0xb2,0xfc, 0x00,0xc0,0x4f,0xd9,0x15,0xa9);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IXMLElement2 : public IDispatch
+{
+ virtual HRESULT STDMETHODCALLTYPE get_tagName(
+ BSTR* p) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE put_tagName(
+ BSTR p) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get_parent(
+ IXMLElement2** ppParent) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE setAttribute(
+ BSTR strPropertyName,
+ VARIANT PropertyValue) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE getAttribute(
+ BSTR strPropertyName,
+ VARIANT* PropertyValue) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE removeAttribute(
+ BSTR strPropertyName) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get_children(
+ IXMLElementCollection** pp) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get_type(
+ long* plType) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get_text(
+ BSTR* p) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE put_text(
+ BSTR p) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE addChild(
+ IXMLElement2* pChildElem,
+ long lIndex,
+ long lReserved) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE removeChild(
+ IXMLElement2* pChildElem) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get_attributes(
+ IXMLElementCollection** pp) = 0;
+
+};
+#else
+typedef struct IXMLElement2Vtbl IXMLElement2Vtbl;
+struct IXMLElement2 {
+ const IXMLElement2Vtbl* lpVtbl;
+};
+struct IXMLElement2Vtbl {
+ BEGIN_INTERFACE
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IXMLElement2* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IXMLElement2* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IXMLElement2* This);
+
+ /*** IDispatch methods ***/
+ HRESULT (STDMETHODCALLTYPE *GetTypeInfoCount)(
+ IXMLElement2* This,
+ UINT* pctinfo);
+
+ HRESULT (STDMETHODCALLTYPE *GetTypeInfo)(
+ IXMLElement2* This,
+ UINT iTInfo,
+ LCID lcid,
+ ITypeInfo** ppTInfo);
+
+ HRESULT (STDMETHODCALLTYPE *GetIDsOfNames)(
+ IXMLElement2* This,
+ REFIID riid,
+ LPOLESTR* rgszNames,
+ UINT cNames,
+ LCID lcid,
+ DISPID* rgDispId);
+
+ HRESULT (STDMETHODCALLTYPE *Invoke)(
+ IXMLElement2* This,
+ DISPID dispIdMember,
+ REFIID riid,
+ LCID lcid,
+ WORD wFlags,
+ DISPPARAMS* pDispParams,
+ VARIANT* pVarResult,
+ EXCEPINFO* pExcepInfo,
+ UINT* puArgErr);
+
+ /*** IXMLElement2 methods ***/
+ HRESULT (STDMETHODCALLTYPE *get_tagName)(
+ IXMLElement2* This,
+ BSTR* p);
+
+ HRESULT (STDMETHODCALLTYPE *put_tagName)(
+ IXMLElement2* This,
+ BSTR p);
+
+ HRESULT (STDMETHODCALLTYPE *get_parent)(
+ IXMLElement2* This,
+ IXMLElement2** ppParent);
+
+ HRESULT (STDMETHODCALLTYPE *setAttribute)(
+ IXMLElement2* This,
+ BSTR strPropertyName,
+ VARIANT PropertyValue);
+
+ HRESULT (STDMETHODCALLTYPE *getAttribute)(
+ IXMLElement2* This,
+ BSTR strPropertyName,
+ VARIANT* PropertyValue);
+
+ HRESULT (STDMETHODCALLTYPE *removeAttribute)(
+ IXMLElement2* This,
+ BSTR strPropertyName);
+
+ HRESULT (STDMETHODCALLTYPE *get_children)(
+ IXMLElement2* This,
+ IXMLElementCollection** pp);
+
+ HRESULT (STDMETHODCALLTYPE *get_type)(
+ IXMLElement2* This,
+ long* plType);
+
+ HRESULT (STDMETHODCALLTYPE *get_text)(
+ IXMLElement2* This,
+ BSTR* p);
+
+ HRESULT (STDMETHODCALLTYPE *put_text)(
+ IXMLElement2* This,
+ BSTR p);
+
+ HRESULT (STDMETHODCALLTYPE *addChild)(
+ IXMLElement2* This,
+ IXMLElement2* pChildElem,
+ long lIndex,
+ long lReserved);
+
+ HRESULT (STDMETHODCALLTYPE *removeChild)(
+ IXMLElement2* This,
+ IXMLElement2* pChildElem);
+
+ HRESULT (STDMETHODCALLTYPE *get_attributes)(
+ IXMLElement2* This,
+ IXMLElementCollection** pp);
+
+ END_INTERFACE
+};
+
+#ifdef COBJMACROS
+/*** IUnknown methods ***/
+#define IXMLElement2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IXMLElement2_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IXMLElement2_Release(p) (p)->lpVtbl->Release(p)
+/*** IDispatch methods ***/
+#define IXMLElement2_GetTypeInfoCount(p,a) (p)->lpVtbl->GetTypeInfoCount(p,a)
+#define IXMLElement2_GetTypeInfo(p,a,b,c) (p)->lpVtbl->GetTypeInfo(p,a,b,c)
+#define IXMLElement2_GetIDsOfNames(p,a,b,c,d,e) (p)->lpVtbl->GetIDsOfNames(p,a,b,c,d,e)
+#define IXMLElement2_Invoke(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g,h)
+/*** IXMLElement2 methods ***/
+#define IXMLElement2_get_tagName(p,a) (p)->lpVtbl->get_tagName(p,a)
+#define IXMLElement2_put_tagName(p,a) (p)->lpVtbl->put_tagName(p,a)
+#define IXMLElement2_get_parent(p,a) (p)->lpVtbl->get_parent(p,a)
+#define IXMLElement2_setAttribute(p,a,b) (p)->lpVtbl->setAttribute(p,a,b)
+#define IXMLElement2_getAttribute(p,a,b) (p)->lpVtbl->getAttribute(p,a,b)
+#define IXMLElement2_removeAttribute(p,a) (p)->lpVtbl->removeAttribute(p,a)
+#define IXMLElement2_get_children(p,a) (p)->lpVtbl->get_children(p,a)
+#define IXMLElement2_get_type(p,a) (p)->lpVtbl->get_type(p,a)
+#define IXMLElement2_get_text(p,a) (p)->lpVtbl->get_text(p,a)
+#define IXMLElement2_put_text(p,a) (p)->lpVtbl->put_text(p,a)
+#define IXMLElement2_addChild(p,a,b,c) (p)->lpVtbl->addChild(p,a,b,c)
+#define IXMLElement2_removeChild(p,a) (p)->lpVtbl->removeChild(p,a)
+#define IXMLElement2_get_attributes(p,a) (p)->lpVtbl->get_attributes(p,a)
+#endif
+
+#endif
+
+HRESULT CALLBACK IXMLElement2_get_tagName_Proxy(
+ IXMLElement2* This,
+ BSTR* p);
+void __RPC_STUB IXMLElement2_get_tagName_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLElement2_put_tagName_Proxy(
+ IXMLElement2* This,
+ BSTR p);
+void __RPC_STUB IXMLElement2_put_tagName_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLElement2_get_parent_Proxy(
+ IXMLElement2* This,
+ IXMLElement2** ppParent);
+void __RPC_STUB IXMLElement2_get_parent_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLElement2_setAttribute_Proxy(
+ IXMLElement2* This,
+ BSTR strPropertyName,
+ VARIANT PropertyValue);
+void __RPC_STUB IXMLElement2_setAttribute_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLElement2_getAttribute_Proxy(
+ IXMLElement2* This,
+ BSTR strPropertyName,
+ VARIANT* PropertyValue);
+void __RPC_STUB IXMLElement2_getAttribute_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLElement2_removeAttribute_Proxy(
+ IXMLElement2* This,
+ BSTR strPropertyName);
+void __RPC_STUB IXMLElement2_removeAttribute_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLElement2_get_children_Proxy(
+ IXMLElement2* This,
+ IXMLElementCollection** pp);
+void __RPC_STUB IXMLElement2_get_children_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLElement2_get_type_Proxy(
+ IXMLElement2* This,
+ long* plType);
+void __RPC_STUB IXMLElement2_get_type_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLElement2_get_text_Proxy(
+ IXMLElement2* This,
+ BSTR* p);
+void __RPC_STUB IXMLElement2_get_text_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLElement2_put_text_Proxy(
+ IXMLElement2* This,
+ BSTR p);
+void __RPC_STUB IXMLElement2_put_text_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLElement2_addChild_Proxy(
+ IXMLElement2* This,
+ IXMLElement2* pChildElem,
+ long lIndex,
+ long lReserved);
+void __RPC_STUB IXMLElement2_addChild_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLElement2_removeChild_Proxy(
+ IXMLElement2* This,
+ IXMLElement2* pChildElem);
+void __RPC_STUB IXMLElement2_removeChild_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLElement2_get_attributes_Proxy(
+ IXMLElement2* This,
+ IXMLElementCollection** pp);
+void __RPC_STUB IXMLElement2_get_attributes_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+#endif /* __IXMLElement2_INTERFACE_DEFINED__ */
+
+#ifndef __IXMLDocument2_FWD_DEFINED__
+#define __IXMLDocument2_FWD_DEFINED__
+typedef struct IXMLDocument2 IXMLDocument2;
+#endif
+
+/*****************************************************************************
+ * IXMLDocument2 interface
+ */
+#ifndef __IXMLDocument2_INTERFACE_DEFINED__
+#define __IXMLDocument2_INTERFACE_DEFINED__
+
+DEFINE_GUID(IID_IXMLDocument2, 0x2b8de2fe, 0x8d2d, 0x11d1, 0xb2,0xfc, 0x00,0xc0,0x4f,0xd9,0x15,0xa9);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IXMLDocument2 : public IDispatch
+{
+ virtual HRESULT STDMETHODCALLTYPE get_root(
+ IXMLElement2** p) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get_fileSize(
+ BSTR* p) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get_fileModifiedDate(
+ BSTR* p) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get_fileUpdatedDate(
+ BSTR* p) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get_URL(
+ BSTR* p) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE put_URL(
+ BSTR p) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get_mimeType(
+ BSTR* p) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get_readyState(
+ long* pl) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get_charset(
+ BSTR* p) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE put_charset(
+ BSTR p) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get_version(
+ BSTR* p) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get_doctype(
+ BSTR* p) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get_dtdURL(
+ BSTR* p) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE createElement(
+ VARIANT vType,
+ VARIANT var,
+ IXMLElement2** ppElem) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get_async(
+ VARIANT_BOOL* pf) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE put_async(
+ VARIANT_BOOL f) = 0;
+
+};
+#else
+typedef struct IXMLDocument2Vtbl IXMLDocument2Vtbl;
+struct IXMLDocument2 {
+ const IXMLDocument2Vtbl* lpVtbl;
+};
+struct IXMLDocument2Vtbl {
+ BEGIN_INTERFACE
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IXMLDocument2* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IXMLDocument2* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IXMLDocument2* This);
+
+ /*** IDispatch methods ***/
+ HRESULT (STDMETHODCALLTYPE *GetTypeInfoCount)(
+ IXMLDocument2* This,
+ UINT* pctinfo);
+
+ HRESULT (STDMETHODCALLTYPE *GetTypeInfo)(
+ IXMLDocument2* This,
+ UINT iTInfo,
+ LCID lcid,
+ ITypeInfo** ppTInfo);
+
+ HRESULT (STDMETHODCALLTYPE *GetIDsOfNames)(
+ IXMLDocument2* This,
+ REFIID riid,
+ LPOLESTR* rgszNames,
+ UINT cNames,
+ LCID lcid,
+ DISPID* rgDispId);
+
+ HRESULT (STDMETHODCALLTYPE *Invoke)(
+ IXMLDocument2* This,
+ DISPID dispIdMember,
+ REFIID riid,
+ LCID lcid,
+ WORD wFlags,
+ DISPPARAMS* pDispParams,
+ VARIANT* pVarResult,
+ EXCEPINFO* pExcepInfo,
+ UINT* puArgErr);
+
+ /*** IXMLDocument2 methods ***/
+ HRESULT (STDMETHODCALLTYPE *get_root)(
+ IXMLDocument2* This,
+ IXMLElement2** p);
+
+ HRESULT (STDMETHODCALLTYPE *get_fileSize)(
+ IXMLDocument2* This,
+ BSTR* p);
+
+ HRESULT (STDMETHODCALLTYPE *get_fileModifiedDate)(
+ IXMLDocument2* This,
+ BSTR* p);
+
+ HRESULT (STDMETHODCALLTYPE *get_fileUpdatedDate)(
+ IXMLDocument2* This,
+ BSTR* p);
+
+ HRESULT (STDMETHODCALLTYPE *get_URL)(
+ IXMLDocument2* This,
+ BSTR* p);
+
+ HRESULT (STDMETHODCALLTYPE *put_URL)(
+ IXMLDocument2* This,
+ BSTR p);
+
+ HRESULT (STDMETHODCALLTYPE *get_mimeType)(
+ IXMLDocument2* This,
+ BSTR* p);
+
+ HRESULT (STDMETHODCALLTYPE *get_readyState)(
+ IXMLDocument2* This,
+ long* pl);
+
+ HRESULT (STDMETHODCALLTYPE *get_charset)(
+ IXMLDocument2* This,
+ BSTR* p);
+
+ HRESULT (STDMETHODCALLTYPE *put_charset)(
+ IXMLDocument2* This,
+ BSTR p);
+
+ HRESULT (STDMETHODCALLTYPE *get_version)(
+ IXMLDocument2* This,
+ BSTR* p);
+
+ HRESULT (STDMETHODCALLTYPE *get_doctype)(
+ IXMLDocument2* This,
+ BSTR* p);
+
+ HRESULT (STDMETHODCALLTYPE *get_dtdURL)(
+ IXMLDocument2* This,
+ BSTR* p);
+
+ HRESULT (STDMETHODCALLTYPE *createElement)(
+ IXMLDocument2* This,
+ VARIANT vType,
+ VARIANT var,
+ IXMLElement2** ppElem);
+
+ HRESULT (STDMETHODCALLTYPE *get_async)(
+ IXMLDocument2* This,
+ VARIANT_BOOL* pf);
+
+ HRESULT (STDMETHODCALLTYPE *put_async)(
+ IXMLDocument2* This,
+ VARIANT_BOOL f);
+
+ END_INTERFACE
+};
+
+#ifdef COBJMACROS
+/*** IUnknown methods ***/
+#define IXMLDocument2_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IXMLDocument2_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IXMLDocument2_Release(p) (p)->lpVtbl->Release(p)
+/*** IDispatch methods ***/
+#define IXMLDocument2_GetTypeInfoCount(p,a) (p)->lpVtbl->GetTypeInfoCount(p,a)
+#define IXMLDocument2_GetTypeInfo(p,a,b,c) (p)->lpVtbl->GetTypeInfo(p,a,b,c)
+#define IXMLDocument2_GetIDsOfNames(p,a,b,c,d,e) (p)->lpVtbl->GetIDsOfNames(p,a,b,c,d,e)
+#define IXMLDocument2_Invoke(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g,h)
+/*** IXMLDocument2 methods ***/
+#define IXMLDocument2_get_root(p,a) (p)->lpVtbl->get_root(p,a)
+#define IXMLDocument2_get_fileSize(p,a) (p)->lpVtbl->get_fileSize(p,a)
+#define IXMLDocument2_get_fileModifiedDate(p,a) (p)->lpVtbl->get_fileModifiedDate(p,a)
+#define IXMLDocument2_get_fileUpdatedDate(p,a) (p)->lpVtbl->get_fileUpdatedDate(p,a)
+#define IXMLDocument2_get_URL(p,a) (p)->lpVtbl->get_URL(p,a)
+#define IXMLDocument2_put_URL(p,a) (p)->lpVtbl->put_URL(p,a)
+#define IXMLDocument2_get_mimeType(p,a) (p)->lpVtbl->get_mimeType(p,a)
+#define IXMLDocument2_get_readyState(p,a) (p)->lpVtbl->get_readyState(p,a)
+#define IXMLDocument2_get_charset(p,a) (p)->lpVtbl->get_charset(p,a)
+#define IXMLDocument2_put_charset(p,a) (p)->lpVtbl->put_charset(p,a)
+#define IXMLDocument2_get_version(p,a) (p)->lpVtbl->get_version(p,a)
+#define IXMLDocument2_get_doctype(p,a) (p)->lpVtbl->get_doctype(p,a)
+#define IXMLDocument2_get_dtdURL(p,a) (p)->lpVtbl->get_dtdURL(p,a)
+#define IXMLDocument2_createElement(p,a,b,c) (p)->lpVtbl->createElement(p,a,b,c)
+#define IXMLDocument2_get_async(p,a) (p)->lpVtbl->get_async(p,a)
+#define IXMLDocument2_put_async(p,a) (p)->lpVtbl->put_async(p,a)
+#endif
+
+#endif
+
+HRESULT CALLBACK IXMLDocument2_get_root_Proxy(
+ IXMLDocument2* This,
+ IXMLElement2** p);
+void __RPC_STUB IXMLDocument2_get_root_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLDocument2_get_fileSize_Proxy(
+ IXMLDocument2* This,
+ BSTR* p);
+void __RPC_STUB IXMLDocument2_get_fileSize_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLDocument2_get_fileModifiedDate_Proxy(
+ IXMLDocument2* This,
+ BSTR* p);
+void __RPC_STUB IXMLDocument2_get_fileModifiedDate_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLDocument2_get_fileUpdatedDate_Proxy(
+ IXMLDocument2* This,
+ BSTR* p);
+void __RPC_STUB IXMLDocument2_get_fileUpdatedDate_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLDocument2_get_URL_Proxy(
+ IXMLDocument2* This,
+ BSTR* p);
+void __RPC_STUB IXMLDocument2_get_URL_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLDocument2_put_URL_Proxy(
+ IXMLDocument2* This,
+ BSTR p);
+void __RPC_STUB IXMLDocument2_put_URL_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLDocument2_get_mimeType_Proxy(
+ IXMLDocument2* This,
+ BSTR* p);
+void __RPC_STUB IXMLDocument2_get_mimeType_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLDocument2_get_readyState_Proxy(
+ IXMLDocument2* This,
+ long* pl);
+void __RPC_STUB IXMLDocument2_get_readyState_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLDocument2_get_charset_Proxy(
+ IXMLDocument2* This,
+ BSTR* p);
+void __RPC_STUB IXMLDocument2_get_charset_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLDocument2_put_charset_Proxy(
+ IXMLDocument2* This,
+ BSTR p);
+void __RPC_STUB IXMLDocument2_put_charset_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLDocument2_get_version_Proxy(
+ IXMLDocument2* This,
+ BSTR* p);
+void __RPC_STUB IXMLDocument2_get_version_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLDocument2_get_doctype_Proxy(
+ IXMLDocument2* This,
+ BSTR* p);
+void __RPC_STUB IXMLDocument2_get_doctype_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLDocument2_get_dtdURL_Proxy(
+ IXMLDocument2* This,
+ BSTR* p);
+void __RPC_STUB IXMLDocument2_get_dtdURL_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLDocument2_createElement_Proxy(
+ IXMLDocument2* This,
+ VARIANT vType,
+ VARIANT var,
+ IXMLElement2** ppElem);
+void __RPC_STUB IXMLDocument2_createElement_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLDocument2_get_async_Proxy(
+ IXMLDocument2* This,
+ VARIANT_BOOL* pf);
+void __RPC_STUB IXMLDocument2_get_async_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLDocument2_put_async_Proxy(
+ IXMLDocument2* This,
+ VARIANT_BOOL f);
+void __RPC_STUB IXMLDocument2_put_async_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+#endif /* __IXMLDocument2_INTERFACE_DEFINED__ */
+
+typedef enum tagXMLEMEM_TYPE {
+ XMLELEMTYPE_ELEMENT = 0,
+ XMLELEMTYPE_TEXT = 1,
+ XMLELEMTYPE_COMMENT = 2,
+ XMLELEMTYPE_DOCUMENT = 3,
+ XMLELEMTYPE_DTD = 4,
+ XMLELEMTYPE_PI = 5,
+ XMLELEMTYPE_OTHER = 6
+} XMLELEM_TYPE;
+
+typedef struct _xml_error {
+ UINT _nLine;
+ BSTR _pchBuf;
+ BSTR _cchBuf;
+ UINT _ich;
+ BSTR _pszFound;
+ BSTR _pszExpected;
+ DWORD _reserved1;
+ DWORD _reserved2;
+} XML_ERROR;
+
+#ifndef __IXMLAttribute_FWD_DEFINED__
+#define __IXMLAttribute_FWD_DEFINED__
+typedef struct IXMLAttribute IXMLAttribute;
+#endif
+
+/*****************************************************************************
+ * IXMLAttribute interface
+ */
+#ifndef __IXMLAttribute_INTERFACE_DEFINED__
+#define __IXMLAttribute_INTERFACE_DEFINED__
+
+DEFINE_GUID(IID_IXMLAttribute, 0xd4d4a0fc, 0x3b73, 0x11d1, 0xb2,0xb4, 0x00,0xc0,0x4f,0xb9,0x25,0x96);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IXMLAttribute : public IDispatch
+{
+ virtual HRESULT STDMETHODCALLTYPE get_name(
+ BSTR* p) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE get_value(
+ BSTR* p) = 0;
+
+};
+#else
+typedef struct IXMLAttributeVtbl IXMLAttributeVtbl;
+struct IXMLAttribute {
+ const IXMLAttributeVtbl* lpVtbl;
+};
+struct IXMLAttributeVtbl {
+ BEGIN_INTERFACE
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IXMLAttribute* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IXMLAttribute* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IXMLAttribute* This);
+
+ /*** IDispatch methods ***/
+ HRESULT (STDMETHODCALLTYPE *GetTypeInfoCount)(
+ IXMLAttribute* This,
+ UINT* pctinfo);
+
+ HRESULT (STDMETHODCALLTYPE *GetTypeInfo)(
+ IXMLAttribute* This,
+ UINT iTInfo,
+ LCID lcid,
+ ITypeInfo** ppTInfo);
+
+ HRESULT (STDMETHODCALLTYPE *GetIDsOfNames)(
+ IXMLAttribute* This,
+ REFIID riid,
+ LPOLESTR* rgszNames,
+ UINT cNames,
+ LCID lcid,
+ DISPID* rgDispId);
+
+ HRESULT (STDMETHODCALLTYPE *Invoke)(
+ IXMLAttribute* This,
+ DISPID dispIdMember,
+ REFIID riid,
+ LCID lcid,
+ WORD wFlags,
+ DISPPARAMS* pDispParams,
+ VARIANT* pVarResult,
+ EXCEPINFO* pExcepInfo,
+ UINT* puArgErr);
+
+ /*** IXMLAttribute methods ***/
+ HRESULT (STDMETHODCALLTYPE *get_name)(
+ IXMLAttribute* This,
+ BSTR* p);
+
+ HRESULT (STDMETHODCALLTYPE *get_value)(
+ IXMLAttribute* This,
+ BSTR* p);
+
+ END_INTERFACE
+};
+
+#ifdef COBJMACROS
+/*** IUnknown methods ***/
+#define IXMLAttribute_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IXMLAttribute_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IXMLAttribute_Release(p) (p)->lpVtbl->Release(p)
+/*** IDispatch methods ***/
+#define IXMLAttribute_GetTypeInfoCount(p,a) (p)->lpVtbl->GetTypeInfoCount(p,a)
+#define IXMLAttribute_GetTypeInfo(p,a,b,c) (p)->lpVtbl->GetTypeInfo(p,a,b,c)
+#define IXMLAttribute_GetIDsOfNames(p,a,b,c,d,e) (p)->lpVtbl->GetIDsOfNames(p,a,b,c,d,e)
+#define IXMLAttribute_Invoke(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g,h)
+/*** IXMLAttribute methods ***/
+#define IXMLAttribute_get_name(p,a) (p)->lpVtbl->get_name(p,a)
+#define IXMLAttribute_get_value(p,a) (p)->lpVtbl->get_value(p,a)
+#endif
+
+#endif
+
+HRESULT CALLBACK IXMLAttribute_get_name_Proxy(
+ IXMLAttribute* This,
+ BSTR* p);
+void __RPC_STUB IXMLAttribute_get_name_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IXMLAttribute_get_value_Proxy(
+ IXMLAttribute* This,
+ BSTR* p);
+void __RPC_STUB IXMLAttribute_get_value_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+#endif /* __IXMLAttribute_INTERFACE_DEFINED__ */
+
+#ifndef __IXMLError_FWD_DEFINED__
+#define __IXMLError_FWD_DEFINED__
+typedef struct IXMLError IXMLError;
+#endif
+
+/*****************************************************************************
+ * IXMLError interface
+ */
+#ifndef __IXMLError_INTERFACE_DEFINED__
+#define __IXMLError_INTERFACE_DEFINED__
+
+DEFINE_GUID(IID_IXMLError, 0x948c5ad3, 0xc58d, 0x11d0, 0x9c,0x0b, 0x00,0xc0,0x4f,0xc9,0x9c,0x8e);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IXMLError : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE GetErrorInfo(
+ XML_ERROR* pErrorReturn) = 0;
+
+};
+#else
+typedef struct IXMLErrorVtbl IXMLErrorVtbl;
+struct IXMLError {
+ const IXMLErrorVtbl* lpVtbl;
+};
+struct IXMLErrorVtbl {
+ BEGIN_INTERFACE
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IXMLError* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IXMLError* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IXMLError* This);
+
+ /*** IXMLError methods ***/
+ HRESULT (STDMETHODCALLTYPE *GetErrorInfo)(
+ IXMLError* This,
+ XML_ERROR* pErrorReturn);
+
+ END_INTERFACE
+};
+
+#ifdef COBJMACROS
+/*** IUnknown methods ***/
+#define IXMLError_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IXMLError_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IXMLError_Release(p) (p)->lpVtbl->Release(p)
+/*** IXMLError methods ***/
+#define IXMLError_GetErrorInfo(p,a) (p)->lpVtbl->GetErrorInfo(p,a)
+#endif
+
+#endif
+
+HRESULT CALLBACK IXMLError_GetErrorInfo_Proxy(
+ IXMLError* This,
+ XML_ERROR* pErrorReturn);
+void __RPC_STUB IXMLError_GetErrorInfo_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+#endif /* __IXMLError_INTERFACE_DEFINED__ */
+
+#ifndef __IXMLElementNotificationSink_FWD_DEFINED__
+#define __IXMLElementNotificationSink_FWD_DEFINED__
+typedef struct IXMLElementNotificationSink IXMLElementNotificationSink;
+#endif
+
+/*****************************************************************************
+ * IXMLElementNotificationSink interface
+ */
+#ifndef __IXMLElementNotificationSink_INTERFACE_DEFINED__
+#define __IXMLElementNotificationSink_INTERFACE_DEFINED__
+
+DEFINE_GUID(IID_IXMLElementNotificationSink, 0xd9f1e15a, 0xccdb, 0x11d0, 0x9c,0x0c, 0x00,0xc0,0x4f,0xc9,0x9c,0x8e);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IXMLElementNotificationSink : public IDispatch
+{
+ virtual HRESULT STDMETHODCALLTYPE ChildAdded(
+ IDispatch* pChildElem) = 0;
+
+};
+#else
+typedef struct IXMLElementNotificationSinkVtbl IXMLElementNotificationSinkVtbl;
+struct IXMLElementNotificationSink {
+ const IXMLElementNotificationSinkVtbl* lpVtbl;
+};
+struct IXMLElementNotificationSinkVtbl {
+ BEGIN_INTERFACE
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IXMLElementNotificationSink* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IXMLElementNotificationSink* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IXMLElementNotificationSink* This);
+
+ /*** IDispatch methods ***/
+ HRESULT (STDMETHODCALLTYPE *GetTypeInfoCount)(
+ IXMLElementNotificationSink* This,
+ UINT* pctinfo);
+
+ HRESULT (STDMETHODCALLTYPE *GetTypeInfo)(
+ IXMLElementNotificationSink* This,
+ UINT iTInfo,
+ LCID lcid,
+ ITypeInfo** ppTInfo);
+
+ HRESULT (STDMETHODCALLTYPE *GetIDsOfNames)(
+ IXMLElementNotificationSink* This,
+ REFIID riid,
+ LPOLESTR* rgszNames,
+ UINT cNames,
+ LCID lcid,
+ DISPID* rgDispId);
+
+ HRESULT (STDMETHODCALLTYPE *Invoke)(
+ IXMLElementNotificationSink* This,
+ DISPID dispIdMember,
+ REFIID riid,
+ LCID lcid,
+ WORD wFlags,
+ DISPPARAMS* pDispParams,
+ VARIANT* pVarResult,
+ EXCEPINFO* pExcepInfo,
+ UINT* puArgErr);
+
+ /*** IXMLElementNotificationSink methods ***/
+ HRESULT (STDMETHODCALLTYPE *ChildAdded)(
+ IXMLElementNotificationSink* This,
+ IDispatch* pChildElem);
+
+ END_INTERFACE
+};
+
+#ifdef COBJMACROS
+/*** IUnknown methods ***/
+#define IXMLElementNotificationSink_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IXMLElementNotificationSink_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IXMLElementNotificationSink_Release(p) (p)->lpVtbl->Release(p)
+/*** IDispatch methods ***/
+#define IXMLElementNotificationSink_GetTypeInfoCount(p,a) (p)->lpVtbl->GetTypeInfoCount(p,a)
+#define IXMLElementNotificationSink_GetTypeInfo(p,a,b,c) (p)->lpVtbl->GetTypeInfo(p,a,b,c)
+#define IXMLElementNotificationSink_GetIDsOfNames(p,a,b,c,d,e) (p)->lpVtbl->GetIDsOfNames(p,a,b,c,d,e)
+#define IXMLElementNotificationSink_Invoke(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Invoke(p,a,b,c,d,e,f,g,h)
+/*** IXMLElementNotificationSink methods ***/
+#define IXMLElementNotificationSink_ChildAdded(p,a) (p)->lpVtbl->ChildAdded(p,a)
+#endif
+
+#endif
+
+HRESULT CALLBACK IXMLElementNotificationSink_ChildAdded_Proxy(
+ IXMLElementNotificationSink* This,
+ IDispatch* pChildElem);
+void __RPC_STUB IXMLElementNotificationSink_ChildAdded_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+#endif /* __IXMLElementNotificationSink_INTERFACE_DEFINED__ */
+
+/*****************************************************************************
+ * XMLDocument coclass
+ */
+
+DEFINE_GUID(CLSID_XMLDocument, 0xcfc399af, 0xd876, 0x11d0, 0x9c,0x10, 0x00,0xc0,0x4f,0xc9,0x9c,0x8e);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* __WIDL_MSXML_H */
#endif
#include <ole2.h>
+#include <urlmon.h>
typedef interface IErrorLog *LPERRORLOG;
typedef interface IPropertyBag *LPPROPERTYBAG;
WINSHLWAPI BOOL WINAPI IntlStrEqWorkerA(BOOL,LPCSTR,LPCSTR,int);
WINSHLWAPI BOOL WINAPI IntlStrEqWorkerW(BOOL,LPCWSTR,LPCWSTR,int);
WINSHLWAPI BOOL WINAPI IsOS(DWORD);
+WINSHLWAPI HRESULT WINAPI SHLoadIndirectString(LPCWSTR,LPWSTR,UINT,PVOID*);
WINSHLWAPI HRESULT WINAPI SHStrDupA(LPCSTR,LPWSTR*);
WINSHLWAPI HRESULT WINAPI SHStrDupW(LPCWSTR,LPWSTR*);
WINSHLWAPI LPSTR WINAPI StrCatA(LPSTR,LPCSTR);
#include <objidl.h>
#include <oleidl.h>
#include <servprov.h>
+#include <msxml.h>
+#ifndef __IInternetProtocolSink_FWD_DEFINED__
+#define __IInternetProtocolSink_FWD_DEFINED__
+typedef struct IInternetProtocolSink IInternetProtocolSink;
+#endif
+
#ifndef __IBinding_FWD_DEFINED__
#define __IBinding_FWD_DEFINED__
typedef struct IBinding IBinding;
typedef IBindStatusCallback *LPBINDSTATUSCALLBACK;
+typedef enum {
+ BINDVERB_GET = 0x0,
+ BINDVERB_POST = 0x1,
+ BINDVERB_PUT = 0x2,
+ BINDVERB_CUSTOM = 0x3
+} BINDVERB;
+
typedef enum {
BINDF_ASYNCHRONOUS = 0x1,
BINDF_ASYNCSTORAGE = 0x2,
#endif /* __IBindStatusCallback_INTERFACE_DEFINED__ */
+#ifndef __IAuthenticate_FWD_DEFINED__
+#define __IAuthenticate_FWD_DEFINED__
+typedef struct IAuthenticate IAuthenticate;
+#endif
+
+typedef IAuthenticate *LPAUTHENTICATION;
+
+/*****************************************************************************
+ * IAuthenticate interface
+ */
+#ifndef __IAuthenticate_INTERFACE_DEFINED__
+#define __IAuthenticate_INTERFACE_DEFINED__
+
+DEFINE_GUID(IID_IAuthenticate, 0x79eac9d0, 0xbaf9, 0x11ce, 0x8c,0x82, 0x00,0xaa,0x00,0x4b,0xa9,0x0b);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IAuthenticate : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE Authenticate(
+ HWND* phwnd,
+ LPWSTR* pszUsername,
+ LPWSTR* pszPassword) = 0;
+
+};
+#else
+typedef struct IAuthenticateVtbl IAuthenticateVtbl;
+struct IAuthenticate {
+ const IAuthenticateVtbl* lpVtbl;
+};
+struct IAuthenticateVtbl {
+ BEGIN_INTERFACE
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IAuthenticate* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IAuthenticate* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IAuthenticate* This);
+
+ /*** IAuthenticate methods ***/
+ HRESULT (STDMETHODCALLTYPE *Authenticate)(
+ IAuthenticate* This,
+ HWND* phwnd,
+ LPWSTR* pszUsername,
+ LPWSTR* pszPassword);
+
+ END_INTERFACE
+};
+
+#ifdef COBJMACROS
+/*** IUnknown methods ***/
+#define IAuthenticate_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IAuthenticate_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IAuthenticate_Release(p) (p)->lpVtbl->Release(p)
+/*** IAuthenticate methods ***/
+#define IAuthenticate_Authenticate(p,a,b,c) (p)->lpVtbl->Authenticate(p,a,b,c)
+#endif
+
+#endif
+
+HRESULT CALLBACK IAuthenticate_Authenticate_Proxy(
+ IAuthenticate* This,
+ HWND* phwnd,
+ LPWSTR* pszUsername,
+ LPWSTR* pszPassword);
+void __RPC_STUB IAuthenticate_Authenticate_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+#endif /* __IAuthenticate_INTERFACE_DEFINED__ */
+
#define SID_IBindHost IID_IBindHost
#define SID_SBindHost IID_IBindHost
#ifndef __IBindHost_FWD_DEFINED__
#endif /* __IPersistMoniker_INTERFACE_DEFINED__ */
+#ifndef __IMonikerProp_FWD_DEFINED__
+#define __IMonikerProp_FWD_DEFINED__
+typedef struct IMonikerProp IMonikerProp;
+#endif
+
+typedef IMonikerProp *LPMONIKERPROP;
+
+typedef enum {
+ MIMETYPEPROP = 0x0,
+ USE_SRC_URL = 0x1
+} MONIKERPROPERTY;
+
+/*****************************************************************************
+ * IMonikerProp interface
+ */
+#ifndef __IMonikerProp_INTERFACE_DEFINED__
+#define __IMonikerProp_INTERFACE_DEFINED__
+
+DEFINE_GUID(IID_IMonikerProp, 0xa5ca5f7f, 0x1847, 0x4d87, 0x9c,0x5b, 0x91,0x85,0x09,0xf7,0x51,0x1d);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IMonikerProp : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE PutProperty(
+ MONIKERPROPERTY mkp,
+ LPCWSTR val) = 0;
+
+};
+#else
+typedef struct IMonikerPropVtbl IMonikerPropVtbl;
+struct IMonikerProp {
+ const IMonikerPropVtbl* lpVtbl;
+};
+struct IMonikerPropVtbl {
+ BEGIN_INTERFACE
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IMonikerProp* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IMonikerProp* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IMonikerProp* This);
+
+ /*** IMonikerProp methods ***/
+ HRESULT (STDMETHODCALLTYPE *PutProperty)(
+ IMonikerProp* This,
+ MONIKERPROPERTY mkp,
+ LPCWSTR val);
+
+ END_INTERFACE
+};
+
+#ifdef COBJMACROS
+/*** IUnknown methods ***/
+#define IMonikerProp_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IMonikerProp_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IMonikerProp_Release(p) (p)->lpVtbl->Release(p)
+/*** IMonikerProp methods ***/
+#define IMonikerProp_PutProperty(p,a,b) (p)->lpVtbl->PutProperty(p,a,b)
+#endif
+
+#endif
+
+HRESULT CALLBACK IMonikerProp_PutProperty_Proxy(
+ IMonikerProp* This,
+ MONIKERPROPERTY mkp,
+ LPCWSTR val);
+void __RPC_STUB IMonikerProp_PutProperty_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+#endif /* __IMonikerProp_INTERFACE_DEFINED__ */
+
+#ifndef __IInternetBindInfo_FWD_DEFINED__
+#define __IInternetBindInfo_FWD_DEFINED__
+typedef struct IInternetBindInfo IInternetBindInfo;
+#endif
+
+typedef IInternetBindInfo *LPIINTERNETBINDINFO;
+
+typedef enum tagBINDSTRING {
+ BINDSTRING_HEADERS = 1,
+ BINDSTRING_ACCEPT_MIMES,
+ BINDSTRING_EXTRA_URL,
+ BINDSTRING_LANGUAGE,
+ BINDSTRING_USERNAME,
+ BINDSTRING_PASSWORD,
+ BINDSTRING_UA_PIXELS,
+ BINDSTRING_UA_COLOR,
+ BINDSTRING_OS,
+ BINDSTRING_USER_AGENT,
+ BINDSTRING_ACCEPT_ENCODINGS,
+ BINDSTRING_POST_COOKIE,
+ BINDSTRING_POST_DATA_MIME,
+ BINDSTRING_URL
+} BINDSTRING;
+
+/*****************************************************************************
+ * IInternetBindInfo interface
+ */
+#ifndef __IInternetBindInfo_INTERFACE_DEFINED__
+#define __IInternetBindInfo_INTERFACE_DEFINED__
+
+DEFINE_GUID(IID_IInternetBindInfo, 0x79eac9e1, 0xbaf9, 0x11ce, 0x8c,0x82, 0x00,0xaa,0x00,0x4b,0xa9,0x0b);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IInternetBindInfo : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE GetBindInfo(
+ DWORD* grfBINDF,
+ BINDINFO* pbindinfo) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetBindString(
+ ULONG ulStringType,
+ LPOLESTR* ppwzStr,
+ ULONG cEl,
+ ULONG* pcElFetched) = 0;
+
+};
+#else
+typedef struct IInternetBindInfoVtbl IInternetBindInfoVtbl;
+struct IInternetBindInfo {
+ const IInternetBindInfoVtbl* lpVtbl;
+};
+struct IInternetBindInfoVtbl {
+ BEGIN_INTERFACE
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IInternetBindInfo* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IInternetBindInfo* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IInternetBindInfo* This);
+
+ /*** IInternetBindInfo methods ***/
+ HRESULT (STDMETHODCALLTYPE *GetBindInfo)(
+ IInternetBindInfo* This,
+ DWORD* grfBINDF,
+ BINDINFO* pbindinfo);
+
+ HRESULT (STDMETHODCALLTYPE *GetBindString)(
+ IInternetBindInfo* This,
+ ULONG ulStringType,
+ LPOLESTR* ppwzStr,
+ ULONG cEl,
+ ULONG* pcElFetched);
+
+ END_INTERFACE
+};
+
+#ifdef COBJMACROS
+/*** IUnknown methods ***/
+#define IInternetBindInfo_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IInternetBindInfo_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IInternetBindInfo_Release(p) (p)->lpVtbl->Release(p)
+/*** IInternetBindInfo methods ***/
+#define IInternetBindInfo_GetBindInfo(p,a,b) (p)->lpVtbl->GetBindInfo(p,a,b)
+#define IInternetBindInfo_GetBindString(p,a,b,c,d) (p)->lpVtbl->GetBindString(p,a,b,c,d)
+#endif
+
+#endif
+
+HRESULT CALLBACK IInternetBindInfo_GetBindInfo_Proxy(
+ IInternetBindInfo* This,
+ DWORD* grfBINDF,
+ BINDINFO* pbindinfo);
+void __RPC_STUB IInternetBindInfo_GetBindInfo_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IInternetBindInfo_GetBindString_Proxy(
+ IInternetBindInfo* This,
+ ULONG ulStringType,
+ LPOLESTR* ppwzStr,
+ ULONG cEl,
+ ULONG* pcElFetched);
+void __RPC_STUB IInternetBindInfo_GetBindString_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+#endif /* __IInternetBindInfo_INTERFACE_DEFINED__ */
+
+#ifndef __IInternetPriority_FWD_DEFINED__
+#define __IInternetPriority_FWD_DEFINED__
+typedef struct IInternetPriority IInternetPriority;
+#endif
+
+typedef IInternetPriority *LPIINTERNETPRIORITY;
+
+/*****************************************************************************
+ * IInternetPriority interface
+ */
+#ifndef __IInternetPriority_INTERFACE_DEFINED__
+#define __IInternetPriority_INTERFACE_DEFINED__
+
+DEFINE_GUID(IID_IInternetPriority, 0x79eac9eb, 0xbaf9, 0x11ce, 0x8c,0x82, 0x00,0xaa,0x00,0x4b,0xa9,0x0b);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IInternetPriority : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE SetPriority(
+ LONG nPriority) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetPriority(
+ LONG* pnPriority) = 0;
+
+};
+#else
+typedef struct IInternetPriorityVtbl IInternetPriorityVtbl;
+struct IInternetPriority {
+ const IInternetPriorityVtbl* lpVtbl;
+};
+struct IInternetPriorityVtbl {
+ BEGIN_INTERFACE
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IInternetPriority* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IInternetPriority* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IInternetPriority* This);
+
+ /*** IInternetPriority methods ***/
+ HRESULT (STDMETHODCALLTYPE *SetPriority)(
+ IInternetPriority* This,
+ LONG nPriority);
+
+ HRESULT (STDMETHODCALLTYPE *GetPriority)(
+ IInternetPriority* This,
+ LONG* pnPriority);
+
+ END_INTERFACE
+};
+
+#ifdef COBJMACROS
+/*** IUnknown methods ***/
+#define IInternetPriority_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IInternetPriority_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IInternetPriority_Release(p) (p)->lpVtbl->Release(p)
+/*** IInternetPriority methods ***/
+#define IInternetPriority_SetPriority(p,a) (p)->lpVtbl->SetPriority(p,a)
+#define IInternetPriority_GetPriority(p,a) (p)->lpVtbl->GetPriority(p,a)
+#endif
+
+#endif
+
+HRESULT CALLBACK IInternetPriority_SetPriority_Proxy(
+ IInternetPriority* This,
+ LONG nPriority);
+void __RPC_STUB IInternetPriority_SetPriority_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IInternetPriority_GetPriority_Proxy(
+ IInternetPriority* This,
+ LONG* pnPriority);
+void __RPC_STUB IInternetPriority_GetPriority_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+#endif /* __IInternetPriority_INTERFACE_DEFINED__ */
+
+#ifndef __IInternetProtocolRoot_FWD_DEFINED__
+#define __IInternetProtocolRoot_FWD_DEFINED__
+typedef struct IInternetProtocolRoot IInternetProtocolRoot;
+#endif
+
+typedef IInternetProtocolRoot *LPIINTERNETPROTOCOLROOT;
+
+typedef enum _tagPI_FLAGS {
+ PI_PARSE_URL = 0x1,
+ PI_FILTER_MODE = 0x2,
+ PI_FORCE_ASYNC = 0x4,
+ PI_USE_WORKERTHREAD = 0x8,
+ PI_MIMEVERIFICATION = 0x10,
+ PI_CLSIDLOOKUP = 0x20,
+ PI_DATAPROGRESS = 0x40,
+ PI_SYNCHRONOUS = 0x80,
+ PI_APARTMENTTHREADED = 0x100,
+ PI_CLASSINSTALL = 0x200,
+ PD_FORCE_SWITCH = 0x10000
+} PI_FLAGS;
+
+typedef struct _tagPROTOCOLDATA {
+ DWORD grfFlags;
+ DWORD dwState;
+ LPVOID pData;
+ ULONG cbData;
+} PROTOCOLDATA;
+
+/*****************************************************************************
+ * IInternetProtocolRoot interface
+ */
+#ifndef __IInternetProtocolRoot_INTERFACE_DEFINED__
+#define __IInternetProtocolRoot_INTERFACE_DEFINED__
+
+DEFINE_GUID(IID_IInternetProtocolRoot, 0x79eac9e3, 0xbaf9, 0x11ce, 0x8c,0x82, 0x00,0xaa,0x00,0x4b,0xa9,0x0b);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IInternetProtocolRoot : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE Start(
+ LPCWSTR szUrl,
+ IInternetProtocolSink* pOIProtSink,
+ IInternetBindInfo* pOIBindInfo,
+ DWORD grfPI,
+ DWORD dwReserved) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE Continue(
+ PROTOCOLDATA* pProtocolData) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE Abort(
+ HRESULT hrReason,
+ DWORD dwOptions) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE Terminate(
+ DWORD dwOptions) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE Suspend(
+ ) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE Resume(
+ ) = 0;
+
+};
+#else
+typedef struct IInternetProtocolRootVtbl IInternetProtocolRootVtbl;
+struct IInternetProtocolRoot {
+ const IInternetProtocolRootVtbl* lpVtbl;
+};
+struct IInternetProtocolRootVtbl {
+ BEGIN_INTERFACE
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IInternetProtocolRoot* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IInternetProtocolRoot* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IInternetProtocolRoot* This);
+
+ /*** IInternetProtocolRoot methods ***/
+ HRESULT (STDMETHODCALLTYPE *Start)(
+ IInternetProtocolRoot* This,
+ LPCWSTR szUrl,
+ IInternetProtocolSink* pOIProtSink,
+ IInternetBindInfo* pOIBindInfo,
+ DWORD grfPI,
+ DWORD dwReserved);
+
+ HRESULT (STDMETHODCALLTYPE *Continue)(
+ IInternetProtocolRoot* This,
+ PROTOCOLDATA* pProtocolData);
+
+ HRESULT (STDMETHODCALLTYPE *Abort)(
+ IInternetProtocolRoot* This,
+ HRESULT hrReason,
+ DWORD dwOptions);
+
+ HRESULT (STDMETHODCALLTYPE *Terminate)(
+ IInternetProtocolRoot* This,
+ DWORD dwOptions);
+
+ HRESULT (STDMETHODCALLTYPE *Suspend)(
+ IInternetProtocolRoot* This);
+
+ HRESULT (STDMETHODCALLTYPE *Resume)(
+ IInternetProtocolRoot* This);
+
+ END_INTERFACE
+};
+
+#ifdef COBJMACROS
+/*** IUnknown methods ***/
+#define IInternetProtocolRoot_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IInternetProtocolRoot_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IInternetProtocolRoot_Release(p) (p)->lpVtbl->Release(p)
+/*** IInternetProtocolRoot methods ***/
+#define IInternetProtocolRoot_Start(p,a,b,c,d,e) (p)->lpVtbl->Start(p,a,b,c,d,e)
+#define IInternetProtocolRoot_Continue(p,a) (p)->lpVtbl->Continue(p,a)
+#define IInternetProtocolRoot_Abort(p,a,b) (p)->lpVtbl->Abort(p,a,b)
+#define IInternetProtocolRoot_Terminate(p,a) (p)->lpVtbl->Terminate(p,a)
+#define IInternetProtocolRoot_Suspend(p) (p)->lpVtbl->Suspend(p)
+#define IInternetProtocolRoot_Resume(p) (p)->lpVtbl->Resume(p)
+#endif
+
+#endif
+
+HRESULT CALLBACK IInternetProtocolRoot_Start_Proxy(
+ IInternetProtocolRoot* This,
+ LPCWSTR szUrl,
+ IInternetProtocolSink* pOIProtSink,
+ IInternetBindInfo* pOIBindInfo,
+ DWORD grfPI,
+ DWORD dwReserved);
+void __RPC_STUB IInternetProtocolRoot_Start_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IInternetProtocolRoot_Continue_Proxy(
+ IInternetProtocolRoot* This,
+ PROTOCOLDATA* pProtocolData);
+void __RPC_STUB IInternetProtocolRoot_Continue_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IInternetProtocolRoot_Abort_Proxy(
+ IInternetProtocolRoot* This,
+ HRESULT hrReason,
+ DWORD dwOptions);
+void __RPC_STUB IInternetProtocolRoot_Abort_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IInternetProtocolRoot_Terminate_Proxy(
+ IInternetProtocolRoot* This,
+ DWORD dwOptions);
+void __RPC_STUB IInternetProtocolRoot_Terminate_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IInternetProtocolRoot_Suspend_Proxy(
+ IInternetProtocolRoot* This);
+void __RPC_STUB IInternetProtocolRoot_Suspend_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IInternetProtocolRoot_Resume_Proxy(
+ IInternetProtocolRoot* This);
+void __RPC_STUB IInternetProtocolRoot_Resume_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+#endif /* __IInternetProtocolRoot_INTERFACE_DEFINED__ */
+
+typedef IInternetProtocolSink *LPIINTERNETPROTOCOLSINK;
+
+/*****************************************************************************
+ * IInternetProtocolSink interface
+ */
+#ifndef __IInternetProtocolSink_INTERFACE_DEFINED__
+#define __IInternetProtocolSink_INTERFACE_DEFINED__
+
+DEFINE_GUID(IID_IInternetProtocolSink, 0x79eac9e5, 0xbaf9, 0x11ce, 0x8c,0x82, 0x00,0xaa,0x00,0x4b,0xa9,0x0b);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IInternetProtocolSink : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE Switch(
+ PROTOCOLDATA* pProtocolData) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE ReportProgress(
+ ULONG ulStatusCode,
+ LPCWSTR szStatusText) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE ReportData(
+ DWORD grfBSCF,
+ ULONG ulProgress,
+ ULONG ulProgressMax) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE ReportResult(
+ HRESULT hrResult,
+ DWORD dwError,
+ LPCWSTR szResult) = 0;
+
+};
+#else
+typedef struct IInternetProtocolSinkVtbl IInternetProtocolSinkVtbl;
+struct IInternetProtocolSink {
+ const IInternetProtocolSinkVtbl* lpVtbl;
+};
+struct IInternetProtocolSinkVtbl {
+ BEGIN_INTERFACE
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IInternetProtocolSink* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IInternetProtocolSink* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IInternetProtocolSink* This);
+
+ /*** IInternetProtocolSink methods ***/
+ HRESULT (STDMETHODCALLTYPE *Switch)(
+ IInternetProtocolSink* This,
+ PROTOCOLDATA* pProtocolData);
+
+ HRESULT (STDMETHODCALLTYPE *ReportProgress)(
+ IInternetProtocolSink* This,
+ ULONG ulStatusCode,
+ LPCWSTR szStatusText);
+
+ HRESULT (STDMETHODCALLTYPE *ReportData)(
+ IInternetProtocolSink* This,
+ DWORD grfBSCF,
+ ULONG ulProgress,
+ ULONG ulProgressMax);
+
+ HRESULT (STDMETHODCALLTYPE *ReportResult)(
+ IInternetProtocolSink* This,
+ HRESULT hrResult,
+ DWORD dwError,
+ LPCWSTR szResult);
+
+ END_INTERFACE
+};
+
+#ifdef COBJMACROS
+/*** IUnknown methods ***/
+#define IInternetProtocolSink_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IInternetProtocolSink_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IInternetProtocolSink_Release(p) (p)->lpVtbl->Release(p)
+/*** IInternetProtocolSink methods ***/
+#define IInternetProtocolSink_Switch(p,a) (p)->lpVtbl->Switch(p,a)
+#define IInternetProtocolSink_ReportProgress(p,a,b) (p)->lpVtbl->ReportProgress(p,a,b)
+#define IInternetProtocolSink_ReportData(p,a,b,c) (p)->lpVtbl->ReportData(p,a,b,c)
+#define IInternetProtocolSink_ReportResult(p,a,b,c) (p)->lpVtbl->ReportResult(p,a,b,c)
+#endif
+
+#endif
+
+HRESULT CALLBACK IInternetProtocolSink_Switch_Proxy(
+ IInternetProtocolSink* This,
+ PROTOCOLDATA* pProtocolData);
+void __RPC_STUB IInternetProtocolSink_Switch_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IInternetProtocolSink_ReportProgress_Proxy(
+ IInternetProtocolSink* This,
+ ULONG ulStatusCode,
+ LPCWSTR szStatusText);
+void __RPC_STUB IInternetProtocolSink_ReportProgress_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IInternetProtocolSink_ReportData_Proxy(
+ IInternetProtocolSink* This,
+ DWORD grfBSCF,
+ ULONG ulProgress,
+ ULONG ulProgressMax);
+void __RPC_STUB IInternetProtocolSink_ReportData_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IInternetProtocolSink_ReportResult_Proxy(
+ IInternetProtocolSink* This,
+ HRESULT hrResult,
+ DWORD dwError,
+ LPCWSTR szResult);
+void __RPC_STUB IInternetProtocolSink_ReportResult_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+#endif /* __IInternetProtocolSink_INTERFACE_DEFINED__ */
+
+#ifndef __IInternetProtocol_FWD_DEFINED__
+#define __IInternetProtocol_FWD_DEFINED__
+typedef struct IInternetProtocol IInternetProtocol;
+#endif
+
+typedef IInternetProtocol *LPIINTERNETPROTOCOL;
+
+/*****************************************************************************
+ * IInternetProtocol interface
+ */
+#ifndef __IInternetProtocol_INTERFACE_DEFINED__
+#define __IInternetProtocol_INTERFACE_DEFINED__
+
+DEFINE_GUID(IID_IInternetProtocol, 0x79eac9e4, 0xbaf9, 0x11ce, 0x8c,0x82, 0x00,0xaa,0x00,0x4b,0xa9,0x0b);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct IInternetProtocol : public IInternetProtocolRoot
+{
+ virtual HRESULT STDMETHODCALLTYPE Read(
+ void* pv,
+ ULONG cb,
+ ULONG* pcbRead) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE Seek(
+ LARGE_INTEGER dlibMove,
+ DWORD dwOrigin,
+ ULARGE_INTEGER* plibNewPosition) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE LockRequest(
+ DWORD dwOptions) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE UnlockRequest(
+ ) = 0;
+
+};
+#else
+typedef struct IInternetProtocolVtbl IInternetProtocolVtbl;
+struct IInternetProtocol {
+ const IInternetProtocolVtbl* lpVtbl;
+};
+struct IInternetProtocolVtbl {
+ BEGIN_INTERFACE
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ IInternetProtocol* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ IInternetProtocol* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ IInternetProtocol* This);
+
+ /*** IInternetProtocolRoot methods ***/
+ HRESULT (STDMETHODCALLTYPE *Start)(
+ IInternetProtocol* This,
+ LPCWSTR szUrl,
+ IInternetProtocolSink* pOIProtSink,
+ IInternetBindInfo* pOIBindInfo,
+ DWORD grfPI,
+ DWORD dwReserved);
+
+ HRESULT (STDMETHODCALLTYPE *Continue)(
+ IInternetProtocol* This,
+ PROTOCOLDATA* pProtocolData);
+
+ HRESULT (STDMETHODCALLTYPE *Abort)(
+ IInternetProtocol* This,
+ HRESULT hrReason,
+ DWORD dwOptions);
+
+ HRESULT (STDMETHODCALLTYPE *Terminate)(
+ IInternetProtocol* This,
+ DWORD dwOptions);
+
+ HRESULT (STDMETHODCALLTYPE *Suspend)(
+ IInternetProtocol* This);
+
+ HRESULT (STDMETHODCALLTYPE *Resume)(
+ IInternetProtocol* This);
+
+ /*** IInternetProtocol methods ***/
+ HRESULT (STDMETHODCALLTYPE *Read)(
+ IInternetProtocol* This,
+ void* pv,
+ ULONG cb,
+ ULONG* pcbRead);
+
+ HRESULT (STDMETHODCALLTYPE *Seek)(
+ IInternetProtocol* This,
+ LARGE_INTEGER dlibMove,
+ DWORD dwOrigin,
+ ULARGE_INTEGER* plibNewPosition);
+
+ HRESULT (STDMETHODCALLTYPE *LockRequest)(
+ IInternetProtocol* This,
+ DWORD dwOptions);
+
+ HRESULT (STDMETHODCALLTYPE *UnlockRequest)(
+ IInternetProtocol* This);
+
+ END_INTERFACE
+};
+
+#ifdef COBJMACROS
+/*** IUnknown methods ***/
+#define IInternetProtocol_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define IInternetProtocol_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define IInternetProtocol_Release(p) (p)->lpVtbl->Release(p)
+/*** IInternetProtocolRoot methods ***/
+#define IInternetProtocol_Start(p,a,b,c,d,e) (p)->lpVtbl->Start(p,a,b,c,d,e)
+#define IInternetProtocol_Continue(p,a) (p)->lpVtbl->Continue(p,a)
+#define IInternetProtocol_Abort(p,a,b) (p)->lpVtbl->Abort(p,a,b)
+#define IInternetProtocol_Terminate(p,a) (p)->lpVtbl->Terminate(p,a)
+#define IInternetProtocol_Suspend(p) (p)->lpVtbl->Suspend(p)
+#define IInternetProtocol_Resume(p) (p)->lpVtbl->Resume(p)
+/*** IInternetProtocol methods ***/
+#define IInternetProtocol_Read(p,a,b,c) (p)->lpVtbl->Read(p,a,b,c)
+#define IInternetProtocol_Seek(p,a,b,c) (p)->lpVtbl->Seek(p,a,b,c)
+#define IInternetProtocol_LockRequest(p,a) (p)->lpVtbl->LockRequest(p,a)
+#define IInternetProtocol_UnlockRequest(p) (p)->lpVtbl->UnlockRequest(p)
+#endif
+
+#endif
+
+HRESULT CALLBACK IInternetProtocol_Read_Proxy(
+ IInternetProtocol* This,
+ void* pv,
+ ULONG cb,
+ ULONG* pcbRead);
+void __RPC_STUB IInternetProtocol_Read_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IInternetProtocol_Seek_Proxy(
+ IInternetProtocol* This,
+ LARGE_INTEGER dlibMove,
+ DWORD dwOrigin,
+ ULARGE_INTEGER* plibNewPosition);
+void __RPC_STUB IInternetProtocol_Seek_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IInternetProtocol_LockRequest_Proxy(
+ IInternetProtocol* This,
+ DWORD dwOptions);
+void __RPC_STUB IInternetProtocol_LockRequest_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK IInternetProtocol_UnlockRequest_Proxy(
+ IInternetProtocol* This);
+void __RPC_STUB IInternetProtocol_UnlockRequest_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+#endif /* __IInternetProtocol_INTERFACE_DEFINED__ */
+
#ifndef __IInternetProtocolInfo_FWD_DEFINED__
#define __IInternetProtocolInfo_FWD_DEFINED__
typedef struct IInternetProtocolInfo IInternetProtocolInfo;
DWORD cbPolicy,
URLZONEREG urlZoneReg) = 0;
+ virtual HRESULT STDMETHODCALLTYPE PromptAction(
+ DWORD dwAction,
+ HWND hwndParent,
+ LPCWSTR pwszUrl,
+ LPCWSTR pwszText,
+ DWORD dwPromptFlags) = 0;
+
virtual HRESULT STDMETHODCALLTYPE LogAction(
DWORD dwAction,
LPCWSTR pwszUrl,
HRESULT (STDMETHODCALLTYPE *PromptAction)(
IInternetZoneManager* This,
DWORD dwAction,
+ HWND hwndParent,
LPCWSTR pwszUrl,
LPCWSTR pwszText,
DWORD dwPromptFlags);
#define IInternetZoneManager_SetZoneCustomPolicy(p,a,b,c,d,e) (p)->lpVtbl->SetZoneCustomPolicy(p,a,b,c,d,e)
#define IInternetZoneManager_GetZoneActionPolicy(p,a,b,c,d,e) (p)->lpVtbl->GetZoneActionPolicy(p,a,b,c,d,e)
#define IInternetZoneManager_SetZoneActionPolicy(p,a,b,c,d,e) (p)->lpVtbl->SetZoneActionPolicy(p,a,b,c,d,e)
+#define IInternetZoneManager_PromptAction(p,a,b,c,d,e) (p)->lpVtbl->PromptAction(p,a,b,c,d,e)
#define IInternetZoneManager_LogAction(p,a,b,c,d) (p)->lpVtbl->LogAction(p,a,b,c,d)
#define IInternetZoneManager_CreateZoneEnumerator(p,a,b,c) (p)->lpVtbl->CreateZoneEnumerator(p,a,b,c)
#define IInternetZoneManager_GetZoneAt(p,a,b,c) (p)->lpVtbl->GetZoneAt(p,a,b,c)
struct IRpcChannelBuffer* pRpcChannelBuffer,
PRPC_MESSAGE pRpcMessage,
DWORD* pdwStubPhase);
+HRESULT CALLBACK IInternetZoneManager_PromptAction_Proxy(
+ IInternetZoneManager* This,
+ DWORD dwAction,
+ HWND hwndParent,
+ LPCWSTR pwszUrl,
+ LPCWSTR pwszText,
+ DWORD dwPromptFlags);
+void __RPC_STUB IInternetZoneManager_PromptAction_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
HRESULT CALLBACK IInternetZoneManager_LogAction_Proxy(
IInternetZoneManager* This,
DWORD dwAction,
DWORD dwReserved;
} SOFTDISTINFO, *LPSOFTDISTINFO;
+typedef struct _tagCODEBASEHOLD {
+ DWORD cbSize;
+ LPWSTR szDistUnit;
+ LPWSTR szCodeBase;
+ DWORD dwVersionMS;
+ DWORD dwVersionLS;
+ DWORD dwStyle;
+} CODEBASEHOLD, *LPCODEBASEHOLD;
+
+#ifndef __ISoftDistExt_FWD_DEFINED__
+#define __ISoftDistExt_FWD_DEFINED__
+typedef struct ISoftDistExt ISoftDistExt;
+#endif
+
+/*****************************************************************************
+ * ISoftDistExt interface
+ */
+#ifndef __ISoftDistExt_INTERFACE_DEFINED__
+#define __ISoftDistExt_INTERFACE_DEFINED__
+
+DEFINE_GUID(IID_ISoftDistExt, 0xb15b8dc1, 0xc7e1, 0x11d0, 0x86,0x80, 0x00,0xaa,0x00,0xbd,0xcb,0x71);
+#if defined(__cplusplus) && !defined(CINTERFACE)
+struct ISoftDistExt : public IUnknown
+{
+ virtual HRESULT STDMETHODCALLTYPE ProcessSoftDist(
+ LPCWSTR szCDFURL,
+ IXMLElement* pSoftDistElement,
+ LPSOFTDISTINFO lpsdi) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetFirstCodeBase(
+ LPWSTR* szCodeBase,
+ LPDWORD dwMaxSize) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE GetNextCodeBase(
+ LPWSTR* szCodeBase,
+ LPDWORD dwMaxSize) = 0;
+
+ virtual HRESULT STDMETHODCALLTYPE AsyncInstallDistributionUnit(
+ IBindCtx* pbc,
+ LPVOID lpReserved,
+ DWORD flags,
+ LPCODEBASEHOLD lpcbh) = 0;
+
+};
+#else
+typedef struct ISoftDistExtVtbl ISoftDistExtVtbl;
+struct ISoftDistExt {
+ const ISoftDistExtVtbl* lpVtbl;
+};
+struct ISoftDistExtVtbl {
+ BEGIN_INTERFACE
+
+ /*** IUnknown methods ***/
+ HRESULT (STDMETHODCALLTYPE *QueryInterface)(
+ ISoftDistExt* This,
+ REFIID riid,
+ void** ppvObject);
+
+ ULONG (STDMETHODCALLTYPE *AddRef)(
+ ISoftDistExt* This);
+
+ ULONG (STDMETHODCALLTYPE *Release)(
+ ISoftDistExt* This);
+
+ /*** ISoftDistExt methods ***/
+ HRESULT (STDMETHODCALLTYPE *ProcessSoftDist)(
+ ISoftDistExt* This,
+ LPCWSTR szCDFURL,
+ IXMLElement* pSoftDistElement,
+ LPSOFTDISTINFO lpsdi);
+
+ HRESULT (STDMETHODCALLTYPE *GetFirstCodeBase)(
+ ISoftDistExt* This,
+ LPWSTR* szCodeBase,
+ LPDWORD dwMaxSize);
+
+ HRESULT (STDMETHODCALLTYPE *GetNextCodeBase)(
+ ISoftDistExt* This,
+ LPWSTR* szCodeBase,
+ LPDWORD dwMaxSize);
+
+ HRESULT (STDMETHODCALLTYPE *AsyncInstallDistributionUnit)(
+ ISoftDistExt* This,
+ IBindCtx* pbc,
+ LPVOID lpReserved,
+ DWORD flags,
+ LPCODEBASEHOLD lpcbh);
+
+ END_INTERFACE
+};
+
+#ifdef COBJMACROS
+/*** IUnknown methods ***/
+#define ISoftDistExt_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
+#define ISoftDistExt_AddRef(p) (p)->lpVtbl->AddRef(p)
+#define ISoftDistExt_Release(p) (p)->lpVtbl->Release(p)
+/*** ISoftDistExt methods ***/
+#define ISoftDistExt_ProcessSoftDist(p,a,b,c) (p)->lpVtbl->ProcessSoftDist(p,a,b,c)
+#define ISoftDistExt_GetFirstCodeBase(p,a,b) (p)->lpVtbl->GetFirstCodeBase(p,a,b)
+#define ISoftDistExt_GetNextCodeBase(p,a,b) (p)->lpVtbl->GetNextCodeBase(p,a,b)
+#define ISoftDistExt_AsyncInstallDistributionUnit(p,a,b,c,d) (p)->lpVtbl->AsyncInstallDistributionUnit(p,a,b,c,d)
+#endif
+
+#endif
+
+HRESULT CALLBACK ISoftDistExt_ProcessSoftDist_Proxy(
+ ISoftDistExt* This,
+ LPCWSTR szCDFURL,
+ IXMLElement* pSoftDistElement,
+ LPSOFTDISTINFO lpsdi);
+void __RPC_STUB ISoftDistExt_ProcessSoftDist_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK ISoftDistExt_GetFirstCodeBase_Proxy(
+ ISoftDistExt* This,
+ LPWSTR* szCodeBase,
+ LPDWORD dwMaxSize);
+void __RPC_STUB ISoftDistExt_GetFirstCodeBase_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK ISoftDistExt_GetNextCodeBase_Proxy(
+ ISoftDistExt* This,
+ LPWSTR* szCodeBase,
+ LPDWORD dwMaxSize);
+void __RPC_STUB ISoftDistExt_GetNextCodeBase_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+HRESULT CALLBACK ISoftDistExt_AsyncInstallDistributionUnit_Proxy(
+ ISoftDistExt* This,
+ IBindCtx* pbc,
+ LPVOID lpReserved,
+ DWORD flags,
+ LPCODEBASEHOLD lpcbh);
+void __RPC_STUB ISoftDistExt_AsyncInstallDistributionUnit_Stub(
+ struct IRpcStubBuffer* This,
+ struct IRpcChannelBuffer* pRpcChannelBuffer,
+ PRPC_MESSAGE pRpcMessage,
+ DWORD* pdwStubPhase);
+
+#endif /* __ISoftDistExt_INTERFACE_DEFINED__ */
+
DEFINE_GUID(CLSID_InternetSecurityManager, 0x7b8a2d94, 0x0ac9, 0x11d1, 0x89, 0x6c, 0x00, 0xc0, 0x4f, 0xB6, 0xbf, 0xc4);
DEFINE_GUID(CLSID_InternetZoneManager, 0x7B8A2D95, 0x0AC9, 0x11D1, 0x89, 0x6C, 0x00, 0xC0, 0x4F, 0xB6, 0xBF, 0xC4);
DEFINE_GUID(IID_IAsyncMoniker, 0x79EAC9D3, 0xBAF9, 0x11CE, 0x8C, 0x82, 0x00, 0xAA, 0x00, 0x4B, 0xA9, 0x0B);
+DEFINE_GUID(IID_IAsyncBindCtx, 0x79EAC9D4, 0xBAF9, 0x11CE, 0x8C, 0x82, 0x00, 0xAA, 0x00, 0x4B, 0xA9, 0x0B);
DEFINE_GUID(CLSID_StdURLMoniker, 0x79EAC9E0, 0xBAF9, 0x11CE, 0x8C, 0x82, 0x00, 0xAA, 0x00, 0x4B, 0xA9, 0x0B);
#define MK_S_ASYNCHRONOUS 0x000401E8
#define S_ASYNCHRONOUS MK_S_ASYNCHRONOUS
#define INET_E_SECURITY_PROBLEM 0x800C000EL
#define INET_E_CANNOT_LOAD_DATA 0x800C000FL
#define INET_E_CANNOT_INSTANTIATE_OBJECT 0x800C0010L
+#define INET_E_USE_DEFAULT_PROTOCOLHANDLER 0x800C0011L
#define INET_E_QUERYOPTION_UNKNOWN 0x800C0013L
#define INET_E_REDIRECT_FAILED 0x800C0014L
#define INET_E_REDIRECT_TO_DIR 0x800C0015L
#define INET_E_CANNOT_LOCK_REQUEST 0x800C0016L
#define INET_E_ERROR_LAST INET_E_REDIRECT_TO_DIR
+HRESULT WINAPI CoGetClassObjectFromURL(REFCLSID, LPCWSTR, DWORD, DWORD, LPCWSTR, LPBINDCTX, DWORD, LPVOID, REFIID, LPVOID*);
HRESULT WINAPI CreateURLMoniker(IMoniker *pmkContext, LPCWSTR szURL, IMoniker **ppmk);
HRESULT WINAPI RegisterBindStatusCallback(IBindCtx *pbc, IBindStatusCallback *pbsc, IBindStatusCallback **ppbsc, DWORD dwReserved);
HRESULT WINAPI CompareSecurityIds(BYTE*,DWORD,BYTE*,DWORD,DWORD);
HRESULT WINAPI MkParseDisplayNameEx(IBindCtx*,LPCWSTR,ULONG*,IMoniker**);
HRESULT WINAPI IsAsyncMoniker(IMoniker* pmk);
HRESULT WINAPI CreateAsyncBindCtx(DWORD, IBindStatusCallback*, IEnumFORMATETC*, IBindCtx**);
+HRESULT WINAPI CreateAsyncBindCtxEx(IBindCtx*,DWORD,IBindStatusCallback*,IEnumFORMATETC*,IBindCtx**,DWORD);
+HRESULT WINAPI CoInternetCreateSecurityManager(IServiceProvider*,IInternetSecurityManager**,DWORD);
HRESULT WINAPI CoInternetCombineUrl(LPCWSTR,LPCWSTR,DWORD,LPWSTR,DWORD,DWORD*,DWORD);
HRESULT WINAPI CoInternetCompareUrl(LPCWSTR,LPCWSTR,DWORD);
HRESULT WINAPI CoInternetCreateZoneManager(IServiceProvider*, IInternetZoneManager**, DWORD);
+HRESULT WINAPI CoInternetQueryInfo(LPCWSTR,QUERYOPTION,DWORD,LPVOID,DWORD,DWORD*,DWORD);
+HRESULT WINAPI GetSoftwareUpdateInfo( LPCWSTR szDistUnit, LPSOFTDISTINFO psdi);
+HRESULT WINAPI FaultInIEFeature(HWND,uCLSSPEC*,QUERYCONTEXT*,DWORD);
+HRESULT WINAPI FindMimeFromData(LPBC,LPCWSTR,LPVOID,DWORD,LPCWSTR,DWORD,LPWSTR*,DWORD);
+HRESULT WINAPI HlinkGoBack(IUnknown*);
+HRESULT WINAPI HlinkGoForward(IUnknown*);
+HRESULT WINAPI HlinkNavigateMoniker(IUnknown*,IMoniker*);
+HRESULT WINAPI HlinkNavigateString(IUnknown*,LPCWSTR);
+HRESULT WINAPI HlinkSimpleNavigateToMoniker(IMoniker*,LPCWSTR,LPCWSTR,IUnknown*,IBindCtx*,IBindStatusCallback*,DWORD,DWORD);
+HRESULT WINAPI HlinkSimpleNavigateToString(LPCWSTR,LPCWSTR,LPCWSTR,IUnknown*,IBindCtx*,IBindStatusCallback*,DWORD,DWORD);
+HRESULT WINAPI IsValidURL(LPBC,LPCWSTR,DWORD);
+HRESULT WINAPI ObtainUserAgentString(DWORD,LPSTR,DWORD*);
+HRESULT WINAPI RevokeBindStatusCallback(LPBC,IBindStatusCallback*);
+void WINAPI ReleaseBindInfo(BINDINFO*);
+HRESULT WINAPI UrlMkGetSessionOption(DWORD,LPVOID,DWORD,DWORD*,DWORD);
+HRESULT WINAPI UrlMkSetSessionOption(DWORD,LPVOID,DWORD,DWORD);
#define OInetCombineUrl CoInternetCombineUrl
#define OInetCompareUrl CoInternetCompareUrl
#define OInetGetSession CoInternetGetSession
projects / reactos.git / commitdiff