clipboard.c File Reference

#include <assert.h>
#include <stdarg.h>
#include <string.h>
#include <stdio.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "winerror.h"
#include "winnls.h"
#include "ole2.h"
#include "wine/debug.h"
#include "olestd.h"
#include "storage32.h"
#include "compobj_private.h"

Include dependency graph for clipboard.c:

Go to the source code of this file.

Classes
struct	ole_priv_data_entry
struct	ole_priv_data
struct	snapshot
struct	ole_clipbrd
struct	PresentationDataHeader
struct	enum_fmtetc

Macros
#define	COBJMACROS
#define	NONAMELESSUNION

Typedefs
typedef struct snapshot	snapshot
typedef struct ole_clipbrd	ole_clipbrd
typedef struct PresentationDataHeader	PresentationDataHeader
typedef struct enum_fmtetc	enum_fmtetc

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (ole)
static DVTARGETDEVICE *	td_offs_to_ptr (ole_priv_data *data, DWORD_PTR off)
static DWORD_PTR	td_get_offs (ole_priv_data *data, DWORD idx)
static snapshot *	impl_from_IDataObject (IDataObject *iface)
static HRESULT	get_ole_clipbrd (ole_clipbrd **clipbrd)
static const char *	dump_fmtetc (FORMATETC *fmt)
static enum_fmtetc *	impl_from_IEnumFORMATETC (IEnumFORMATETC *iface)
static HRESULT WINAPI	OLEClipbrd_IEnumFORMATETC_QueryInterface (LPENUMFORMATETC iface, REFIID riid, LPVOID *ppvObj)
static ULONG WINAPI	OLEClipbrd_IEnumFORMATETC_AddRef (LPENUMFORMATETC iface)
static ULONG WINAPI	OLEClipbrd_IEnumFORMATETC_Release (LPENUMFORMATETC iface)
static HRESULT WINAPI	OLEClipbrd_IEnumFORMATETC_Next (LPENUMFORMATETC iface, ULONG celt, FORMATETC *rgelt, ULONG *pceltFethed)
static HRESULT WINAPI	OLEClipbrd_IEnumFORMATETC_Skip (LPENUMFORMATETC iface, ULONG celt)
static HRESULT WINAPI	OLEClipbrd_IEnumFORMATETC_Reset (LPENUMFORMATETC iface)
static HRESULT	enum_fmtetc_construct (ole_priv_data *data, UINT pos, IEnumFORMATETC **obj)
static HRESULT WINAPI	OLEClipbrd_IEnumFORMATETC_Clone (LPENUMFORMATETC iface, LPENUMFORMATETC *obj)
static HRESULT	dup_global_mem (HGLOBAL src, DWORD flags, HGLOBAL *dst)
static HRESULT	dup_metafilepict (HGLOBAL src, HGLOBAL *pdest)
static void	free_metafilepict (HGLOBAL src)
static HRESULT	dup_bitmap (HBITMAP src, HBITMAP *pdest)
static HRESULT	render_embed_source_hack (IDataObject *data, LPFORMATETC fmt)
static ole_priv_data_entry *	find_format_in_list (ole_priv_data_entry *entries, DWORD num, UINT cf)
static HRESULT	get_data_from_storage (IDataObject *data, FORMATETC *fmt, HGLOBAL *mem)
static HRESULT	get_data_from_stream (IDataObject *data, FORMATETC *fmt, HGLOBAL *mem)
static HRESULT	get_data_from_global (IDataObject *data, FORMATETC *fmt, HGLOBAL *mem)
static HRESULT	get_data_from_enhmetafile (IDataObject *data, FORMATETC *fmt, HGLOBAL *mem)
static HRESULT	get_data_from_metafilepict (IDataObject *data, FORMATETC *fmt, HGLOBAL *mem)
static HRESULT	get_data_from_bitmap (IDataObject *data, FORMATETC *fmt, HBITMAP *hbm)
static HRESULT	render_format (IDataObject *data, LPFORMATETC fmt)
static HRESULT WINAPI	snapshot_QueryInterface (IDataObject *iface, REFIID riid, void **ppvObject)
static ULONG WINAPI	snapshot_AddRef (IDataObject *iface)
static ULONG WINAPI	snapshot_Release (IDataObject *iface)
static HWND	get_current_ole_clip_window (void)
static HRESULT	get_current_dataobject (IDataObject **data)
static DWORD	get_tymed_from_nonole_cf (UINT cf)
static HRESULT	get_priv_data (ole_priv_data **data)
static HRESULT	get_stgmed_for_global (HGLOBAL h, STGMEDIUM *med)
static HRESULT	get_stgmed_for_stream (HGLOBAL h, STGMEDIUM *med)
static HRESULT	get_stgmed_for_storage (HGLOBAL h, STGMEDIUM *med)
static HRESULT	get_stgmed_for_emf (HENHMETAFILE hemf, STGMEDIUM *med)
static HRESULT	get_stgmed_for_bitmap (HBITMAP hbmp, STGMEDIUM *med)
static BOOL	string_off_equal (const DVTARGETDEVICE *t1, WORD off1, const DVTARGETDEVICE *t2, WORD off2)
static BOOL	td_equal (const DVTARGETDEVICE *t1, const DVTARGETDEVICE *t2)
static HRESULT WINAPI	snapshot_GetData (IDataObject *iface, FORMATETC *fmt, STGMEDIUM *med)
static HRESULT WINAPI	snapshot_GetDataHere (IDataObject *iface, FORMATETC *fmt, STGMEDIUM *med)
static HRESULT WINAPI	snapshot_QueryGetData (IDataObject *iface, FORMATETC *fmt)
static HRESULT WINAPI	snapshot_GetCanonicalFormatEtc (IDataObject *iface, FORMATETC *fmt_in, FORMATETC *fmt_out)
static HRESULT WINAPI	snapshot_SetData (IDataObject *iface, FORMATETC *fmt, STGMEDIUM *med, BOOL release)
static HRESULT WINAPI	snapshot_EnumFormatEtc (IDataObject *iface, DWORD dir, IEnumFORMATETC **enum_fmt)
static HRESULT WINAPI	snapshot_DAdvise (IDataObject *iface, FORMATETC *fmt, DWORD flags, IAdviseSink *sink, DWORD *conn)
static HRESULT WINAPI	snapshot_DUnadvise (IDataObject *iface, DWORD conn)
static HRESULT WINAPI	snapshot_EnumDAdvise (IDataObject *iface, IEnumSTATDATA **enum_advise)
static snapshot *	snapshot_construct (DWORD seq_no)
static void	register_clipboard_formats (void)
void	OLEClipbrd_Initialize (void)
static HRESULT	set_clipboard_formats (ole_clipbrd *clipbrd, IDataObject *data)
static HWND	create_clipbrd_window (void)
static HRESULT	get_clipbrd_window (ole_clipbrd *clipbrd, HWND *wnd)
static void	release_marshal_data (IStream *stm)
static HRESULT	expose_marshalled_dataobject (ole_clipbrd *clipbrd, IDataObject *data)
static HRESULT	set_src_dataobject (ole_clipbrd *clipbrd, IDataObject *data)
void	OLEClipbrd_UnInitialize (void)
static LRESULT CALLBACK	clipbrd_wndproc (HWND hwnd, UINT message, WPARAM wparam, LPARAM lparam)
static HRESULT	set_dataobject_format (HWND hwnd)
HRESULT WINAPI	OleSetClipboard (IDataObject *data)
HRESULT WINAPI	OleGetClipboard (IDataObject **obj)
HRESULT WINAPI	OleFlushClipboard (void)
HRESULT WINAPI	OleIsCurrentClipboard (IDataObject *data)

Variables
static ole_clipbrd *	theOleClipboard
static CRITICAL_SECTION	latest_snapshot_cs = { &latest_snapshot_cs_debug, -1, 0, 0, 0, 0 }
static CRITICAL_SECTION_DEBUG	latest_snapshot_cs_debug
static const WCHAR	clipbrd_wndclass [] = {'C','L','I','P','B','R','D','W','N','D','C','L','A','S','S',0}
UINT	ownerlink_clipboard_format = 0
UINT	filename_clipboard_format = 0
UINT	filenameW_clipboard_format = 0
UINT	dataobject_clipboard_format = 0
UINT	embedded_object_clipboard_format = 0
UINT	embed_source_clipboard_format = 0
UINT	custom_link_source_clipboard_format = 0
UINT	link_source_clipboard_format = 0
UINT	object_descriptor_clipboard_format = 0
UINT	link_source_descriptor_clipboard_format = 0
UINT	ole_private_data_clipboard_format = 0
static UINT	wine_marshal_clipboard_format
static const IEnumFORMATETCVtbl	efvt
static const IDataObjectVtbl	snapshot_vtable

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 66 of file clipboard.c.

NONAMELESSUNION

#define NONAMELESSUNION

Definition at line 67 of file clipboard.c.

Typedef Documentation

enum_fmtetc

typedef struct enum_fmtetc enum_fmtetc

ole_clipbrd

typedef struct ole_clipbrd ole_clipbrd

PresentationDataHeader

typedef struct PresentationDataHeader PresentationDataHeader

snapshot

typedef struct snapshot snapshot

Function Documentation

clipbrd_wndproc()

static LRESULT CALLBACK clipbrd_wndproc ( HWND  hwnd, UINT  message, WPARAM  wparam, LPARAM  lparam  )

static

Definition at line 2061 of file clipboard.c.

{
    ole_clipbrd *clipbrd;
 
    get_ole_clipbrd(&clipbrd);
#ifdef __REACTOS__
    if(clipbrd == NULL)
        return DefWindowProcW(hwnd, message, wparam, lparam);
#endif
 
    switch (message)
    {
    case WM_RENDERFORMAT:
    {
#ifdef __REACTOS__
    if (clipbrd->cached_enum)
    {
#endif
        UINT cf = wparam;
        ole_priv_data_entry *entry;
 
        TRACE("(): WM_RENDERFORMAT(cfFormat=%x)\n", cf);
        entry = find_format_in_list(clipbrd->cached_enum->entries, clipbrd->cached_enum->count, cf);
 
        if(entry)
            render_format(clipbrd->src_data, &entry->fmtetc);
#ifdef __REACTOS__
    }
#endif
        break;
    }
 
    case WM_RENDERALLFORMATS:
    {
        DWORD i;
        ole_priv_data_entry *entries;
 
        TRACE("(): WM_RENDERALLFORMATS\n");
 
        if (!clipbrd || !clipbrd->cached_enum) break;
        entries = clipbrd->cached_enum->entries;
        for(i = 0; i < clipbrd->cached_enum->count; i++)
        {
            if(entries[i].first_use)
                render_format(clipbrd->src_data, &entries[i].fmtetc);
        }
        break;
    }
 
    case WM_DESTROYCLIPBOARD:
    {
        TRACE("(): WM_DESTROYCLIPBOARD\n");
 
        set_src_dataobject(clipbrd, NULL);
        break;
    }
 
    default:
        return DefWindowProcW(hwnd, message, wparam, lparam);
    }
 
    return 0;
}

