[wxWidgets.git] / src / msw / ole / dataobj.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        msw/ole/dataobj.cpp
// Purpose:     implementation of wx[I]DataObject class
// Author:      Vadim Zeitlin
// Modified by:
// Created:     10.05.98
// RCS-ID:      $Id$
// Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
// Licence:     wxWindows license
///////////////////////////////////////////////////////////////////////////////

// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

#ifdef __GNUG__
  #pragma implementation "dataobj.h"
#endif

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#if defined(__BORLANDC__)
  #pragma hdrstop
#endif

#include "wx/defs.h"

#if defined(__WIN32__) && !defined(__GNUWIN32__)

#include "wx/log.h"
#include "wx/dataobj.h"

#include <windows.h>
#include <oleauto.h>

#ifndef __WIN32__
  #include <ole2.h>
  #include <olestd.h>
#endif

#include  "wx/msw/ole/oleutils.h"

// ----------------------------------------------------------------------------
// functions
// ----------------------------------------------------------------------------

static const char *GetTymedName(DWORD tymed);

// ----------------------------------------------------------------------------
// wxIEnumFORMATETC interface implementation
// ----------------------------------------------------------------------------
class wxIEnumFORMATETC : public IEnumFORMATETC
{
public:
  wxIEnumFORMATETC(CLIPFORMAT cf);

  DECLARE_IUNKNOWN_METHODS;

  // IEnumFORMATETC
  STDMETHODIMP Next(ULONG celt, FORMATETC *rgelt, ULONG *pceltFetched);
  STDMETHODIMP Skip(ULONG celt);
  STDMETHODIMP Reset();
  STDMETHODIMP Clone(IEnumFORMATETC **ppenum);

private:
  FORMATETC   m_format;   // (unique @@@) format we can provide data in
  ULONG       m_nCurrent; // current enum position (currently either 0 or 1)
};

// ----------------------------------------------------------------------------
// wxIDataObject implementation of IDataObject interface
// ----------------------------------------------------------------------------
class wxIDataObject : public IDataObject
{
public:
  wxIDataObject(wxDataObject *pDataObject);

  DECLARE_IUNKNOWN_METHODS;

  // IDataObject
  STDMETHODIMP GetData(FORMATETC *pformatetcIn, STGMEDIUM *pmedium);
  STDMETHODIMP GetDataHere(FORMATETC *pformatetc, STGMEDIUM *pmedium);
  STDMETHODIMP QueryGetData(FORMATETC *pformatetc);
  STDMETHODIMP GetCanonicalFormatEtc(FORMATETC *In, FORMATETC *pOut);
  STDMETHODIMP SetData(FORMATETC *pfetc, STGMEDIUM *pmedium, BOOL fRelease);
  STDMETHODIMP EnumFormatEtc(DWORD dwDirection, IEnumFORMATETC **ppenumFEtc);
  STDMETHODIMP DAdvise(FORMATETC *pfetc, DWORD ad, IAdviseSink *p, DWORD *pdw);
  STDMETHODIMP DUnadvise(DWORD dwConnection);
  STDMETHODIMP EnumDAdvise(IEnumSTATDATA **ppenumAdvise);

private:
  wxDataObject *m_pDataObject;      // pointer to C++ class we belong to
};

// ============================================================================
// implementation
// ============================================================================

// ----------------------------------------------------------------------------
// wxDataFormat
// ----------------------------------------------------------------------------

void wxDataFormat::SetId(const wxChar *format)
{
    m_format = ::RegisterClipboardFormat(format);
    if ( !m_format )
    {
        wxLogError(_("Couldn't register clipboard format '%s'."), format);
    }
}

wxString wxDataFormat::GetId() const
{
    static const int max = 256;

    wxString s;

    wxCHECK_MSG( !IsStandard(), s,
                 _T("name of predefined format cannot be retrieved") );

    int len = ::GetClipboardFormatName(m_format, s.GetWriteBuf(max), max);
    s.UngetWriteBuf();

    if ( !len )
    {
        wxLogError(_("The clipboard format '%d' doesn't exist."), m_format);
    }

    return s;
}

// ----------------------------------------------------------------------------
// wxIEnumFORMATETC
// ----------------------------------------------------------------------------

BEGIN_IID_TABLE(wxIEnumFORMATETC)
  ADD_IID(Unknown)
  ADD_IID(EnumFORMATETC)
END_IID_TABLE;

