Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-07-07 21:25:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

Sync to Wine-0_9_3:

Browse source 
Michael Jung <mjung@iss.tu-darmstadt.de>
- Made the Drag&Drop cursors' rubber band visible on a white background.
- Correct the hot spot position of the drag&drop 'move' and 'link' cursors.
Francois Gouget <fgouget@free.fr>
- Assorted spelling fixes.
Robert Shearman <rob@codeweavers.com>
- Delegate advises to the remote object to enable the client to receive
  data change notifications.
- Implement IOleObject_DoVerb function by running the object and then
  delegating to the remote IOleObject_DoVerb function.
- Call DefaultHandler_Stop if we fail to start the server running
  correctly and a few formatting fixes.
- Call the equivalent delegate function for all of the simple
  functions.
- OLE: Fix a typo where brackets were missing.
- Implement some user marshal functions and add tests.

svn path=/trunk/; revision=20135
This commit is contained in:
Gé van Geldorp 2005-12-12 23:53:06 +00:00
parent e526cc62f9
commit 2b8ceb888a
11 changed files with 1138 additions and 141 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

32
reactos/include/wine/objidl.h
View file

@ -2120,5 +2120,37 @@ void __RPC_STUB IMultiQI_QueryMultipleInterfaces_Stub(
#endif /* __IMultiQI_INTERFACE_DEFINED__ */
typedef struct _GDI_OBJECT {
DWORD ObjectType;
union {
wireHBITMAP hBitmap;
wireHPALETTE hPalette;
wireHGLOBAL hGeneric;
} u;
} GDI_OBJECT;
typedef struct _userSTGMEDIUM {
struct {
DWORD tymed;
union {
wireHMETAFILEPICT hMetaFilePict;
wireHENHMETAFILE hHEnhMetaFile;
GDI_OBJECT *hGdiHandle;
wireHGLOBAL hGlobal;
LPOLESTR lpszFileName;
BYTE_BLOB *pstm;
BYTE_BLOB *pstg;
} u;
} DUMMYSTRUCTNAME;
IUnknown *pUnkForRelease;
} userSTGMEDIUM;
typedef userSTGMEDIUM *wireSTGMEDIUM;
typedef userSTGMEDIUM *wireASYNC_STGMEDIUM;
typedef STGMEDIUM ASYNC_STGMEDIUM;
typedef STGMEDIUM *LPSTGMEDIUM;
typedef struct _FLAG_STGMEDIUM {
long ContextFlags;
long fPassOwnership;
STGMEDIUM Stgmed;
} FLAG_STGMEDIUM;
#endif /* __WINE_OBJIDL_H */

78
reactos/lib/ole32/Makefile.in
View file

@ -1,78 +0,0 @@
EXTRADEFS = -D_OLE32_ -DCOM_NO_WINDOWS_H
TOPSRCDIR = @top_srcdir@
TOPOBJDIR = ../..
SRCDIR = @srcdir@
VPATH = @srcdir@
MODULE = ole32.dll
IMPORTLIB = libole32.$(IMPLIBEXT)
IMPORTS = advapi32 user32 gdi32 rpcrt4 kernel32 ntdll
EXTRALIBS = -luuid $(LIBUNICODE)
C_SRCS = \
antimoniker.c \
bindctx.c \
clipboard.c \
compobj.c \
compositemoniker.c \
datacache.c \
defaulthandler.c \
dictionary.c \
errorinfo.c \
filemoniker.c \
ftmarshal.c \
git.c \
hglobalstream.c \
ifs.c \
itemmoniker.c \
marshal.c \
memlockbytes.c \
moniker.c \
ole2.c \
ole2stubs.c \
ole2impl.c \
ole32_main.c \
oleobj.c \
oleproxy.c \
regsvr.c \
rpc.c \
stg_bigblockfile.c \
stg_prop.c \
stg_stream.c \
storage32.c \
stubmanager.c
C_SRCS16 = \
memlockbytes16.c \
ole16.c \
ole2_16.c \
ole2nls.c \
storage.c
SPEC_SRCS16 = \
compobj.spec \
ole2.spec \
ole2conv.spec \
ole2nls.spec \
ole2prox.spec \
ole2thk.spec \
storage.spec
RC_SRCS = ole32res.rc
RC_BINSRC = ole32res.rc
RC_BINARIES = \
drag_copy.cur \
drag_link.cur \
drag_move.cur \
nodrop.cur
IDL_SRCS = \
dcom.idl
SUBDIRS = tests
@MAKE_DLL_RULES@
### Dependencies:
# note: this will get overwritten by make depend
$(ALL_OBJS): $(IDL_SRCS:.idl=.h)

4
reactos/lib/ole32/compobj_private.h
View file

@ -263,4 +263,8 @@ extern HINSTANCE OLE32_hInstance; /* FIXME: make static */
#define CHARS_IN_GUID 39 /* including NULL */
/* Exported non-interface Data Advise Holder functions */
HRESULT DataAdviseHolder_OnConnect(IDataAdviseHolder *iface, IDataObject *pDelegate);
void DataAdviseHolder_OnDisconnect(IDataAdviseHolder *iface);
#endif /* __WINE_OLE_COMPOBJ_H */

96
reactos/lib/ole32/defaulthandler.c
View file

@ -55,8 +55,11 @@
#include "winbase.h"
#include "winuser.h"
#include "winerror.h"
#include "wine/unicode.h"
#include "ole2.h"
#include "compobj_private.h"
#include "wine/unicode.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(ole);
@ -108,6 +111,8 @@ struct DefaultHandler
IOleObject *pOleDelegate;
/* IPersistStorage delegate */
IPersistStorage *pPSDelegate;
/* IDataObject delegate */
IDataObject *pDataDelegate;
/* connection cookie for the advise on the delegate OLE object */
DWORD dwAdvConn;
@ -307,9 +312,13 @@ static HRESULT WINAPI DefaultHandler_SetClientSite(
IOleClientSite* pClientSite)
{
DefaultHandler *This = impl_from_IOleObject(iface);
HRESULT hr = S_OK;
TRACE("(%p, %p)\n", iface, pClientSite);
if (This->pOleDelegate)
hr = IOleObject_SetClientSite(This->pOleDelegate, pClientSite);
/*
* Make sure we release the previous client site if there
* was one.
@ -371,6 +380,9 @@ static HRESULT WINAPI DefaultHandler_SetHostNames(
debugstr_w(szContainerApp),
debugstr_w(szContainerObj));
if (This->pOleDelegate)
IOleObject_SetHostNames(This->pOleDelegate, szContainerApp, szContainerObj);
/* Be sure to cleanup before re-assinging the strings. */
HeapFree( GetProcessHeap(), 0, This->containerApp );
This->containerApp = NULL;
@ -404,6 +416,12 @@ static void WINAPI DefaultHandler_Stop(DefaultHandler *This)
/* FIXME: call IOleCache_OnStop */
DataAdviseHolder_OnDisconnect(This->dataAdviseHolder);
if (This->pDataDelegate)
{
IDataObject_Release(This->pDataDelegate);
This->pDataDelegate = NULL;
}
if (This->pPSDelegate)
{
IPersistStorage_Release(This->pPSDelegate);
@ -452,11 +470,16 @@ static HRESULT WINAPI DefaultHandler_SetMoniker(
DWORD dwWhichMoniker,
IMoniker* pmk)
{
DefaultHandler *This = impl_from_IOleObject(iface);
TRACE("(%p, %ld, %p)\n",
iface,
dwWhichMoniker,
pmk);
if (This->pOleDelegate)
return IOleObject_SetMoniker(This->pOleDelegate, dwWhichMoniker, pmk);
return S_OK;
}
@ -478,6 +501,11 @@ static HRESULT WINAPI DefaultHandler_GetMoniker(
TRACE("(%p, %ld, %ld, %p)\n",
iface, dwAssign, dwWhichMoniker, ppmk);
if (This->pOleDelegate)
return IOleObject_GetMoniker(This->pOleDelegate, dwAssign, dwWhichMoniker,
ppmk);
/* FIXME: dwWhichMoniker == OLEWHICHMK_CONTAINER only? */
if (This->clientSite)
{
return IOleClientSite_GetMoniker(This->clientSite,
@ -503,9 +531,14 @@ static HRESULT WINAPI DefaultHandler_InitFromData(
BOOL fCreation,
DWORD dwReserved)
{
DefaultHandler *This = impl_from_IOleObject(iface);
TRACE("(%p, %p, %d, %ld)\n",
iface, pDataObject, fCreation, dwReserved);
if (This->pOleDelegate)
return IOleObject_InitFromData(This->pOleDelegate, pDataObject, fCreation,
dwReserved);
return OLE_E_NOTRUNNING;
}
@ -521,9 +554,15 @@ static HRESULT WINAPI DefaultHandler_GetClipboardData(
DWORD dwReserved,
IDataObject** ppDataObject)
{
DefaultHandler *This = impl_from_IOleObject(iface);
TRACE("(%p, %ld, %p)\n",
iface, dwReserved, ppDataObject);
if (This->pOleDelegate)
return IOleObject_GetClipboardData(This->pOleDelegate, dwReserved,
ppDataObject);
return OLE_E_NOTRUNNING;
}
@ -536,8 +575,17 @@ static HRESULT WINAPI DefaultHandler_DoVerb(
HWND hwndParent,
LPCRECT lprcPosRect)
{
FIXME(": Stub\n");
return E_NOTIMPL;
DefaultHandler *This = impl_from_IOleObject(iface);
IRunnableObject *pRunnableObj = (IRunnableObject *)&This->lpvtblIRunnableObject;
HRESULT hr;
TRACE("(%ld, %p, %p, %ld, %p, %s)\n", iVerb, lpmsg, pActiveSite, lindex, hwndParent, wine_dbgstr_rect(lprcPosRect));
hr = IRunnableObject_Run(pRunnableObj, NULL);
if (FAILED(hr)) return hr;
return IOleObject_DoVerb(This->pOleDelegate, iVerb, lpmsg, pActiveSite,
lindex, hwndParent, lprcPosRect);
}
/************************************************************************
@ -650,8 +698,14 @@ static HRESULT WINAPI DefaultHandler_SetExtent(
DWORD dwDrawAspect,
SIZEL* psizel)
{
DefaultHandler *This = impl_from_IOleObject(iface);
TRACE("(%p, %lx, (%ld x %ld))\n", iface,
dwDrawAspect, psizel->cx, psizel->cy);
if (This->pOleDelegate)
IOleObject_SetExtent(This->pOleDelegate, dwDrawAspect, psizel);
return OLE_E_NOTRUNNING;
}
@ -676,8 +730,10 @@ static HRESULT WINAPI DefaultHandler_GetExtent(
TRACE("(%p, %lx, %p)\n", iface, dwDrawAspect, psizel);
hres = IUnknown_QueryInterface(This->dataCache, &IID_IViewObject2, (void**)&cacheView);
if (This->pOleDelegate)
return IOleObject_GetExtent(This->pOleDelegate, dwDrawAspect, psizel);
hres = IUnknown_QueryInterface(This->dataCache, &IID_IViewObject2, (void**)&cacheView);
if (FAILED(hres))
return E_UNEXPECTED;
@ -824,7 +880,7 @@ static HRESULT WINAPI DefaultHandler_GetMiscStatus(
}
/************************************************************************
* DefaultHandler_SetExtent (IOleObject)
* DefaultHandler_SetColorScheme (IOleObject)
*
* This method is meaningless if the server is not running
*
@ -834,7 +890,13 @@ static HRESULT WINAPI DefaultHandler_SetColorScheme(
IOleObject* iface,
struct tagLOGPALETTE* pLogpal)
{
DefaultHandler *This = impl_from_IOleObject(iface);
TRACE("(%p, %p))\n", iface, pLogpal);
if (This->pOleDelegate)
return IOleObject_SetColorScheme(This->pOleDelegate, pLogpal);
return OLE_E_NOTRUNNING;
}
@ -1212,24 +1274,29 @@ static HRESULT WINAPI DefaultHandler_Run(
if (This->pOleDelegate)
return S_OK;
hr = CoCreateInstance(&This->clsid, NULL, CLSCTX_LOCAL_SERVER, &IID_IOleObject, (void **)&This->pOleDelegate);
hr = CoCreateInstance(&This->clsid, NULL, CLSCTX_LOCAL_SERVER,
&IID_IOleObject, (void **)&This->pOleDelegate);
if (FAILED(hr))
return hr;
hr = IOleObject_Advise(This->pOleDelegate, (IAdviseSink *)&This->lpvtblIAdviseSink, &This->dwAdvConn);
hr = IOleObject_Advise(This->pOleDelegate,
(IAdviseSink *)&This->lpvtblIAdviseSink,
&This->dwAdvConn);
if (SUCCEEDED(hr) && This->clientSite)
hr = IOleObject_SetClientSite(This->pOleDelegate, This->clientSite);
if (SUCCEEDED(hr))
{
IOleObject_QueryInterface(This->pOleDelegate, &IID_IPersistStorage, (void **)&This->pPSDelegate);
IOleObject_QueryInterface(This->pOleDelegate, &IID_IPersistStorage,
(void **)&This->pPSDelegate);
if (This->pPSDelegate)
hr = IPersistStorage_InitNew(This->pPSDelegate, NULL);
}
if (SUCCEEDED(hr) && This->containerApp)
hr = IOleObject_SetHostNames(This->pOleDelegate, This->containerApp, This->containerObj);
hr = IOleObject_SetHostNames(This->pOleDelegate, This->containerApp,
This->containerObj);
/* FIXME: do more stuff here:
* - IOleObject_GetMiscStatus
@ -1237,7 +1304,15 @@ static HRESULT WINAPI DefaultHandler_Run(
* - IOleCache_OnRun
*/
/* FIXME: if we failed, Close the object */
if (SUCCEEDED(hr))
hr = IOleObject_QueryInterface(This->pOleDelegate, &IID_IDataObject,
(void **)&This->pDataDelegate);
if (SUCCEEDED(hr) && This->dataAdviseHolder)
hr = DataAdviseHolder_OnConnect(This->dataAdviseHolder, This->pDataDelegate);
if (FAILED(hr))
DefaultHandler_Stop(This);
return hr;
}
@ -1510,6 +1585,7 @@ static DefaultHandler* DefaultHandler_Construct(
This->containerObj = NULL;
This->pOleDelegate = NULL;
This->pPSDelegate = NULL;
This->pDataDelegate = NULL;
This->dwAdvConn = 0;

84
reactos/lib/ole32/ole32.spec
View file

@ -1,8 +1,8 @@
@ stdcall BindMoniker(ptr long ptr ptr)
@ stub CLIPFORMAT_UserFree
@ stub CLIPFORMAT_UserMarshal
@ stub CLIPFORMAT_UserSize
@ stub CLIPFORMAT_UserUnmarshal
@ stdcall CLIPFORMAT_UserFree(ptr ptr)
@ stdcall CLIPFORMAT_UserMarshal(ptr ptr ptr)
@ stdcall CLIPFORMAT_UserSize(ptr long ptr)
@ stdcall CLIPFORMAT_UserUnmarshal(ptr ptr ptr)
@ stdcall CLSIDFromProgID(wstr ptr)
@ stdcall CLSIDFromString(wstr ptr)
@ stdcall CoAddRefServerProcess()
@ -107,30 +107,34 @@
@ stdcall GetHGlobalFromStream(ptr ptr)
@ stub GetHookInterface
@ stdcall GetRunningObjectTable(long ptr)
@ stub HACCEL_UserFree
@ stub HACCEL_UserMarshal
@ stub HACCEL_UserSize
@ stub HACCEL_UserUnmarshal
@ stub HBITMAP_UserFree
@ stub HBITMAP_UserMarshal
@ stub HBITMAP_UserSize
@ stub HBITMAP_UserUnmarshal
@ stdcall HACCEL_UserFree(ptr ptr)
@ stdcall HACCEL_UserMarshal(ptr ptr ptr)
@ stdcall HACCEL_UserSize(ptr long ptr)
@ stdcall HACCEL_UserUnmarshal(ptr ptr ptr)
@ stdcall HBITMAP_UserFree(ptr ptr)
@ stdcall HBITMAP_UserMarshal(ptr ptr ptr)
@ stdcall HBITMAP_UserSize(ptr long ptr)
@ stdcall HBITMAP_UserUnmarshal(ptr ptr ptr)
@ stub HBRUSH_UserFree
@ stub HBRUSH_UserMarshal
@ stub HBRUSH_UserSize
@ stub HBRUSH_UserUnmarshal
@ stub HENHMETAFILE_UserFree
@ stub HENHMETAFILE_UserMarshal
@ stub HENHMETAFILE_UserSize
@ stub HENHMETAFILE_UserUnmarshal
@ stub HGLOBAL_UserFree
@ stub HGLOBAL_UserMarshal
@ stub HGLOBAL_UserSize
@ stub HGLOBAL_UserUnmarshal
@ stub HMENU_UserFree
@ stub HMENU_UserMarshal
@ stub HMENU_UserSize
@ stub HMENU_UserUnmarshal
@ stdcall HDC_UserFree(ptr ptr)
@ stdcall HDC_UserMarshal(ptr ptr ptr)
@ stdcall HDC_UserSize(ptr long ptr)
@ stdcall HDC_UserUnmarshal(ptr ptr ptr)
@ stdcall HENHMETAFILE_UserFree(ptr ptr)
@ stdcall HENHMETAFILE_UserMarshal(ptr ptr ptr)
@ stdcall HENHMETAFILE_UserSize(ptr long ptr)
@ stdcall HENHMETAFILE_UserUnmarshal(ptr ptr ptr)
@ stdcall HGLOBAL_UserFree(ptr ptr)
@ stdcall HGLOBAL_UserMarshal(ptr ptr ptr)
@ stdcall HGLOBAL_UserSize(ptr long ptr)
@ stdcall HGLOBAL_UserUnmarshal(ptr ptr ptr)
@ stdcall HMENU_UserFree(ptr ptr)
@ stdcall HMENU_UserMarshal(ptr ptr ptr)
@ stdcall HMENU_UserSize(ptr long ptr)
@ stdcall HMENU_UserUnmarshal(ptr ptr ptr)
@ stub HMETAFILEPICT_UserFree
@ stub HMETAFILEPICT_UserMarshal
@ stub HMETAFILEPICT_UserSize
@ -139,14 +143,14 @@
@ stub HMETAFILE_UserMarshal
@ stub HMETAFILE_UserSize
@ stub HMETAFILE_UserUnmarshal
@ stub HPALETTE_UserFree
@ stub HPALETTE_UserMarshal
@ stub HPALETTE_UserSize
@ stub HPALETTE_UserUnmarshal
@ stub HWND_UserFree
@ stub HWND_UserMarshal
@ stub HWND_UserSize
@ stub HWND_UserUnmarshal
@ stdcall HPALETTE_UserFree(ptr ptr)
@ stdcall HPALETTE_UserMarshal(ptr ptr ptr)
@ stdcall HPALETTE_UserSize(ptr long ptr)
@ stdcall HPALETTE_UserUnmarshal(ptr ptr ptr)
@ stdcall HWND_UserFree(ptr ptr)
@ stdcall HWND_UserMarshal(ptr ptr ptr)
@ stdcall HWND_UserSize(ptr long ptr)
@ stdcall HWND_UserUnmarshal(ptr ptr ptr)
@ stdcall IIDFromString(wstr ptr) CLSIDFromString
@ stub I_RemoteMain
@ stdcall IsAccelerator(long long ptr long)
@ -227,14 +231,14 @@
@ stdcall RegisterDragDrop(long ptr)
@ stdcall ReleaseStgMedium(ptr)
@ stdcall RevokeDragDrop(long)
@ stub SNB_UserFree
@ stub SNB_UserMarshal
@ stub SNB_UserSize
@ stub SNB_UserUnmarshal
@ stub STGMEDIUM_UserFree
@ stub STGMEDIUM_UserMarshal
@ stub STGMEDIUM_UserSize
@ stub STGMEDIUM_UserUnmarshal
@ stdcall SNB_UserFree(ptr ptr)
@ stdcall SNB_UserMarshal(ptr ptr ptr)
@ stdcall SNB_UserSize(ptr long ptr)
@ stdcall SNB_UserUnmarshal(ptr ptr ptr)
@ stdcall STGMEDIUM_UserFree(ptr ptr)
@ stdcall STGMEDIUM_UserMarshal(ptr ptr ptr)
@ stdcall STGMEDIUM_UserSize(ptr long ptr)
@ stdcall STGMEDIUM_UserUnmarshal(ptr ptr ptr)
@ stdcall SetConvertStg(ptr long)
@ stub SetDocumentBitStg
@ stdcall SetErrorInfo(long ptr)

1
reactos/lib/ole32/ole32.xml
View file

@ -48,6 +48,7 @@
<file>stg_stream.c</file>
<file>storage32.c</file>
<file>stubmanager.c</file>
<file>usrmarshal.c</file>
<file>ole32res.rc</file>
<file>ole32.spec</file>
</module>

22
reactos/lib/ole32/ole32res.rc
View file

@ -62,22 +62,22 @@ LANGUAGE LANG_NEUTRAL, SUBLANG_NEUTRAL
/* BINRES drag_move.cur */
1 CURSOR drag_move.cur
/* {
'00 00 02 00 01 00 20 20 00 00 12 00 16 00 30 01'
'00 00 02 00 01 00 20 20 00 00 01 00 01 00 30 01'
'00 00 16 00 00 00 28 00 00 00 20 00 00 00 40 00'
'00 00 01 00 01 00 00 00 00 00 00 01 00 00 00 00'
'00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00'
'00 00 FF FF FF 00 00 00 00 00 00 00 00 00 00 00'
'00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00'
'00 00 05 55 00 00 0A AA 80 00 04 01 00 00 08 00'
'80 00 04 01 00 00 08 00 80 00 05 55 00 00 0A EA'
'80 00 04 01 00 00 08 00 80 00 05 55 00 00 0A AA'
'80 00 00 C0 00 00 01 80 00 00 01 80 00 00 03 00'
'00 00 23 00 00 00 36 00 00 00 3E 00 00 00 3F C0'
'00 00 3F 80 00 00 3F 00 00 00 3E 00 00 00 3C 00'
'00 00 38 00 00 00 30 00 00 00 20 00 00 00 00 00'
'00 00 00 00 00 00 FF FF FF FF FF FF FF FF FF FF'
'FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF'
'FF FF FA AA FF FF F5 55 7F FF FB FE FF FF F7 FF'
'7F FF FB FE FF FF F7 FF 7F FF FA AA FF FF F5 15'
'FF FF F0 00 7F FF F0 00 7F FF F3 FE 7F FF F3 FE'
'7F FF F3 FE 7F FF F3 FE 7F FF F0 00 7F FF F0 00'
'7F FF FE 1F FF FF FC 3F FF FF BC 3F FF FF 98 7F'
'FF FF 88 7F FF FF 80 FF FF FF 80 0F FF FF 80 1F'
'FF FF 80 3F FF FF 80 7F FF FF 80 FF FF FF 81 FF'
@ -95,15 +95,15 @@ LANGUAGE LANG_NEUTRAL, SUBLANG_NEUTRAL
'00 00 FF FF FF 00 00 00 00 00 00 00 00 00 00 00'
'00 00 00 00 00 00 00 07 F0 00 00 07 70 00 00 07'
'70 00 05 54 10 00 0A A7 70 00 04 07 70 00 08 07'
'F0 00 04 00 00 00 08 00 80 00 05 55 00 00 0A EA'
'F0 00 04 00 00 00 08 00 80 00 05 55 00 00 0A AA'
'80 00 00 C0 00 00 01 80 00 00 01 80 00 00 03 00'
'00 00 23 00 00 00 36 00 00 00 3E 00 00 00 3F C0'
'00 00 3F 80 00 00 3F 00 00 00 3E 00 00 00 3C 00'
'00 00 38 00 00 00 30 00 00 00 20 00 00 00 00 00'
'00 00 00 00 00 00 FF FF FF FF FF FF FF FF FF FF'
'FF FF FF F0 07 FF FF F0 07 FF FF F0 07 FF FF F0'
'07 FF FA A0 07 FF F5 50 07 FF FB F0 07 FF F7 F0'
'07 FF FB F0 07 FF F7 FF 7F FF FA AA FF FF F5 15'
'07 FF F0 00 07 FF F0 00 07 FF F3 F0 07 FF F3 F0'
'07 FF F3 F0 07 FF F3 FE 7F FF F0 00 7F FF F0 00'
'7F FF FE 1F FF FF FC 3F FF FF BC 3F FF FF 98 7F'
'FF FF 88 7F FF FF 80 FF FF FF 80 0F FF FF 80 1F'
'FF FF 80 3F FF FF 80 7F FF FF 80 FF FF FF 81 FF'
@ -114,22 +114,22 @@ LANGUAGE LANG_NEUTRAL, SUBLANG_NEUTRAL
/* BINRES drag_link.cur */
3 CURSOR drag_link.cur
/* {
'00 00 02 00 01 00 20 20 00 00 12 00 16 00 30 01'
'00 00 02 00 01 00 20 20 00 00 01 00 01 00 30 01'
'00 00 16 00 00 00 28 00 00 00 20 00 00 00 40 00'
'00 00 01 00 01 00 00 00 00 00 00 01 00 00 00 00'
'00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00'
'00 00 FF FF FF 00 00 00 00 00 00 00 00 00 00 00'
'00 00 00 00 00 00 00 07 F0 00 00 06 F0 00 00 06'
'F0 00 05 57 50 00 0A A7 90 00 04 07 10 00 08 07'
'F0 00 04 00 00 00 08 00 80 00 05 55 00 00 0A EA'
'F0 00 04 00 00 00 08 00 80 00 05 55 00 00 0A AA'
'80 00 00 C0 00 00 01 80 00 00 01 80 00 00 03 00'
'00 00 23 00 00 00 36 00 00 00 3E 00 00 00 3F C0'
'00 00 3F 80 00 00 3F 00 00 00 3E 00 00 00 3C 00'
'00 00 38 00 00 00 30 00 00 00 20 00 00 00 00 00'
'00 00 00 00 00 00 FF FF FF FF FF FF FF FF FF FF'
'FF FF FF F0 07 FF FF F0 07 FF FF F0 07 FF FF F0'
'07 FF FA A0 07 FF F5 50 07 FF FB F0 07 FF F7 F0'
'07 FF FB F0 07 FF F7 FF 7F FF FA AA FF FF F5 15'
'07 FF F0 00 07 FF F0 00 07 FF F3 F0 07 FF F3 F0'
'07 FF F3 F0 07 FF F3 FE 7F FF F0 00 7F FF F0 00'
'7F FF FE 1F FF FF FC 3F FF FF BC 3F FF FF 98 7F'
'FF FF 88 7F FF FF 80 FF FF FF 80 0F FF FF 80 1F'
'FF FF 80 3F FF FF 80 7F FF FF 80 FF FF FF 81 FF'

33
reactos/lib/ole32/oleobj.c
View file

@ -351,6 +351,7 @@ typedef struct DataAdviseConnection {
IAdviseSink *sink;
FORMATETC fmat;
DWORD advf;
DWORD remote_connection;
} DataAdviseConnection;
typedef struct DataAdviseHolder
@ -362,6 +363,9 @@ typedef struct DataAdviseHolder
DataAdviseConnection* Connections;
} DataAdviseHolder;
/* this connection has also has been advised to the delegate data object */
#define WINE_ADVF_REMOTE 0x80000000
/******************************************************************************
* DataAdviseHolder_Destructor
*/
@ -520,7 +524,7 @@ static HRESULT WINAPI DataAdviseHolder_Advise(
*/
This->Connections[index].sink = pAdvise;
memcpy(&(This->Connections[index].fmat), pFetc, sizeof(FORMATETC));
This->Connections[index].advf = advf;
This->Connections[index].advf = advf & ~WINE_ADVF_REMOTE;
if (This->Connections[index].sink != NULL) {
IAdviseSink_AddRef(This->Connections[index].sink);
@ -636,6 +640,33 @@ static const IDataAdviseHolderVtbl DataAdviseHolderImpl_VTable =
DataAdviseHolder_SendOnDataChange
};
HRESULT DataAdviseHolder_OnConnect(IDataAdviseHolder *iface, IDataObject *pDelegate)
{
DataAdviseHolder *This = (DataAdviseHolder *)iface;
DWORD index;
HRESULT hr = S_OK;
for(index = 0; index < This->maxCons; index++)
{
if(This->Connections[index].sink != NULL)
{
hr = IDataObject_DAdvise(pDelegate, &This->Connections[index].fmat,
This->Connections[index].advf,
This->Connections[index].sink,
&This->Connections[index].remote_connection);
if (FAILED(hr)) break;
This->Connections[index].advf |= WINE_ADVF_REMOTE;
}
}
/* FIXME: store pDelegate somewhere */
return hr;
}
void DataAdviseHolder_OnDisconnect(IDataAdviseHolder *iface)
{
/* FIXME: Unadvise all remote interfaces */
}
/******************************************************************************
* DataAdviseHolder_Constructor
*/

2
reactos/lib/ole32/rpc.c
View file

@ -624,7 +624,7 @@ static HRESULT create_server(REFCLSID rclsid)
HKEY key;
HRESULT hres;
WCHAR command[MAX_PATH+sizeof(embedding)/sizeof(WCHAR)];
DWORD size = MAX_PATH+1 * sizeof(WCHAR);
DWORD size = (MAX_PATH+1) * sizeof(WCHAR);
STARTUPINFOW sinfo;
PROCESS_INFORMATION pinfo;

800
reactos/lib/ole32/usrmarshal.c Normal file
View file

@ -0,0 +1,800 @@
/*
* Miscellaneous Marshaling Routines
*
* Copyright 2005 Robert Shearman
*
* 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#include <stdarg.h>
#include <string.h>
#define COBJMACROS
#define NONAMELESSUNION
#define NONAMELESSSTRUCT
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "winerror.h"
#include "ole2.h"
#include "oleauto.h"
#include "rpcproxy.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(ole);
#define ALIGNED_LENGTH(_Len, _Align) (((_Len)+(_Align))&~(_Align))
#define ALIGNED_POINTER(_Ptr, _Align) ((LPVOID)ALIGNED_LENGTH((ULONG_PTR)(_Ptr), _Align))
#define ALIGN_LENGTH(_Len, _Align) _Len = ALIGNED_LENGTH(_Len, _Align)
#define ALIGN_POINTER(_Ptr, _Align) _Ptr = ALIGNED_POINTER(_Ptr, _Align)
static void dump_user_flags(unsigned long *pFlags)
{
if (HIWORD(*pFlags) == NDR_LOCAL_DATA_REPRESENTATION)
TRACE("MAKELONG(NDR_LOCAL_REPRESENTATION, ");
else
TRACE("MAKELONG(0x%04x, ", HIWORD(*pFlags));
switch (LOWORD(*pFlags))
{
case MSHCTX_LOCAL: TRACE("MSHCTX_LOCAL)"); break;
case MSHCTX_NOSHAREDMEM: TRACE("MSHCTX_NOSHAREDMEM)"); break;
case MSHCTX_DIFFERENTMACHINE: TRACE("MSHCTX_DIFFERENTMACHINE)"); break;
case MSHCTX_INPROC: TRACE("MSHCTX_INPROC)"); break;
default: TRACE("%d)", LOWORD(*pFlags));
}
}
unsigned long __RPC_USER CLIPFORMAT_UserSize(unsigned long *pFlags, unsigned long StartingSize, CLIPFORMAT *pCF)
{
unsigned long size = StartingSize;
TRACE("("); dump_user_flags(pFlags); TRACE(", %ld, %p\n", StartingSize, pCF);
size += sizeof(userCLIPFORMAT);
/* only need to marshal the name if it is not a pre-defined type and
* we are going remote */
if ((*pCF >= 0xc000) && (LOWORD(*pFlags) == MSHCTX_DIFFERENTMACHINE))
{
WCHAR format[255];
INT ret;
size += 3 * sizeof(INT);
/* urg! this function is badly designed because it won't tell us how
* much space is needed without doing a dummy run of storing the
* name into a buffer */
ret = GetClipboardFormatNameW(*pCF, format, sizeof(format)/sizeof(format[0])-1);
if (!ret)
RaiseException(DV_E_CLIPFORMAT, 0, 0, NULL);
size += (ret + 1) * sizeof(WCHAR);
}
return size;
}
unsigned char * __RPC_USER CLIPFORMAT_UserMarshal(unsigned long *pFlags, unsigned char *pBuffer, CLIPFORMAT *pCF)
{
wireCLIPFORMAT wirecf = (wireCLIPFORMAT)pBuffer;
TRACE("("); dump_user_flags(pFlags); TRACE(", %p, &0x%04x\n", pBuffer, *pCF);
wirecf->u.dwValue = *pCF;
pBuffer += sizeof(*wirecf);
/* only need to marshal the name if it is not a pre-defined type and
* we are going remote */
if ((*pCF >= 0xc000) && (LOWORD(*pFlags) == MSHCTX_DIFFERENTMACHINE))
{
WCHAR format[255];
INT len;
wirecf->fContext = WDT_REMOTE_CALL;
len = GetClipboardFormatNameW(*pCF, format, sizeof(format)/sizeof(format[0])-1);
if (!len)
RaiseException(DV_E_CLIPFORMAT, 0, 0, NULL);
len += 1;
*(INT *)pBuffer = len;
pBuffer += sizeof(INT);
*(INT *)pBuffer = 0;
pBuffer += sizeof(INT);
*(INT *)pBuffer = len;
pBuffer += sizeof(INT);
TRACE("marshaling format name %s\n", debugstr_wn(format, len-1));
lstrcpynW((LPWSTR)pBuffer, format, len);
pBuffer += len * sizeof(WCHAR);
*(WCHAR *)pBuffer = '\0';
pBuffer += sizeof(WCHAR);
}
else
wirecf->fContext = WDT_INPROC_CALL;
return pBuffer;
}
unsigned char * __RPC_USER CLIPFORMAT_UserUnmarshal(unsigned long *pFlags, unsigned char *pBuffer, CLIPFORMAT *pCF)
{
wireCLIPFORMAT wirecf = (wireCLIPFORMAT)pBuffer;
TRACE("("); dump_user_flags(pFlags); TRACE(", %p, %p\n", pBuffer, pCF);
pBuffer += sizeof(*wirecf);
if (wirecf->fContext == WDT_INPROC_CALL)
*pCF = (CLIPFORMAT)wirecf->u.dwValue;
else if (wirecf->fContext == WDT_REMOTE_CALL)
{
CLIPFORMAT cf;
INT len = *(INT *)pBuffer;
pBuffer += sizeof(INT);
if (*(INT *)pBuffer != 0)
RaiseException(RPC_S_INVALID_BOUND, 0, 0, NULL);
pBuffer += sizeof(INT);
if (*(INT *)pBuffer != len)
RaiseException(RPC_S_INVALID_BOUND, 0, 0, NULL);
pBuffer += sizeof(INT);
if (((WCHAR *)pBuffer)[len] != '\0')
RaiseException(RPC_S_INVALID_BOUND, 0, 0, NULL);
TRACE("unmarshaling clip format %s\n", debugstr_w((LPCWSTR)pBuffer));
cf = RegisterClipboardFormatW((LPCWSTR)pBuffer);
pBuffer += (len + 1) * sizeof(WCHAR);
if (!cf)
RaiseException(DV_E_CLIPFORMAT, 0, 0, NULL);
*pCF = cf;
}
else
/* code not really appropriate, but nearest I can find */
RaiseException(RPC_S_INVALID_TAG, 0, 0, NULL);
return pBuffer;
}
void __RPC_USER CLIPFORMAT_UserFree(unsigned long *pFlags, CLIPFORMAT *pCF)
{
/* there is no inverse of the RegisterClipboardFormat function,
* so nothing to do */
}
static unsigned long __RPC_USER handle_UserSize(unsigned long *pFlags, unsigned long StartingSize, HANDLE *handle)
{
if (LOWORD(*pFlags) == MSHCTX_DIFFERENTMACHINE)
{
ERR("can't remote a local handle\n");
RaiseException(RPC_S_INVALID_TAG, 0, 0, NULL);
return StartingSize;
}
return StartingSize + sizeof(RemotableHandle);
}
static unsigned char * __RPC_USER handle_UserMarshal(unsigned long *pFlags, unsigned char *pBuffer, HANDLE *handle)
{
RemotableHandle *remhandle = (RemotableHandle *)pBuffer;
if (LOWORD(*pFlags) == MSHCTX_DIFFERENTMACHINE)
{
ERR("can't remote a local handle\n");
RaiseException(RPC_S_INVALID_TAG, 0, 0, NULL);
return pBuffer;
}
remhandle->fContext = WDT_INPROC_CALL;
remhandle->u.hInproc = (LONG_PTR)*handle;
return pBuffer + sizeof(RemotableHandle);
}
static unsigned char * __RPC_USER handle_UserUnmarshal(unsigned long *pFlags, unsigned char *pBuffer, HANDLE *handle)
{
RemotableHandle *remhandle = (RemotableHandle *)pBuffer;
if (remhandle->fContext != WDT_INPROC_CALL)
RaiseException(RPC_X_BAD_STUB_DATA, 0, 0, NULL);
*handle = (HANDLE)remhandle->u.hInproc;
return pBuffer + sizeof(RemotableHandle);
}
static void __RPC_USER handle_UserFree(unsigned long *pFlags, HANDLE *phMenu)
{
/* nothing to do */
}
#define IMPL_WIREM_HANDLE(type) \
unsigned long __RPC_USER type##_UserSize(unsigned long *pFlags, unsigned long StartingSize, type *handle) \
{ \
TRACE("("); dump_user_flags(pFlags); TRACE(", %ld, %p\n", StartingSize, handle); \
return handle_UserSize(pFlags, StartingSize, (HANDLE *)handle); \
} \
\
unsigned char * __RPC_USER type##_UserMarshal(unsigned long *pFlags, unsigned char *pBuffer, type *handle) \
{ \
TRACE("("); dump_user_flags(pFlags); TRACE(", %p, &%p\n", pBuffer, *handle); \
return handle_UserMarshal(pFlags, pBuffer, (HANDLE *)handle); \
} \
\
unsigned char * __RPC_USER type##_UserUnmarshal(unsigned long *pFlags, unsigned char *pBuffer, type *handle) \
{ \
TRACE("("); dump_user_flags(pFlags); TRACE(", %p, %p\n", pBuffer, handle); \
return handle_UserUnmarshal(pFlags, pBuffer, (HANDLE *)handle); \
} \
\
void __RPC_USER type##_UserFree(unsigned long *pFlags, type *handle) \
{ \
TRACE("("); dump_user_flags(pFlags); TRACE(", &%p\n", *handle); \
return handle_UserFree(pFlags, (HANDLE *)handle); \
}
IMPL_WIREM_HANDLE(HACCEL)
IMPL_WIREM_HANDLE(HMENU)
IMPL_WIREM_HANDLE(HWND)
unsigned long __RPC_USER HGLOBAL_UserSize(unsigned long *pFlags, unsigned long StartingSize, HGLOBAL *phGlobal)
{
unsigned long size = StartingSize;
TRACE("("); dump_user_flags(pFlags); TRACE(", %ld, %p\n", StartingSize, phGlobal);
ALIGN_LENGTH(size, 3);
size += sizeof(ULONG);
if (LOWORD(*pFlags == MSHCTX_INPROC))
size += sizeof(HGLOBAL);
else
{
size += sizeof(ULONG);
if (*phGlobal)
{
SIZE_T ret;
size += 3 * sizeof(ULONG);
ret = GlobalSize(*phGlobal);
size += (unsigned long)ret;
}
}
return size;
}
unsigned char * __RPC_USER HGLOBAL_UserMarshal(unsigned long *pFlags, unsigned char *pBuffer, HGLOBAL *phGlobal)
{
TRACE("("); dump_user_flags(pFlags); TRACE(", %p, &%p\n", pBuffer, *phGlobal);
ALIGN_POINTER(pBuffer, 3);
if (LOWORD(*pFlags == MSHCTX_INPROC))
{
if (sizeof(*phGlobal) == 8)
*(ULONG *)pBuffer = WDT_INPROC64_CALL;
else
*(ULONG *)pBuffer = WDT_INPROC_CALL;
pBuffer += sizeof(ULONG);
*(HGLOBAL *)pBuffer = *phGlobal;
pBuffer += sizeof(HGLOBAL);
}
else
{
*(ULONG *)pBuffer = WDT_REMOTE_CALL;
pBuffer += sizeof(ULONG);
*(ULONG *)pBuffer = (ULONG)*phGlobal;
pBuffer += sizeof(ULONG);
if (*phGlobal)
{
const unsigned char *memory;
SIZE_T size = GlobalSize(*phGlobal);
*(ULONG *)pBuffer = (ULONG)size;
pBuffer += sizeof(ULONG);
*(ULONG *)pBuffer = (ULONG)*phGlobal;
pBuffer += sizeof(ULONG);
*(ULONG *)pBuffer = (ULONG)size;
pBuffer += sizeof(ULONG);
memory = GlobalLock(*phGlobal);
memcpy(pBuffer, memory, size);
pBuffer += size;
GlobalUnlock(*phGlobal);
}
}
return pBuffer;
}
unsigned char * __RPC_USER HGLOBAL_UserUnmarshal(unsigned long *pFlags, unsigned char *pBuffer, HGLOBAL *phGlobal)
{
ULONG fContext;
TRACE("("); dump_user_flags(pFlags); TRACE(", %p, &%p\n", pBuffer, *phGlobal);
ALIGN_POINTER(pBuffer, 3);
fContext = *(ULONG *)pBuffer;
pBuffer += sizeof(ULONG);
if (((fContext == WDT_INPROC_CALL) && (sizeof(*phGlobal) < 8)) ||
((fContext == WDT_INPROC64_CALL) && (sizeof(*phGlobal) == 8)))
{
*phGlobal = *(HGLOBAL *)pBuffer;
pBuffer += sizeof(*phGlobal);
}
else if (fContext == WDT_REMOTE_CALL)
{
ULONG handle;
handle = *(ULONG *)pBuffer;
pBuffer += sizeof(ULONG);
if (handle)
{
ULONG size;
void *memory;
size = *(ULONG *)pBuffer;
pBuffer += sizeof(ULONG);
/* redundancy is bad - it means you have to check consistency like
* this: */
if (*(ULONG *)pBuffer != handle)
{
RaiseException(RPC_X_BAD_STUB_DATA, 0, 0, NULL);
return pBuffer;
}
pBuffer += sizeof(ULONG);
/* redundancy is bad - it means you have to check consistency like
* this: */
if (*(ULONG *)pBuffer != size)
{
RaiseException(RPC_X_BAD_STUB_DATA, 0, 0, NULL);
return pBuffer;
}
pBuffer += sizeof(ULONG);
/* FIXME: check size is not too big */
*phGlobal = GlobalAlloc(GMEM_MOVEABLE, size);
memory = GlobalLock(*phGlobal);
memcpy(memory, pBuffer, size);
pBuffer += size;
GlobalUnlock(*phGlobal);
}
else
*phGlobal = NULL;
}
else
RaiseException(RPC_S_INVALID_TAG, 0, 0, NULL);
return pBuffer;
}
void __RPC_USER HGLOBAL_UserFree(unsigned long *pFlags, HGLOBAL *phGlobal)
{
TRACE("("); dump_user_flags(pFlags); TRACE(", &%p\n", *phGlobal);
if (LOWORD(*pFlags != MSHCTX_INPROC) && *phGlobal)
GlobalFree(*phGlobal);
}
unsigned long __RPC_USER HBITMAP_UserSize(unsigned long *pFlags, unsigned long StartingSize, HBITMAP *phBmp)
{
FIXME(":stub\n");
return StartingSize;
}
unsigned char * __RPC_USER HBITMAP_UserMarshal(unsigned long *pFlags, unsigned char *pBuffer, HBITMAP *phBmp)
{
FIXME(":stub\n");
return pBuffer;
}
unsigned char * __RPC_USER HBITMAP_UserUnmarshal(unsigned long *pFlags, unsigned char *pBuffer, HBITMAP *phBmp)
{
FIXME(":stub\n");
return pBuffer;
}
void __RPC_USER HBITMAP_UserFree(unsigned long *pFlags, HBITMAP *phBmp)
{
FIXME(":stub\n");
}
unsigned long __RPC_USER HDC_UserSize(unsigned long *pFlags, unsigned long StartingSize, HDC *phdc)
{
FIXME(":stub\n");
return StartingSize;
}
unsigned char * __RPC_USER HDC_UserMarshal(unsigned long *pFlags, unsigned char *pBuffer, HDC *phdc)
{
FIXME(":stub\n");
return pBuffer;
}
unsigned char * __RPC_USER HDC_UserUnmarshal(unsigned long *pFlags, unsigned char *pBuffer, HDC *phdc)
{
FIXME(":stub\n");
return pBuffer;
}
void __RPC_USER HDC_UserFree(unsigned long *pFlags, HDC *phdc)
{
FIXME(":stub\n");
}
unsigned long __RPC_USER HPALETTE_UserSize(unsigned long *pFlags, unsigned long StartingSize, HPALETTE *phPal)
{
FIXME(":stub\n");
return StartingSize;
}
unsigned char * __RPC_USER HPALETTE_UserMarshal(unsigned long *pFlags, unsigned char *pBuffer, HPALETTE *phPal)
{
FIXME(":stub\n");
return pBuffer;
}
unsigned char * __RPC_USER HPALETTE_UserUnmarshal(unsigned long *pFlags, unsigned char *pBuffer, HPALETTE *phPal)
{
FIXME(":stub\n");
return pBuffer;
}
void __RPC_USER HPALETTE_UserFree(unsigned long *pFlags, HPALETTE *phPal)
{
FIXME(":stub\n");
}
unsigned long __RPC_USER HENHMETAFILE_UserSize(unsigned long *pFlags, unsigned long StartingSize, HENHMETAFILE *phEmf)
{
unsigned long size = StartingSize;
TRACE("("); dump_user_flags(pFlags); TRACE(", %ld, %p\n", StartingSize, *phEmf);
size += sizeof(ULONG);
if (LOWORD(*pFlags) == MSHCTX_INPROC)
size += sizeof(ULONG_PTR);
else
{
size += sizeof(ULONG);
if (*phEmf)
{
UINT emfsize;
size += 2 * sizeof(ULONG);
emfsize = GetEnhMetaFileBits(*phEmf, 0, NULL);
size += emfsize;
}
}
return size;
}
unsigned char * __RPC_USER HENHMETAFILE_UserMarshal(unsigned long *pFlags, unsigned char *pBuffer, HENHMETAFILE *phEmf)
{
TRACE("("); dump_user_flags(pFlags); TRACE(", %p, &%p\n", pBuffer, *phEmf);
if (LOWORD(*pFlags) == MSHCTX_INPROC)
{
if (sizeof(*phEmf) == 8)
*(ULONG *)pBuffer = WDT_INPROC64_CALL;
else
*(ULONG *)pBuffer = WDT_INPROC_CALL;
pBuffer += sizeof(ULONG);
*(HENHMETAFILE *)pBuffer = *phEmf;
pBuffer += sizeof(HENHMETAFILE);
}
else
{
*(ULONG *)pBuffer = WDT_REMOTE_CALL;
pBuffer += sizeof(ULONG);
*(ULONG *)pBuffer = (ULONG)(ULONG_PTR)*phEmf;
pBuffer += sizeof(ULONG);
if (*phEmf)
{
UINT emfsize = GetEnhMetaFileBits(*phEmf, 0, NULL);
*(ULONG *)pBuffer = emfsize;
pBuffer += sizeof(ULONG);
*(ULONG *)pBuffer = emfsize;
pBuffer += sizeof(ULONG);
GetEnhMetaFileBits(*phEmf, emfsize, pBuffer);
pBuffer += emfsize;
}
}
return pBuffer;
}
unsigned char * __RPC_USER HENHMETAFILE_UserUnmarshal(unsigned long *pFlags, unsigned char *pBuffer, HENHMETAFILE *phEmf)
{
ULONG fContext;
TRACE("("); dump_user_flags(pFlags); TRACE(", %p, %p\n", pBuffer, phEmf);
fContext = *(ULONG *)pBuffer;
pBuffer += sizeof(ULONG);
if (((fContext == WDT_INPROC_CALL) && (sizeof(*phEmf) < 8)) ||
((fContext == WDT_INPROC64_CALL) && (sizeof(*phEmf) == 8)))
{
*phEmf = *(HENHMETAFILE *)pBuffer;
pBuffer += sizeof(*phEmf);
}
else if (fContext == WDT_REMOTE_CALL)
{
ULONG handle;
handle = *(ULONG *)pBuffer;
pBuffer += sizeof(ULONG);
if (handle)
{
ULONG size;
size = *(ULONG *)pBuffer;
pBuffer += sizeof(ULONG);
if (size != *(ULONG *)pBuffer)
{
RaiseException(RPC_X_BAD_STUB_DATA, 0, 0, NULL);
return pBuffer;
}
pBuffer += sizeof(ULONG);
*phEmf = SetEnhMetaFileBits(size, pBuffer);
pBuffer += size;
}
else
*phEmf = NULL;
}
else
RaiseException(RPC_S_INVALID_TAG, 0, 0, NULL);
return pBuffer;
}
void __RPC_USER HENHMETAFILE_UserFree(unsigned long *pFlags, HENHMETAFILE *phEmf)
{
TRACE("("); dump_user_flags(pFlags); TRACE(", &%p\n", *phEmf);
if (LOWORD(*pFlags) != MSHCTX_INPROC)
DeleteEnhMetaFile(*phEmf);
}
unsigned long __RPC_USER STGMEDIUM_UserSize(unsigned long *pFlags, unsigned long StartingSize, STGMEDIUM *pStgMedium)
{
unsigned long size = StartingSize;
TRACE("("); dump_user_flags(pFlags); TRACE(", %ld, %p\n", StartingSize, pStgMedium);
ALIGN_LENGTH(size, 3);
size += 2 * sizeof(DWORD);
if (pStgMedium->tymed != TYMED_NULL)
size += sizeof(DWORD);
switch (pStgMedium->tymed)
{
case TYMED_NULL:
TRACE("TYMED_NULL\n");
break;
case TYMED_HGLOBAL:
TRACE("TYMED_HGLOBAL\n");
size = HGLOBAL_UserSize(pFlags, size, &pStgMedium->u.hGlobal);
break;
case TYMED_FILE:
FIXME("TYMED_FILE\n");
break;
case TYMED_ISTREAM:
FIXME("TYMED_ISTREAM\n");
break;
case TYMED_ISTORAGE:
FIXME("TYMED_ISTORAGE\n");
break;
case TYMED_GDI:
FIXME("TYMED_GDI\n");
break;
case TYMED_MFPICT:
FIXME("TYMED_MFPICT\n");
break;
case TYMED_ENHMF:
TRACE("TYMED_ENHMF\n");
size = HENHMETAFILE_UserSize(pFlags, size, &pStgMedium->u.hEnhMetaFile);
break;
default:
RaiseException(DV_E_TYMED, 0, 0, NULL);
}
if (pStgMedium->pUnkForRelease)
FIXME("buffer size pUnkForRelease\n");
return size;
}
unsigned char * __RPC_USER STGMEDIUM_UserMarshal(unsigned long *pFlags, unsigned char *pBuffer, STGMEDIUM *pStgMedium)
{
TRACE("("); dump_user_flags(pFlags); TRACE(", %p, %p\n", pBuffer, pStgMedium);
ALIGN_POINTER(pBuffer, 3);
*(DWORD *)pBuffer = pStgMedium->tymed;
pBuffer += sizeof(DWORD);
if (pStgMedium->tymed != TYMED_NULL)
{
*(DWORD *)pBuffer = (DWORD)(DWORD_PTR)pStgMedium->u.pstg;
pBuffer += sizeof(DWORD);
}
*(DWORD *)pBuffer = (DWORD)(DWORD_PTR)pStgMedium->pUnkForRelease;
pBuffer += sizeof(DWORD);
switch (pStgMedium->tymed)
{
case TYMED_NULL:
TRACE("TYMED_NULL\n");
break;
case TYMED_HGLOBAL:
TRACE("TYMED_HGLOBAL\n");
pBuffer = HGLOBAL_UserMarshal(pFlags, pBuffer, &pStgMedium->u.hGlobal);
break;
case TYMED_FILE:
FIXME("TYMED_FILE\n");
break;
case TYMED_ISTREAM:
FIXME("TYMED_ISTREAM\n");
break;
case TYMED_ISTORAGE:
FIXME("TYMED_ISTORAGE\n");
break;
case TYMED_GDI:
FIXME("TYMED_GDI\n");
break;
case TYMED_MFPICT:
FIXME("TYMED_MFPICT\n");
break;
case TYMED_ENHMF:
TRACE("TYMED_ENHMF\n");
pBuffer = HENHMETAFILE_UserMarshal(pFlags, pBuffer, &pStgMedium->u.hEnhMetaFile);
break;
default:
RaiseException(DV_E_TYMED, 0, 0, NULL);
}
if (pStgMedium->pUnkForRelease)
FIXME("marshal pUnkForRelease\n");
return pBuffer;
}
unsigned char * __RPC_USER STGMEDIUM_UserUnmarshal(unsigned long *pFlags, unsigned char *pBuffer, STGMEDIUM *pStgMedium)
{
DWORD content;
DWORD releaseunk;
ALIGN_POINTER(pBuffer, 3);
TRACE("("); dump_user_flags(pFlags); TRACE(", %p, %p\n", pBuffer, pStgMedium);
pStgMedium->tymed = *(DWORD *)pBuffer;
pBuffer += sizeof(DWORD);
if (pStgMedium->tymed != TYMED_NULL)
{
content = *(DWORD *)pBuffer;
pBuffer += sizeof(DWORD);
}
releaseunk = *(DWORD *)pBuffer;
pBuffer += sizeof(DWORD);
switch (pStgMedium->tymed)
{
case TYMED_NULL:
TRACE("TYMED_NULL\n");
break;
case TYMED_HGLOBAL:
TRACE("TYMED_HGLOBAL\n");
pBuffer = HGLOBAL_UserUnmarshal(pFlags, pBuffer, &pStgMedium->u.hGlobal);
break;
case TYMED_FILE:
FIXME("TYMED_FILE\n");
break;
case TYMED_ISTREAM:
FIXME("TYMED_ISTREAM\n");
break;
case TYMED_ISTORAGE:
FIXME("TYMED_ISTORAGE\n");
break;
case TYMED_GDI:
FIXME("TYMED_GDI\n");
break;
case TYMED_MFPICT:
FIXME("TYMED_MFPICT\n");
break;
case TYMED_ENHMF:
TRACE("TYMED_ENHMF\n");
pBuffer = HENHMETAFILE_UserUnmarshal(pFlags, pBuffer, &pStgMedium->u.hEnhMetaFile);
break;
default:
RaiseException(DV_E_TYMED, 0, 0, NULL);
}
pStgMedium->pUnkForRelease = NULL;
if (releaseunk)
FIXME("unmarshal pUnkForRelease\n");
return pBuffer;
}
void __RPC_USER STGMEDIUM_UserFree(unsigned long *pFlags, STGMEDIUM *pStgMedium)
{
TRACE("("); dump_user_flags(pFlags); TRACE(", %p\n", pStgMedium);
ReleaseStgMedium(pStgMedium);
}
unsigned long __RPC_USER ASYNC_STGMEDIUM_UserSize(unsigned long *pFlags, unsigned long StartingSize, ASYNC_STGMEDIUM *pStgMedium)
{
FIXME(":stub\n");
return StartingSize;
}
unsigned char * __RPC_USER ASYNC_STGMEDIUM_UserMarshal( unsigned long *pFlags, unsigned char *pBuffer, ASYNC_STGMEDIUM *pStgMedium)
{
FIXME(":stub\n");
return pBuffer;
}
unsigned char * __RPC_USER ASYNC_STGMEDIUM_UserUnmarshal(unsigned long *pFlags, unsigned char *pBuffer, ASYNC_STGMEDIUM *pStgMedium)
{
FIXME(":stub\n");
return pBuffer;
}
void __RPC_USER ASYNC_STGMEDIUM_UserFree(unsigned long *pFlags, ASYNC_STGMEDIUM *pStgMedium)
{
FIXME(":stub\n");
}
unsigned long __RPC_USER FLAG_STGMEDIUM_UserSize(unsigned long *pFlags, unsigned long StartingSize, FLAG_STGMEDIUM *pStgMedium)
{
FIXME(":stub\n");
return StartingSize;
}
unsigned char * __RPC_USER FLAG_STGMEDIUM_UserMarshal( unsigned long *pFlags, unsigned char *pBuffer, FLAG_STGMEDIUM *pStgMedium)
{
FIXME(":stub\n");
return pBuffer;
}
unsigned char * __RPC_USER FLAG_STGMEDIUM_UserUnmarshal(unsigned long *pFlags, unsigned char *pBuffer, FLAG_STGMEDIUM *pStgMedium)
{
FIXME(":stub\n");
return pBuffer;
}
void __RPC_USER FLAG_STGMEDIUM_UserFree(unsigned long *pFlags, FLAG_STGMEDIUM *pStgMedium)
{
FIXME(":stub\n");
}
unsigned long __RPC_USER SNB_UserSize(unsigned long *pFlags, unsigned long StartingSize, SNB *pSnb)
{
FIXME(":stub\n");
return StartingSize;
}
unsigned char * __RPC_USER SNB_UserMarshal( unsigned long *pFlags, unsigned char *pBuffer, SNB *pSnb)
{
FIXME(":stub\n");
return pBuffer;
}
unsigned char * __RPC_USER SNB_UserUnmarshal(unsigned long *pFlags, unsigned char *pBuffer, SNB *pSnb)
{
FIXME(":stub\n");
return pBuffer;
}
void __RPC_USER SNB_UserFree(unsigned long *pFlags, SNB *pSnb)
{
FIXME(":stub\n");
}

127
reactos/w32api/include/wtypes.h
View file

@ -191,6 +191,133 @@ typedef struct {
} ByObjectId;
} tagged_union;
} uCLSSPEC;
#define WDT_INPROC_CALL (0x48746457)
#define WDT_REMOTE_CALL (0x52746457)
#define WDT_INPROC64_CALL (0x50746457)
typedef struct _userCLIPFORMAT {
long fContext;
union {
DWORD dwValue;
LPWSTR pwszName;
} u;
} userCLIPFORMAT;
typedef userCLIPFORMAT *wireCLIPFORMAT;
typedef WORD CLIPFORMAT;
typedef struct _RemotableHandle {
long fContext;
union {
long hInproc;
long hRemote;
} u;
} RemotableHandle;
typedef RemotableHandle *wireHACCEL;
typedef RemotableHandle *wireHBRUSH;
typedef RemotableHandle *wireHDC;
typedef RemotableHandle *wireHFONT;
typedef RemotableHandle *wireHICON;
typedef RemotableHandle *wireHMENU;
typedef RemotableHandle *wireHWND;
typedef struct _BYTE_BLOB {
unsigned long clSize;
byte abData[1];
} BYTE_BLOB;
typedef BYTE_BLOB *UP_BYTE_BLOB;
typedef struct _FLAGGED_BYTE_BLOB {
unsigned long fFlags;
unsigned long clSize;
byte abData[1];
} FLAGGED_BYTE_BLOB;
typedef FLAGGED_BYTE_BLOB *UP_FLAGGED_BYTE_BLOB;
typedef struct _userHENHMETAFILE {
long fContext;
union {
long hInproc;
BYTE_BLOB *hRemote;
long hGlobal;
} u;
} userHENHMETAFILE;
typedef userHENHMETAFILE *wireHENHMETAFILE;
typedef struct tagRemHMETAFILEPICT {
long mm;
long xExt;
long yExt;
unsigned long cbData;
byte data[1];
} RemHMETAFILEPICT;
typedef struct _userHMETAFILE {
long fContext;
union {
long hInproc;
BYTE_BLOB *hRemote;
long hGlobal;
} u;
} userHMETAFILE;
typedef userHMETAFILE *wireHMETAFILE;
typedef struct _remoteMETAFILEPICT {
long mm;
long xExt;
long yExt;
userHMETAFILE *hMF;
} remoteMETAFILEPICT;
typedef struct _userHMETAFILEPICT {
long fContext;
union {
long hInproc;
remoteMETAFILEPICT *hRemote;
long hGlobal;
} u;
} userHMETAFILEPICT;
typedef userHMETAFILEPICT *wireHMETAFILEPICT;
typedef struct _userBITMAP {
LONG bmType;
LONG bmWidth;
LONG bmHeight;
LONG bmWidthBytes;
WORD bmPlanes;
WORD bmBitsPixel;
ULONG cbSize;
byte pBuffer[1];
} userBITMAP;
typedef struct _userHBITMAP {
long fContext;
union {
long hInproc;
userBITMAP *hRemote;
long hGlobal;
} u;
} userHBITMAP;
typedef userHBITMAP *wireHBITMAP;
typedef struct tagrpcLOGPALETTE {
WORD palVersion;
WORD palNumEntries;
PALETTEENTRY palPalEntry[1];
} rpcLOGPALETTE;
typedef struct _userHPALETTE {
long fContext;
union {
long hInproc;
rpcLOGPALETTE *hRemote;
long hGlobal;
} u;
} userHPALETTE;
typedef userHPALETTE *wireHPALETTE;
typedef struct _userHGLOBAL {
long fContext;
union {
long hInproc;
FLAGGED_BYTE_BLOB *hRemote;
long hGlobal;
} u;
} userHGLOBAL;
typedef userHGLOBAL *wireHGLOBAL;
#ifdef __cplusplus
}
#endif