Referenced by create_clipbrd_window().

create_clipbrd_window()

static HWND create_clipbrd_window ( void  )

static

Definition at line 2129 of file clipboard.c.

{
    WNDCLASSEXW class;
    static const WCHAR ole32W[] = {'o','l','e','3','2',0};
    static const WCHAR title[] = {'C','l','i','p','b','o','a','r','d','W','i','n','d','o','w',0};
    HINSTANCE hinst = GetModuleHandleW(ole32W);
 
    class.cbSize         = sizeof(class);
    class.style          = 0;
    class.lpfnWndProc    = clipbrd_wndproc;
    class.cbClsExtra     = 0;
    class.cbWndExtra     = 0;
    class.hInstance      = hinst;
    class.hIcon          = 0;
    class.hCursor        = 0;
    class.hbrBackground  = 0;
    class.lpszMenuName   = NULL;
    class.lpszClassName  = clipbrd_wndclass;
    class.hIconSm        = NULL;
 
    RegisterClassExW(&class);
 
    return CreateWindowW(clipbrd_wndclass, title, WS_POPUP | WS_CLIPSIBLINGS | WS_OVERLAPPED,
                         0, 0, 0, 0, HWND_MESSAGE, NULL, hinst, 0);
}

Referenced by get_clipbrd_window().

dump_fmtetc()

static const char * dump_fmtetc ( FORMATETC *  fmt )

inlinestatic

Definition at line 217 of file clipboard.c.

{
    if (!fmt) return "(null)";
    return wine_dbg_sprintf("cf %04x ptd %p aspect %x lindex %d tymed %x",
                            fmt->cfFormat, fmt->ptd, fmt->dwAspect, fmt->lindex, fmt->tymed);
}

Referenced by DataObjectImpl_GetData(), DataObjectImpl_GetDataHere(), DataObjectImpl_QueryGetData(), set_clipboard_formats(), snapshot_GetData(), snapshot_GetDataHere(), snapshot_QueryGetData(), and test_enum_fmtetc().

dup_bitmap()

static HRESULT dup_bitmap ( HBITMAP  src, HBITMAP *  pdest  )

static

Definition at line 538 of file clipboard.c.

{
    HDC src_dc;
    HGDIOBJ orig_src_bitmap;
    BITMAP bm;
    HBITMAP dest;
 
    src_dc = CreateCompatibleDC(NULL);
    orig_src_bitmap = SelectObject(src_dc, src);
    GetObjectW(src, sizeof bm, &bm);
    dest = CreateCompatibleBitmap(src_dc, bm.bmWidth, bm.bmHeight);
    if (dest)
    {
        HDC dest_dc = CreateCompatibleDC(NULL);
        HGDIOBJ orig_dest_bitmap = SelectObject(dest_dc, dest);
        BitBlt(dest_dc, 0, 0, bm.bmWidth, bm.bmHeight, src_dc, 0, 0, SRCCOPY);
        SelectObject(dest_dc, orig_dest_bitmap);
        DeleteDC(dest_dc);
    }
    SelectObject(src_dc, orig_src_bitmap);
    DeleteDC(src_dc);
    *pdest = dest;
    return dest ? S_OK : E_FAIL;
}

Referenced by get_data_from_bitmap(), and get_stgmed_for_bitmap().

dup_global_mem()

static HRESULT dup_global_mem ( HGLOBAL  src, DWORD  flags, HGLOBAL *  dst  )

static

Definition at line 453 of file clipboard.c.

{
    void *src_ptr, *dst_ptr;
    DWORD size;
 
    *dst = NULL;
    if ( !src ) return S_FALSE;
 
    size = GlobalSize(src);
 
    *dst = GlobalAlloc( flags, size );
    if ( !*dst ) return E_OUTOFMEMORY;
 
    src_ptr = GlobalLock(src);
    dst_ptr = GlobalLock(*dst);
 
    memcpy(dst_ptr, src_ptr, size);
 
    GlobalUnlock(*dst);
    GlobalUnlock(src);
 
    return S_OK;
}

Referenced by dup_metafilepict(), expose_marshalled_dataobject(), get_data_from_global(), get_stgmed_for_global(), get_stgmed_for_storage(), and get_stgmed_for_stream().

dup_metafilepict()

static HRESULT dup_metafilepict ( HGLOBAL  src, HGLOBAL *  pdest  )

static

Definition at line 483 of file clipboard.c.

{
    HRESULT hr;
    HGLOBAL dest;
    METAFILEPICT *dest_ptr;
 
    *pdest = NULL;
 
    /* Copy the METAFILEPICT structure. */
    hr = dup_global_mem(src, GMEM_DDESHARE|GMEM_MOVEABLE, &dest);
    if (FAILED(hr)) return hr;
 
    dest_ptr = GlobalLock(dest);
    if (!dest_ptr) return E_FAIL;
 
    /* Give the new METAFILEPICT a separate HMETAFILE. */
    dest_ptr->hMF = CopyMetaFileW(dest_ptr->hMF, NULL);
    if (dest_ptr->hMF)
    {
       GlobalUnlock(dest);
       *pdest = dest;
       return S_OK;
    }
    else
    {
       GlobalUnlock(dest);
       GlobalFree(dest);
       return E_FAIL;
    }
}

Referenced by get_data_from_metafilepict().

enum_fmtetc_construct()

static HRESULT enum_fmtetc_construct ( ole_priv_data *  data, UINT  pos, IEnumFORMATETC **  obj  )

static

Definition at line 430 of file clipboard.c.

{
  enum_fmtetc* ef;
 
  *obj = NULL;
  ef = HeapAlloc(GetProcessHeap(), 0, sizeof(*ef));
  if (!ef) return E_OUTOFMEMORY;
 
  ef->ref = 1;
  ef->IEnumFORMATETC_iface.lpVtbl = &efvt;
  ef->data = data;
  ef->pos = pos;
 
  TRACE("(%p)->()\n", ef);
  *obj = &ef->IEnumFORMATETC_iface;
  return S_OK;
}

Referenced by OLEClipbrd_IEnumFORMATETC_Clone(), and snapshot_EnumFormatEtc().

expose_marshalled_dataobject()

static HRESULT expose_marshalled_dataobject ( ole_clipbrd *  clipbrd, IDataObject *  data  )

static

Definition at line 1957 of file clipboard.c.

{
    HGLOBAL h;
 
    if(data)
    {
        HGLOBAL h_stm;
        GetHGlobalFromStream(clipbrd->marshal_data, &h_stm);
        dup_global_mem(h_stm, GMEM_DDESHARE|GMEM_MOVEABLE, &h);
    }
    else /* flushed */
        h = GlobalAlloc(GMEM_DDESHARE|GMEM_MOVEABLE, 1);
 
    if(!h) return E_OUTOFMEMORY;
 
    if(!SetClipboardData(wine_marshal_clipboard_format, h))
    {
        GlobalFree(h);
        return CLIPBRD_E_CANT_SET;
    }
    return S_OK;
}

Referenced by OleFlushClipboard(), and OleSetClipboard().

find_format_in_list()

static ole_priv_data_entry * find_format_in_list ( ole_priv_data_entry *  entries, DWORD  num, UINT  cf  )

inlinestatic

Definition at line 689 of file clipboard.c.

{
    DWORD i;
    for(i = 0; i < num; i++)
        if(entries[i].fmtetc.cfFormat == cf)
            return &entries[i];
 
    return NULL;
}

Referenced by clipbrd_wndproc(), set_clipboard_formats(), snapshot_GetData(), and snapshot_GetDataHere().

free_metafilepict()

static void free_metafilepict ( HGLOBAL  src )

static

Definition at line 520 of file clipboard.c.

{
    METAFILEPICT *src_ptr;
 
    src_ptr = GlobalLock(src);
    if (src_ptr)
    {
        DeleteMetaFile(src_ptr->hMF);
        GlobalUnlock(src);
    }
    GlobalFree(src);
}

Referenced by render_format().

get_clipbrd_window()

static HRESULT get_clipbrd_window ( ole_clipbrd *  clipbrd, HWND *  wnd  )

inlinestatic

Definition at line 1918 of file clipboard.c.

{
#ifdef __REACTOS__
    /* The clipboard window can get destroyed if the  thread that created it dies so we may need to create it again */
    if (!IsWindow(clipbrd->window))
        clipbrd->window = create_clipbrd_window();
#endif
 
    if ( !clipbrd->window )
        clipbrd->window = create_clipbrd_window();
 
    *wnd = clipbrd->window;
    return *wnd ? S_OK : E_FAIL;
}

Referenced by OleFlushClipboard(), OleSetClipboard(), and set_src_dataobject().

get_current_dataobject()

static HRESULT get_current_dataobject ( IDataObject **  data )

static

Definition at line 1097 of file clipboard.c.

{
    HRESULT hr = S_FALSE;
    HWND wnd = get_current_ole_clip_window();
    HGLOBAL h;
    void *ptr;
    IStream *stm;
    LARGE_INTEGER pos;
 
    *data = NULL;
    if(!wnd) return S_FALSE;
 
    h = GetClipboardData(wine_marshal_clipboard_format);
    if(!h) return S_FALSE;
    if(GlobalSize(h) <= 1) return S_FALSE;
    ptr = GlobalLock(h);
    if(!ptr) return S_FALSE;
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &stm);
    if(FAILED(hr)) goto end;
 
    hr = IStream_Write(stm, ptr, GlobalSize(h), NULL);
    if(SUCCEEDED(hr))
    {
        pos.QuadPart = 0;
        IStream_Seek(stm, pos, STREAM_SEEK_SET, NULL);
        hr = CoUnmarshalInterface(stm, &IID_IDataObject, (void**)data);
    }
    IStream_Release(stm);
 
end:
    GlobalUnlock(h);
    return hr;
}

Referenced by snapshot_GetData(), and snapshot_GetDataHere().

get_current_ole_clip_window()

static HWND get_current_ole_clip_window ( void  )

static

Definition at line 1077 of file clipboard.c.

{
    HGLOBAL h;
    HWND *ptr, wnd;
 
    h = GetClipboardData(dataobject_clipboard_format);
    if(!h) return NULL;
    ptr = GlobalLock(h);
    if(!ptr) return NULL;
    wnd = *ptr;
    GlobalUnlock(h);
    return wnd;
}

Referenced by get_current_dataobject().

get_data_from_bitmap()

static HRESULT get_data_from_bitmap ( IDataObject *  data, FORMATETC *  fmt, HBITMAP *  hbm  )

static

Definition at line 898 of file clipboard.c.