IMPLEMENT_IUNKNOWN_METHODS(wxIEnumFORMATETC)

wxIEnumFORMATETC::wxIEnumFORMATETC(CLIPFORMAT cf)
{
  m_format.cfFormat = cf;
  m_format.ptd      = NULL;
  m_format.dwAspect = DVASPECT_CONTENT;
  m_format.lindex   = -1;
  m_format.tymed    = TYMED_HGLOBAL;
  m_cRef = 0;
  m_nCurrent = 0;
}

STDMETHODIMP wxIEnumFORMATETC::Next(ULONG      celt,
                                    FORMATETC *rgelt,
                                    ULONG     *pceltFetched)
{
  wxLogTrace("wxIEnumFORMATETC::Next");

  if ( celt > 1 )
    return S_FALSE;

  if ( m_nCurrent == 0 ) {
    *rgelt = m_format;
    m_nCurrent++;

    return S_OK;
  }
  else
    return S_FALSE;
}

STDMETHODIMP wxIEnumFORMATETC::Skip(ULONG celt)
{
  wxLogTrace("wxIEnumFORMATETC::Skip");

  if ( m_nCurrent == 0 )
    m_nCurrent++;

  return S_FALSE;
}

STDMETHODIMP wxIEnumFORMATETC::Reset()
{
  wxLogTrace("wxIEnumFORMATETC::Reset");

  m_nCurrent = 0;

  return S_OK;
}

STDMETHODIMP wxIEnumFORMATETC::Clone(IEnumFORMATETC **ppenum)
{
  wxLogTrace("wxIEnumFORMATETC::Clone");

  wxIEnumFORMATETC *pNew = new wxIEnumFORMATETC(m_format.cfFormat);
  pNew->AddRef();
  *ppenum = pNew;

  return S_OK;
}

// ----------------------------------------------------------------------------
// wxIDataObject
// ----------------------------------------------------------------------------

BEGIN_IID_TABLE(wxIDataObject)
  ADD_IID(Unknown)
  ADD_IID(DataObject)
END_IID_TABLE;

IMPLEMENT_IUNKNOWN_METHODS(wxIDataObject)

wxIDataObject::wxIDataObject(wxDataObject *pDataObject)
{
  m_cRef = 0;
  m_pDataObject = pDataObject;
}

// get data functions
STDMETHODIMP wxIDataObject::GetData(FORMATETC *pformatetcIn, STGMEDIUM *pmedium)
{
  wxLogTrace("wxIDataObject::GetData");

  // is data is in our format?
  HRESULT hr = QueryGetData(pformatetcIn);
  if ( FAILED(hr) )
    return hr;

  // alloc memory
  HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE,
                                m_pDataObject->GetDataSize());
  if ( hGlobal == NULL ) {
    wxLogLastError("GlobalAlloc");
    return E_OUTOFMEMORY;
  }

  // copy data
  pmedium->tymed          = TYMED_HGLOBAL;
  pmedium->hGlobal        = hGlobal;
  pmedium->pUnkForRelease = NULL;

  hr = GetDataHere(pformatetcIn, pmedium);
  if ( FAILED(hr) ) {
    GlobalFree(hGlobal);
    return hr;
  }

  return S_OK;
}

STDMETHODIMP wxIDataObject::GetDataHere(FORMATETC *pformatetc,
                                        STGMEDIUM *pmedium)
{
  wxLogTrace("wxIDataObject::GetDataHere");

  // put data in caller provided medium
  if ( pmedium->tymed != TYMED_HGLOBAL )
    return DV_E_TYMED;

  // copy data
  void *pBuf = GlobalLock(pmedium->hGlobal);
  if ( pBuf == NULL ) {
    wxLogLastError("GlobalLock");
    return E_OUTOFMEMORY;
  }

  m_pDataObject->GetDataHere(pBuf);

  GlobalUnlock(pmedium->hGlobal);

  return S_OK;
}

// set data functions (not implemented)
STDMETHODIMP wxIDataObject::SetData(FORMATETC *pformatetc,
                                    STGMEDIUM *pmedium,
                                    BOOL       fRelease)
{
  wxLogTrace("wxIDataObject::SetData");
  return E_NOTIMPL;
}

