Sync to Wine-20050830:
authorGé van Geldorp <ge@gse.nl>
Wed, 7 Sep 2005 15:52:47 +0000 (15:52 +0000)
committerGé van Geldorp <ge@gse.nl>
Wed, 7 Sep 2005 15:52:47 +0000 (15:52 +0000)
Huw Davies <huw@codeweavers.com>
- IUnknown_SetSite calls IObjectWithSite_SetSite or
  IInternetSecurityManager_SetSecuritySite.
- Fix call to GetMenuItemInfo and unicodify while we're at it.
- Implement SHLoadIndirectString.
- _CreateAllAccessSecurityAttributes takes three parameters.
- Forward ordinals 457,458 to GetLongPathNameW,A.
- Implement SHLoadRegUIStringW.
- Partial implementation of DeleteMenuWrap.
- Implement IUnknown_EnumObjects.
- Implement and add tests for the FDSA functions.
Alexandre Julliard <julliard@winehq.org>
- Don't prefix the functions DllInstall and DllGetVersion with the dll
  name so that the compiler can check the prototypes.
Vincent Beron <vberon@mecano.gme.usherb.ca>
- Correct typo in format string.
Mike McCormack <mike@codeweavers.com>
- gcc 4.0 warning fixes.
Steven Edwards <steven_ed4153@yahoo.com>
- Correct RegCreateKeyEx[A/W] prototype to match the PSDK.

svn path=/trunk/; revision=17716

12 files changed:
reactos/lib/shlwapi/istream.c
reactos/lib/shlwapi/ordinal.c
reactos/lib/shlwapi/reg.c
reactos/lib/shlwapi/regstream.c
reactos/lib/shlwapi/shlwapi.spec
reactos/lib/shlwapi/shlwapi_main.c
reactos/lib/shlwapi/string.c
reactos/lib/shlwapi/thread.c
reactos/w32api/include/msxml.h [new file with mode: 0644]
reactos/w32api/include/ocidl.h
reactos/w32api/include/shlwapi.h
reactos/w32api/include/urlmon.h [moved from reactos/include/wine/urlmon.h with 68% similarity]

index 7cad980..43c5853 100644 (file)
@@ -43,7 +43,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(shell);
 typedef struct
 {
   const IStreamVtbl *lpVtbl;
-  ULONG    ref;
+  LONG     ref;
   HANDLE   hFile;
   DWORD    dwMode;
   LPOLESTR lpszPath;
index 530b57c..6321be3 100644 (file)
@@ -74,11 +74,6 @@ extern HMODULE SHLWAPI_hversion;
 
 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;
@@ -1496,48 +1491,39 @@ HRESULT WINAPI IUnknown_SetOwner(IUnknown *pUnk, ULONG arg)
 /*************************************************************************
  *      @      [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;
 }
 
 /*************************************************************************
@@ -1962,14 +1948,14 @@ HRESULT WINAPI IUnknown_HandleIRestrict(LPUNKNOWN lpUnknown, PVOID lpArg1,
  */
 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;
@@ -2230,63 +2216,129 @@ BOOL WINAPI SHIsChildOrSelf(HWND hParent, HWND hChild)
   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;
@@ -3527,6 +3579,31 @@ BOOL WINAPI GetOpenFileNameWrapW(LPOPENFILENAMEW ofn)
   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)
 {
@@ -3644,6 +3721,16 @@ BOOL WINAPI SHFlushSFCacheWrap(void) {
   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.
@@ -3905,6 +3992,19 @@ BOOL WINAPI IsOS(DWORD feature)
     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]
  *
@@ -4122,13 +4222,14 @@ BOOL WINAPI SHIsLowMemoryMachine (DWORD x)
  */
 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++;
  }