{
    HBITMAP copy;
    HRESULT hr;
    FORMATETC mem_fmt;
    STGMEDIUM med;
 
    *hbm = NULL;
 
    mem_fmt = *fmt;
    mem_fmt.tymed = TYMED_GDI;
    memset(&med, 0, sizeof(med));
 
    hr = IDataObject_GetData(data, &mem_fmt, &med);
    if(FAILED(hr)) return hr;
 
    hr = dup_bitmap(med.u.hBitmap, &copy);
 
    if(SUCCEEDED(hr)) *hbm = copy;
 
    ReleaseStgMedium(&med);
 
    return hr;
}

Referenced by render_format().

get_data_from_enhmetafile()

static HRESULT get_data_from_enhmetafile ( IDataObject *  data, FORMATETC *  fmt, HGLOBAL *  mem  )

static

Definition at line 840 of file clipboard.c.

{
    HENHMETAFILE copy;
    HRESULT hr;
    FORMATETC mem_fmt;
    STGMEDIUM med;
 
    *mem = NULL;
 
    mem_fmt = *fmt;
    mem_fmt.tymed = TYMED_ENHMF;
    memset(&med, 0, sizeof(med));
 
    hr = IDataObject_GetData(data, &mem_fmt, &med);
    if(FAILED(hr)) return hr;
 
    copy = CopyEnhMetaFileW(med.u.hEnhMetaFile, NULL);
    if(copy) *mem = (HGLOBAL)copy;
    else hr = E_FAIL;
 
    ReleaseStgMedium(&med);
 
    return hr;
}

Referenced by render_format().

get_data_from_global()

static HRESULT get_data_from_global ( IDataObject *  data, FORMATETC *  fmt, HGLOBAL *  mem  )

static

Definition at line 812 of file clipboard.c.

{
    HGLOBAL h;
    HRESULT hr;
    FORMATETC mem_fmt;
    STGMEDIUM med;
 
    *mem = NULL;
 
    mem_fmt = *fmt;
    mem_fmt.tymed = TYMED_HGLOBAL;
    memset(&med, 0, sizeof(med));
 
    hr = IDataObject_GetData(data, &mem_fmt, &med);
    if(FAILED(hr)) return hr;
 
    hr = dup_global_mem(med.u.hGlobal, GMEM_DDESHARE|GMEM_MOVEABLE, &h);
 
    if(SUCCEEDED(hr)) *mem = h;
 
    ReleaseStgMedium(&med);
 
    return hr;
}

Referenced by render_format().

get_data_from_metafilepict()

static HRESULT get_data_from_metafilepict ( IDataObject *  data, FORMATETC *  fmt, HGLOBAL *  mem  )

static

Definition at line 868 of file clipboard.c.

{
    HGLOBAL copy;
    HRESULT hr;
    FORMATETC mem_fmt;
    STGMEDIUM med;
 
    *mem = NULL;
 
    mem_fmt = *fmt;
    mem_fmt.tymed = TYMED_MFPICT;
    memset(&med, 0, sizeof(med));
 
    hr = IDataObject_GetData(data, &mem_fmt, &med);
    if(FAILED(hr)) return hr;
 
    hr = dup_metafilepict(med.u.hMetaFilePict, &copy);
 
    if(SUCCEEDED(hr)) *mem = copy;
 
    ReleaseStgMedium(&med);
 
    return hr;
}

Referenced by render_format().

get_data_from_storage()

static HRESULT get_data_from_storage ( IDataObject *  data, FORMATETC *  fmt, HGLOBAL *  mem  )

static

Definition at line 704 of file clipboard.c.

{
    HGLOBAL h;
    IStorage *stg;
    HRESULT hr;
    FORMATETC stg_fmt;
    STGMEDIUM med;
    ILockBytes *lbs;
 
    *mem = NULL;
 
    h = GlobalAlloc( GMEM_DDESHARE|GMEM_MOVEABLE, 0 );
    if(!h) return E_OUTOFMEMORY;
 
    hr = CreateILockBytesOnHGlobal(h, FALSE, &lbs);
    if(SUCCEEDED(hr))
    {
        hr = StgCreateDocfileOnILockBytes(lbs, STGM_CREATE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stg);
        ILockBytes_Release(lbs);
    }
    if(FAILED(hr))
    {
        GlobalFree(h);
        return hr;
    }
 
    stg_fmt = *fmt;
    med.tymed = stg_fmt.tymed = TYMED_ISTORAGE;
    med.u.pstg = stg;
    med.pUnkForRelease = NULL;
 
    hr = IDataObject_GetDataHere(data, &stg_fmt, &med);
    if(FAILED(hr))
    {
        memset(&med, 0, sizeof(med));
        hr = IDataObject_GetData(data, &stg_fmt, &med);
        if(FAILED(hr)) goto end;
 
        hr = IStorage_CopyTo(med.u.pstg, 0, NULL, NULL, stg);
        ReleaseStgMedium(&med);
        if(FAILED(hr)) goto end;
    }
    *mem = h;
 
end:
    IStorage_Release(stg);
    if(FAILED(hr)) GlobalFree(h);
    return hr;
}

Referenced by render_format().

get_data_from_stream()

static HRESULT get_data_from_stream ( IDataObject *  data, FORMATETC *  fmt, HGLOBAL *  mem  )

static

Definition at line 759 of file clipboard.c.

{
    HGLOBAL h;
    IStream *stm = NULL;
    HRESULT hr;
    FORMATETC stm_fmt;
    STGMEDIUM med;
 
    *mem = NULL;
 
    h = GlobalAlloc( GMEM_DDESHARE|GMEM_MOVEABLE, 0 );
    if(!h) return E_OUTOFMEMORY;
 
    hr = CreateStreamOnHGlobal(h, FALSE, &stm);
    if(FAILED(hr)) goto error;
 
    stm_fmt = *fmt;
    med.tymed = stm_fmt.tymed = TYMED_ISTREAM;
    med.u.pstm = stm;
    med.pUnkForRelease = NULL;
 
    hr = IDataObject_GetDataHere(data, &stm_fmt, &med);
    if(FAILED(hr))
    {
        LARGE_INTEGER offs;
        ULARGE_INTEGER pos;
 
        memset(&med, 0, sizeof(med));
        hr = IDataObject_GetData(data, &stm_fmt, &med);
        if(FAILED(hr)) goto error;
 
        offs.QuadPart = 0;
        IStream_Seek(med.u.pstm, offs, STREAM_SEEK_CUR, &pos);
        IStream_Seek(med.u.pstm, offs, STREAM_SEEK_SET, NULL);
        hr = IStream_CopyTo(med.u.pstm, stm, pos, NULL, NULL);
        ReleaseStgMedium(&med);
        if(FAILED(hr)) goto error;
    }
    *mem = h;
    IStream_Release(stm);
    return S_OK;
 
error:
    if(stm) IStream_Release(stm);
    GlobalFree(h);
    return hr;
}

Referenced by render_format().

get_ole_clipbrd()

static HRESULT get_ole_clipbrd ( ole_clipbrd **  clipbrd )

inlinestatic

Definition at line 186 of file clipboard.c.

{
    struct oletls *info = COM_CurrentInfo();
    *clipbrd = NULL;
 
    if(!info->ole_inits)
        return CO_E_NOTINITIALIZED;
    *clipbrd = theOleClipboard;
 
    return S_OK;
}

Referenced by clipbrd_wndproc(), OleFlushClipboard(), OleGetClipboard(), OleIsCurrentClipboard(), and OleSetClipboard().

get_priv_data()

static HRESULT get_priv_data ( ole_priv_data **  data )

static

Definition at line 1159 of file clipboard.c.

{
    HGLOBAL handle;
    HRESULT hr = S_OK;
    ole_priv_data *ret = NULL;
 
    *data = NULL;
 
    handle = GetClipboardData( ole_private_data_clipboard_format );
    if(handle)
    {
        ole_priv_data *src = GlobalLock(handle);
        if(src)
        {
            DWORD i;
 
            /* FIXME: sanity check on size */
            ret = HeapAlloc(GetProcessHeap(), 0, src->size);
            if(!ret)
            {
                GlobalUnlock(handle);
                return E_OUTOFMEMORY;
            }
            memcpy(ret, src, src->size);
            GlobalUnlock(handle);
 
            /* Fixup any target device offsets to ptrs */
            for(i = 0; i < ret->count; i++)
                ret->entries[i].fmtetc.ptd =
                    td_offs_to_ptr(ret, (DWORD_PTR) ret->entries[i].fmtetc.ptd);
        }
    }
 
    if(!ret) /* Non-ole data */
    {
        UINT cf;
        DWORD count = 0, idx, size = FIELD_OFFSET(ole_priv_data, entries);
 
        for(cf = 0; (cf = EnumClipboardFormats(cf)) != 0; count++)
        {
            WCHAR buf[256];
            if (GetClipboardFormatNameW(cf, buf, ARRAY_SIZE(buf)))
                TRACE("cf %04x %s\n", cf, debugstr_w(buf));
            else
                TRACE("cf %04x\n", cf);
        }
        TRACE("count %d\n", count);
        size += count * sizeof(ret->entries[0]);
 
        /* There are holes in fmtetc so zero init */
        ret = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size);
        if(!ret) return E_OUTOFMEMORY;
        ret->size = size;
        ret->count = count;
 
        for(cf = 0, idx = 0; (cf = EnumClipboardFormats(cf)) != 0; idx++)
        {
            ret->entries[idx].fmtetc.cfFormat = cf;
            ret->entries[idx].fmtetc.ptd = NULL;
            ret->entries[idx].fmtetc.dwAspect = DVASPECT_CONTENT;
            ret->entries[idx].fmtetc.lindex = -1;
            ret->entries[idx].fmtetc.tymed = get_tymed_from_nonole_cf(cf);
            ret->entries[idx].first_use = 1;
        }
    }
 
    *data = ret;
    return hr;
}

Referenced by snapshot_EnumFormatEtc(), snapshot_GetData(), and snapshot_GetDataHere().

get_stgmed_for_bitmap()

static HRESULT get_stgmed_for_bitmap ( HBITMAP  hbmp, STGMEDIUM *  med  )

static

Definition at line 1340 of file clipboard.c.

{
    HRESULT hr;
 
    med->pUnkForRelease = NULL;
    med->tymed = TYMED_NULL;
 
    hr = dup_bitmap(hbmp, &med->u.hBitmap);
 
    if (FAILED(hr))
        return hr;
 
    med->tymed = TYMED_GDI;
    return S_OK;
}

Referenced by snapshot_GetData().

get_stgmed_for_emf()

static HRESULT get_stgmed_for_emf ( HENHMETAFILE  hemf, STGMEDIUM *  med  )

static

Definition at line 1324 of file clipboard.c.

{
    med->pUnkForRelease = NULL;
    med->tymed = TYMED_NULL;
 
    med->u.hEnhMetaFile = CopyEnhMetaFileW(hemf, NULL);
    if(!med->u.hEnhMetaFile) return E_OUTOFMEMORY;
    med->tymed = TYMED_ENHMF;
    return S_OK;
}