// information functions
STDMETHODIMP wxIDataObject::QueryGetData(FORMATETC *pformatetc)
{
  // do we accept data in this format?
  if ( pformatetc == NULL ) {
    wxLogTrace("wxIDataObject::QueryGetData: invalid ptr.");
    return E_INVALIDARG;
  }

  // the only one allowed by current COM implementation
  if ( pformatetc->lindex != -1 ) {
    wxLogTrace("wxIDataObject::QueryGetData: bad lindex %d",
               pformatetc->lindex);
    return DV_E_LINDEX;
  }

  // we don't support anything other (THUMBNAIL, ICON, DOCPRINT...)
  if ( pformatetc->dwAspect != DVASPECT_CONTENT ) {
    wxLogTrace("wxIDataObject::QueryGetData: bad dwAspect %d",
               pformatetc->dwAspect);
    return DV_E_DVASPECT;
  }

  // @@ we only transfer data by global memory (bad for large amounts of it!)
  if ( !(pformatetc->tymed & TYMED_HGLOBAL) ) {
    wxLogTrace("wxIDataObject::QueryGetData: %s != TYMED_HGLOBAL.",
               GetTymedName(pformatetc->tymed));
    return DV_E_TYMED;
  }

  // and now check the type of data requested
  if ( m_pDataObject->IsSupportedFormat((wxDataFormatId)pformatetc->cfFormat) ) {
    wxLogTrace("wxIDataObject::QueryGetData: %s ok",
               wxDataObject::GetFormatName((wxDataFormatId)pformatetc->cfFormat));
    return S_OK;
  }
  else {
    wxLogTrace("wxIDataObject::QueryGetData: %s unsupported",
               wxDataObject::GetFormatName((wxDataFormatId)pformatetc->cfFormat));
    return DV_E_FORMATETC;
  }
}

STDMETHODIMP wxIDataObject::GetCanonicalFormatEtc(FORMATETC *pFormatetcIn,
                                                  FORMATETC *pFormatetcOut)
{
  wxLogTrace("wxIDataObject::GetCanonicalFormatEtc");

  // @@ implementation is trivial, we might want something better here
  if ( pFormatetcOut != NULL )
    pFormatetcOut->ptd = NULL;
  return DATA_S_SAMEFORMATETC;
}

STDMETHODIMP wxIDataObject::EnumFormatEtc(DWORD dwDirection,
                                          IEnumFORMATETC **ppenumFormatEtc)
{
  wxLogTrace("wxIDataObject::EnumFormatEtc");

  if ( dwDirection == DATADIR_SET ) {
    // we don't allow setting of data anyhow
    return E_NOTIMPL;
  }

  wxIEnumFORMATETC *pEnum =
    new wxIEnumFORMATETC(m_pDataObject->GetPreferredFormat());
  pEnum->AddRef();
  *ppenumFormatEtc = pEnum;

  return S_OK;
}

// advise sink functions (not implemented)
STDMETHODIMP wxIDataObject::DAdvise(FORMATETC   *pformatetc,
                                    DWORD        advf,
                                    IAdviseSink *pAdvSink,
                                    DWORD       *pdwConnection)
{
  return OLE_E_ADVISENOTSUPPORTED;
}

STDMETHODIMP wxIDataObject::DUnadvise(DWORD dwConnection)
{
  return OLE_E_ADVISENOTSUPPORTED;
}

STDMETHODIMP wxIDataObject::EnumDAdvise(IEnumSTATDATA **ppenumAdvise)
{
  return OLE_E_ADVISENOTSUPPORTED;
}

// ----------------------------------------------------------------------------
// wxDataObject
// ----------------------------------------------------------------------------

wxDataObject::wxDataObject()
{
  m_pIDataObject = new wxIDataObject(this);
  m_pIDataObject->AddRef();
}

wxDataObject::~wxDataObject()
{
  m_pIDataObject->Release();
}

const char *wxDataObject::GetFormatName(wxDataFormat format)
{
#ifdef __WXDEBUG__
  // case 'xxx' is not a valid value for switch of enum 'wxDataFormat'
  #ifdef __VISUALC__
    #pragma warning(disable:4063)
  #endif // VC++

  static char s_szBuf[128];
  switch ( format ) {
    case CF_TEXT:         return "CF_TEXT";
    case CF_BITMAP:       return "CF_BITMAP";
    case CF_METAFILEPICT: return "CF_METAFILEPICT";
    case CF_SYLK:         return "CF_SYLK";
    case CF_DIF:          return "CF_DIF";
    case CF_TIFF:         return "CF_TIFF";
    case CF_OEMTEXT:      return "CF_OEMTEXT";
    case CF_DIB:          return "CF_DIB";
    case CF_PALETTE:      return "CF_PALETTE";
    case CF_PENDATA:      return "CF_PENDATA";
    case CF_RIFF:         return "CF_RIFF";
    case CF_WAVE:         return "CF_WAVE";
    case CF_UNICODETEXT:  return "CF_UNICODETEXT";
    case CF_ENHMETAFILE:  return "CF_ENHMETAFILE";
    case CF_HDROP:        return "CF_HDROP";
    case CF_LOCALE:       return "CF_LOCALE";
    default:
      sprintf(s_szBuf, "clipboard format %d (unknown)", format);
      return s_szBuf;
  }

  #ifdef __VISUALC__
    #pragma warning(default:4063)
  #endif // VC++

#else // !Debug
  return "";
#endif // Debug
}

