#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);
IOleObject *pOleDelegate;
/* IPersistStorage delegate */
IPersistStorage *pPSDelegate;
+ /* IDataObject delegate */
+ IDataObject *pDataDelegate;
/* connection cookie for the advise on the delegate OLE object */
DWORD dwAdvConn;
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.
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;
/* 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);
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;
}
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,
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;
}
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;
}
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);
}
/************************************************************************
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;
}
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;
}
/************************************************************************
- * DefaultHandler_SetExtent (IOleObject)
+ * DefaultHandler_SetColorScheme (IOleObject)
*
* This method is meaningless if the server is not running
*
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;
}
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
* - 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;
}
This->containerObj = NULL;
This->pOleDelegate = NULL;
This->pPSDelegate = NULL;
+ This->pDataDelegate = NULL;
This->dwAdvConn = 0;
--- /dev/null
+/*
+ * 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");
+}
projects / reactos.git / commitdiff