Referenced by snapshot_GetData().

get_stgmed_for_global()

static HRESULT get_stgmed_for_global ( HGLOBAL  h, STGMEDIUM *  med  )

static

Definition at line 1234 of file clipboard.c.

{
    HRESULT hr;
 
    med->pUnkForRelease = NULL;
    med->tymed = TYMED_NULL;
 
    hr = dup_global_mem(h, GMEM_MOVEABLE, &med->u.hGlobal);
 
    if(SUCCEEDED(hr)) med->tymed = TYMED_HGLOBAL;
 
    return hr;
}

Referenced by snapshot_GetData().

get_stgmed_for_storage()

static HRESULT get_stgmed_for_storage ( HGLOBAL  h, STGMEDIUM *  med  )

static

Definition at line 1280 of file clipboard.c.

{
    HRESULT hr;
    HGLOBAL dst;
    ILockBytes *lbs;
 
    med->pUnkForRelease = NULL;
    med->tymed = TYMED_NULL;
 
    hr = dup_global_mem(h, GMEM_MOVEABLE, &dst);
    if(FAILED(hr)) return hr;
 
    hr = CreateILockBytesOnHGlobal(dst, TRUE, &lbs);
    if(FAILED(hr))
    {
        GlobalFree(dst);
        return hr;
    }
 
    hr = StgIsStorageILockBytes(lbs);
    if(hr!=S_OK)
    {
        ILockBytes_Release(lbs);
        GlobalFree(dst);
        return SUCCEEDED(hr) ? E_FAIL : hr;
    }
 
    hr = StgOpenStorageOnILockBytes(lbs, NULL,  STGM_SHARE_EXCLUSIVE | STGM_READWRITE, NULL, 0, &med->u.pstg);
    ILockBytes_Release(lbs);
    if(FAILED(hr))
    {
        GlobalFree(dst);
        return hr;
    }
 
    med->tymed = TYMED_ISTORAGE;
    return hr;
}

Referenced by snapshot_GetData(), and snapshot_GetDataHere().

get_stgmed_for_stream()

static HRESULT get_stgmed_for_stream ( HGLOBAL  h, STGMEDIUM *  med  )

static

Definition at line 1253 of file clipboard.c.

{
    HRESULT hr;
    HGLOBAL dst;
 
    med->pUnkForRelease = NULL;
    med->tymed = TYMED_NULL;
 
    hr = dup_global_mem(h, GMEM_MOVEABLE, &dst);
    if(FAILED(hr)) return hr;
 
    hr = CreateStreamOnHGlobal(dst, TRUE, &med->u.pstm);
    if(FAILED(hr))
    {
        GlobalFree(dst);
        return hr;
    }
 
    med->tymed = TYMED_ISTREAM;
    return hr;
}

Referenced by snapshot_GetData().

get_tymed_from_nonole_cf()

static DWORD get_tymed_from_nonole_cf ( UINT  cf )

static

Definition at line 1132 of file clipboard.c.

{
    if(cf >= 0xc000) return TYMED_ISTREAM | TYMED_HGLOBAL;
 
    switch(cf)
    {
    case CF_TEXT:
    case CF_OEMTEXT:
    case CF_UNICODETEXT:
        return TYMED_ISTREAM | TYMED_HGLOBAL;
    case CF_ENHMETAFILE:
        return TYMED_ENHMF;
    case CF_METAFILEPICT:
        return TYMED_MFPICT;
    case CF_BITMAP:
        return TYMED_GDI;
    default:
        FIXME("returning TYMED_NULL for cf %04x\n", cf);
        return TYMED_NULL;
    }
}

Referenced by get_priv_data(), and snapshot_GetData().

impl_from_IDataObject()

static snapshot * impl_from_IDataObject ( IDataObject *  iface )

inlinestatic

Definition at line 159 of file clipboard.c.

{
    return CONTAINING_RECORD(iface, snapshot, IDataObject_iface);
}

Referenced by DataObjectImpl_AddRef(), DataObjectImpl_DAdvise(), DataObjectImpl_DUnadvise(), DataObjectImpl_EnumDAdvise(), DataObjectImpl_EnumFormatEtc(), DataObjectImpl_GetCanonicalFormatEtc(), DataObjectImpl_GetData(), DataObjectImpl_GetDataHere(), DataObjectImpl_QueryGetData(), DataObjectImpl_QueryInterface(), DataObjectImpl_Release(), DataObjectImpl_SetData(), snapshot_AddRef(), snapshot_GetData(), snapshot_GetDataHere(), snapshot_QueryInterface(), and snapshot_Release().

impl_from_IEnumFORMATETC()

static enum_fmtetc * impl_from_IEnumFORMATETC ( IEnumFORMATETC *  iface )

inlinestatic

Definition at line 238 of file clipboard.c.

{
    return CONTAINING_RECORD(iface, enum_fmtetc, IEnumFORMATETC_iface);
}

Referenced by EnumFormatImpl_AddRef(), EnumFormatImpl_Clone(), EnumFormatImpl_Next(), EnumFormatImpl_QueryInterface(), EnumFormatImpl_Release(), EnumFormatImpl_Reset(), EnumFormatImpl_Skip(), OLEClipbrd_IEnumFORMATETC_AddRef(), OLEClipbrd_IEnumFORMATETC_Clone(), OLEClipbrd_IEnumFORMATETC_Next(), OLEClipbrd_IEnumFORMATETC_QueryInterface(), OLEClipbrd_IEnumFORMATETC_Release(), OLEClipbrd_IEnumFORMATETC_Reset(), and OLEClipbrd_IEnumFORMATETC_Skip().

OLEClipbrd_IEnumFORMATETC_AddRef()

static ULONG WINAPI OLEClipbrd_IEnumFORMATETC_AddRef ( LPENUMFORMATETC  iface )

static

Definition at line 278 of file clipboard.c.

{
  enum_fmtetc *This = impl_from_IEnumFORMATETC(iface);
  TRACE("(%p)->(count=%u)\n",This, This->ref);
 
  return InterlockedIncrement(&This->ref);
}

OLEClipbrd_IEnumFORMATETC_Clone()

static HRESULT WINAPI OLEClipbrd_IEnumFORMATETC_Clone ( LPENUMFORMATETC  iface, LPENUMFORMATETC *  obj  )

static

Definition at line 390 of file clipboard.c.

{
  enum_fmtetc *This = impl_from_IEnumFORMATETC(iface);
  ole_priv_data *new_data;
  DWORD i;
 
  TRACE("(%p)->(%p)\n", This, obj);
 
  if ( !obj ) return E_INVALIDARG;
  *obj = NULL;
 
  new_data = HeapAlloc(GetProcessHeap(), 0, This->data->size);
  if(!new_data) return E_OUTOFMEMORY;
  memcpy(new_data, This->data, This->data->size);
 
  /* Fixup any target device ptrs */
  for(i = 0; i < This->data->count; i++)
      new_data->entries[i].fmtetc.ptd =
          td_offs_to_ptr(new_data, td_get_offs(This->data, i));
 
  return enum_fmtetc_construct(new_data, This->pos, obj);
}

OLEClipbrd_IEnumFORMATETC_Next()

static HRESULT WINAPI OLEClipbrd_IEnumFORMATETC_Next ( LPENUMFORMATETC  iface, ULONG  celt, FORMATETC *  rgelt, ULONG *  pceltFethed  )

static

Definition at line 313 of file clipboard.c.

{
  enum_fmtetc *This = impl_from_IEnumFORMATETC(iface);
  UINT cfetch, i;
  HRESULT hres = S_FALSE;
 
  TRACE("(%p)->(pos=%u)\n", This, This->pos);
 
  if (This->pos < This->data->count)
  {
    cfetch = This->data->count - This->pos;
    if (cfetch >= celt)
    {
      cfetch = celt;
      hres = S_OK;
    }
 
    for(i = 0; i < cfetch; i++)
    {
      hres = copy_formatetc(rgelt + i, &This->data->entries[This->pos++].fmtetc);
      if(FAILED(hres)) return hres;
    }
  }
  else
  {
    cfetch = 0;
  }
 
  if (pceltFethed)
  {
    *pceltFethed = cfetch;
  }
 
  return hres;
}

OLEClipbrd_IEnumFORMATETC_QueryInterface()

static HRESULT WINAPI OLEClipbrd_IEnumFORMATETC_QueryInterface ( LPENUMFORMATETC  iface, REFIID  riid, LPVOID *  ppvObj  )

static

Definition at line 248 of file clipboard.c.

{
  enum_fmtetc *This = impl_from_IEnumFORMATETC(iface);
 
  TRACE("(%p)->(IID: %s, %p)\n", This, debugstr_guid(riid), ppvObj);
 
  *ppvObj = NULL;
 
  if(IsEqualIID(riid, &IID_IUnknown) ||
     IsEqualIID(riid, &IID_IEnumFORMATETC))
  {
    *ppvObj = iface;
  }
 
  if(*ppvObj)
  {
    IEnumFORMATETC_AddRef((IEnumFORMATETC*)*ppvObj);
    TRACE("-- Interface: (%p)->(%p)\n",ppvObj,*ppvObj);
    return S_OK;
  }
 
  TRACE("-- Interface: E_NOINTERFACE\n");
  return E_NOINTERFACE;
}

OLEClipbrd_IEnumFORMATETC_Release()

static ULONG WINAPI OLEClipbrd_IEnumFORMATETC_Release ( LPENUMFORMATETC  iface )

static

Definition at line 291 of file clipboard.c.

{
  enum_fmtetc *This = impl_from_IEnumFORMATETC(iface);
  ULONG ref;
 
  TRACE("(%p)->(count=%u)\n",This, This->ref);
 
  ref = InterlockedDecrement(&This->ref);
  if (!ref)
  {
    TRACE("() - destroying IEnumFORMATETC(%p)\n",This);
    HeapFree(GetProcessHeap(), 0, This->data);
    HeapFree(GetProcessHeap(), 0, This);
  }
  return ref;
}

OLEClipbrd_IEnumFORMATETC_Reset()

static HRESULT WINAPI OLEClipbrd_IEnumFORMATETC_Reset ( LPENUMFORMATETC  iface )

static

Definition at line 374 of file clipboard.c.

{
  enum_fmtetc *This = impl_from_IEnumFORMATETC(iface);
  TRACE("(%p)->()\n", This);
 
  This->pos = 0;
  return S_OK;
}

OLEClipbrd_IEnumFORMATETC_Skip()

static HRESULT WINAPI OLEClipbrd_IEnumFORMATETC_Skip ( LPENUMFORMATETC  iface, ULONG  celt  )

static

Definition at line 355 of file clipboard.c.