// ----------------------------------------------------------------------------
// wxPrivateDataObject
// ----------------------------------------------------------------------------

wxPrivateDataObject::wxPrivateDataObject()
{
    m_size = 0;
    m_data = NULL;
}

void wxPrivateDataObject::Free()
{
    if ( m_data )
        free(m_data);
}

void wxPrivateDataObject::SetData( const void *data, size_t size )
{
    Free();

    m_size = size;
    m_data = malloc(size);

    memcpy( m_data, data, size );
}

void wxPrivateDataObject::WriteData( void *dest ) const
{
    WriteData( m_data, dest );
}

size_t wxPrivateDataObject::GetSize() const
{
    return m_size;
}

void wxPrivateDataObject::WriteData( const void *data, void *dest ) const
{
    memcpy( dest, data, GetSize() );
}

// ----------------------------------------------------------------------------
// private functions
// ----------------------------------------------------------------------------
static const char *GetTymedName(DWORD tymed)
{
  static char s_szBuf[128];
  switch ( tymed ) {
    case TYMED_HGLOBAL:   return "TYMED_HGLOBAL";
    case TYMED_FILE:      return "TYMED_FILE";
    case TYMED_ISTREAM:   return "TYMED_ISTREAM";
    case TYMED_ISTORAGE:  return "TYMED_ISTORAGE";
    case TYMED_GDI:       return "TYMED_GDI";
    case TYMED_MFPICT:    return "TYMED_MFPICT";
    case TYMED_ENHMF:     return "TYMED_ENHMF";
    default:
      sprintf(s_szBuf, "type of media format %d (unknown)", tymed);
      return s_szBuf;
  }
}

// TODO: OLE parts of wxBitmap/File/MetafileDataObject

#endif
Commit	Line	Data
269a5a34 VZ	1	///////////////////////////////////////////////////////////////////////////////
	2	// Name: msw/ole/dataobj.cpp
	3	// Purpose: implementation of wx[I]DataObject class
	4	// Author: Vadim Zeitlin
3f4a0c5b	5	// Modified by:
269a5a34 VZ	6	// Created: 10.05.98
	7	// RCS-ID: $Id$
	8	// Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
	9	// Licence: wxWindows license
	10	///////////////////////////////////////////////////////////////////////////////
	11
	12	// ============================================================================
	13	// declarations
	14	// ============================================================================
	15
	16	// ----------------------------------------------------------------------------
	17	// headers
	18	// ----------------------------------------------------------------------------
	19
	20	#ifdef __GNUG__
	21	#pragma implementation "dataobj.h"
	22	#endif
	23
	24	// For compilers that support precompilation, includes "wx.h".
	25	#include "wx/wxprec.h"
	26
	27	#if defined(__BORLANDC__)
	28	#pragma hdrstop
	29	#endif
	30
3f480da3	31	#include "wx/defs.h"
5260b1c5	32
cfe780fb	33	#if defined(__WIN32__) && !defined(__GNUWIN32__)
5260b1c5	34
3f480da3 VZ	35	#include "wx/log.h"
3f480da3 VZ	36	#include "wx/dataobj.h"
17b74d79 JS	37
	38	#include <windows.h>
	39	#include <oleauto.h>
269a5a34 VZ	40
	41	#ifndef __WIN32__
	42	#include <ole2.h>
	43	#include <olestd.h>
	44	#endif
	45
3f480da3	46	#include "wx/msw/ole/oleutils.h"
17b74d79	47
269a5a34 VZ	48	// ----------------------------------------------------------------------------
	49	// functions
	50	// ----------------------------------------------------------------------------
	51