index ccee4a8..ea3b73c 100644 (file)
@@ -1191,13 +1191,12 @@ DWORD WINAPI SHSetValueA(HKEY hKey, LPCSTR lpszSubKey, LPCSTR lpszValue,
 {
   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;
@@ -1220,13 +1219,12 @@ DWORD WINAPI SHSetValueW(HKEY hKey, LPCWSTR lpszSubKey, LPCWSTR lpszValue,
 {
   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;
index c09a42d..50b6c45 100644 (file)
@@ -37,7 +37,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(shell);
 typedef struct
 {
        const IStreamVtbl *lpVtbl;
-       DWORD  ref;
+       LONG   ref;
        HKEY   hKey;
        LPBYTE pbBuffer;
        DWORD  dwLength;
index 2d60b1b..2c9adea 100644 (file)
 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)
index 5d68bb7..1624f96 100644 (file)
@@ -105,7 +105,7 @@ BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID fImpLoad)
  *     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;
 
index 4e634f2..2f2f924 100644 (file)
@@ -2699,3 +2699,58 @@ BOOL WINAPI DoesStringRoundTripW(LPCWSTR lpSrcStr, LPSTR lpDst, INT iLen)
     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;
+}
index ae482df..67d5ba6 100644 (file)
@@ -75,12 +75,13 @@ DWORD WINAPI SHStringFromGUIDA(REFGUID,LPSTR,INT);
  */
 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 */
   {
@@ -426,7 +427,7 @@ HANDLE WINAPI _SHGlobalCounterCreateNamedW(LPCWSTR lpszName, DWORD iInitial)
     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);
diff --git a/reactos/w32api/include/msxml.h b/reactos/w32api/include/msxml.h
new file mode 100644 (file)
index 0000000..e876eba
--- /dev/null
@@ -0,0 +1,1763 @@
+/*** 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 */
index 499c868..83546f7 100644 (file)
@@ -9,6 +9,7 @@ extern "C" {
 #endif
 
 #include <ole2.h>
+#include <urlmon.h>
 
 typedef interface IErrorLog *LPERRORLOG;
 typedef interface IPropertyBag *LPPROPERTYBAG;
index 8d86732..01e3c9d 100644 (file)
@@ -259,6 +259,7 @@ WINSHLWAPI BOOL WINAPI ChrCmpIW(WCHAR,WCHAR);
 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);
similarity index 68%
rename from reactos/include/wine/urlmon.h
rename to reactos/w32api/include/urlmon.h
index 4d87221..062d0e4 100644 (file)
@@ -10,6 +10,12 @@ extern "C" {
 #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;
@@ -183,6 +189,13 @@ typedef struct IBindStatusCallback IBindStatusCallback;
 
 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,
@@ -544,6 +557,83 @@ void __RPC_STUB IBindStatusCallback_OnObjectAvailable_Stub(
 
 #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__
@@ -1070,6 +1160,764 @@ void __RPC_STUB IPersistMoniker_GetCurMoniker_Stub(
 
 #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;
@@ -1955,6 +2803,13 @@ struct IInternetZoneManager : public IUnknown
         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,
@@ -2046,6 +2901,7 @@ struct IInternetZoneManagerVtbl {
     HRESULT (STDMETHODCALLTYPE *PromptAction)(
         IInternetZoneManager* This,
         DWORD dwAction,
+        HWND hwndParent,
         LPCWSTR pwszUrl,
         LPCWSTR pwszText,
         DWORD dwPromptFlags);
@@ -2094,6 +2950,7 @@ struct IInternetZoneManagerVtbl {
 #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)
@@ -2169,6 +3026,18 @@ void __RPC_STUB IInternetZoneManager_SetZoneActionPolicy_Stub(
     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,
@@ -2237,9 +3106,157 @@ typedef struct _tagSOFTDISTINFO {
     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
@@ -2259,11 +3276,13 @@ DEFINE_GUID(CLSID_StdURLMoniker, 0x79EAC9E0, 0xBAF9, 0x11CE, 0x8C, 0x82, 0x00, 0
 #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);
@@ -2273,9 +3292,27 @@ HRESULT WINAPI CoInternetGetSession(DWORD,IInternetSession**,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