{
  enum_fmtetc *This = impl_from_IEnumFORMATETC(iface);
  TRACE("(%p)->(num=%u)\n", This, celt);
 
  This->pos += celt;
  if (This->pos > This->data->count)
  {
    This->pos = This->data->count;
    return S_FALSE;
  }
  return S_OK;
}

OLEClipbrd_Initialize()

void OLEClipbrd_Initialize

(

void

)

Definition at line 1781 of file clipboard.c.

{
    register_clipboard_formats();
 
    if ( !theOleClipboard )
    {
        ole_clipbrd* clipbrd;
        HGLOBAL h;
 
        TRACE("()\n");
 
        clipbrd = HeapAlloc( GetProcessHeap(), 0, sizeof(*clipbrd) );
        if (!clipbrd) return;
 
        clipbrd->latest_snapshot = NULL;
        clipbrd->window = NULL;
        clipbrd->src_data = NULL;
        clipbrd->cached_enum = NULL;
 
        h = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, 0);
        if(!h)
        {
            HeapFree(GetProcessHeap(), 0, clipbrd);
            return;
        }
 
        if(FAILED(CreateStreamOnHGlobal(h, TRUE, &clipbrd->marshal_data)))
        {
            GlobalFree(h);
            HeapFree(GetProcessHeap(), 0, clipbrd);
            return;
        }
 
        theOleClipboard = clipbrd;
    }
}

Referenced by OleInitialize().

OLEClipbrd_UnInitialize()

void OLEClipbrd_UnInitialize

(

void

)

Definition at line 2027 of file clipboard.c.

{
    ole_clipbrd *clipbrd = theOleClipboard;
 
    TRACE("()\n");
 
    if ( clipbrd )
    {
        static const WCHAR ole32W[] = {'o','l','e','3','2',0};
        HINSTANCE hinst = GetModuleHandleW(ole32W);
 
        /* OleUninitialize() does not release the reference to the dataobject, so
           take an additional reference here.  This reference is then leaked. */
        if (clipbrd->src_data)
        {
            IDataObject_AddRef(clipbrd->src_data);
            set_src_dataobject(clipbrd, NULL);
        }
 
        if ( clipbrd->window )
        {
            DestroyWindow(clipbrd->window);
            UnregisterClassW( clipbrd_wndclass, hinst );
        }
 
        IStream_Release(clipbrd->marshal_data);
        HeapFree(GetProcessHeap(), 0, clipbrd);
        theOleClipboard = NULL;
    }
}

Referenced by OleUninitialize().

OleFlushClipboard()

HRESULT WINAPI OleFlushClipboard

(

void

)

Definition at line 2293 of file clipboard.c.

{
  HRESULT hr;
  ole_clipbrd *clipbrd;
  HWND wnd;
 
  TRACE("()\n");
 
  if(FAILED(hr = get_ole_clipbrd(&clipbrd))) return hr;
 
  if(FAILED(hr = get_clipbrd_window(clipbrd, &wnd))) return hr;
 
  /*
   * Already flushed or no source DataObject? Nothing to do.
   */
  if (!clipbrd->src_data) return S_OK;
 
  if (!OpenClipboard(wnd)) return CLIPBRD_E_CANT_OPEN;
 
  SendMessageW(wnd, WM_RENDERALLFORMATS, 0, 0);
 
  hr = set_dataobject_format(NULL);
 
  expose_marshalled_dataobject(clipbrd, NULL);
  set_src_dataobject(clipbrd, NULL);
 
  if ( !CloseClipboard() ) hr = CLIPBRD_E_CANT_CLOSE;
 
  return hr;
}

Referenced by fnTextSrv_TxSetText(), CShellBrowser::OnDestroy(), SHFlushClipboard(), START_TEST(), test_consumer_refs(), test_flushed_getdata(), test_set_clipboard(), test_set_clipboard_DRAWCLIPBOARD(), and test_WM_PASTE().

OleGetClipboard()

HRESULT WINAPI OleGetClipboard

(

IDataObject **

obj

)

Definition at line 2249 of file clipboard.c.

{
    HRESULT hr;
    ole_clipbrd *clipbrd;
    DWORD seq_no;
 
    TRACE("(%p)\n", obj);
 
    if(!obj) return E_INVALIDARG;
    *obj = NULL;
 
    if(FAILED(hr = get_ole_clipbrd(&clipbrd))) return hr;
 
    seq_no = GetClipboardSequenceNumber();
    EnterCriticalSection(&latest_snapshot_cs);
    if(clipbrd->latest_snapshot && clipbrd->latest_snapshot->seq_no != seq_no)
        clipbrd->latest_snapshot = NULL;
 
    if(!clipbrd->latest_snapshot)
    {
        clipbrd->latest_snapshot = snapshot_construct(seq_no);
        if(!clipbrd->latest_snapshot)
        {
            LeaveCriticalSection(&latest_snapshot_cs);
            return E_OUTOFMEMORY;
        }
    }
 
    *obj = &clipbrd->latest_snapshot->IDataObject_iface;
    IDataObject_AddRef(*obj);
    LeaveCriticalSection(&latest_snapshot_cs);
 
    return S_OK;
}

Referenced by CDefViewBckgrndMenu::_bCanPaste(), CDefaultContextMenu::DoPaste(), HasClipboardData(), OleUIPasteSpecialW(), paste_special(), test_complex_get_clipboard(), test_consumer_refs(), test_enum_fmtetc(), test_flushed_getdata(), test_get_clipboard(), test_get_clipboard_locked(), test_get_clipboard_uninitialized(), test_getdatahere(), test_multithreaded_clipboard(), and test_nonole_clipboard().

OleIsCurrentClipboard()

HRESULT WINAPI OleIsCurrentClipboard

(

IDataObject *

data

)

Definition at line 2328 of file clipboard.c.

{
    HRESULT hr;
    ole_clipbrd *clipbrd;
    TRACE("()\n");
 
    if(FAILED(hr = get_ole_clipbrd(&clipbrd))) return hr;
 
    if (data == NULL) return S_FALSE;
 
    return (data == clipbrd->src_data) ? S_OK : S_FALSE;
}

Referenced by clipboard_wnd_proc(), and test_set_clipboard().

OleSetClipboard()

HRESULT WINAPI OleSetClipboard

(

IDataObject *

data

)

Definition at line 2199 of file clipboard.c.

{
  HRESULT hr;
  ole_clipbrd *clipbrd;
  HWND wnd;
 
  TRACE("(%p)\n", data);
 
  if(FAILED(hr = get_ole_clipbrd(&clipbrd))) return hr;
 
  if(FAILED(hr = get_clipbrd_window(clipbrd, &wnd))) return hr;
 
  if ( !OpenClipboard(wnd) ) return CLIPBRD_E_CANT_OPEN;
 
  if ( !EmptyClipboard() )
  {
    hr = CLIPBRD_E_CANT_EMPTY;
    goto end;
  }
 
  hr = set_src_dataobject(clipbrd, data);
  if(FAILED(hr)) goto end;
 
  if(data)
  {
    hr = expose_marshalled_dataobject(clipbrd, data);
    if(FAILED(hr)) goto end;
    hr = set_dataobject_format(wnd);
  }
 
end:
 
  if ( !CloseClipboard() ) hr = CLIPBRD_E_CANT_CLOSE;
 
  if ( FAILED(hr) )
  {
    expose_marshalled_dataobject(clipbrd, NULL);
    set_src_dataobject(clipbrd, NULL);
  }
 
  return hr;
}

Referenced by CDefaultContextMenu::DoCopyOrCut(), ME_Copy(), test_consumer_refs(), test_flushed_getdata(), test_getdatahere(), test_set_clipboard(), and test_set_clipboard_DRAWCLIPBOARD().

register_clipboard_formats()

static void register_clipboard_formats ( void  )

static

Definition at line 1744 of file clipboard.c.

{
    static const WCHAR OwnerLink[] = {'O','w','n','e','r','L','i','n','k',0};
    static const WCHAR FileName[] = {'F','i','l','e','N','a','m','e',0};
    static const WCHAR FileNameW[] = {'F','i','l','e','N','a','m','e','W',0};
    static const WCHAR DataObject[] = {'D','a','t','a','O','b','j','e','c','t',0};
    static const WCHAR EmbeddedObject[] = {'E','m','b','e','d','d','e','d',' ','O','b','j','e','c','t',0};
    static const WCHAR EmbedSource[] = {'E','m','b','e','d',' ','S','o','u','r','c','e',0};
    static const WCHAR CustomLinkSource[] = {'C','u','s','t','o','m',' ','L','i','n','k',' ','S','o','u','r','c','e',0};
    static const WCHAR LinkSource[] = {'L','i','n','k',' ','S','o','u','r','c','e',0};
    static const WCHAR ObjectDescriptor[] = {'O','b','j','e','c','t',' ','D','e','s','c','r','i','p','t','o','r',0};
    static const WCHAR LinkSourceDescriptor[] = {'L','i','n','k',' ','S','o','u','r','c','e',' ',
                                                 'D','e','s','c','r','i','p','t','o','r',0};
    static const WCHAR OlePrivateData[] = {'O','l','e',' ','P','r','i','v','a','t','e',' ','D','a','t','a',0};
 
    static const WCHAR WineMarshalledDataObject[] = {'W','i','n','e',' ','M','a','r','s','h','a','l','l','e','d',' ',
                                                     'D','a','t','a','O','b','j','e','c','t',0};
 
    ownerlink_clipboard_format = RegisterClipboardFormatW(OwnerLink);
    filename_clipboard_format = RegisterClipboardFormatW(FileName);
    filenameW_clipboard_format = RegisterClipboardFormatW(FileNameW);
    dataobject_clipboard_format = RegisterClipboardFormatW(DataObject);
    embedded_object_clipboard_format = RegisterClipboardFormatW(EmbeddedObject);
    embed_source_clipboard_format = RegisterClipboardFormatW(EmbedSource);
    custom_link_source_clipboard_format = RegisterClipboardFormatW(CustomLinkSource);
    link_source_clipboard_format = RegisterClipboardFormatW(LinkSource);
    object_descriptor_clipboard_format = RegisterClipboardFormatW(ObjectDescriptor);
    link_source_descriptor_clipboard_format = RegisterClipboardFormatW(LinkSourceDescriptor);
    ole_private_data_clipboard_format = RegisterClipboardFormatW(OlePrivateData);
 
    wine_marshal_clipboard_format = RegisterClipboardFormatW(WineMarshalledDataObject);
}

Referenced by OLEClipbrd_Initialize().

release_marshal_data()

static void release_marshal_data ( IStream *  stm )

inlinestatic

Definition at line 1939 of file clipboard.c.

{
    LARGE_INTEGER pos;
    ULARGE_INTEGER size;
    pos.QuadPart = size.QuadPart = 0;
 
    IStream_Seek(stm, pos, STREAM_SEEK_SET, NULL);
    CoReleaseMarshalData(stm);
    IStream_Seek(stm, pos, STREAM_SEEK_SET, NULL);
    IStream_SetSize(stm, size);
}