40e1a9c0	52	static const char *GetTymedName(DWORD tymed);
269a5a34 VZ	53
	54	// ----------------------------------------------------------------------------
	55	// wxIEnumFORMATETC interface implementation
	56	// ----------------------------------------------------------------------------
	57	class wxIEnumFORMATETC : public IEnumFORMATETC
	58	{
	59	public:
	60	wxIEnumFORMATETC(CLIPFORMAT cf);
	61
	62	DECLARE_IUNKNOWN_METHODS;
	63
	64	// IEnumFORMATETC
	65	STDMETHODIMP Next(ULONG celt, FORMATETC rgelt, ULONG pceltFetched);
	66	STDMETHODIMP Skip(ULONG celt);
	67	STDMETHODIMP Reset();
	68	STDMETHODIMP Clone(IEnumFORMATETC **ppenum);
	69
	70	private:
	71	FORMATETC m_format; // (unique @@@) format we can provide data in
	72	ULONG m_nCurrent; // current enum position (currently either 0 or 1)
	73	};
	74
	75	// ----------------------------------------------------------------------------
	76	// wxIDataObject implementation of IDataObject interface
	77	// ----------------------------------------------------------------------------
	78	class wxIDataObject : public IDataObject
	79	{
	80	public:
	81	wxIDataObject(wxDataObject *pDataObject);
	82
	83	DECLARE_IUNKNOWN_METHODS;
	84
	85	// IDataObject
	86	STDMETHODIMP GetData(FORMATETC pformatetcIn, STGMEDIUM pmedium);
	87	STDMETHODIMP GetDataHere(FORMATETC pformatetc, STGMEDIUM pmedium);
	88	STDMETHODIMP QueryGetData(FORMATETC *pformatetc);
	89	STDMETHODIMP GetCanonicalFormatEtc(FORMATETC In, FORMATETC pOut);
	90	STDMETHODIMP SetData(FORMATETC pfetc, STGMEDIUM pmedium, BOOL fRelease);
	91	STDMETHODIMP EnumFormatEtc(DWORD dwDirection, IEnumFORMATETC **ppenumFEtc);
	92	STDMETHODIMP DAdvise(FORMATETC pfetc, DWORD ad, IAdviseSink p, DWORD *pdw);
	93	STDMETHODIMP DUnadvise(DWORD dwConnection);
	94	STDMETHODIMP EnumDAdvise(IEnumSTATDATA **ppenumAdvise);
	95
	96	private:
	97	wxDataObject *m_pDataObject; // pointer to C++ class we belong to
	98	};
	99
	100	// ============================================================================
	101	// implementation
	102	// ============================================================================
	103
3f480da3 VZ	104	// ----------------------------------------------------------------------------
	105	// wxDataFormat
	106	// ----------------------------------------------------------------------------
	107
	108	void wxDataFormat::SetId(const wxChar *format)
	109	{
	110	m_format = ::RegisterClipboardFormat(format);
	111	if ( !m_format )
	112	{
	113	wxLogError(_("Couldn't register clipboard format '%s'."), format);
	114	}
	115	}
	116
	117	wxString wxDataFormat::GetId() const
	118	{
	119	static const int max = 256;
	120
	121	wxString s;
	122
	123	wxCHECK_MSG( !IsStandard(), s,
	124	_T("name of predefined format cannot be retrieved") );
	125
	126	int len = ::GetClipboardFormatName(m_format, s.GetWriteBuf(max), max);
	127	s.UngetWriteBuf();
	128
	129	if ( !len )
	130	{
	131	wxLogError(_("The clipboard format '%d' doesn't exist."), m_format);
	132	}
	133
	134	return s;
	135	}
	136
