diff --git a/mingw-w64-headers/direct-x/ChangeLog b/mingw-w64-headers/direct-x/ChangeLog
index de391db..a426c2c 100644
--- a/mingw-w64-headers/direct-x/ChangeLog
+++ b/mingw-w64-headers/direct-x/ChangeLog
@@ -1,3 +1,9 @@
+2010-02-11  Ozkan Sezer <sezeroz@gmail.com>
+
+	* ddstream.h, docobj.h, downloadmgr.h: Regenerated using widl-1.1.38
+	from the latest wine-1.1.38 *.idl files.
+	* ddstream.idl, docobj.idl, downloadmgr.idl: Added as idl versions.
+
 2010-02-03  Ozkan Sezer <sezeroz@gmail.com>
 
 	* dinput.h: Add DISEQUENCE_COMPARE macro. (wine git, 23 Aug 2009,
diff --git a/mingw-w64-headers/direct-x/include/ddstream.h b/mingw-w64-headers/direct-x/include/ddstream.h
index 734782b..71b5e1f 100644
--- a/mingw-w64-headers/direct-x/include/ddstream.h
+++ b/mingw-w64-headers/direct-x/include/ddstream.h
@@ -1,14 +1,33 @@
-/*** Autogenerated by WIDL 0.9.14 from ../../wine-src/include/ddstream.idl - Do not edit ***/
+/*** Autogenerated by WIDL 1.1.38 from ddstream.idl - Do not edit ***/
+
 #include <rpc.h>
 #include <rpcndr.h>
 
 #ifndef __WIDL_DDSTREAM_H
 #define __WIDL_DDSTREAM_H
+
 #ifdef __cplusplus
 extern "C" {
 #endif
+
+/* Headers for imported files */
+
 #include <unknwn.h>
 #include <mmstream.h>
+
+/* Forward declarations */
+
+#ifndef __IDirectDrawMediaStream_FWD_DEFINED__
+#define __IDirectDrawMediaStream_FWD_DEFINED__
+typedef interface IDirectDrawMediaStream IDirectDrawMediaStream;
+#endif
+
+#ifndef __IDirectDrawStreamSample_FWD_DEFINED__
+#define __IDirectDrawStreamSample_FWD_DEFINED__
+typedef interface IDirectDrawStreamSample IDirectDrawStreamSample;
+#endif
+
+
 #ifndef __WINE_DDRAW_H
 typedef void *LPDDSURFACEDESC;
 typedef struct tDDSURFACEDESC DDSURFACEDESC;
@@ -160,33 +179,33 @@
     END_INTERFACE
 } IDirectDrawMediaStreamVtbl;
 interface IDirectDrawMediaStream {
-    const IDirectDrawMediaStreamVtbl* lpVtbl;
+    CONST_VTBL IDirectDrawMediaStreamVtbl* lpVtbl;
 };
 
 #ifdef COBJMACROS
 /*** IUnknown methods ***/
-#define IDirectDrawMediaStream_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
-#define IDirectDrawMediaStream_AddRef(p) (p)->lpVtbl->AddRef(p)
-#define IDirectDrawMediaStream_Release(p) (p)->lpVtbl->Release(p)
+#define IDirectDrawMediaStream_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDirectDrawMediaStream_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDirectDrawMediaStream_Release(This) (This)->lpVtbl->Release(This)
 /*** IMediaStream methods ***/
-#define IDirectDrawMediaStream_GetMultiMediaStream(p,a) (p)->lpVtbl->GetMultiMediaStream(p,a)
-#define IDirectDrawMediaStream_GetInformation(p,a,b) (p)->lpVtbl->GetInformation(p,a,b)
-#define IDirectDrawMediaStream_SetSameFormat(p,a,b) (p)->lpVtbl->SetSameFormat(p,a,b)
-#define IDirectDrawMediaStream_AllocateSample(p,a,b) (p)->lpVtbl->AllocateSample(p,a,b)
-#define IDirectDrawMediaStream_CreateSharedSample(p,a,b,c) (p)->lpVtbl->CreateSharedSample(p,a,b,c)
-#define IDirectDrawMediaStream_SendEndOfStream(p,a) (p)->lpVtbl->SendEndOfStream(p,a)
+#define IDirectDrawMediaStream_GetMultiMediaStream(This,ppMultiMediaStream) (This)->lpVtbl->GetMultiMediaStream(This,ppMultiMediaStream)
+#define IDirectDrawMediaStream_GetInformation(This,pPurposeId,pType) (This)->lpVtbl->GetInformation(This,pPurposeId,pType)
+#define IDirectDrawMediaStream_SetSameFormat(This,pStreamThatHasDesiredFormat,dwFlags) (This)->lpVtbl->SetSameFormat(This,pStreamThatHasDesiredFormat,dwFlags)
+#define IDirectDrawMediaStream_AllocateSample(This,dwFlags,ppSample) (This)->lpVtbl->AllocateSample(This,dwFlags,ppSample)
+#define IDirectDrawMediaStream_CreateSharedSample(This,pExistingSample,dwFlags,ppNewSample) (This)->lpVtbl->CreateSharedSample(This,pExistingSample,dwFlags,ppNewSample)
+#define IDirectDrawMediaStream_SendEndOfStream(This,dwFlags) (This)->lpVtbl->SendEndOfStream(This,dwFlags)
 /*** IDirectDrawMediaStream methods ***/
-#define IDirectDrawMediaStream_GetFormat(p,a,b,c,d) (p)->lpVtbl->GetFormat(p,a,b,c,d)
-#define IDirectDrawMediaStream_SetFormat(p,a,b) (p)->lpVtbl->SetFormat(p,a,b)
-#define IDirectDrawMediaStream_GetDirectDraw(p,a) (p)->lpVtbl->GetDirectDraw(p,a)
-#define IDirectDrawMediaStream_SetDirectDraw(p,a) (p)->lpVtbl->SetDirectDraw(p,a)
-#define IDirectDrawMediaStream_CreateSample(p,a,b,c,d) (p)->lpVtbl->CreateSample(p,a,b,c,d)
-#define IDirectDrawMediaStream_GetTimePerFrame(p,a) (p)->lpVtbl->GetTimePerFrame(p,a)
+#define IDirectDrawMediaStream_GetFormat(This,pDDSDCurrent,ppDirectDrawPalette,pDDSDDesired,pdwFlags) (This)->lpVtbl->GetFormat(This,pDDSDCurrent,ppDirectDrawPalette,pDDSDDesired,pdwFlags)
+#define IDirectDrawMediaStream_SetFormat(This,pDDSurfaceDesc,pDirectDrawPalette) (This)->lpVtbl->SetFormat(This,pDDSurfaceDesc,pDirectDrawPalette)
+#define IDirectDrawMediaStream_GetDirectDraw(This,ppDirectDraw) (This)->lpVtbl->GetDirectDraw(This,ppDirectDraw)
+#define IDirectDrawMediaStream_SetDirectDraw(This,pDirectDraw) (This)->lpVtbl->SetDirectDraw(This,pDirectDraw)
+#define IDirectDrawMediaStream_CreateSample(This,pSurface,pRect,dwFlags,ppSample) (This)->lpVtbl->CreateSample(This,pSurface,pRect,dwFlags,ppSample)
+#define IDirectDrawMediaStream_GetTimePerFrame(This,pFrameTime) (This)->lpVtbl->GetTimePerFrame(This,pFrameTime)
 #endif
 
 #endif
 
-HRESULT CALLBACK IDirectDrawMediaStream_GetFormat_Proxy(
+HRESULT STDMETHODCALLTYPE IDirectDrawMediaStream_GetFormat_Proxy(
     IDirectDrawMediaStream* This,
     DDSURFACEDESC *pDDSDCurrent,
     IDirectDrawPalette **ppDirectDrawPalette,
@@ -197,7 +216,7 @@
     IRpcChannelBuffer* pRpcChannelBuffer,
     PRPC_MESSAGE pRpcMessage,
     DWORD* pdwStubPhase);
-HRESULT CALLBACK IDirectDrawMediaStream_SetFormat_Proxy(
+HRESULT STDMETHODCALLTYPE IDirectDrawMediaStream_SetFormat_Proxy(
     IDirectDrawMediaStream* This,
     const DDSURFACEDESC *pDDSurfaceDesc,
     IDirectDrawPalette *pDirectDrawPalette);
@@ -206,7 +225,7 @@
     IRpcChannelBuffer* pRpcChannelBuffer,
     PRPC_MESSAGE pRpcMessage,
     DWORD* pdwStubPhase);
-HRESULT CALLBACK IDirectDrawMediaStream_GetDirectDraw_Proxy(
+HRESULT STDMETHODCALLTYPE IDirectDrawMediaStream_GetDirectDraw_Proxy(
     IDirectDrawMediaStream* This,
     IDirectDraw **ppDirectDraw);
 void __RPC_STUB IDirectDrawMediaStream_GetDirectDraw_Stub(
@@ -214,7 +233,7 @@
     IRpcChannelBuffer* pRpcChannelBuffer,
     PRPC_MESSAGE pRpcMessage,
     DWORD* pdwStubPhase);
-HRESULT CALLBACK IDirectDrawMediaStream_SetDirectDraw_Proxy(
+HRESULT STDMETHODCALLTYPE IDirectDrawMediaStream_SetDirectDraw_Proxy(
     IDirectDrawMediaStream* This,
     IDirectDraw *pDirectDraw);
 void __RPC_STUB IDirectDrawMediaStream_SetDirectDraw_Stub(
@@ -222,7 +241,7 @@
     IRpcChannelBuffer* pRpcChannelBuffer,
     PRPC_MESSAGE pRpcMessage,
     DWORD* pdwStubPhase);
-HRESULT CALLBACK IDirectDrawMediaStream_CreateSample_Proxy(
+HRESULT STDMETHODCALLTYPE IDirectDrawMediaStream_CreateSample_Proxy(
     IDirectDrawMediaStream* This,
     IDirectDrawSurface *pSurface,
     const RECT *pRect,
@@ -233,7 +252,7 @@
     IRpcChannelBuffer* pRpcChannelBuffer,
     PRPC_MESSAGE pRpcMessage,
     DWORD* pdwStubPhase);
-HRESULT CALLBACK IDirectDrawMediaStream_GetTimePerFrame_Proxy(
+HRESULT STDMETHODCALLTYPE IDirectDrawMediaStream_GetTimePerFrame_Proxy(
     IDirectDrawMediaStream* This,
     STREAM_TIME *pFrameTime);
 void __RPC_STUB IDirectDrawMediaStream_GetTimePerFrame_Stub(
@@ -319,28 +338,28 @@
     END_INTERFACE
 } IDirectDrawStreamSampleVtbl;
 interface IDirectDrawStreamSample {
-    const IDirectDrawStreamSampleVtbl* lpVtbl;
+    CONST_VTBL IDirectDrawStreamSampleVtbl* lpVtbl;
 };
 
 #ifdef COBJMACROS
 /*** IUnknown methods ***/
-#define IDirectDrawStreamSample_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
-#define IDirectDrawStreamSample_AddRef(p) (p)->lpVtbl->AddRef(p)
-#define IDirectDrawStreamSample_Release(p) (p)->lpVtbl->Release(p)
+#define IDirectDrawStreamSample_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDirectDrawStreamSample_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDirectDrawStreamSample_Release(This) (This)->lpVtbl->Release(This)
 /*** IStreamSample methods ***/
-#define IDirectDrawStreamSample_GetMediaStream(p,a) (p)->lpVtbl->GetMediaStream(p,a)
-#define IDirectDrawStreamSample_GetSampleTimes(p,a,b,c) (p)->lpVtbl->GetSampleTimes(p,a,b,c)
-#define IDirectDrawStreamSample_SetSampleTimes(p,a,b) (p)->lpVtbl->SetSampleTimes(p,a,b)
-#define IDirectDrawStreamSample_Update(p,a,b,c,d) (p)->lpVtbl->Update(p,a,b,c,d)
-#define IDirectDrawStreamSample_CompletionStatus(p,a,b) (p)->lpVtbl->CompletionStatus(p,a,b)
+#define IDirectDrawStreamSample_GetMediaStream(This,ppMediaStream) (This)->lpVtbl->GetMediaStream(This,ppMediaStream)
+#define IDirectDrawStreamSample_GetSampleTimes(This,pStartTime,pEndTime,pCurrentTime) (This)->lpVtbl->GetSampleTimes(This,pStartTime,pEndTime,pCurrentTime)
+#define IDirectDrawStreamSample_SetSampleTimes(This,pStartTime,pEndTime) (This)->lpVtbl->SetSampleTimes(This,pStartTime,pEndTime)
+#define IDirectDrawStreamSample_Update(This,dwFlags,hEvent,pfnAPC,dwAPCData) (This)->lpVtbl->Update(This,dwFlags,hEvent,pfnAPC,dwAPCData)
+#define IDirectDrawStreamSample_CompletionStatus(This,dwFlags,dwMilliseconds) (This)->lpVtbl->CompletionStatus(This,dwFlags,dwMilliseconds)
 /*** IDirectDrawStreamSample methods ***/
-#define IDirectDrawStreamSample_GetSurface(p,a,b) (p)->lpVtbl->GetSurface(p,a,b)
-#define IDirectDrawStreamSample_SetRect(p,a) (p)->lpVtbl->SetRect(p,a)
+#define IDirectDrawStreamSample_GetSurface(This,ppDirectDrawSurface,pRect) (This)->lpVtbl->GetSurface(This,ppDirectDrawSurface,pRect)
+#define IDirectDrawStreamSample_SetRect(This,pRect) (This)->lpVtbl->SetRect(This,pRect)
 #endif
 
 #endif
 
-HRESULT CALLBACK IDirectDrawStreamSample_GetSurface_Proxy(
+HRESULT STDMETHODCALLTYPE IDirectDrawStreamSample_GetSurface_Proxy(
     IDirectDrawStreamSample* This,
     IDirectDrawSurface **ppDirectDrawSurface,
     RECT *pRect);
@@ -349,7 +368,7 @@
     IRpcChannelBuffer* pRpcChannelBuffer,
     PRPC_MESSAGE pRpcMessage,
     DWORD* pdwStubPhase);
-HRESULT CALLBACK IDirectDrawStreamSample_SetRect_Proxy(
+HRESULT STDMETHODCALLTYPE IDirectDrawStreamSample_SetRect_Proxy(
     IDirectDrawStreamSample* This,
     const RECT *pRect);
 void __RPC_STUB IDirectDrawStreamSample_SetRect_Stub(
@@ -368,4 +387,5 @@
 #ifdef __cplusplus
 }
 #endif
+
 #endif /* __WIDL_DDSTREAM_H */
diff --git a/mingw-w64-headers/direct-x/include/ddstream.idl b/mingw-w64-headers/direct-x/include/ddstream.idl
new file mode 100644
index 0000000..947e2bc
--- /dev/null
+++ b/mingw-w64-headers/direct-x/include/ddstream.idl
@@ -0,0 +1,88 @@
+/*
+ * Copyright 2004 Christian Costa
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+import "unknwn.idl";
+import "mmstream.idl";
+
+cpp_quote("#ifndef __WINE_DDRAW_H")
+typedef void * LPDDSURFACEDESC;
+typedef struct tDDSURFACEDESC DDSURFACEDESC;
+interface IDirectDraw;
+interface IDirectDrawSurface;
+interface IDirectDrawPalette;
+cpp_quote("#endif")
+cpp_quote("#include <ddraw.h>")
+
+enum {
+	DDSFF_PROGRESSIVERENDER = 0x00000001
+};
+
+interface IDirectDrawMediaStream;
+interface IDirectDrawStreamSample;
+
+[
+object,
+local,
+uuid(F4104FCE-9A70-11d0-8FDE-00C04FD9189D),
+pointer_default(unique)
+]
+interface IDirectDrawMediaStream : IMediaStream
+{
+	HRESULT GetFormat(
+		[out] DDSURFACEDESC *pDDSDCurrent,
+		[out] IDirectDrawPalette **ppDirectDrawPalette,
+		[out] DDSURFACEDESC *pDDSDDesired,
+		[out] DWORD *pdwFlags);
+
+	HRESULT SetFormat(
+		[in] const DDSURFACEDESC *pDDSurfaceDesc,
+		[in] IDirectDrawPalette *pDirectDrawPalette);
+
+	HRESULT GetDirectDraw(
+		[out] IDirectDraw **ppDirectDraw);
+
+	HRESULT SetDirectDraw(
+		[in] IDirectDraw *pDirectDraw);
+
+	HRESULT CreateSample(
+		[in] IDirectDrawSurface *pSurface,
+		[in] const RECT *pRect,
+		[in] DWORD dwFlags,
+		[out] IDirectDrawStreamSample **ppSample);
+
+	HRESULT GetTimePerFrame(
+		[out] STREAM_TIME *pFrameTime);
+}
+
+
+[
+object,
+local,
+uuid(F4104FCF-9A70-11d0-8FDE-00C04FD9189D),
+pointer_default(unique)
+]
+interface IDirectDrawStreamSample : IStreamSample
+{
+	HRESULT GetSurface(
+		[out] IDirectDrawSurface ** ppDirectDrawSurface,
+		[out] RECT * pRect);
+
+	HRESULT SetRect(
+		[in] const RECT * pRect);
+
+}
diff --git a/mingw-w64-headers/direct-x/include/docobj.h b/mingw-w64-headers/direct-x/include/docobj.h
index 5d4c68c..180bb9a 100644
--- a/mingw-w64-headers/direct-x/include/docobj.h
+++ b/mingw-w64-headers/direct-x/include/docobj.h
@@ -1,17 +1,35 @@
-/*** Autogenerated by WIDL 0.9.14 from ../../wine-src/include/docobj.idl - Do not edit ***/
+/*** Autogenerated by WIDL 1.1.38 from docobj.idl - Do not edit ***/
+
 #include <rpc.h>
 #include <rpcndr.h>
 
 #ifndef __WIDL_DOCOBJ_H
 #define __WIDL_DOCOBJ_H
+
 #ifdef __cplusplus
 extern "C" {
 #endif
+
+/* Headers for imported files */
+
 #include <ocidl.h>
 #include <objidl.h>
 #include <oleidl.h>
 #include <oaidl.h>
 #include <servprov.h>
+
+/* Forward declarations */
+
+#ifndef __IOleDocument_FWD_DEFINED__
+#define __IOleDocument_FWD_DEFINED__
+typedef interface IOleDocument IOleDocument;
+#endif
+
+#ifndef __IOleDocumentSite_FWD_DEFINED__
+#define __IOleDocumentSite_FWD_DEFINED__
+typedef interface IOleDocumentSite IOleDocumentSite;
+#endif
+
 #ifndef __IOleDocumentView_FWD_DEFINED__
 #define __IOleDocumentView_FWD_DEFINED__
 typedef interface IOleDocumentView IOleDocumentView;
@@ -22,24 +40,45 @@
 typedef interface IEnumOleDocumentViews IEnumOleDocumentViews;
 #endif
 
-#ifndef __IOleDocument_FWD_DEFINED__
-#define __IOleDocument_FWD_DEFINED__
-typedef interface IOleDocument IOleDocument;
+#ifndef __IOleCommandTarget_FWD_DEFINED__
+#define __IOleCommandTarget_FWD_DEFINED__
+typedef interface IOleCommandTarget IOleCommandTarget;
 #endif
 
-typedef IOleDocument *LPOLEDOCUMENT;
-typedef enum {
-    DOCMISC_CANCREATEMULTIPLEVIEWS = 1,
-    DOCMISC_SUPPORTCOMPLEXRECTANGLES = 2,
-    DOCMISC_CANTOPENEDIT = 4,
-    DOCMISC_NOFILESUPPORT = 8
-} DOCMISC;
+#ifndef __IContinueCallback_FWD_DEFINED__
+#define __IContinueCallback_FWD_DEFINED__
+typedef interface IContinueCallback IContinueCallback;
+#endif
+
+#ifndef __IPrint_FWD_DEFINED__
+#define __IPrint_FWD_DEFINED__
+typedef interface IPrint IPrint;
+#endif
+
+
+#ifndef __IOleDocumentView_FWD_DEFINED__
+#define __IOleDocumentView_FWD_DEFINED__
+typedef interface IOleDocumentView IOleDocumentView;
+#endif
+
+#ifndef __IEnumOleDocumentViews_FWD_DEFINED__
+#define __IEnumOleDocumentViews_FWD_DEFINED__
+typedef interface IEnumOleDocumentViews IEnumOleDocumentViews;
+#endif
+
 /*****************************************************************************
  * IOleDocument interface
  */
 #ifndef __IOleDocument_INTERFACE_DEFINED__
 #define __IOleDocument_INTERFACE_DEFINED__
 
+typedef IOleDocument *LPOLEDOCUMENT;
+typedef enum __WIDL_docobj_generated_name_00000000 {
+    DOCMISC_CANCREATEMULTIPLEVIEWS = 1,
+    DOCMISC_SUPPORTCOMPLEXRECTANGLES = 2,
+    DOCMISC_CANTOPENEDIT = 4,
+    DOCMISC_NOFILESUPPORT = 8
+} DOCMISC;
 DEFINE_GUID(IID_IOleDocument, 0xb722bcc5, 0x4e68, 0x101b, 0xa2,0xbc, 0x00,0xaa,0x00,0x40,0x47,0x70);
 #if defined(__cplusplus) && !defined(CINTERFACE)
 interface IOleDocument : public IUnknown
@@ -94,23 +133,23 @@
     END_INTERFACE
 } IOleDocumentVtbl;
 interface IOleDocument {
-    const IOleDocumentVtbl* lpVtbl;
+    CONST_VTBL IOleDocumentVtbl* lpVtbl;
 };
 
 #ifdef COBJMACROS
 /*** IUnknown methods ***/
-#define IOleDocument_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
-#define IOleDocument_AddRef(p) (p)->lpVtbl->AddRef(p)
-#define IOleDocument_Release(p) (p)->lpVtbl->Release(p)
+#define IOleDocument_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IOleDocument_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IOleDocument_Release(This) (This)->lpVtbl->Release(This)
 /*** IOleDocument methods ***/
-#define IOleDocument_CreateView(p,a,b,c,d) (p)->lpVtbl->CreateView(p,a,b,c,d)
-#define IOleDocument_GetDocMiscStatus(p,a) (p)->lpVtbl->GetDocMiscStatus(p,a)
-#define IOleDocument_EnumViews(p,a,b) (p)->lpVtbl->EnumViews(p,a,b)
+#define IOleDocument_CreateView(This,pIPSite,pstm,dwReserved,ppView) (This)->lpVtbl->CreateView(This,pIPSite,pstm,dwReserved,ppView)
+#define IOleDocument_GetDocMiscStatus(This,pdwStatus) (This)->lpVtbl->GetDocMiscStatus(This,pdwStatus)
+#define IOleDocument_EnumViews(This,ppEnum,ppView) (This)->lpVtbl->EnumViews(This,ppEnum,ppView)
 #endif
 
 #endif
 
-HRESULT CALLBACK IOleDocument_CreateView_Proxy(
+HRESULT STDMETHODCALLTYPE IOleDocument_CreateView_Proxy(
     IOleDocument* This,
     IOleInPlaceSite *pIPSite,
     IStream *pstm,
@@ -121,7 +160,7 @@
     IRpcChannelBuffer* pRpcChannelBuffer,
     PRPC_MESSAGE pRpcMessage,
     DWORD* pdwStubPhase);
-HRESULT CALLBACK IOleDocument_GetDocMiscStatus_Proxy(
+HRESULT STDMETHODCALLTYPE IOleDocument_GetDocMiscStatus_Proxy(
     IOleDocument* This,
     DWORD *pdwStatus);
 void __RPC_STUB IOleDocument_GetDocMiscStatus_Stub(
@@ -129,7 +168,7 @@
     IRpcChannelBuffer* pRpcChannelBuffer,
     PRPC_MESSAGE pRpcMessage,
     DWORD* pdwStubPhase);
-HRESULT CALLBACK IOleDocument_EnumViews_Proxy(
+HRESULT STDMETHODCALLTYPE IOleDocument_EnumViews_Proxy(
     IOleDocument* This,
     IEnumOleDocumentViews **ppEnum,
     IOleDocumentView **ppView);
@@ -141,18 +180,13 @@
 
 #endif  /* __IOleDocument_INTERFACE_DEFINED__ */
 
-#ifndef __IOleDocumentSite_FWD_DEFINED__
-#define __IOleDocumentSite_FWD_DEFINED__
-typedef interface IOleDocumentSite IOleDocumentSite;
-#endif
-
-typedef IOleDocumentSite *LPOLEDOCUMENTSITE;
 /*****************************************************************************
  * IOleDocumentSite interface
  */
 #ifndef __IOleDocumentSite_INTERFACE_DEFINED__
 #define __IOleDocumentSite_INTERFACE_DEFINED__
 
+typedef IOleDocumentSite *LPOLEDOCUMENTSITE;
 DEFINE_GUID(IID_IOleDocumentSite, 0xb722bcc7, 0x4e68, 0x101b, 0xa2,0xbc, 0x00,0xaa,0x00,0x40,0x47,0x70);
 #if defined(__cplusplus) && !defined(CINTERFACE)
 interface IOleDocumentSite : public IUnknown
@@ -185,21 +219,21 @@
     END_INTERFACE
 } IOleDocumentSiteVtbl;
 interface IOleDocumentSite {
-    const IOleDocumentSiteVtbl* lpVtbl;
+    CONST_VTBL IOleDocumentSiteVtbl* lpVtbl;
 };
 
 #ifdef COBJMACROS
 /*** IUnknown methods ***/
-#define IOleDocumentSite_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
-#define IOleDocumentSite_AddRef(p) (p)->lpVtbl->AddRef(p)
-#define IOleDocumentSite_Release(p) (p)->lpVtbl->Release(p)
+#define IOleDocumentSite_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IOleDocumentSite_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IOleDocumentSite_Release(This) (This)->lpVtbl->Release(This)
 /*** IOleDocumentSite methods ***/
-#define IOleDocumentSite_ActivateMe(p,a) (p)->lpVtbl->ActivateMe(p,a)
+#define IOleDocumentSite_ActivateMe(This,pViewToActivate) (This)->lpVtbl->ActivateMe(This,pViewToActivate)
 #endif
 
 #endif
 
-HRESULT CALLBACK IOleDocumentSite_ActivateMe_Proxy(
+HRESULT STDMETHODCALLTYPE IOleDocumentSite_ActivateMe_Proxy(
     IOleDocumentSite* This,
     IOleDocumentView *pViewToActivate);
 void __RPC_STUB IOleDocumentSite_ActivateMe_Stub(
@@ -210,13 +244,13 @@
 
 #endif  /* __IOleDocumentSite_INTERFACE_DEFINED__ */
 
-typedef IOleDocumentView *LPOLEDOCUMENTVIEW;
 /*****************************************************************************
  * IOleDocumentView interface
  */
 #ifndef __IOleDocumentView_INTERFACE_DEFINED__
 #define __IOleDocumentView_INTERFACE_DEFINED__
 
+typedef IOleDocumentView *LPOLEDOCUMENTVIEW;
 DEFINE_GUID(IID_IOleDocumentView, 0xb722bcc6, 0x4e68, 0x101b, 0xa2,0xbc, 0x00,0xaa,0x00,0x40,0x47,0x70);
 #if defined(__cplusplus) && !defined(CINTERFACE)
 interface IOleDocumentView : public IUnknown
@@ -340,33 +374,33 @@
     END_INTERFACE
 } IOleDocumentViewVtbl;
 interface IOleDocumentView {
-    const IOleDocumentViewVtbl* lpVtbl;
+    CONST_VTBL IOleDocumentViewVtbl* lpVtbl;
 };
 
 #ifdef COBJMACROS
 /*** IUnknown methods ***/
-#define IOleDocumentView_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
-#define IOleDocumentView_AddRef(p) (p)->lpVtbl->AddRef(p)
-#define IOleDocumentView_Release(p) (p)->lpVtbl->Release(p)
+#define IOleDocumentView_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IOleDocumentView_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IOleDocumentView_Release(This) (This)->lpVtbl->Release(This)
 /*** IOleDocumentView methods ***/
-#define IOleDocumentView_SetInPlaceSite(p,a) (p)->lpVtbl->SetInPlaceSite(p,a)
-#define IOleDocumentView_GetInPlaceSite(p,a) (p)->lpVtbl->GetInPlaceSite(p,a)
-#define IOleDocumentView_GetDocument(p,a) (p)->lpVtbl->GetDocument(p,a)
-#define IOleDocumentView_SetRect(p,a) (p)->lpVtbl->SetRect(p,a)
-#define IOleDocumentView_GetRect(p,a) (p)->lpVtbl->GetRect(p,a)
-#define IOleDocumentView_SetRectComplex(p,a,b,c,d) (p)->lpVtbl->SetRectComplex(p,a,b,c,d)
-#define IOleDocumentView_Show(p,a) (p)->lpVtbl->Show(p,a)
-#define IOleDocumentView_UIActivate(p,a) (p)->lpVtbl->UIActivate(p,a)
-#define IOleDocumentView_Open(p) (p)->lpVtbl->Open(p)
-#define IOleDocumentView_CloseView(p,a) (p)->lpVtbl->CloseView(p,a)
-#define IOleDocumentView_SaveViewState(p,a) (p)->lpVtbl->SaveViewState(p,a)
-#define IOleDocumentView_ApplyViewState(p,a) (p)->lpVtbl->ApplyViewState(p,a)
-#define IOleDocumentView_Clone(p,a,b) (p)->lpVtbl->Clone(p,a,b)
+#define IOleDocumentView_SetInPlaceSite(This,pIPSite) (This)->lpVtbl->SetInPlaceSite(This,pIPSite)
+#define IOleDocumentView_GetInPlaceSite(This,ppIPSite) (This)->lpVtbl->GetInPlaceSite(This,ppIPSite)
+#define IOleDocumentView_GetDocument(This,ppunk) (This)->lpVtbl->GetDocument(This,ppunk)
+#define IOleDocumentView_SetRect(This,prcView) (This)->lpVtbl->SetRect(This,prcView)
+#define IOleDocumentView_GetRect(This,prcView) (This)->lpVtbl->GetRect(This,prcView)
+#define IOleDocumentView_SetRectComplex(This,prcView,prcHScroll,prcVScroll,prcSizeBox) (This)->lpVtbl->SetRectComplex(This,prcView,prcHScroll,prcVScroll,prcSizeBox)
+#define IOleDocumentView_Show(This,fShow) (This)->lpVtbl->Show(This,fShow)
+#define IOleDocumentView_UIActivate(This,fUIActivate) (This)->lpVtbl->UIActivate(This,fUIActivate)
+#define IOleDocumentView_Open(This) (This)->lpVtbl->Open(This)
+#define IOleDocumentView_CloseView(This,dwReserved) (This)->lpVtbl->CloseView(This,dwReserved)
+#define IOleDocumentView_SaveViewState(This,pstm) (This)->lpVtbl->SaveViewState(This,pstm)
+#define IOleDocumentView_ApplyViewState(This,pstm) (This)->lpVtbl->ApplyViewState(This,pstm)
+#define IOleDocumentView_Clone(This,pIPSiteNew,ppViewNew) (This)->lpVtbl->Clone(This,pIPSiteNew,ppViewNew)
 #endif
 
 #endif
 
-HRESULT CALLBACK IOleDocumentView_SetInPlaceSite_Proxy(
+HRESULT STDMETHODCALLTYPE IOleDocumentView_SetInPlaceSite_Proxy(
     IOleDocumentView* This,
     IOleInPlaceSite *pIPSite);
 void __RPC_STUB IOleDocumentView_SetInPlaceSite_Stub(
@@ -374,7 +408,7 @@
     IRpcChannelBuffer* pRpcChannelBuffer,
     PRPC_MESSAGE pRpcMessage,
     DWORD* pdwStubPhase);
-HRESULT CALLBACK IOleDocumentView_GetInPlaceSite_Proxy(
+HRESULT STDMETHODCALLTYPE IOleDocumentView_GetInPlaceSite_Proxy(
     IOleDocumentView* This,
     IOleInPlaceSite **ppIPSite);
 void __RPC_STUB IOleDocumentView_GetInPlaceSite_Stub(
@@ -382,7 +416,7 @@
     IRpcChannelBuffer* pRpcChannelBuffer,
     PRPC_MESSAGE pRpcMessage,
     DWORD* pdwStubPhase);
-HRESULT CALLBACK IOleDocumentView_GetDocument_Proxy(
+HRESULT STDMETHODCALLTYPE IOleDocumentView_GetDocument_Proxy(
     IOleDocumentView* This,
     IUnknown **ppunk);
 void __RPC_STUB IOleDocumentView_GetDocument_Stub(
@@ -390,7 +424,7 @@
     IRpcChannelBuffer* pRpcChannelBuffer,
     PRPC_MESSAGE pRpcMessage,
     DWORD* pdwStubPhase);
-HRESULT CALLBACK IOleDocumentView_SetRect_Proxy(
+HRESULT STDMETHODCALLTYPE IOleDocumentView_SetRect_Proxy(
     IOleDocumentView* This,
     LPRECT prcView);
 void __RPC_STUB IOleDocumentView_SetRect_Stub(
@@ -398,7 +432,7 @@
     IRpcChannelBuffer* pRpcChannelBuffer,
     PRPC_MESSAGE pRpcMessage,
     DWORD* pdwStubPhase);
-HRESULT CALLBACK IOleDocumentView_GetRect_Proxy(
+HRESULT STDMETHODCALLTYPE IOleDocumentView_GetRect_Proxy(
     IOleDocumentView* This,
     LPRECT prcView);
 void __RPC_STUB IOleDocumentView_GetRect_Stub(
@@ -406,7 +440,7 @@
     IRpcChannelBuffer* pRpcChannelBuffer,
     PRPC_MESSAGE pRpcMessage,
     DWORD* pdwStubPhase);
-HRESULT CALLBACK IOleDocumentView_SetRectComplex_Proxy(
+HRESULT STDMETHODCALLTYPE IOleDocumentView_SetRectComplex_Proxy(
     IOleDocumentView* This,
     LPRECT prcView,
     LPRECT prcHScroll,
@@ -417,7 +451,7 @@
     IRpcChannelBuffer* pRpcChannelBuffer,
     PRPC_MESSAGE pRpcMessage,
     DWORD* pdwStubPhase);
-HRESULT CALLBACK IOleDocumentView_Show_Proxy(
+HRESULT STDMETHODCALLTYPE IOleDocumentView_Show_Proxy(
     IOleDocumentView* This,
     BOOL fShow);
 void __RPC_STUB IOleDocumentView_Show_Stub(
@@ -425,7 +459,7 @@
     IRpcChannelBuffer* pRpcChannelBuffer,
     PRPC_MESSAGE pRpcMessage,
     DWORD* pdwStubPhase);
-HRESULT CALLBACK IOleDocumentView_UIActivate_Proxy(
+HRESULT STDMETHODCALLTYPE IOleDocumentView_UIActivate_Proxy(
     IOleDocumentView* This,
     BOOL fUIActivate);
 void __RPC_STUB IOleDocumentView_UIActivate_Stub(
@@ -433,14 +467,14 @@
     IRpcChannelBuffer* pRpcChannelBuffer,
     PRPC_MESSAGE pRpcMessage,
     DWORD* pdwStubPhase);
-HRESULT CALLBACK IOleDocumentView_Open_Proxy(
+HRESULT STDMETHODCALLTYPE IOleDocumentView_Open_Proxy(
     IOleDocumentView* This);
 void __RPC_STUB IOleDocumentView_Open_Stub(
     IRpcStubBuffer* This,
     IRpcChannelBuffer* pRpcChannelBuffer,
     PRPC_MESSAGE pRpcMessage,
     DWORD* pdwStubPhase);
-HRESULT CALLBACK IOleDocumentView_CloseView_Proxy(
+HRESULT STDMETHODCALLTYPE IOleDocumentView_CloseView_Proxy(
     IOleDocumentView* This,
     DWORD dwReserved);
 void __RPC_STUB IOleDocumentView_CloseView_Stub(
@@ -448,7 +482,7 @@
     IRpcChannelBuffer* pRpcChannelBuffer,
     PRPC_MESSAGE pRpcMessage,
     DWORD* pdwStubPhase);
-HRESULT CALLBACK IOleDocumentView_SaveViewState_Proxy(
+HRESULT STDMETHODCALLTYPE IOleDocumentView_SaveViewState_Proxy(
     IOleDocumentView* This,
     LPSTREAM pstm);
 void __RPC_STUB IOleDocumentView_SaveViewState_Stub(
@@ -456,7 +490,7 @@
     IRpcChannelBuffer* pRpcChannelBuffer,
     PRPC_MESSAGE pRpcMessage,
     DWORD* pdwStubPhase);
-HRESULT CALLBACK IOleDocumentView_ApplyViewState_Proxy(
+HRESULT STDMETHODCALLTYPE IOleDocumentView_ApplyViewState_Proxy(
     IOleDocumentView* This,
     LPSTREAM pstm);
 void __RPC_STUB IOleDocumentView_ApplyViewState_Stub(
@@ -464,7 +498,7 @@
     IRpcChannelBuffer* pRpcChannelBuffer,
     PRPC_MESSAGE pRpcMessage,
     DWORD* pdwStubPhase);
-HRESULT CALLBACK IOleDocumentView_Clone_Proxy(
+HRESULT STDMETHODCALLTYPE IOleDocumentView_Clone_Proxy(
     IOleDocumentView* This,
     IOleInPlaceSite *pIPSiteNew,
     IOleDocumentView **ppViewNew);
@@ -476,13 +510,13 @@
 
 #endif  /* __IOleDocumentView_INTERFACE_DEFINED__ */
 
-typedef IEnumOleDocumentViews *LPENUMOLEDOCUMENTVIEWS;
 /*****************************************************************************
  * IEnumOleDocumentViews interface
  */
 #ifndef __IEnumOleDocumentViews_INTERFACE_DEFINED__
 #define __IEnumOleDocumentViews_INTERFACE_DEFINED__
 
+typedef IEnumOleDocumentViews *LPENUMOLEDOCUMENTVIEWS;
 DEFINE_GUID(IID_IEnumOleDocumentViews, 0xb722bcc8, 0x4e68, 0x101b, 0xa2,0xbc, 0x00,0xaa,0x00,0x40,0x47,0x70);
 #if defined(__cplusplus) && !defined(CINTERFACE)
 interface IEnumOleDocumentViews : public IUnknown
@@ -539,24 +573,24 @@
     END_INTERFACE
 } IEnumOleDocumentViewsVtbl;
 interface IEnumOleDocumentViews {
-    const IEnumOleDocumentViewsVtbl* lpVtbl;
+    CONST_VTBL IEnumOleDocumentViewsVtbl* lpVtbl;
 };
 
 #ifdef COBJMACROS
 /*** IUnknown methods ***/
-#define IEnumOleDocumentViews_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
-#define IEnumOleDocumentViews_AddRef(p) (p)->lpVtbl->AddRef(p)
-#define IEnumOleDocumentViews_Release(p) (p)->lpVtbl->Release(p)
+#define IEnumOleDocumentViews_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IEnumOleDocumentViews_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IEnumOleDocumentViews_Release(This) (This)->lpVtbl->Release(This)
 /*** IEnumOleDocumentViews methods ***/
-#define IEnumOleDocumentViews_Next(p,a,b,c) (p)->lpVtbl->Next(p,a,b,c)
-#define IEnumOleDocumentViews_Skip(p,a) (p)->lpVtbl->Skip(p,a)
-#define IEnumOleDocumentViews_Reset(p) (p)->lpVtbl->Reset(p)
-#define IEnumOleDocumentViews_Clone(p,a) (p)->lpVtbl->Clone(p,a)
+#define IEnumOleDocumentViews_Next(This,cViews,rgpView,pcFetched) (This)->lpVtbl->Next(This,cViews,rgpView,pcFetched)
+#define IEnumOleDocumentViews_Skip(This,cViews) (This)->lpVtbl->Skip(This,cViews)
+#define IEnumOleDocumentViews_Reset(This) (This)->lpVtbl->Reset(This)
+#define IEnumOleDocumentViews_Clone(This,ppEnum) (This)->lpVtbl->Clone(This,ppEnum)
 #endif
 
 #endif
 
-HRESULT CALLBACK IEnumOleDocumentViews_RemoteNext_Proxy(
+HRESULT STDMETHODCALLTYPE IEnumOleDocumentViews_RemoteNext_Proxy(
     IEnumOleDocumentViews* This,
     ULONG cViews,
     IOleDocumentView **rgpView,
@@ -566,17 +600,7 @@
     IRpcChannelBuffer* pRpcChannelBuffer,
     PRPC_MESSAGE pRpcMessage,
     DWORD* pdwStubPhase);
-HRESULT CALLBACK IEnumOleDocumentViews_Next_Proxy(
-    IEnumOleDocumentViews* This,
-    ULONG cViews,
-    IOleDocumentView** rgpView,
-    ULONG* pcFetched);
-HRESULT __RPC_STUB IEnumOleDocumentViews_Next_Stub(
-    IEnumOleDocumentViews* This,
-    ULONG cViews,
-    IOleDocumentView** rgpView,
-    ULONG* pcFetched);
-HRESULT CALLBACK IEnumOleDocumentViews_Skip_Proxy(
+HRESULT STDMETHODCALLTYPE IEnumOleDocumentViews_Skip_Proxy(
     IEnumOleDocumentViews* This,
     ULONG cViews);
 void __RPC_STUB IEnumOleDocumentViews_Skip_Stub(
@@ -584,14 +608,14 @@
     IRpcChannelBuffer* pRpcChannelBuffer,
     PRPC_MESSAGE pRpcMessage,
     DWORD* pdwStubPhase);
-HRESULT CALLBACK IEnumOleDocumentViews_Reset_Proxy(
+HRESULT STDMETHODCALLTYPE IEnumOleDocumentViews_Reset_Proxy(
     IEnumOleDocumentViews* This);
 void __RPC_STUB IEnumOleDocumentViews_Reset_Stub(
     IRpcStubBuffer* This,
     IRpcChannelBuffer* pRpcChannelBuffer,
     PRPC_MESSAGE pRpcMessage,
     DWORD* pdwStubPhase);
-HRESULT CALLBACK IEnumOleDocumentViews_Clone_Proxy(
+HRESULT STDMETHODCALLTYPE IEnumOleDocumentViews_Clone_Proxy(
     IEnumOleDocumentViews* This,
     IEnumOleDocumentViews **ppEnum);
 void __RPC_STUB IEnumOleDocumentViews_Clone_Stub(
@@ -599,13 +623,24 @@
     IRpcChannelBuffer* pRpcChannelBuffer,
     PRPC_MESSAGE pRpcMessage,
     DWORD* pdwStubPhase);
+HRESULT CALLBACK IEnumOleDocumentViews_Next_Proxy(
+    IEnumOleDocumentViews* This,
+    ULONG cViews,
+    IOleDocumentView **rgpView,
+    ULONG *pcFetched);
+HRESULT __RPC_STUB IEnumOleDocumentViews_Next_Stub(
+    IEnumOleDocumentViews* This,
+    ULONG cViews,
+    IOleDocumentView **rgpView,
+    ULONG *pcFetched);
 
 #endif  /* __IEnumOleDocumentViews_INTERFACE_DEFINED__ */
 
-#ifndef __IOleCommandTarget_FWD_DEFINED__
-#define __IOleCommandTarget_FWD_DEFINED__
-typedef interface IOleCommandTarget IOleCommandTarget;
-#endif
+/*****************************************************************************
+ * IOleCommandTarget interface
+ */
+#ifndef __IOleCommandTarget_INTERFACE_DEFINED__
+#define __IOleCommandTarget_INTERFACE_DEFINED__
 
 typedef IOleCommandTarget *LPOLECOMMANDTARGET;
 typedef enum OLECMDF {
@@ -689,14 +724,20 @@
     OLECMDID_PRINT2 = 49,
     OLECMDID_PRINTPREVIEW2 = 50,
     OLECMDID_SETPRINTTEMPLATE = 51,
-    OLECMDID_GETPRINTTEMPLATE = 52
+    OLECMDID_GETPRINTTEMPLATE = 52,
+    OLECMDID_PAGEACTIONBLOCKED = 55,
+    OLECMDID_PAGEACTIONUIQUERY = 56,
+    OLECMDID_FOCUSVIEWCONTROLS = 57,
+    OLECMDID_FOCUSVIEWCONTROLSQUERY = 58,
+    OLECMDID_SHOWPAGEACTIONMENU = 59,
+    OLECMDID_ADDTRAVELENTRY = 60,
+    OLECMDID_UPDATETRAVELENTRY = 61,
+    OLECMDID_UPDATEBACKFORWARDSTATE = 62,
+    OLECMDID_OPTICAL_ZOOM = 63,
+    OLECMDID_OPTICAL_GETZOOMRANGE = 64,
+    OLECMDID_WINDOWSTATECHANGED = 65,
+    OLECMDID_ACTIVEXINSTALLSCOPE = 66
 } OLECMDID;
-/*****************************************************************************
- * IOleCommandTarget interface
- */
-#ifndef __IOleCommandTarget_INTERFACE_DEFINED__
-#define __IOleCommandTarget_INTERFACE_DEFINED__
-
 DEFINE_GUID(IID_IOleCommandTarget, 0xb722bccb, 0x4e68, 0x101b, 0xa2,0xbc, 0x00,0xaa,0x00,0x40,0x47,0x70);
 #if defined(__cplusplus) && !defined(CINTERFACE)
 interface IOleCommandTarget : public IUnknown
@@ -750,22 +791,22 @@
     END_INTERFACE
 } IOleCommandTargetVtbl;
 interface IOleCommandTarget {
-    const IOleCommandTargetVtbl* lpVtbl;
+    CONST_VTBL IOleCommandTargetVtbl* lpVtbl;
 };
 
 #ifdef COBJMACROS
 /*** IUnknown methods ***/
-#define IOleCommandTarget_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
-#define IOleCommandTarget_AddRef(p) (p)->lpVtbl->AddRef(p)
-#define IOleCommandTarget_Release(p) (p)->lpVtbl->Release(p)
+#define IOleCommandTarget_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IOleCommandTarget_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IOleCommandTarget_Release(This) (This)->lpVtbl->Release(This)
 /*** IOleCommandTarget methods ***/
-#define IOleCommandTarget_QueryStatus(p,a,b,c,d) (p)->lpVtbl->QueryStatus(p,a,b,c,d)
-#define IOleCommandTarget_Exec(p,a,b,c,d,e) (p)->lpVtbl->Exec(p,a,b,c,d,e)
+#define IOleCommandTarget_QueryStatus(This,pguidCmdGroup,cCmds,prgCmds,pCmdText) (This)->lpVtbl->QueryStatus(This,pguidCmdGroup,cCmds,prgCmds,pCmdText)
+#define IOleCommandTarget_Exec(This,pguidCmdGroup,nCmdID,nCmdexecopt,pvaIn,pvaOut) (This)->lpVtbl->Exec(This,pguidCmdGroup,nCmdID,nCmdexecopt,pvaIn,pvaOut)
 #endif
 
 #endif
 
-HRESULT CALLBACK IOleCommandTarget_QueryStatus_Proxy(
+HRESULT STDMETHODCALLTYPE IOleCommandTarget_QueryStatus_Proxy(
     IOleCommandTarget* This,
     const GUID *pguidCmdGroup,
     ULONG cCmds,
@@ -776,7 +817,7 @@
     IRpcChannelBuffer* pRpcChannelBuffer,
     PRPC_MESSAGE pRpcMessage,
     DWORD* pdwStubPhase);
-HRESULT CALLBACK IOleCommandTarget_Exec_Proxy(
+HRESULT STDMETHODCALLTYPE IOleCommandTarget_Exec_Proxy(
     IOleCommandTarget* This,
     const GUID *pguidCmdGroup,
     DWORD nCmdID,
@@ -791,18 +832,13 @@
 
 #endif  /* __IOleCommandTarget_INTERFACE_DEFINED__ */
 
-#ifndef __IContinueCallback_FWD_DEFINED__
-#define __IContinueCallback_FWD_DEFINED__
-typedef interface IContinueCallback IContinueCallback;
-#endif
-
-typedef IContinueCallback *LPCONTINUECALLBACK;
 /*****************************************************************************
  * IContinueCallback interface
  */
 #ifndef __IContinueCallback_INTERFACE_DEFINED__
 #define __IContinueCallback_INTERFACE_DEFINED__
 
+typedef IContinueCallback *LPCONTINUECALLBACK;
 DEFINE_GUID(IID_IContinueCallback, 0xb722bcca, 0x4e68, 0x101b, 0xa2,0xbc, 0x00,0xaa,0x00,0x40,0x47,0x70);
 #if defined(__cplusplus) && !defined(CINTERFACE)
 interface IContinueCallback : public IUnknown
@@ -845,29 +881,29 @@
     END_INTERFACE
 } IContinueCallbackVtbl;
 interface IContinueCallback {
-    const IContinueCallbackVtbl* lpVtbl;
+    CONST_VTBL IContinueCallbackVtbl* lpVtbl;
 };
 
 #ifdef COBJMACROS
 /*** IUnknown methods ***/
-#define IContinueCallback_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
-#define IContinueCallback_AddRef(p) (p)->lpVtbl->AddRef(p)
-#define IContinueCallback_Release(p) (p)->lpVtbl->Release(p)
+#define IContinueCallback_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IContinueCallback_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IContinueCallback_Release(This) (This)->lpVtbl->Release(This)
 /*** IContinueCallback methods ***/
-#define IContinueCallback_FContinue(p) (p)->lpVtbl->FContinue(p)
-#define IContinueCallback_FContinuePrinting(p,a,b,c) (p)->lpVtbl->FContinuePrinting(p,a,b,c)
+#define IContinueCallback_FContinue(This) (This)->lpVtbl->FContinue(This)
+#define IContinueCallback_FContinuePrinting(This,nCntPrinted,nCurPage,pwszPrintStatus) (This)->lpVtbl->FContinuePrinting(This,nCntPrinted,nCurPage,pwszPrintStatus)
 #endif
 
 #endif
 
-HRESULT CALLBACK IContinueCallback_FContinue_Proxy(
+HRESULT STDMETHODCALLTYPE IContinueCallback_FContinue_Proxy(
     IContinueCallback* This);
 void __RPC_STUB IContinueCallback_FContinue_Stub(
     IRpcStubBuffer* This,
     IRpcChannelBuffer* pRpcChannelBuffer,
     PRPC_MESSAGE pRpcMessage,
     DWORD* pdwStubPhase);
-HRESULT CALLBACK IContinueCallback_FContinuePrinting_Proxy(
+HRESULT STDMETHODCALLTYPE IContinueCallback_FContinuePrinting_Proxy(
     IContinueCallback* This,
     LONG nCntPrinted,
     LONG nCurPage,
@@ -880,13 +916,14 @@
 
 #endif  /* __IContinueCallback_INTERFACE_DEFINED__ */
 
-#ifndef __IPrint_FWD_DEFINED__
-#define __IPrint_FWD_DEFINED__
-typedef interface IPrint IPrint;
-#endif
+/*****************************************************************************
+ * IPrint interface
+ */
+#ifndef __IPrint_INTERFACE_DEFINED__
+#define __IPrint_INTERFACE_DEFINED__
 
 typedef IPrint *LPPRINT;
-typedef enum {
+typedef enum __WIDL_docobj_generated_name_00000001 {
     PRINTFLAG_MAYBOTHERUSER = 1,
     PRINTFLAG_PROMPTUSER = 2,
     PRINTFLAG_USERMAYCHANGEPRINTER = 4,
@@ -906,12 +943,6 @@
     ULONG cPageRange;
     PAGERANGE rgPages[1];
 } PAGESET;
-/*****************************************************************************
- * IPrint interface
- */
-#ifndef __IPrint_INTERFACE_DEFINED__
-#define __IPrint_INTERFACE_DEFINED__
-
 DEFINE_GUID(IID_IPrint, 0xb722bcc9, 0x4e68, 0x101b, 0xa2,0xbc, 0x00,0xaa,0x00,0x40,0x47,0x70);
 #if defined(__cplusplus) && !defined(CINTERFACE)
 interface IPrint : public IUnknown
@@ -974,23 +1005,23 @@
     END_INTERFACE
 } IPrintVtbl;
 interface IPrint {
-    const IPrintVtbl* lpVtbl;
+    CONST_VTBL IPrintVtbl* lpVtbl;
 };
 
 #ifdef COBJMACROS
 /*** IUnknown methods ***/
-#define IPrint_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
-#define IPrint_AddRef(p) (p)->lpVtbl->AddRef(p)
-#define IPrint_Release(p) (p)->lpVtbl->Release(p)
+#define IPrint_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IPrint_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IPrint_Release(This) (This)->lpVtbl->Release(This)
 /*** IPrint methods ***/
-#define IPrint_SetInitialPageNum(p,a) (p)->lpVtbl->SetInitialPageNum(p,a)
-#define IPrint_GetPageInfo(p,a,b) (p)->lpVtbl->GetPageInfo(p,a,b)
-#define IPrint_Print(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Print(p,a,b,c,d,e,f,g,h)
+#define IPrint_SetInitialPageNum(This,nFirstPage) (This)->lpVtbl->SetInitialPageNum(This,nFirstPage)
+#define IPrint_GetPageInfo(This,pnFirstPage,pcPages) (This)->lpVtbl->GetPageInfo(This,pnFirstPage,pcPages)
+#define IPrint_Print(This,grfFlags,pptd,ppPageSet,pstgmOptions,pcallback,nFirstPage,pcPagesPrinted,pnLastPage) (This)->lpVtbl->Print(This,grfFlags,pptd,ppPageSet,pstgmOptions,pcallback,nFirstPage,pcPagesPrinted,pnLastPage)
 #endif
 
 #endif
 
-HRESULT CALLBACK IPrint_SetInitialPageNum_Proxy(
+HRESULT STDMETHODCALLTYPE IPrint_SetInitialPageNum_Proxy(
     IPrint* This,
     LONG nFirstPage);
 void __RPC_STUB IPrint_SetInitialPageNum_Stub(
@@ -998,7 +1029,7 @@
     IRpcChannelBuffer* pRpcChannelBuffer,
     PRPC_MESSAGE pRpcMessage,
     DWORD* pdwStubPhase);
-HRESULT CALLBACK IPrint_GetPageInfo_Proxy(
+HRESULT STDMETHODCALLTYPE IPrint_GetPageInfo_Proxy(
     IPrint* This,
     LONG *pnFirstPage,
     LONG *pcPages);
@@ -1007,7 +1038,7 @@
     IRpcChannelBuffer* pRpcChannelBuffer,
     PRPC_MESSAGE pRpcMessage,
     DWORD* pdwStubPhase);
-HRESULT CALLBACK IPrint_RemotePrint_Proxy(
+HRESULT STDMETHODCALLTYPE IPrint_RemotePrint_Proxy(
     IPrint* This,
     DWORD grfFlags,
     DVTARGETDEVICE **pptd,
@@ -1069,18 +1100,19 @@
 #define IID_IMsoCommandTarget          IID_IOleCommandTarget
 /* Begin additional prototypes for all interfaces */
 
-unsigned long   __RPC_USER BSTR_UserSize     (unsigned long *, unsigned long,   BSTR *);
-unsigned char * __RPC_USER BSTR_UserMarshal  (unsigned long *, unsigned char *, BSTR *);
-unsigned char * __RPC_USER BSTR_UserUnmarshal(unsigned long *, unsigned char *, BSTR *);
-void            __RPC_USER BSTR_UserFree     (unsigned long *, BSTR *);
-unsigned long   __RPC_USER VARIANT_UserSize     (unsigned long *, unsigned long,   VARIANT *);
-unsigned char * __RPC_USER VARIANT_UserMarshal  (unsigned long *, unsigned char *, VARIANT *);
-unsigned char * __RPC_USER VARIANT_UserUnmarshal(unsigned long *, unsigned char *, VARIANT *);
-void            __RPC_USER VARIANT_UserFree     (unsigned long *, VARIANT *);
+ULONG           __RPC_USER VARIANT_UserSize     (ULONG *, ULONG, VARIANT *);
+unsigned char * __RPC_USER VARIANT_UserMarshal  (ULONG *, unsigned char *, VARIANT *);
+unsigned char * __RPC_USER VARIANT_UserUnmarshal(ULONG *, unsigned char *, VARIANT *);
+void            __RPC_USER VARIANT_UserFree     (ULONG *, VARIANT *);
+ULONG           __RPC_USER STGMEDIUM_UserSize     (ULONG *, ULONG, STGMEDIUM *);
+unsigned char * __RPC_USER STGMEDIUM_UserMarshal  (ULONG *, unsigned char *, STGMEDIUM *);
+unsigned char * __RPC_USER STGMEDIUM_UserUnmarshal(ULONG *, unsigned char *, STGMEDIUM *);
+void            __RPC_USER STGMEDIUM_UserFree     (ULONG *, STGMEDIUM *);
 
 /* End additional prototypes */
 
 #ifdef __cplusplus
 }
 #endif
+
 #endif /* __WIDL_DOCOBJ_H */
diff --git a/mingw-w64-headers/direct-x/include/docobj.idl b/mingw-w64-headers/direct-x/include/docobj.idl
new file mode 100644
index 0000000..c47d111
--- /dev/null
+++ b/mingw-w64-headers/direct-x/include/docobj.idl
@@ -0,0 +1,408 @@
+/*
+ * Copyright (C) 1999 Paul Quinn
+ * Copyright (C) 2003 Alexandre Julliard
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+import "ocidl.idl";
+import "objidl.idl";
+import "oleidl.idl";
+import "oaidl.idl";
+import "servprov.idl";
+
+
+interface IOleDocumentView;
+interface IEnumOleDocumentViews;
+
+
+/*****************************************************************************
+ * IOleDocument interface
+ */
+[
+    object,
+    uuid(b722bcc5-4e68-101b-a2bc-00aa00404770),
+    pointer_default(unique)
+]
+interface IOleDocument : IUnknown
+{
+    typedef [unique] IOleDocument *LPOLEDOCUMENT;
+
+    typedef enum
+    {
+        DOCMISC_CANCREATEMULTIPLEVIEWS = 1,
+        DOCMISC_SUPPORTCOMPLEXRECTANGLES = 2,
+        DOCMISC_CANTOPENEDIT = 4,
+        DOCMISC_NOFILESUPPORT = 8
+    } DOCMISC;
+
+    HRESULT CreateView(
+        [in, unique] IOleInPlaceSite *pIPSite,
+        [in, unique] IStream *pstm,
+        [in] DWORD dwReserved,
+        [out] IOleDocumentView **ppView);
+
+    HRESULT GetDocMiscStatus(
+        [out] DWORD *pdwStatus);
+
+    HRESULT EnumViews(
+        [out] IEnumOleDocumentViews **ppEnum,
+        [out] IOleDocumentView **ppView);
+}
+
+
+/*****************************************************************************
+ * IOleDocumentSite interface
+ */
+[
+    object,
+    uuid(b722bcc7-4e68-101b-a2bc-00aa00404770),
+    pointer_default(unique)
+]
+interface IOleDocumentSite : IUnknown
+{
+    typedef [unique] IOleDocumentSite *LPOLEDOCUMENTSITE;
+
+    HRESULT ActivateMe( [in] IOleDocumentView *pViewToActivate );
+}
+
+
+/*****************************************************************************
+ * IOleDocumentView interface
+ */
+[
+    object,
+    uuid(b722bcc6-4e68-101b-a2bc-00aa00404770),
+    pointer_default(unique)
+]
+interface IOleDocumentView : IUnknown
+{
+    typedef [unique] IOleDocumentView *LPOLEDOCUMENTVIEW;
+
+    HRESULT SetInPlaceSite( [in, unique] IOleInPlaceSite *pIPSite );
+
+    HRESULT GetInPlaceSite( [out] IOleInPlaceSite **ppIPSite );
+
+    HRESULT GetDocument( [out] IUnknown **ppunk );
+
+    HRESULT SetRect( [in] LPRECT prcView );
+
+    HRESULT GetRect( [out] LPRECT prcView );
+
+    HRESULT SetRectComplex(
+        [in, unique] LPRECT prcView,
+        [in, unique] LPRECT prcHScroll,
+        [in, unique] LPRECT prcVScroll,
+        [in, unique] LPRECT prcSizeBox);
+
+    HRESULT Show( [in] BOOL fShow );
+
+    HRESULT UIActivate( [in] BOOL fUIActivate );
+
+    HRESULT Open();
+
+    HRESULT CloseView( [in] DWORD dwReserved );
+
+    HRESULT SaveViewState( [in] LPSTREAM pstm );
+
+    HRESULT ApplyViewState( [in] LPSTREAM pstm );
+
+    HRESULT Clone(
+        [in] IOleInPlaceSite *pIPSiteNew,
+        [out] IOleDocumentView **ppViewNew);
+}
+
+
+/*****************************************************************************
+ * IEnumOleDocumentViews interface
+ */
+[
+    object,
+    uuid(b722bcc8-4e68-101b-a2bc-00aa00404770),
+    pointer_default(unique)
+]
+interface IEnumOleDocumentViews : IUnknown
+{
+    typedef [unique] IEnumOleDocumentViews *LPENUMOLEDOCUMENTVIEWS;
+
+    [local]
+    HRESULT Next(
+        [in] ULONG cViews,
+        [out] IOleDocumentView **rgpView,
+        [out] ULONG *pcFetched);
+
+    [call_as(Next)]
+    HRESULT RemoteNext(
+        [in] ULONG cViews,
+        [out, size_is(cViews), length_is(*pcFetched)] IOleDocumentView **rgpView,
+        [out] ULONG *pcFetched);
+
+    HRESULT Skip( [in] ULONG cViews );
+
+    HRESULT Reset();
+
+    HRESULT Clone( [out] IEnumOleDocumentViews **ppEnum );
+}
+
+
+/*****************************************************************************
+ * IOleCommandTarget interface
+ */
+[
+    object,
+    uuid(b722bccb-4e68-101b-a2bc-00aa00404770),
+    pointer_default(unique)
+]
+interface IOleCommandTarget : IUnknown
+{
+    typedef [unique] IOleCommandTarget *LPOLECOMMANDTARGET;
+
+    typedef enum OLECMDF
+    {
+        OLECMDF_SUPPORTED = 0x1,
+        OLECMDF_ENABLED = 0x2,
+        OLECMDF_LATCHED = 0x4,
+        OLECMDF_NINCHED = 0x8,
+        OLECMDF_INVISIBLE = 0x10,
+        OLECMDF_DEFHIDEONCTXTMENU = 0x20
+    } OLECMDF;
+
+    typedef struct _tagOLECMD
+    {
+        ULONG cmdID;
+        DWORD cmdf;
+    } OLECMD;
+
+    typedef struct _tagOLECMDTEXT
+    {
+        DWORD cmdtextf;
+        ULONG cwActual;
+        ULONG cwBuf;
+        [size_is(cwBuf)] WCHAR rgwz[];
+    } OLECMDTEXT;
+
+    typedef enum OLECMDTEXTF
+    {
+        OLECMDTEXTF_NONE = 0,
+        OLECMDTEXTF_NAME = 1,
+        OLECMDTEXTF_STATUS = 2
+    } OLECMDTEXTF;
+
+    typedef enum OLECMDEXECOPT
+    {
+        OLECMDEXECOPT_DODEFAULT = 0,
+        OLECMDEXECOPT_PROMPTUSER = 1,
+        OLECMDEXECOPT_DONTPROMPTUSER = 2,
+        OLECMDEXECOPT_SHOWHELP = 3
+    } OLECMDEXECOPT;
+
+    typedef enum OLECMDID
+    {
+        OLECMDID_OPEN = 1,
+        OLECMDID_NEW = 2,
+        OLECMDID_SAVE = 3,
+        OLECMDID_SAVEAS = 4,
+        OLECMDID_SAVECOPYAS = 5,
+        OLECMDID_PRINT = 6,
+        OLECMDID_PRINTPREVIEW = 7,
+        OLECMDID_PAGESETUP = 8,
+        OLECMDID_SPELL = 9,
+        OLECMDID_PROPERTIES = 10,
+        OLECMDID_CUT = 11,
+        OLECMDID_COPY = 12,
+        OLECMDID_PASTE = 13,
+        OLECMDID_PASTESPECIAL = 14,
+        OLECMDID_UNDO = 15,
+        OLECMDID_REDO = 16,
+        OLECMDID_SELECTALL = 17,
+        OLECMDID_CLEARSELECTION = 18,
+        OLECMDID_ZOOM = 19,
+        OLECMDID_GETZOOMRANGE = 20,
+        OLECMDID_UPDATECOMMANDS = 21,
+        OLECMDID_REFRESH = 22,
+        OLECMDID_STOP = 23,
+        OLECMDID_HIDETOOLBARS = 24,
+        OLECMDID_SETPROGRESSMAX = 25,
+        OLECMDID_SETPROGRESSPOS = 26,
+        OLECMDID_SETPROGRESSTEXT = 27,
+        OLECMDID_SETTITLE = 28,
+        OLECMDID_SETDOWNLOADSTATE = 29,
+        OLECMDID_STOPDOWNLOAD = 30,
+        OLECMDID_ONTOOLBARACTIVATED = 31,
+        OLECMDID_FIND = 32,
+        OLECMDID_DELETE = 33,
+        OLECMDID_HTTPEQUIV = 34,
+        OLECMDID_HTTPEQUIV_DONE = 35,
+        OLECMDID_ENABLE_INTERACTION = 36,
+        OLECMDID_ONUNLOAD = 37,
+        OLECMDID_PROPERTYBAG2 = 38,
+        OLECMDID_PREREFRESH = 39,
+        /* iexplorer uses ... 44 */
+        OLECMDID_SHOWSCRIPTERROR = 40,
+        OLECMDID_SHOWMESSAGE = 41,
+        OLECMDID_SHOWFIND = 42,
+        OLECMDID_SHOWPAGESETUP = 43,
+        OLECMDID_SHOWPRINT = 44,
+        OLECMDID_CLOSE = 45,
+        OLECMDID_ALLOWUILESSSAVEAS = 46,
+        OLECMDID_DONTDOWNLOADCSS = 47,
+        OLECMDID_UPDATEPAGESTATUS = 48,
+        OLECMDID_PRINT2 = 49,
+        OLECMDID_PRINTPREVIEW2 = 50,
+        OLECMDID_SETPRINTTEMPLATE = 51,
+        OLECMDID_GETPRINTTEMPLATE = 52,
+        OLECMDID_PAGEACTIONBLOCKED = 55,
+        OLECMDID_PAGEACTIONUIQUERY = 56,
+        OLECMDID_FOCUSVIEWCONTROLS = 57,
+        OLECMDID_FOCUSVIEWCONTROLSQUERY = 58,
+        OLECMDID_SHOWPAGEACTIONMENU = 59,
+        OLECMDID_ADDTRAVELENTRY = 60,
+        OLECMDID_UPDATETRAVELENTRY = 61,
+        OLECMDID_UPDATEBACKFORWARDSTATE = 62,
+        OLECMDID_OPTICAL_ZOOM = 63,
+        OLECMDID_OPTICAL_GETZOOMRANGE = 64,
+        OLECMDID_WINDOWSTATECHANGED = 65,
+        OLECMDID_ACTIVEXINSTALLSCOPE = 66
+    } OLECMDID;
+
+    HRESULT QueryStatus(
+        [in, unique] const GUID *pguidCmdGroup,
+        [in] ULONG cCmds,
+        [in, out, size_is(cCmds)] OLECMD prgCmds[],
+        [in, out, unique] OLECMDTEXT *pCmdText);
+
+    HRESULT Exec(
+        [in, unique] const GUID *pguidCmdGroup,
+        [in] DWORD nCmdID,
+        [in] DWORD nCmdexecopt,
+        [in, unique] VARIANT *pvaIn,
+        [in, out, unique] VARIANT *pvaOut);
+}
+
+
+/*****************************************************************************
+ * IContinueCallback interface
+ */
+[
+   object,
+   uuid(b722bcca-4e68-101b-a2bc-00aa00404770),
+   pointer_default(unique)
+]
+interface IContinueCallback : IUnknown
+{
+    typedef [unique] IContinueCallback *LPCONTINUECALLBACK;
+
+    HRESULT FContinue();
+
+    HRESULT FContinuePrinting(
+        [in] LONG nCntPrinted,
+        [in] LONG nCurPage,
+        [in, unique] WCHAR *pwszPrintStatus);
+}
+
+
+/*****************************************************************************
+ * IPrint interface
+ */
+[
+   object,
+   uuid(b722bcc9-4e68-101b-a2bc-00aa00404770),
+   pointer_default(unique)
+]
+interface IPrint : IUnknown
+{
+    typedef [unique] IPrint *LPPRINT;
+
+    typedef enum
+    {
+        PRINTFLAG_MAYBOTHERUSER = 1,
+        PRINTFLAG_PROMPTUSER  = 2,
+        PRINTFLAG_USERMAYCHANGEPRINTER  = 4,
+        PRINTFLAG_RECOMPOSETODEVICE = 8,
+        PRINTFLAG_DONTACTUALLYPRINT = 16,
+        PRINTFLAG_FORCEPROPERTIES = 32,
+        PRINTFLAG_PRINTTOFILE = 64
+    } PRINTFLAG;
+
+    typedef struct tagPAGERANGE
+    {
+        LONG nFromPage;
+        LONG nToPage;
+    } PAGERANGE;
+
+    typedef struct tagPAGESET
+    {
+        ULONG cbStruct;
+        BOOL fOddPages;
+        BOOL fEvenPages;
+        ULONG cPageRange;
+        [size_is(cPageRange)] PAGERANGE rgPages[];
+    } PAGESET;
+
+    HRESULT SetInitialPageNum(
+        [in] LONG nFirstPage);
+
+    HRESULT GetPageInfo(
+        [out] LONG *pnFirstPage,
+        [out] LONG *pcPages);
+
+    [local]
+    HRESULT Print(
+        [in] DWORD grfFlags,
+        [in, out] DVTARGETDEVICE **pptd,
+        [in, out] PAGESET **ppPageSet,
+        [in, out, unique] STGMEDIUM *pstgmOptions,
+        [in] IContinueCallback *pcallback,
+        [in]  LONG nFirstPage,
+        [out] LONG *pcPagesPrinted,
+        [out] LONG *pnLastPage);
+
+    [call_as(Print)]
+    HRESULT RemotePrint(
+        [in] DWORD grfFlags,
+        [in, out] DVTARGETDEVICE **pptd,
+        [in, out] PAGESET **pppageset,
+        [in, out, unique] RemSTGMEDIUM *pstgmOptions,
+        [in] IContinueCallback *pcallback,
+        [in]  LONG nFirstPage,
+        [out] LONG *pcPagesPrinted,
+        [out] LONG *pnLastPage);
+}
+
+
+cpp_quote("#define OLECMDERR_E_FIRST            (OLE_E_LAST+1)")
+cpp_quote("#define OLECMDERR_E_NOTSUPPORTED     (OLECMDERR_E_FIRST)")
+cpp_quote("#define OLECMDERR_E_DISABLED         (OLECMDERR_E_FIRST+1)")
+cpp_quote("#define OLECMDERR_E_NOHELP           (OLECMDERR_E_FIRST+2)")
+cpp_quote("#define OLECMDERR_E_CANCELED         (OLECMDERR_E_FIRST+3)")
+cpp_quote("#define OLECMDERR_E_UNKNOWNGROUP     (OLECMDERR_E_FIRST+4)")
+
+cpp_quote("#define MSOCMDERR_E_FIRST OLECMDERR_E_FIRST")
+cpp_quote("#define MSOCMDERR_E_NOTSUPPORTED OLECMDERR_E_NOTSUPPORTED")
+cpp_quote("#define MSOCMDERR_E_DISABLED OLECMDERR_E_DISABLED")
+cpp_quote("#define MSOCMDERR_E_NOHELP OLECMDERR_E_NOHELP")
+cpp_quote("#define MSOCMDERR_E_CANCELED OLECMDERR_E_CANCELED")
+cpp_quote("#define MSOCMDERR_E_UNKNOWNGROUP OLECMDERR_E_UNKNOWNGROUP")
+
+cpp_quote("#define LPMSODOCUMENT                  LPOLEDOCUMENT")
+cpp_quote("#define LPMSODOCUMENTSITE              LPOLEDOCUMENTSITE")
+cpp_quote("#define LPMSOVIEW                      LPOLEDOCUMENTVIEW")
+cpp_quote("#define LPENUMMSOVIEW                  LPENUMOLEDOCUMENTVIEWS")
+cpp_quote("#define LPMSOCOMMANDTARGET             LPOLECOMMANDTARGET")
+cpp_quote("#define IID_IMsoDocument               IID_IOleDocument")
+cpp_quote("#define IID_IMsoDocumentSite           IID_IOleDocumentSite")
+cpp_quote("#define IID_IMsoView                   IID_IOleDocumentView")
+cpp_quote("#define IID_IEnumMsoView               IID_IEnumOleDocumentViews")
+cpp_quote("#define IID_IMsoCommandTarget          IID_IOleCommandTarget")
diff --git a/mingw-w64-headers/direct-x/include/downloadmgr.h b/mingw-w64-headers/direct-x/include/downloadmgr.h
index 5442d3e..0cb669f 100644
--- a/mingw-w64-headers/direct-x/include/downloadmgr.h
+++ b/mingw-w64-headers/direct-x/include/downloadmgr.h
@@ -1,21 +1,30 @@
-/*** Autogenerated by WIDL 0.9.14 from ../../wine-src/include/downloadmgr.idl - Do not edit ***/
+/*** Autogenerated by WIDL 1.1.38 from downloadmgr.idl - Do not edit ***/
+
 #include <rpc.h>
 #include <rpcndr.h>
 
 #ifndef __WIDL_DOWNLOADMGR_H
 #define __WIDL_DOWNLOADMGR_H
+
 #ifdef __cplusplus
 extern "C" {
 #endif
+
+/* Headers for imported files */
+
 #include <unknwn.h>
 #include <ocidl.h>
 #include <oleidl.h>
 #include <oaidl.h>
+
+/* Forward declarations */
+
 #ifndef __IDownloadManager_FWD_DEFINED__
 #define __IDownloadManager_FWD_DEFINED__
 typedef interface IDownloadManager IDownloadManager;
 #endif
 
+
 /*****************************************************************************
  * IDownloadManager interface
  */
@@ -68,21 +77,21 @@
     END_INTERFACE
 } IDownloadManagerVtbl;
 interface IDownloadManager {
-    const IDownloadManagerVtbl* lpVtbl;
+    CONST_VTBL IDownloadManagerVtbl* lpVtbl;
 };
 
 #ifdef COBJMACROS
 /*** IUnknown methods ***/
-#define IDownloadManager_QueryInterface(p,a,b) (p)->lpVtbl->QueryInterface(p,a,b)
-#define IDownloadManager_AddRef(p) (p)->lpVtbl->AddRef(p)
-#define IDownloadManager_Release(p) (p)->lpVtbl->Release(p)
+#define IDownloadManager_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDownloadManager_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDownloadManager_Release(This) (This)->lpVtbl->Release(This)
 /*** IDownloadManager methods ***/
-#define IDownloadManager_Download(p,a,b,c,d,e,f,g,h) (p)->lpVtbl->Download(p,a,b,c,d,e,f,g,h)
+#define IDownloadManager_Download(This,pmk,pbc,dwBindVerb,grfBINDF,pBindInfo,pszHeaders,pszRedir,uiCP) (This)->lpVtbl->Download(This,pmk,pbc,dwBindVerb,grfBINDF,pBindInfo,pszHeaders,pszRedir,uiCP)
 #endif
 
 #endif
 
-HRESULT CALLBACK IDownloadManager_Download_Proxy(
+HRESULT STDMETHODCALLTYPE IDownloadManager_Download_Proxy(
     IDownloadManager* This,
     IMoniker *pmk,
     IBindCtx *pbc,
@@ -102,14 +111,11 @@
 
 /* Begin additional prototypes for all interfaces */
 
-unsigned long   __RPC_USER STGMEDIUM_UserSize     (unsigned long *, unsigned long,   STGMEDIUM *);
-unsigned char * __RPC_USER STGMEDIUM_UserMarshal  (unsigned long *, unsigned char *, STGMEDIUM *);
-unsigned char * __RPC_USER STGMEDIUM_UserUnmarshal(unsigned long *, unsigned char *, STGMEDIUM *);
-void            __RPC_USER STGMEDIUM_UserFree     (unsigned long *, STGMEDIUM *);
 
 /* End additional prototypes */
 
 #ifdef __cplusplus
 }
 #endif
+
 #endif /* __WIDL_DOWNLOADMGR_H */
diff --git a/mingw-w64-headers/direct-x/include/downloadmgr.idl b/mingw-w64-headers/direct-x/include/downloadmgr.idl
new file mode 100644
index 0000000..2ba6573
--- /dev/null
+++ b/mingw-w64-headers/direct-x/include/downloadmgr.idl
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2005 Jacek Caban
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#ifndef DO_NO_IMPORTS
+import "unknwn.idl";
+import "ocidl.idl";
+import "oleidl.idl";
+import "oaidl.idl";
+#endif
+
+[
+    object,
+    uuid(988934A4-064B-11D3-BB80-00104B35E7F9),
+    pointer_default(unique),
+    local
+]
+interface IDownloadManager : IUnknown
+{
+    HRESULT Download(
+        [in] IMoniker *pmk,
+        [in] IBindCtx *pbc,
+        [in] DWORD dwBindVerb,
+        [in] LONG grfBINDF,
+        [in] BINDINFO *pBindInfo,
+        [in] LPCOLESTR pszHeaders,
+        [in] LPCOLESTR pszRedir,
+        [in] UINT uiCP);
+}