Referenced by set_src_dataobject().

render_embed_source_hack()

static HRESULT render_embed_source_hack ( IDataObject *  data, LPFORMATETC  fmt  )

static

Definition at line 569 of file clipboard.c.

{
    STGMEDIUM std;
    HGLOBAL hStorage = 0;
    HRESULT hr = S_OK;
    ILockBytes *ptrILockBytes;
 
    memset(&std, 0, sizeof(STGMEDIUM));
    std.tymed = fmt->tymed = TYMED_ISTORAGE;
 
    hStorage = GlobalAlloc(GMEM_SHARE|GMEM_MOVEABLE, 0);
    if (hStorage == NULL) return E_OUTOFMEMORY;
    hr = CreateILockBytesOnHGlobal(hStorage, FALSE, &ptrILockBytes);
    if (FAILED(hr))
    {
        GlobalFree(hStorage);
        return hr;
    }
 
    hr = StgCreateDocfileOnILockBytes(ptrILockBytes, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &std.u.pstg);
    ILockBytes_Release(ptrILockBytes);
 
    if (FAILED(hr = IDataObject_GetDataHere(theOleClipboard->src_data, fmt, &std)))
    {
        WARN("() : IDataObject_GetDataHere failed to render clipboard data! (%x)\n", hr);
        GlobalFree(hStorage);
        return hr;
    }
 
    if (1) /* check whether the presentation data is already -not- present */
    {
        FORMATETC fmt2;
        STGMEDIUM std2;
        METAFILEPICT *mfp = 0;
 
        fmt2.cfFormat = CF_METAFILEPICT;
        fmt2.ptd = 0;
        fmt2.dwAspect = DVASPECT_CONTENT;
        fmt2.lindex = -1;
        fmt2.tymed = TYMED_MFPICT;
 
        memset(&std2, 0, sizeof(STGMEDIUM));
        std2.tymed = TYMED_MFPICT;
 
        /* Get the metafile picture out of it */
 
        if (SUCCEEDED(hr = IDataObject_GetData(theOleClipboard->src_data, &fmt2, &std2)))
        {
            mfp = GlobalLock(std2.u.hGlobal);
        }
 
        if (mfp)
        {
            OLECHAR name[]={ 2, 'O', 'l', 'e', 'P', 'r', 'e', 's', '0', '0', '0', 0};
            IStream *pStream = 0;
            void *mfBits;
            PresentationDataHeader pdh;
            INT nSize;
            CLSID clsID;
            LPOLESTR strProgID;
            CHAR strOleTypeName[51];
            BYTE OlePresStreamHeader [] =
            {
                0xFF, 0xFF, 0xFF, 0xFF, 0x03, 0x00, 0x00, 0x00,
                0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
                0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
                0x00, 0x00, 0x00, 0x00
            };
 
            nSize = GetMetaFileBitsEx(mfp->hMF, 0, NULL);
 
            memset(&pdh, 0, sizeof(PresentationDataHeader));
            memcpy(&pdh, OlePresStreamHeader, sizeof(OlePresStreamHeader));
 
            pdh.dwObjectExtentX = mfp->xExt;
            pdh.dwObjectExtentY = mfp->yExt;
            pdh.dwSize = nSize;
 
            hr = IStorage_CreateStream(std.u.pstg, name, STGM_CREATE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, 0, &pStream);
 
            hr = IStream_Write(pStream, &pdh, sizeof(PresentationDataHeader), NULL);
 
            mfBits = HeapAlloc(GetProcessHeap(), 0, nSize);
            nSize = GetMetaFileBitsEx(mfp->hMF, nSize, mfBits);
 
            hr = IStream_Write(pStream, mfBits, nSize, NULL);
 
            IStream_Release(pStream);
 
            HeapFree(GetProcessHeap(), 0, mfBits);
 
            GlobalUnlock(std2.u.hGlobal);
            ReleaseStgMedium(&std2);
 
            ReadClassStg(std.u.pstg, &clsID);
            ProgIDFromCLSID(&clsID, &strProgID);
 
            WideCharToMultiByte( CP_ACP, 0, strProgID, -1, strOleTypeName, sizeof(strOleTypeName), NULL, NULL );
            STORAGE_CreateOleStream(std.u.pstg, 0);
            OLECONVERT_CreateCompObjStream(std.u.pstg, strOleTypeName);
            CoTaskMemFree(strProgID);
        }
    }
 
    if ( !SetClipboardData( fmt->cfFormat, hStorage ) )
    {
        WARN("() : Failed to set rendered clipboard data into clipboard!\n");
        GlobalFree(hStorage);
        hr = CLIPBRD_E_CANT_SET;
    }
 
    ReleaseStgMedium(&std);
    return hr;
}

Referenced by render_format().

render_format()

static HRESULT render_format ( IDataObject *  data, LPFORMATETC  fmt  )

static

Definition at line 929 of file clipboard.c.

{
    HANDLE clip_data = NULL;  /* HGLOBAL unless otherwise specified */
    HRESULT hr;
 
    /* Embed source hack */
    if(fmt->cfFormat == embed_source_clipboard_format)
    {
        return render_embed_source_hack(data, fmt);
    }
 
    if(fmt->tymed & TYMED_ISTORAGE)
    {
        hr = get_data_from_storage(data, fmt, &clip_data);
    }
    else if(fmt->tymed & TYMED_ISTREAM)
    {
        hr = get_data_from_stream(data, fmt, &clip_data);
    }
    else if(fmt->tymed & TYMED_HGLOBAL)
    {
        hr = get_data_from_global(data, fmt, &clip_data);
    }
    else if(fmt->tymed & TYMED_ENHMF)
    {
        hr = get_data_from_enhmetafile(data, fmt, &clip_data);
    }
    else if(fmt->tymed & TYMED_MFPICT)
    {
        /* Returns global handle to METAFILEPICT, containing a copied HMETAFILE */
        hr = get_data_from_metafilepict(data, fmt, &clip_data);
    }
    else if(fmt->tymed & TYMED_GDI)
    {
        /* Returns HBITMAP not HGLOBAL */
        hr = get_data_from_bitmap(data, fmt, (HBITMAP *)&clip_data);
    }
    else
    {
        FIXME("Unhandled tymed %x\n", fmt->tymed);
        hr = DV_E_FORMATETC;
    }
 
    if(SUCCEEDED(hr))
    {
        if ( !SetClipboardData(fmt->cfFormat, clip_data) )
        {
            WARN("() : Failed to set rendered clipboard data into clipboard!\n");
            if(fmt->tymed & TYMED_MFPICT)
                free_metafilepict(clip_data);
            else if(fmt->tymed & TYMED_GDI)
                DeleteObject(clip_data);
            else
                GlobalFree(clip_data);
            hr = CLIPBRD_E_CANT_SET;
        }
    }
 
    return hr;
}

Referenced by clipbrd_wndproc().

set_clipboard_formats()

static HRESULT set_clipboard_formats ( ole_clipbrd *  clipbrd, IDataObject *  data  )

static

Definition at line 1827 of file clipboard.c.

{
    HRESULT hr;
    FORMATETC fmt;
    IEnumFORMATETC *enum_fmt;
    HGLOBAL priv_data_handle;
    DWORD_PTR target_offset;
    ole_priv_data *priv_data;
    DWORD count = 0, needed = sizeof(*priv_data), idx;
 
    hr = IDataObject_EnumFormatEtc(data, DATADIR_GET, &enum_fmt);
    if(FAILED(hr)) return hr;
 
    while(IEnumFORMATETC_Next(enum_fmt, 1, &fmt, NULL) == S_OK)
    {
        count++;
        needed += sizeof(priv_data->entries[0]);
        if(fmt.ptd)
        {
            needed += fmt.ptd->tdSize;
            CoTaskMemFree(fmt.ptd);
        }
    }
 
    /* Windows pads the list with two empty ole_priv_data_entries, one
     * after the entries array and one after the target device data.
     * Allocating with zero init to zero these pads. */
 
    needed += sizeof(priv_data->entries[0]); /* initialisation of needed includes one of these. */
    priv_data_handle = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE | GMEM_ZEROINIT, needed);
    priv_data = GlobalLock(priv_data_handle);
 
    priv_data->unk1 = 0;
    priv_data->size = needed;
    priv_data->unk2 = 1;
    priv_data->count = count;
    priv_data->unk3[0] = 0;
    priv_data->unk3[1] = 0;
 
    IEnumFORMATETC_Reset(enum_fmt);
 
    idx = 0;
    target_offset = FIELD_OFFSET(ole_priv_data, entries[count + 1]); /* count entries + one pad. */
 
    while(IEnumFORMATETC_Next(enum_fmt, 1, &fmt, NULL) == S_OK)
    {
        TRACE("%s\n", dump_fmtetc(&fmt));
 
        priv_data->entries[idx].fmtetc = fmt;
        if(fmt.ptd)
        {
            memcpy((char*)priv_data + target_offset, fmt.ptd, fmt.ptd->tdSize);
            priv_data->entries[idx].fmtetc.ptd = (DVTARGETDEVICE*)target_offset;
            target_offset += fmt.ptd->tdSize;
            CoTaskMemFree(fmt.ptd);
        }
 
        priv_data->entries[idx].first_use = !find_format_in_list(priv_data->entries, idx, fmt.cfFormat);
        priv_data->entries[idx].unk[0] = 0;
        priv_data->entries[idx].unk[1] = 0;
 
        if (priv_data->entries[idx].first_use)
            SetClipboardData(fmt.cfFormat, NULL);
 
        idx++;
    }
 
    IEnumFORMATETC_Release(enum_fmt);
 
    /* Cache the list and fixup any target device offsets to ptrs */
    clipbrd->cached_enum = HeapAlloc(GetProcessHeap(), 0, needed);
    memcpy(clipbrd->cached_enum, priv_data, needed);
    for(idx = 0; idx < clipbrd->cached_enum->count; idx++)
        clipbrd->cached_enum->entries[idx].fmtetc.ptd =
            td_offs_to_ptr(clipbrd->cached_enum, (DWORD_PTR)clipbrd->cached_enum->entries[idx].fmtetc.ptd);
 
    GlobalUnlock(priv_data_handle);
    if(!SetClipboardData(ole_private_data_clipboard_format, priv_data_handle))
    {
        GlobalFree(priv_data_handle);
        return CLIPBRD_E_CANT_SET;
    }
 
    return S_OK;
}

Referenced by set_src_dataobject().

set_dataobject_format()

static HRESULT set_dataobject_format ( HWND  hwnd )

static

Definition at line 2161 of file clipboard.c.

{
    HGLOBAL h = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, sizeof(hwnd));
    HWND *data;
 
    if(!h) return E_OUTOFMEMORY;
 
    data = GlobalLock(h);
    *data = hwnd;
    GlobalUnlock(h);
 
    if(!SetClipboardData(dataobject_clipboard_format, h))
    {
        GlobalFree(h);
        return CLIPBRD_E_CANT_SET;
    }
 
    return S_OK;
}