269a5a34 VZ	137	// ----------------------------------------------------------------------------
	138	// wxIEnumFORMATETC
	139	// ----------------------------------------------------------------------------
	140
	141	BEGIN_IID_TABLE(wxIEnumFORMATETC)
	142	ADD_IID(Unknown)
	143	ADD_IID(EnumFORMATETC)
	144	END_IID_TABLE;
	145
	146	IMPLEMENT_IUNKNOWN_METHODS(wxIEnumFORMATETC)
	147
	148	wxIEnumFORMATETC::wxIEnumFORMATETC(CLIPFORMAT cf)
	149	{
	150	m_format.cfFormat = cf;
	151	m_format.ptd = NULL;
	152	m_format.dwAspect = DVASPECT_CONTENT;
	153	m_format.lindex = -1;
	154	m_format.tymed = TYMED_HGLOBAL;
	155	m_cRef = 0;
	156	m_nCurrent = 0;
	157	}
	158
	159	STDMETHODIMP wxIEnumFORMATETC::Next(ULONG celt,
	160	FORMATETC *rgelt,
	161	ULONG *pceltFetched)
	162	{
	163	wxLogTrace("wxIEnumFORMATETC::Next");
	164
	165	if ( celt > 1 )
	166	return S_FALSE;
	167
	168	if ( m_nCurrent == 0 ) {
	169	*rgelt = m_format;
	170	m_nCurrent++;
	171
	172	return S_OK;
	173	}
	174	else
	175	return S_FALSE;
	176	}
	177
	178	STDMETHODIMP wxIEnumFORMATETC::Skip(ULONG celt)
	179	{
	180	wxLogTrace("wxIEnumFORMATETC::Skip");
	181
	182	if ( m_nCurrent == 0 )
	183	m_nCurrent++;
	184
	185	return S_FALSE;
	186	}
	187
	188	STDMETHODIMP wxIEnumFORMATETC::Reset()
	189	{
	190	wxLogTrace("wxIEnumFORMATETC::Reset");
	191
	192	m_nCurrent = 0;
	193
	194	return S_OK;
	195	}
	196
	197	STDMETHODIMP wxIEnumFORMATETC::Clone(IEnumFORMATETC **ppenum)
	198	{
	199	wxLogTrace("wxIEnumFORMATETC::Clone");
	200
201	wxIEnumFORMATETC *pNew = new wxIEnumFORMATETC(m_format.cfFormat);
202	pNew->AddRef();
203	*ppenum = pNew;
204
205	return S_OK;
206	}
207
208	// ----------------------------------------------------------------------------
209	// wxIDataObject
210	// ----------------------------------------------------------------------------
211
212	BEGIN_IID_TABLE(wxIDataObject)
213	ADD_IID(Unknown)
214	ADD_IID(DataObject)
215	END_IID_TABLE;
216
217	IMPLEMENT_IUNKNOWN_METHODS(wxIDataObject)
218
219	wxIDataObject::wxIDataObject(wxDataObject *pDataObject)
220	{
221	m_cRef = 0;
222	m_pDataObject = pDataObject;
223	}
224
225	// get data functions
226	STDMETHODIMP wxIDataObject::GetData(FORMATETC pformatetcIn, STGMEDIUM pmedium)
227	{
228	wxLogTrace("wxIDataObject::GetData");
229
230	// is data is in our format?
231	HRESULT hr = QueryGetData(pformatetcIn);
232	if ( FAILED(hr) )
233	return hr;
234
235	// alloc memory
236	HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE \| GMEM_SHARE,
237	m_pDataObject->GetDataSize());
238	if ( hGlobal == NULL ) {
239	wxLogLastError("GlobalAlloc");
240	return E_OUTOFMEMORY;
241	}
242
243	// copy data
244	pmedium->tymed = TYMED_HGLOBAL;
245	pmedium->hGlobal = hGlobal;
246	pmedium->pUnkForRelease = NULL;
247
248	hr = GetDataHere(pformatetcIn, pmedium);
249	if ( FAILED(hr) ) {
250	GlobalFree(hGlobal);
251	return hr;
252	}
253
254	return S_OK;
255	}
256
257	STDMETHODIMP wxIDataObject::GetDataHere(FORMATETC *pformatetc,
258	STGMEDIUM *pmedium)
259	{
260	wxLogTrace("wxIDataObject::GetDataHere");
261
262	// put data in caller provided medium
263	if ( pmedium->tymed != TYMED_HGLOBAL )
264	return DV_E_TYMED;
265
266	// copy data
267	void *pBuf = GlobalLock(pmedium->hGlobal);
268	if ( pBuf == NULL ) {
269	wxLogLastError("GlobalLock");
270	return E_OUTOFMEMORY;
271	}
272
273	m_pDataObject->GetDataHere(pBuf);
274
275	GlobalUnlock(pmedium->hGlobal);
276
277	return S_OK;
278	}
279
280	// set data functions (not implemented)
281	STDMETHODIMP wxIDataObject::SetData(FORMATETC *pformatetc,
282	STGMEDIUM *pmedium,
283	BOOL fRelease)
284	{
285	wxLogTrace("wxIDataObject::SetData");
286	return E_NOTIMPL;
287	}
288
289	// information functions
290	STDMETHODIMP wxIDataObject::QueryGetData(FORMATETC *pformatetc)
291	{
292	// do we accept data in this format?
293	if ( pformatetc == NULL ) {
294	wxLogTrace("wxIDataObject::QueryGetData: invalid ptr.");
295	return E_INVALIDARG;
296	}
297
298	// the only one allowed by current COM implementation
299	if ( pformatetc->lindex != -1 ) {
300	wxLogTrace("wxIDataObject::QueryGetData: bad lindex %d",
301	pformatetc->lindex);
302	return DV_E_LINDEX;
303	}
304
305	// we don't support anything other (THUMBNAIL, ICON, DOCPRINT...)
306	if ( pformatetc->dwAspect != DVASPECT_CONTENT ) {
307	wxLogTrace("wxIDataObject::QueryGetData: bad dwAspect %d",
308	pformatetc->dwAspect);
309	return DV_E_DVASPECT;
310	}
311
312	// @@ we only transfer data by global memory (bad for large amounts of it!)
313	if ( !(pformatetc->tymed & TYMED_HGLOBAL) ) {
314	wxLogTrace("wxIDataObject::QueryGetData: %s != TYMED_HGLOBAL.",
315	GetTymedName(pformatetc->tymed));
316	return DV_E_TYMED;
317	}
318
319	// and now check the type of data requested
3f480da3	320	if ( m_pDataObject->IsSupportedFormat((wxDataFormatId)pformatetc->cfFormat) ) {
269a5a34	321	wxLogTrace("wxIDataObject::QueryGetData: %s ok",
3f480da3	322	wxDataObject::GetFormatName((wxDataFormatId)pformatetc->cfFormat));
269a5a34 VZ	323	return S_OK;
	324	}
	325	else {
	326	wxLogTrace("wxIDataObject::QueryGetData: %s unsupported",
3f480da3	327	wxDataObject::GetFormatName((wxDataFormatId)pformatetc->cfFormat));
269a5a34 VZ	328	return DV_E_FORMATETC;
	329	}
	330	}
	331
	332	STDMETHODIMP wxIDataObject::GetCanonicalFormatEtc(FORMATETC *pFormatetcIn,
	333	FORMATETC *pFormatetcOut)
	334	{
	335	wxLogTrace("wxIDataObject::GetCanonicalFormatEtc");
	336
	337	// @@ implementation is trivial, we might want something better here
	338	if ( pFormatetcOut != NULL )
	339	pFormatetcOut->ptd = NULL;
	340	return DATA_S_SAMEFORMATETC;
	341	}
	342
	343	STDMETHODIMP wxIDataObject::EnumFormatEtc(DWORD dwDirection,
	344	IEnumFORMATETC **ppenumFormatEtc)
	345	{
	346	wxLogTrace("wxIDataObject::EnumFormatEtc");
	347
	348	if ( dwDirection == DATADIR_SET ) {
	349	// we don't allow setting of data anyhow
	350	return E_NOTIMPL;
	351	}
	352
3f4a0c5b	353	wxIEnumFORMATETC *pEnum =
269a5a34 VZ	354	new wxIEnumFORMATETC(m_pDataObject->GetPreferredFormat());
	355	pEnum->AddRef();
	356	*ppenumFormatEtc = pEnum;
	357
	358	return S_OK;
	359	}
	360
	361	// advise sink functions (not implemented)
	362	STDMETHODIMP wxIDataObject::DAdvise(FORMATETC *pformatetc,
	363	DWORD advf,
	364	IAdviseSink *pAdvSink,
	365	DWORD *pdwConnection)
	366	{
	367	return OLE_E_ADVISENOTSUPPORTED;
	368	}
	369
	370	STDMETHODIMP wxIDataObject::DUnadvise(DWORD dwConnection)
	371	{
	372	return OLE_E_ADVISENOTSUPPORTED;
	373	}
	374
	375	STDMETHODIMP wxIDataObject::EnumDAdvise(IEnumSTATDATA **ppenumAdvise)
	376	{
	377	return OLE_E_ADVISENOTSUPPORTED;
	378	}
	379
	380	// ----------------------------------------------------------------------------
	381	// wxDataObject
	382	// ----------------------------------------------------------------------------
	383
	384	wxDataObject::wxDataObject()
	385	{
	386	m_pIDataObject = new wxIDataObject(this);
	387	m_pIDataObject->AddRef();
	388	}
	389
	390	wxDataObject::~wxDataObject()
	391	{
	392	m_pIDataObject->Release();
	393	}
	394