Referenced by OleFlushClipboard(), and OleSetClipboard().

set_src_dataobject()

static HRESULT set_src_dataobject ( ole_clipbrd *  clipbrd, IDataObject *  data  )

static

Definition at line 1989 of file clipboard.c.

{
    HRESULT hr;
    HWND wnd;
 
    if(FAILED(hr = get_clipbrd_window(clipbrd, &wnd))) return hr;
 
    if(clipbrd->src_data)
    {
        release_marshal_data(clipbrd->marshal_data);
 
        IDataObject_Release(clipbrd->src_data);
        clipbrd->src_data = NULL;
        HeapFree(GetProcessHeap(), 0, clipbrd->cached_enum);
        clipbrd->cached_enum = NULL;
    }
 
    if(data)
    {
        IUnknown *unk;
 
        IDataObject_AddRef(data);
        clipbrd->src_data = data;
 
        IDataObject_QueryInterface(data, &IID_IUnknown, (void**)&unk);
        hr = CoMarshalInterface(clipbrd->marshal_data, &IID_IDataObject, unk,
                                MSHCTX_LOCAL, NULL, MSHLFLAGS_TABLESTRONG);
        IUnknown_Release(unk); /* Don't hold a ref on IUnknown, we have one on IDataObject. */
        if(FAILED(hr)) return hr;
        hr = set_clipboard_formats(clipbrd, data);
    }
    return hr;
}

Referenced by clipbrd_wndproc(), OLEClipbrd_UnInitialize(), OleFlushClipboard(), and OleSetClipboard().

snapshot_AddRef()

static ULONG WINAPI snapshot_AddRef ( IDataObject *  iface )

static

Definition at line 1029 of file clipboard.c.

{
    snapshot *This = impl_from_IDataObject(iface);
 
    TRACE("(%p)->(count=%u)\n", This, This->ref);
 
    return InterlockedIncrement(&This->ref);
}

snapshot_construct()

static snapshot * snapshot_construct ( DWORD  seq_no )

static

Definition at line 1726 of file clipboard.c.

{
    snapshot *This;
 
    This = HeapAlloc( GetProcessHeap(), 0, sizeof(*This) );
    if (!This) return NULL;
 
    This->IDataObject_iface.lpVtbl = &snapshot_vtable;
    This->ref = 0;
    This->seq_no = seq_no;
    This->data = NULL;
 
    return This;
}

Referenced by OleGetClipboard().

snapshot_DAdvise()

static HRESULT WINAPI snapshot_DAdvise ( IDataObject *  iface, FORMATETC *  fmt, DWORD  flags, IAdviseSink *  sink, DWORD *  conn  )

static

Definition at line 1675 of file clipboard.c.

{
    TRACE("(%p, %p, %x, %p, %p): not implemented\n", iface, fmt, flags, sink, conn);
    return E_NOTIMPL;
}

snapshot_DUnadvise()

static HRESULT WINAPI snapshot_DUnadvise ( IDataObject *  iface, DWORD  conn  )

static

Definition at line 1688 of file clipboard.c.

{
    TRACE("(%p, %d): not implemented\n", iface, conn);
    return E_NOTIMPL;
}

snapshot_EnumDAdvise()

static HRESULT WINAPI snapshot_EnumDAdvise ( IDataObject *  iface, IEnumSTATDATA **  enum_advise  )

static

Definition at line 1699 of file clipboard.c.

{
    TRACE("(%p, %p): not implemented\n", iface, enum_advise);
    return E_NOTIMPL;
}

snapshot_EnumFormatEtc()

static HRESULT WINAPI snapshot_EnumFormatEtc ( IDataObject *  iface, DWORD  dir, IEnumFORMATETC **  enum_fmt  )

static

Definition at line 1646 of file clipboard.c.

{
    HRESULT hr;
    ole_priv_data *data = NULL;
 
    TRACE("(%p, %x, %p)\n", iface, dir, enum_fmt);
 
    *enum_fmt = NULL;
 
    if ( dir != DATADIR_GET ) return E_NOTIMPL;
    if ( !OpenClipboard(NULL) ) return CLIPBRD_E_CANT_OPEN;
 
    hr = get_priv_data(&data);
 
    if(FAILED(hr)) goto end;
 
    hr = enum_fmtetc_construct( data, 0, enum_fmt );
 
end:
    if ( !CloseClipboard() ) hr = CLIPBRD_E_CANT_CLOSE;
    return hr;
}

snapshot_GetCanonicalFormatEtc()

static HRESULT WINAPI snapshot_GetCanonicalFormatEtc ( IDataObject *  iface, FORMATETC *  fmt_in, FORMATETC *  fmt_out  )

static

Definition at line 1619 of file clipboard.c.

{
    TRACE("(%p, %p, %p)\n", iface, fmt_in, fmt_out);
 
    if ( !fmt_in || !fmt_out ) return E_INVALIDARG;
 
    *fmt_out = *fmt_in;
    return DATA_S_SAMEFORMATETC;
}

snapshot_GetData()

static HRESULT WINAPI snapshot_GetData ( IDataObject *  iface, FORMATETC *  fmt, STGMEDIUM *  med  )

static

Definition at line 1389 of file clipboard.c.

{
    snapshot *This = impl_from_IDataObject(iface);
    HANDLE h;
    HRESULT hr;
    ole_priv_data *enum_data = NULL;
    ole_priv_data_entry *entry;
    DWORD mask;
 
    TRACE("(%p, %p {%s}, %p)\n", iface, fmt, dump_fmtetc(fmt), med);
 
    if ( !fmt || !med ) return E_INVALIDARG;
 
    memset(med, 0, sizeof(*med));
 
    if ( !OpenClipboard(NULL)) return CLIPBRD_E_CANT_OPEN;
 
    if(!This->data)
        hr = get_current_dataobject(&This->data);
 
    if(This->data)
    {
        hr = IDataObject_GetData(This->data, fmt, med);
        if(SUCCEEDED(hr))
        {
            CloseClipboard();
            return hr;
        }
    }
    if(fmt->lindex != -1)
    {
        hr = DV_E_FORMATETC;
        goto end;
    }
 
    if(!IsClipboardFormatAvailable(fmt->cfFormat))
    {
        hr = DV_E_FORMATETC;
        goto end;
    }
 
    hr = get_priv_data(&enum_data);
    if(FAILED(hr)) goto end;
 
    entry = find_format_in_list(enum_data->entries, enum_data->count, fmt->cfFormat);
    if(entry)
    {
        if(!td_equal(fmt->ptd, entry->fmtetc.ptd))
        {
            hr = DV_E_FORMATETC;
            goto end;
        }
        mask = fmt->tymed & entry->fmtetc.tymed;
        if(!mask && (entry->fmtetc.tymed & (TYMED_ISTREAM | TYMED_HGLOBAL | TYMED_ISTORAGE)))
            mask = fmt->tymed & (TYMED_ISTREAM | TYMED_HGLOBAL | TYMED_ISTORAGE);
    }
    else /* non-Ole format */
        mask = fmt->tymed & get_tymed_from_nonole_cf(fmt->cfFormat);
 
    if(!mask)
    {
        hr = DV_E_TYMED;
        goto end;
    }
 
    h = GetClipboardData(fmt->cfFormat);
    if(!h)
    {
        hr = DV_E_FORMATETC;
        goto end;
    }
 
    if(mask & TYMED_HGLOBAL)
        hr = get_stgmed_for_global(h, med);
    else if(mask & TYMED_ISTREAM)
        hr = get_stgmed_for_stream(h, med);
    else if(mask & TYMED_ISTORAGE)
        hr = get_stgmed_for_storage(h, med);
    else if(mask & TYMED_ENHMF)
        hr = get_stgmed_for_emf((HENHMETAFILE)h, med);
    else if(mask & TYMED_GDI)
        hr = get_stgmed_for_bitmap((HBITMAP)h, med);
    else
    {
        FIXME("Unhandled tymed - mask %x req tymed %x\n", mask, fmt->tymed);
        hr = E_FAIL;
        goto end;
    }
 
end:
    HeapFree(GetProcessHeap(), 0, enum_data);
    if ( !CloseClipboard() ) hr = CLIPBRD_E_CANT_CLOSE;
    return hr;
}

snapshot_GetDataHere()

static HRESULT WINAPI snapshot_GetDataHere ( IDataObject *  iface, FORMATETC *  fmt, STGMEDIUM *  med  )

static

Definition at line 1488 of file clipboard.c.

{
    snapshot *This = impl_from_IDataObject(iface);
    HANDLE h;
    HRESULT hr;
    ole_priv_data *enum_data = NULL;
    ole_priv_data_entry *entry;
    TYMED supported;
 
    if ( !fmt || !med ) return E_INVALIDARG;
 
    TRACE("(%p, %p {%s}, %p (tymed %x)\n", iface, fmt, dump_fmtetc(fmt), med, med->tymed);
 
    if ( !OpenClipboard(NULL)) return CLIPBRD_E_CANT_OPEN;
 
    if(!This->data)
        hr = get_current_dataobject(&This->data);
 
    if(This->data)
    {
        hr = IDataObject_GetDataHere(This->data, fmt, med);
        if(SUCCEEDED(hr))
        {
            CloseClipboard();
            return hr;
        }
    }
 
    h = GetClipboardData(fmt->cfFormat);
    if(!h)
    {
        hr = DV_E_FORMATETC;
        goto end;
    }
 
    hr = get_priv_data(&enum_data);
    if(FAILED(hr)) goto end;
 
    entry = find_format_in_list(enum_data->entries, enum_data->count, fmt->cfFormat);
    if(entry)
    {
        if(!td_equal(fmt->ptd, entry->fmtetc.ptd))
        {
            hr = DV_E_FORMATETC;
            goto end;
        }
        supported = entry->fmtetc.tymed;
    }
    else /* non-Ole format */
        supported = TYMED_HGLOBAL;
 
    switch(med->tymed)
    {
    case TYMED_HGLOBAL:
    {
        DWORD src_size = GlobalSize(h);
        DWORD dst_size = GlobalSize(med->u.hGlobal);
        hr = E_FAIL;
        if(dst_size >= src_size)
        {
            void *src = GlobalLock(h);
            void *dst = GlobalLock(med->u.hGlobal);
 
            memcpy(dst, src, src_size);
            GlobalUnlock(med->u.hGlobal);
            GlobalUnlock(h);
            hr = S_OK;
        }
        break;
    }
    case TYMED_ISTREAM:
    {
        DWORD src_size = GlobalSize(h);
        void *src = GlobalLock(h);
        hr = IStream_Write(med->u.pstm, src, src_size, NULL);
        GlobalUnlock(h);
        break;
    }
    case TYMED_ISTORAGE:
    {
        STGMEDIUM copy;
        if(!(supported & TYMED_ISTORAGE))
        {
            hr = E_FAIL;
            goto end;
        }
        hr = get_stgmed_for_storage(h, &copy);
        if(SUCCEEDED(hr))
        {
            hr = IStorage_CopyTo(copy.u.pstg, 0, NULL, NULL, med->u.pstg);
            ReleaseStgMedium(&copy);
        }
        break;
    }
    default:
        FIXME("Unhandled tymed - supported %x req tymed %x\n", supported, med->tymed);
        hr = E_FAIL;
        goto end;
    }
 
end:
    HeapFree(GetProcessHeap(), 0, enum_data);
    if ( !CloseClipboard() ) hr = CLIPBRD_E_CANT_CLOSE;
    return hr;
}

snapshot_QueryGetData()

static HRESULT WINAPI snapshot_QueryGetData ( IDataObject *  iface, FORMATETC *  fmt  )

static

Definition at line 1603 of file clipboard.c.

{
    TRACE("(%p, %p {%s})\n", iface, fmt, dump_fmtetc(fmt));
 
    if (!fmt) return E_INVALIDARG;
 
    if ( fmt->dwAspect != DVASPECT_CONTENT ) return DV_E_FORMATETC;
 
    if ( fmt->lindex != -1 ) return DV_E_FORMATETC;
 
    return (IsClipboardFormatAvailable(fmt->cfFormat)) ? S_OK : DV_E_CLIPFORMAT;
}

snapshot_QueryInterface()

static HRESULT WINAPI snapshot_QueryInterface ( IDataObject *  iface, REFIID  riid, void **  ppvObject  )

static

Definition at line 999 of file clipboard.c.

{
  snapshot *This = impl_from_IDataObject(iface);
  TRACE("(%p)->(IID:%s, %p)\n", This, debugstr_guid(riid), ppvObject);
 
  if ( (This==0) || (ppvObject==0) )
    return E_INVALIDARG;
 
  *ppvObject = 0;
 
  if (IsEqualIID(&IID_IUnknown, riid) ||
      IsEqualIID(&IID_IDataObject, riid))
  {
    *ppvObject = iface;
  }
  else
  {
    WARN( "() : asking for unsupported interface %s\n", debugstr_guid(riid));
    return E_NOINTERFACE;
  }
 
  IUnknown_AddRef((IUnknown*)*ppvObject);
 
  return S_OK;
}

snapshot_Release()

static ULONG WINAPI snapshot_Release ( IDataObject *  iface )

static

Definition at line 1041 of file clipboard.c.

{
    snapshot *This = impl_from_IDataObject(iface);
    ULONG ref;
 
    TRACE("(%p)->(count=%u)\n", This, This->ref);
 
    ref = InterlockedDecrement(&This->ref);
 
    if (ref == 0)
    {
        EnterCriticalSection(&latest_snapshot_cs);
        if (This->ref)
        {
            LeaveCriticalSection(&latest_snapshot_cs);
            return ref;
        }
        if (theOleClipboard->latest_snapshot == This)
            theOleClipboard->latest_snapshot = NULL;
        LeaveCriticalSection(&latest_snapshot_cs);
 
        if(This->data) IDataObject_Release(This->data);
        HeapFree(GetProcessHeap(), 0, This);
    }
 
    return ref;
}

snapshot_SetData()

static HRESULT WINAPI snapshot_SetData ( IDataObject *  iface, FORMATETC *  fmt, STGMEDIUM *  med, BOOL  release  )

static

Definition at line 1635 of file clipboard.c.

{
    TRACE("(%p, %p, %p, %d): not implemented\n", iface, fmt, med, release);
    return E_NOTIMPL;
}

string_off_equal()

static BOOL string_off_equal ( const DVTARGETDEVICE *  t1, WORD  off1, const DVTARGETDEVICE *  t2, WORD  off2  )

inlinestatic

Definition at line 1356 of file clipboard.c.

{
    const WCHAR *str1, *str2;
 
    if(off1 == 0 && off2 == 0) return TRUE;
    if(off1 == 0 || off2 == 0) return FALSE;
 
    str1 = (const WCHAR*)((const char*)t1 + off1);
    str2 = (const WCHAR*)((const char*)t2 + off2);
 
    return !wcscmp(str1, str2);
}

Referenced by td_equal().

td_equal()

static BOOL td_equal ( const DVTARGETDEVICE *  t1, const DVTARGETDEVICE *  t2  )

inlinestatic

Definition at line 1369 of file clipboard.c.

{
    if(t1 == NULL && t2 == NULL) return TRUE;
    if(t1 == NULL || t2 == NULL) return FALSE;
 
    if(!string_off_equal(t1, t1->tdDriverNameOffset, t2, t2->tdDriverNameOffset))
        return FALSE;
    if(!string_off_equal(t1, t1->tdDeviceNameOffset, t2, t2->tdDeviceNameOffset))
        return FALSE;
    if(!string_off_equal(t1, t1->tdPortNameOffset, t2, t2->tdPortNameOffset))
        return FALSE;
 
    /* FIXME check devmode? */
 
    return TRUE;
}

Referenced by snapshot_GetData(), and snapshot_GetDataHere().

td_get_offs()

static DWORD_PTR td_get_offs ( ole_priv_data *  data, DWORD  idx  )

inlinestatic

Definition at line 126 of file clipboard.c.

{
    if(data->entries[idx].fmtetc.ptd == NULL) return 0;
    return (char*)data->entries[idx].fmtetc.ptd - (char*)data;
}

Referenced by OLEClipbrd_IEnumFORMATETC_Clone().

td_offs_to_ptr()

static DVTARGETDEVICE * td_offs_to_ptr ( ole_priv_data *  data, DWORD_PTR  off  )

inlinestatic

Definition at line 112 of file clipboard.c.

{
    if(off == 0) return NULL;
    return (DVTARGETDEVICE*)((char*)data + off);
}

Referenced by get_priv_data(), OLEClipbrd_IEnumFORMATETC_Clone(), and set_clipboard_formats().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

ole

)

Variable Documentation

clipbrd_wndclass

const WCHAR clipbrd_wndclass[] = {'C','L','I','P','B','R','D','W','N','D','C','L','A','S','S',0}

static

Definition at line 201 of file clipboard.c.

Referenced by create_clipbrd_window(), and OLEClipbrd_UnInitialize().

custom_link_source_clipboard_format

UINT custom_link_source_clipboard_format = 0

Definition at line 209 of file clipboard.c.

Referenced by register_clipboard_formats().

dataobject_clipboard_format

UINT dataobject_clipboard_format = 0

Definition at line 206 of file clipboard.c.

Referenced by get_current_ole_clip_window(), register_clipboard_formats(), and set_dataobject_format().

efvt

const IEnumFORMATETCVtbl efvt

static

Initial value:

=
{
  OLEClipbrd_IEnumFORMATETC_QueryInterface,
  OLEClipbrd_IEnumFORMATETC_AddRef,
  OLEClipbrd_IEnumFORMATETC_Release,
  OLEClipbrd_IEnumFORMATETC_Next,
  OLEClipbrd_IEnumFORMATETC_Skip,
  OLEClipbrd_IEnumFORMATETC_Reset,
  OLEClipbrd_IEnumFORMATETC_Clone
}

Definition at line 414 of file clipboard.c.

Referenced by enum_fmtetc_construct().

embed_source_clipboard_format

UINT embed_source_clipboard_format = 0

Definition at line 208 of file clipboard.c.

Referenced by get_storage(), OleQueryCreateFromData(), register_clipboard_formats(), and render_format().

embedded_object_clipboard_format

UINT embedded_object_clipboard_format = 0

Definition at line 207 of file clipboard.c.

Referenced by get_storage(), OleQueryCreateFromData(), and register_clipboard_formats().

filename_clipboard_format

UINT filename_clipboard_format = 0

Definition at line 204 of file clipboard.c.

Referenced by OleQueryCreateFromData(), and register_clipboard_formats().

filenameW_clipboard_format

UINT filenameW_clipboard_format = 0

Definition at line 205 of file clipboard.c.

Referenced by register_clipboard_formats().

latest_snapshot_cs

static CRITICAL_SECTION latest_snapshot_cs = { &latest_snapshot_cs_debug, -1, 0, 0, 0, 0 }

static

Definition at line 177 of file clipboard.c.

Referenced by OleGetClipboard(), and snapshot_Release().

latest_snapshot_cs_debug

CRITICAL_SECTION_DEBUG latest_snapshot_cs_debug

static

Initial value:

=
{
        0, 0, &latest_snapshot_cs,
        { &latest_snapshot_cs_debug.ProcessLocksList, &latest_snapshot_cs_debug.ProcessLocksList },
        0, 0, { (DWORD_PTR)(__FILE__ ": clipboard last snapshot") }
}

Definition at line 178 of file clipboard.c.

link_source_clipboard_format

UINT link_source_clipboard_format = 0

Definition at line 210 of file clipboard.c.

Referenced by register_clipboard_formats().

link_source_descriptor_clipboard_format

UINT link_source_descriptor_clipboard_format = 0

Definition at line 212 of file clipboard.c.

Referenced by register_clipboard_formats().

object_descriptor_clipboard_format

UINT object_descriptor_clipboard_format = 0

Definition at line 211 of file clipboard.c.

Referenced by register_clipboard_formats().

ole_private_data_clipboard_format

UINT ole_private_data_clipboard_format = 0

Definition at line 213 of file clipboard.c.

Referenced by get_priv_data(), register_clipboard_formats(), and set_clipboard_formats().

ownerlink_clipboard_format

UINT ownerlink_clipboard_format = 0

Definition at line 203 of file clipboard.c.

Referenced by register_clipboard_formats().

snapshot_vtable

const IDataObjectVtbl snapshot_vtable

static

Initial value:

=
{
    snapshot_QueryInterface,
    snapshot_AddRef,
    snapshot_Release,
    snapshot_GetData,
    snapshot_GetDataHere,
    snapshot_QueryGetData,
    snapshot_GetCanonicalFormatEtc,
    snapshot_SetData,
    snapshot_EnumFormatEtc,
    snapshot_DAdvise,
    snapshot_DUnadvise,
    snapshot_EnumDAdvise
}

Definition at line 1706 of file clipboard.c.

Referenced by snapshot_construct().

theOleClipboard

ole_clipbrd* theOleClipboard

static

Definition at line 175 of file clipboard.c.

Referenced by get_ole_clipbrd(), OLEClipbrd_Initialize(), OLEClipbrd_UnInitialize(), render_embed_source_hack(), and snapshot_Release().

wine_marshal_clipboard_format

UINT wine_marshal_clipboard_format

static

Definition at line 215 of file clipboard.c.

Referenced by expose_marshalled_dataobject(), get_current_dataobject(), and register_clipboard_formats().