269a5a34 VZ	395	const char *wxDataObject::GetFormatName(wxDataFormat format)
269a5a34 VZ	396	{
b2aef89b	397	#ifdef __WXDEBUG__
fd3f686c	398	// case 'xxx' is not a valid value for switch of enum 'wxDataFormat'
3f4a0c5b	399	#ifdef __VISUALC__
fd3f686c VZ	400	#pragma warning(disable:4063)
	401	#endif // VC++
	402
269a5a34 VZ	403	static char s_szBuf[128];
	404	switch ( format ) {
	405	case CF_TEXT: return "CF_TEXT";
	406	case CF_BITMAP: return "CF_BITMAP";
	407	case CF_METAFILEPICT: return "CF_METAFILEPICT";
	408	case CF_SYLK: return "CF_SYLK";
	409	case CF_DIF: return "CF_DIF";
	410	case CF_TIFF: return "CF_TIFF";
	411	case CF_OEMTEXT: return "CF_OEMTEXT";
	412	case CF_DIB: return "CF_DIB";
	413	case CF_PALETTE: return "CF_PALETTE";
	414	case CF_PENDATA: return "CF_PENDATA";
	415	case CF_RIFF: return "CF_RIFF";
	416	case CF_WAVE: return "CF_WAVE";
	417	case CF_UNICODETEXT: return "CF_UNICODETEXT";
	418	case CF_ENHMETAFILE: return "CF_ENHMETAFILE";
	419	case CF_HDROP: return "CF_HDROP";
	420	case CF_LOCALE: return "CF_LOCALE";
	421	default:
	422	sprintf(s_szBuf, "clipboard format %d (unknown)", format);
	423	return s_szBuf;
	424	}
fd3f686c	425
3f4a0c5b	426	#ifdef __VISUALC__
fd3f686c VZ	427	#pragma warning(default:4063)
	428	#endif // VC++
	429
	430	#else // !Debug
40e1a9c0	431	return "";
fd3f686c	432	#endif // Debug
269a5a34 VZ	433	}
269a5a34 VZ	434
3f480da3 VZ	435	// ----------------------------------------------------------------------------
	436	// wxPrivateDataObject
	437	// ----------------------------------------------------------------------------
	438
	439	wxPrivateDataObject::wxPrivateDataObject()
	440	{
	441	m_size = 0;
	442	m_data = NULL;
	443	}
	444
	445	void wxPrivateDataObject::Free()
	446	{
	447	if ( m_data )
	448	free(m_data);
	449	}
	450
	451	void wxPrivateDataObject::SetData( const void *data, size_t size )
	452	{
	453	Free();
	454
	455	m_size = size;
	456	m_data = malloc(size);
	457
	458	memcpy( m_data, data, size );
	459	}
	460
	461	void wxPrivateDataObject::WriteData( void *dest ) const
	462	{
	463	WriteData( m_data, dest );
	464	}
	465
	466	size_t wxPrivateDataObject::GetSize() const
	467	{
	468	return m_size;
	469	}
	470
	471	void wxPrivateDataObject::WriteData( const void data, void dest ) const
	472	{
	473	memcpy( dest, data, GetSize() );
	474	}
	475
269a5a34 VZ	476	// ----------------------------------------------------------------------------
	477	// private functions
	478	// ----------------------------------------------------------------------------
	479	static const char *GetTymedName(DWORD tymed)
	480	{
	481	static char s_szBuf[128];
	482	switch ( tymed ) {
	483	case TYMED_HGLOBAL: return "TYMED_HGLOBAL";
	484	case TYMED_FILE: return "TYMED_FILE";
	485	case TYMED_ISTREAM: return "TYMED_ISTREAM";
	486	case TYMED_ISTORAGE: return "TYMED_ISTORAGE";
	487	case TYMED_GDI: return "TYMED_GDI";
	488	case TYMED_MFPICT: return "TYMED_MFPICT";
	489	case TYMED_ENHMF: return "TYMED_ENHMF";
	490	default:
	491	sprintf(s_szBuf, "type of media format %d (unknown)", tymed);
	492	return s_szBuf;
	493	}
	494	}
5260b1c5	495
2845ddc2 JS	496	// TODO: OLE parts of wxBitmap/File/MetafileDataObject
2845ddc2 JS	497
5260b1c5 JS	498	#endif
5260b1c5 JS	499