]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/msw/ole/dataobj.cpp
Hopefully fixed library names generated by wx-config for OS/2's PM port.
[wxWidgets.git] / src / msw / ole / dataobj.cpp
... / ...
CommitLineData
1///////////////////////////////////////////////////////////////////////////////
2// Name: msw/ole/dataobj.cpp
3// Purpose: implementation of wx[I]DataObject class
4// Author: Vadim Zeitlin
5// Modified by:
6// Created: 10.05.98
7// RCS-ID: $Id$
8// Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9// Licence: wxWindows licence
10///////////////////////////////////////////////////////////////////////////////
11
12// ============================================================================
13// declarations
14// ============================================================================
15
16// ----------------------------------------------------------------------------
17// headers
18// ----------------------------------------------------------------------------
19
20#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
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
31#ifndef WX_PRECOMP
32 #include "wx/intl.h"
33 #include "wx/log.h"
34#endif
35
36#include "wx/dataobj.h"
37
38#if wxUSE_OLE && defined(__WIN32__) && !defined(__GNUWIN32_OLD__)
39
40#include "wx/msw/private.h" // includes <windows.h>
41
42#ifdef __WXWINCE__
43#include <winreg.h>
44#endif
45
46// for some compilers, the entire ole2.h must be included, not only oleauto.h
47#if wxUSE_NORLANDER_HEADERS || defined(__WATCOMC__) || defined(__WXWINCE__)
48 #include <ole2.h>
49#endif
50
51#include <oleauto.h>
52#include <shlobj.h>
53
54#include "wx/msw/ole/oleutils.h"
55
56#include "wx/msw/dib.h"
57
58#ifndef CFSTR_SHELLURL
59#define CFSTR_SHELLURL _T("UniformResourceLocator")
60#endif
61
62// ----------------------------------------------------------------------------
63// functions
64// ----------------------------------------------------------------------------
65
66#ifdef __WXDEBUG__
67 static const wxChar *GetTymedName(DWORD tymed);
68#else // !Debug
69 #define GetTymedName(tymed) wxEmptyString
70#endif // Debug/!Debug
71
72// ----------------------------------------------------------------------------
73// wxIEnumFORMATETC interface implementation
74// ----------------------------------------------------------------------------
75
76class wxIEnumFORMATETC : public IEnumFORMATETC
77{
78public:
79 wxIEnumFORMATETC(const wxDataFormat* formats, ULONG nCount);
80 virtual ~wxIEnumFORMATETC() { delete [] m_formats; }
81
82 DECLARE_IUNKNOWN_METHODS;
83
84 // IEnumFORMATETC
85 STDMETHODIMP Next(ULONG celt, FORMATETC *rgelt, ULONG *pceltFetched);
86 STDMETHODIMP Skip(ULONG celt);
87 STDMETHODIMP Reset();
88 STDMETHODIMP Clone(IEnumFORMATETC **ppenum);
89
90private:
91 CLIPFORMAT *m_formats; // formats we can provide data in
92 ULONG m_nCount, // number of formats we support
93 m_nCurrent; // current enum position
94
95 DECLARE_NO_COPY_CLASS(wxIEnumFORMATETC)
96};
97
98// ----------------------------------------------------------------------------
99// wxIDataObject implementation of IDataObject interface
100// ----------------------------------------------------------------------------
101
102class wxIDataObject : public IDataObject
103{
104public:
105 wxIDataObject(wxDataObject *pDataObject);
106 virtual ~wxIDataObject();
107
108 // normally, wxDataObject controls our lifetime (i.e. we're deleted when it
109 // is), but in some cases, the situation is reversed, that is we delete it
110 // when this object is deleted - setting this flag enables such logic
111 void SetDeleteFlag() { m_mustDelete = true; }
112
113 DECLARE_IUNKNOWN_METHODS;
114
115 // IDataObject
116 STDMETHODIMP GetData(FORMATETC *pformatetcIn, STGMEDIUM *pmedium);
117 STDMETHODIMP GetDataHere(FORMATETC *pformatetc, STGMEDIUM *pmedium);
118 STDMETHODIMP QueryGetData(FORMATETC *pformatetc);
119 STDMETHODIMP GetCanonicalFormatEtc(FORMATETC *In, FORMATETC *pOut);
120 STDMETHODIMP SetData(FORMATETC *pfetc, STGMEDIUM *pmedium, BOOL fRelease);
121 STDMETHODIMP EnumFormatEtc(DWORD dwDirection, IEnumFORMATETC **ppenumFEtc);
122 STDMETHODIMP DAdvise(FORMATETC *pfetc, DWORD ad, IAdviseSink *p, DWORD *pdw);
123 STDMETHODIMP DUnadvise(DWORD dwConnection);
124 STDMETHODIMP EnumDAdvise(IEnumSTATDATA **ppenumAdvise);
125
126private:
127 wxDataObject *m_pDataObject; // pointer to C++ class we belong to
128
129 bool m_mustDelete;
130
131 DECLARE_NO_COPY_CLASS(wxIDataObject)
132};
133
134// ============================================================================
135// implementation
136// ============================================================================
137
138// ----------------------------------------------------------------------------
139// wxDataFormat
140// ----------------------------------------------------------------------------
141
142void wxDataFormat::SetId(const wxChar *format)
143{
144 m_format = (wxDataFormat::NativeFormat)::RegisterClipboardFormat(format);
145 if ( !m_format )
146 {
147 wxLogError(_("Couldn't register clipboard format '%s'."), format);
148 }
149}
150
151wxString wxDataFormat::GetId() const
152{
153 static const int max = 256;
154
155 wxString s;
156
157 wxCHECK_MSG( !IsStandard(), s,
158 wxT("name of predefined format cannot be retrieved") );
159
160 int len = ::GetClipboardFormatName(m_format, wxStringBuffer(s, max), max);
161
162 if ( !len )
163 {
164 wxLogError(_("The clipboard format '%d' doesn't exist."), m_format);
165 }
166
167 return s;
168}
169
170// ----------------------------------------------------------------------------
171// wxIEnumFORMATETC
172// ----------------------------------------------------------------------------
173
174BEGIN_IID_TABLE(wxIEnumFORMATETC)
175 ADD_IID(Unknown)
176 ADD_IID(EnumFORMATETC)
177END_IID_TABLE;
178
179IMPLEMENT_IUNKNOWN_METHODS(wxIEnumFORMATETC)
180
181wxIEnumFORMATETC::wxIEnumFORMATETC(const wxDataFormat *formats, ULONG nCount)
182{
183 m_nCurrent = 0;
184 m_nCount = nCount;
185 m_formats = new CLIPFORMAT[nCount];
186 for ( ULONG n = 0; n < nCount; n++ ) {
187 m_formats[n] = formats[n].GetFormatId();
188 }
189}
190
191STDMETHODIMP wxIEnumFORMATETC::Next(ULONG celt,
192 FORMATETC *rgelt,
193 ULONG *pceltFetched)
194{
195 wxLogTrace(wxTRACE_OleCalls, wxT("wxIEnumFORMATETC::Next"));
196
197 ULONG numFetched = 0;
198 while (m_nCurrent < m_nCount && numFetched < celt) {
199 FORMATETC format;
200 format.cfFormat = m_formats[m_nCurrent++];
201 format.ptd = NULL;
202 format.dwAspect = DVASPECT_CONTENT;
203 format.lindex = -1;
204 format.tymed = TYMED_HGLOBAL;
205
206 *rgelt++ = format;
207 numFetched++;
208 }
209
210 if (pceltFetched)
211 *pceltFetched = numFetched;
212
213 return numFetched == celt ? S_OK : S_FALSE;
214}
215
216STDMETHODIMP wxIEnumFORMATETC::Skip(ULONG celt)
217{
218 wxLogTrace(wxTRACE_OleCalls, wxT("wxIEnumFORMATETC::Skip"));
219
220 m_nCurrent += celt;
221 if ( m_nCurrent < m_nCount )
222 return S_OK;
223
224 // no, can't skip this many elements
225 m_nCurrent -= celt;
226
227 return S_FALSE;
228}
229
230STDMETHODIMP wxIEnumFORMATETC::Reset()
231{
232 wxLogTrace(wxTRACE_OleCalls, wxT("wxIEnumFORMATETC::Reset"));
233
234 m_nCurrent = 0;
235
236 return S_OK;
237}
238
239STDMETHODIMP wxIEnumFORMATETC::Clone(IEnumFORMATETC **ppenum)
240{
241 wxLogTrace(wxTRACE_OleCalls, wxT("wxIEnumFORMATETC::Clone"));
242
243 // unfortunately, we can't reuse the code in ctor - types are different
244 wxIEnumFORMATETC *pNew = new wxIEnumFORMATETC(NULL, 0);
245 pNew->m_nCount = m_nCount;
246 pNew->m_formats = new CLIPFORMAT[m_nCount];
247 for ( ULONG n = 0; n < m_nCount; n++ ) {
248 pNew->m_formats[n] = m_formats[n];
249 }
250 pNew->AddRef();
251 *ppenum = pNew;
252
253 return S_OK;
254}
255
256// ----------------------------------------------------------------------------
257// wxIDataObject
258// ----------------------------------------------------------------------------
259
260BEGIN_IID_TABLE(wxIDataObject)
261 ADD_IID(Unknown)
262 ADD_IID(DataObject)
263END_IID_TABLE;
264
265IMPLEMENT_IUNKNOWN_METHODS(wxIDataObject)
266
267wxIDataObject::wxIDataObject(wxDataObject *pDataObject)
268{
269 m_pDataObject = pDataObject;
270 m_mustDelete = false;
271}
272
273wxIDataObject::~wxIDataObject()
274{
275 if ( m_mustDelete )
276 {
277 delete m_pDataObject;
278 }
279}
280
281// get data functions
282STDMETHODIMP wxIDataObject::GetData(FORMATETC *pformatetcIn, STGMEDIUM *pmedium)
283{
284 wxLogTrace(wxTRACE_OleCalls, wxT("wxIDataObject::GetData"));
285
286 // is data is in our format?
287 HRESULT hr = QueryGetData(pformatetcIn);
288 if ( FAILED(hr) )
289 return hr;
290
291 // for the bitmaps and metafiles we use the handles instead of global memory
292 // to pass the data
293 wxDataFormat format = (wxDataFormat::NativeFormat)pformatetcIn->cfFormat;
294
295 switch ( format )
296 {
297 case wxDF_BITMAP:
298 pmedium->tymed = TYMED_GDI;
299 break;
300
301 case wxDF_ENHMETAFILE:
302 pmedium->tymed = TYMED_ENHMF;
303 break;
304
305#ifndef __WXWINCE__
306 case wxDF_METAFILE:
307 pmedium->hGlobal = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE,
308 sizeof(METAFILEPICT));
309 if ( !pmedium->hGlobal ) {
310 wxLogLastError(wxT("GlobalAlloc"));
311 return E_OUTOFMEMORY;
312 }
313 pmedium->tymed = TYMED_MFPICT;
314 break;
315#endif
316 default:
317 // alloc memory
318 size_t size = m_pDataObject->GetDataSize(format);
319 if ( !size ) {
320 // it probably means that the method is just not implemented
321 wxLogDebug(wxT("Invalid data size - can't be 0"));
322
323 return DV_E_FORMATETC;
324 }
325
326 if ( !format.IsStandard() ) {
327 // for custom formats, put the size with the data - alloc the
328 // space for it
329 // MB: not completely sure this is correct,
330 // even if I can't figure out what's wrong
331 size += m_pDataObject->GetBufferOffset( format );
332 }
333
334 HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE, size);
335 if ( hGlobal == NULL ) {
336 wxLogLastError(wxT("GlobalAlloc"));
337 return E_OUTOFMEMORY;
338 }
339
340 // copy data
341 pmedium->tymed = TYMED_HGLOBAL;
342 pmedium->hGlobal = hGlobal;
343 }
344
345 pmedium->pUnkForRelease = NULL;
346
347 // do copy the data
348 hr = GetDataHere(pformatetcIn, pmedium);
349 if ( FAILED(hr) ) {
350 // free resources we allocated
351 if ( pmedium->tymed & (TYMED_HGLOBAL | TYMED_MFPICT) ) {
352 GlobalFree(pmedium->hGlobal);
353 }
354
355 return hr;
356 }
357
358 return S_OK;
359}
360
361STDMETHODIMP wxIDataObject::GetDataHere(FORMATETC *pformatetc,
362 STGMEDIUM *pmedium)
363{
364 wxLogTrace(wxTRACE_OleCalls, wxT("wxIDataObject::GetDataHere"));
365
366 // put data in caller provided medium
367 switch ( pmedium->tymed )
368 {
369 case TYMED_GDI:
370 if ( !m_pDataObject->GetDataHere(wxDF_BITMAP, &pmedium->hBitmap) )
371 return E_UNEXPECTED;
372 break;
373
374 case TYMED_ENHMF:
375 if ( !m_pDataObject->GetDataHere(wxDF_ENHMETAFILE,
376 &pmedium->hEnhMetaFile) )
377 return E_UNEXPECTED;
378 break;
379
380 case TYMED_MFPICT:
381 // fall through - we pass METAFILEPICT through HGLOBAL
382
383 case TYMED_HGLOBAL:
384 {
385 // copy data
386 HGLOBAL hGlobal = pmedium->hGlobal;
387 void *pBuf = GlobalLock(hGlobal);
388 if ( pBuf == NULL ) {
389 wxLogLastError(wxT("GlobalLock"));
390 return E_OUTOFMEMORY;
391 }
392
393 wxDataFormat format = pformatetc->cfFormat;
394 if ( !format.IsStandard() ) {
395 // for custom formats, put the size with the data
396 pBuf = m_pDataObject->SetSizeInBuffer( pBuf, GlobalSize(hGlobal), format );
397 }
398
399 if ( !m_pDataObject->GetDataHere(format, pBuf) )
400 return E_UNEXPECTED;
401
402 GlobalUnlock(hGlobal);
403 }
404 break;
405
406 default:
407 return DV_E_TYMED;
408 }
409
410 return S_OK;
411}
412
413
414// set data functions
415STDMETHODIMP wxIDataObject::SetData(FORMATETC *pformatetc,
416 STGMEDIUM *pmedium,
417 BOOL fRelease)
418{
419 wxLogTrace(wxTRACE_OleCalls, wxT("wxIDataObject::SetData"));
420
421 switch ( pmedium->tymed )
422 {
423 case TYMED_GDI:
424 m_pDataObject->SetData(wxDF_BITMAP, 0, &pmedium->hBitmap);
425 break;
426
427 case TYMED_ENHMF:
428 m_pDataObject->SetData(wxDF_ENHMETAFILE, 0, &pmedium->hEnhMetaFile);
429 break;
430
431 case TYMED_MFPICT:
432 // fall through - we pass METAFILEPICT through HGLOBAL
433 case TYMED_HGLOBAL:
434 {
435 wxDataFormat format = pformatetc->cfFormat;
436
437 // this is quite weird, but for file drag and drop, explorer
438 // calls our SetData() with the formats we do *not* support!
439 //
440 // as we can't fix this bug in explorer (it's a bug because it
441 // should only use formats returned by EnumFormatEtc), do the
442 // check here
443 if ( !m_pDataObject->IsSupported(format, wxDataObject::Set) ) {
444 // go away!
445 return DV_E_FORMATETC;
446 }
447
448 // copy data
449 const void *pBuf = GlobalLock(pmedium->hGlobal);
450 if ( pBuf == NULL ) {
451 wxLogLastError(wxT("GlobalLock"));
452
453 return E_OUTOFMEMORY;
454 }
455
456 // we've got a problem with SetData() here because the base
457 // class version requires the size parameter which we don't
458 // have anywhere in OLE data transfer - so we need to
459 // synthetise it for known formats and we suppose that all data
460 // in custom formats starts with a DWORD containing the size
461 size_t size;
462 switch ( format )
463 {
464 case CF_TEXT:
465 case CF_OEMTEXT:
466 size = strlen((const char *)pBuf);
467 break;
468#if !(defined(__BORLANDC__) && (__BORLANDC__ < 0x500))
469 case CF_UNICODETEXT:
470#if ( defined(__BORLANDC__) && (__BORLANDC__ > 0x530) ) \
471 || ( defined(__MWERKS__) && defined(__WXMSW__) )
472 size = std::wcslen((const wchar_t *)pBuf) * sizeof(wchar_t);
473#else
474 size = wxWcslen((const wchar_t *)pBuf) * sizeof(wchar_t);
475#endif
476 break;
477#endif
478 case CF_BITMAP:
479#ifndef __WXWINCE__
480 case CF_HDROP:
481 // these formats don't use size at all, anyhow (but
482 // pass data by handle, which is always a single DWORD)
483 size = 0;
484 break;
485#endif
486
487 case CF_DIB:
488 // the handler will calculate size itself (it's too
489 // complicated to do it here)
490 size = 0;
491 break;
492
493#ifndef __WXWINCE__
494 case CF_METAFILEPICT:
495 size = sizeof(METAFILEPICT);
496 break;
497#endif
498 default:
499 {
500 // we suppose that the size precedes the data
501 pBuf = m_pDataObject->GetSizeFromBuffer( pBuf, &size, format );
502 if (! format.IsStandard() ) {
503 // see GetData for corresponding increment
504 size -= m_pDataObject->GetBufferOffset( format );
505 }
506 }
507 }
508
509 bool ok = m_pDataObject->SetData(format, size, pBuf);
510
511 GlobalUnlock(pmedium->hGlobal);
512
513 if ( !ok ) {
514 return E_UNEXPECTED;
515 }
516 }
517 break;
518
519 default:
520 return DV_E_TYMED;
521 }
522
523 if ( fRelease ) {
524 // we own the medium, so we must release it - but do *not* free any
525 // data we pass by handle because we have copied it elsewhere
526 switch ( pmedium->tymed )
527 {
528 case TYMED_GDI:
529 pmedium->hBitmap = 0;
530 break;
531
532 case TYMED_MFPICT:
533 pmedium->hMetaFilePict = 0;
534 break;
535
536 case TYMED_ENHMF:
537 pmedium->hEnhMetaFile = 0;
538 break;
539 }
540
541 ReleaseStgMedium(pmedium);
542 }
543
544 return S_OK;
545}
546
547// information functions
548STDMETHODIMP wxIDataObject::QueryGetData(FORMATETC *pformatetc)
549{
550 // do we accept data in this format?
551 if ( pformatetc == NULL ) {
552 wxLogTrace(wxTRACE_OleCalls,
553 wxT("wxIDataObject::QueryGetData: invalid ptr."));
554
555 return E_INVALIDARG;
556 }
557
558 // the only one allowed by current COM implementation
559 if ( pformatetc->lindex != -1 ) {
560 wxLogTrace(wxTRACE_OleCalls,
561 wxT("wxIDataObject::QueryGetData: bad lindex %ld"),
562 pformatetc->lindex);
563
564 return DV_E_LINDEX;
565 }
566
567 // we don't support anything other (THUMBNAIL, ICON, DOCPRINT...)
568 if ( pformatetc->dwAspect != DVASPECT_CONTENT ) {
569 wxLogTrace(wxTRACE_OleCalls,
570 wxT("wxIDataObject::QueryGetData: bad dwAspect %ld"),
571 pformatetc->dwAspect);
572
573 return DV_E_DVASPECT;
574 }
575
576 // and now check the type of data requested
577 wxDataFormat format = pformatetc->cfFormat;
578 if ( m_pDataObject->IsSupportedFormat(format) ) {
579 wxLogTrace(wxTRACE_OleCalls, wxT("wxIDataObject::QueryGetData: %s ok"),
580 wxGetFormatName(format));
581 }
582 else {
583 wxLogTrace(wxTRACE_OleCalls,
584 wxT("wxIDataObject::QueryGetData: %s unsupported"),
585 wxGetFormatName(format));
586
587 return DV_E_FORMATETC;
588 }
589
590 // we only transfer data by global memory, except for some particular cases
591 DWORD tymed = pformatetc->tymed;
592 if ( (format == wxDF_BITMAP && !(tymed & TYMED_GDI)) &&
593 !(tymed & TYMED_HGLOBAL) ) {
594 // it's not what we're waiting for
595 wxLogTrace(wxTRACE_OleCalls,
596 wxT("wxIDataObject::QueryGetData: %s != %s"),
597 GetTymedName(tymed),
598 GetTymedName(format == wxDF_BITMAP ? TYMED_GDI
599 : TYMED_HGLOBAL));
600
601 return DV_E_TYMED;
602 }
603
604 return S_OK;
605}
606
607STDMETHODIMP wxIDataObject::GetCanonicalFormatEtc(FORMATETC *WXUNUSED(pFormatetcIn),
608 FORMATETC *pFormatetcOut)
609{
610 wxLogTrace(wxTRACE_OleCalls, wxT("wxIDataObject::GetCanonicalFormatEtc"));
611
612 // TODO we might want something better than this trivial implementation here
613 if ( pFormatetcOut != NULL )
614 pFormatetcOut->ptd = NULL;
615
616 return DATA_S_SAMEFORMATETC;
617}
618
619STDMETHODIMP wxIDataObject::EnumFormatEtc(DWORD dwDir,
620 IEnumFORMATETC **ppenumFormatEtc)
621{
622 wxLogTrace(wxTRACE_OleCalls, wxT("wxIDataObject::EnumFormatEtc"));
623
624 wxDataObject::Direction dir = dwDir == DATADIR_GET ? wxDataObject::Get
625 : wxDataObject::Set;
626
627 size_t nFormatCount = m_pDataObject->GetFormatCount(dir);
628 wxDataFormat format;
629 wxDataFormat *formats;
630 formats = nFormatCount == 1 ? &format : new wxDataFormat[nFormatCount];
631 m_pDataObject->GetAllFormats(formats, dir);
632
633 wxIEnumFORMATETC *pEnum = new wxIEnumFORMATETC(formats, nFormatCount);
634 pEnum->AddRef();
635 *ppenumFormatEtc = pEnum;
636
637 if ( formats != &format ) {
638 delete [] formats;
639 }
640
641 return S_OK;
642}
643
644// ----------------------------------------------------------------------------
645// advise sink functions (not implemented)
646// ----------------------------------------------------------------------------
647
648STDMETHODIMP wxIDataObject::DAdvise(FORMATETC *WXUNUSED(pformatetc),
649 DWORD WXUNUSED(advf),
650 IAdviseSink *WXUNUSED(pAdvSink),
651 DWORD *WXUNUSED(pdwConnection))
652{
653 return OLE_E_ADVISENOTSUPPORTED;
654}
655
656STDMETHODIMP wxIDataObject::DUnadvise(DWORD WXUNUSED(dwConnection))
657{
658 return OLE_E_ADVISENOTSUPPORTED;
659}
660
661STDMETHODIMP wxIDataObject::EnumDAdvise(IEnumSTATDATA **WXUNUSED(ppenumAdvise))
662{
663 return OLE_E_ADVISENOTSUPPORTED;
664}
665
666// ----------------------------------------------------------------------------
667// wxDataObject
668// ----------------------------------------------------------------------------
669
670wxDataObject::wxDataObject()
671{
672 m_pIDataObject = new wxIDataObject(this);
673 m_pIDataObject->AddRef();
674}
675
676wxDataObject::~wxDataObject()
677{
678 ReleaseInterface(m_pIDataObject);
679}
680
681void wxDataObject::SetAutoDelete()
682{
683 ((wxIDataObject *)m_pIDataObject)->SetDeleteFlag();
684 m_pIDataObject->Release();
685
686 // so that the dtor doesnt' crash
687 m_pIDataObject = NULL;
688}
689
690size_t wxDataObject::GetBufferOffset( const wxDataFormat& WXUNUSED(format) )
691{
692 return sizeof(size_t);
693}
694
695const void* wxDataObject::GetSizeFromBuffer( const void* buffer, size_t* size,
696 const wxDataFormat& WXUNUSED(format) )
697{
698 size_t* p = (size_t*)buffer;
699 *size = *p;
700
701 return p + 1;
702}
703
704void* wxDataObject::SetSizeInBuffer( void* buffer, size_t size,
705 const wxDataFormat& WXUNUSED(format) )
706{
707 size_t* p = (size_t*)buffer;
708 *p = size;
709
710 return p + 1;
711}
712
713#ifdef __WXDEBUG__
714
715const wxChar *wxDataObject::GetFormatName(wxDataFormat format)
716{
717 // case 'xxx' is not a valid value for switch of enum 'wxDataFormat'
718 #ifdef __VISUALC__
719 #pragma warning(disable:4063)
720 #endif // VC++
721
722 static wxChar s_szBuf[256];
723 switch ( format ) {
724 case CF_TEXT: return wxT("CF_TEXT");
725 case CF_BITMAP: return wxT("CF_BITMAP");
726 case CF_SYLK: return wxT("CF_SYLK");
727 case CF_DIF: return wxT("CF_DIF");
728 case CF_TIFF: return wxT("CF_TIFF");
729 case CF_OEMTEXT: return wxT("CF_OEMTEXT");
730 case CF_DIB: return wxT("CF_DIB");
731 case CF_PALETTE: return wxT("CF_PALETTE");
732 case CF_PENDATA: return wxT("CF_PENDATA");
733 case CF_RIFF: return wxT("CF_RIFF");
734 case CF_WAVE: return wxT("CF_WAVE");
735 case CF_UNICODETEXT: return wxT("CF_UNICODETEXT");
736#ifndef __WXWINCE__
737 case CF_METAFILEPICT: return wxT("CF_METAFILEPICT");
738 case CF_ENHMETAFILE: return wxT("CF_ENHMETAFILE");
739 case CF_LOCALE: return wxT("CF_LOCALE");
740 case CF_HDROP: return wxT("CF_HDROP");
741#endif
742
743 default:
744 if ( !::GetClipboardFormatName(format, s_szBuf, WXSIZEOF(s_szBuf)) )
745 {
746 // it must be a new predefined format we don't know the name of
747 wxSprintf(s_szBuf, wxT("unknown CF (0x%04x)"), format.GetFormatId());
748 }
749
750 return s_szBuf;
751 }
752
753 #ifdef __VISUALC__
754 #pragma warning(default:4063)
755 #endif // VC++
756}
757
758#endif // Debug
759
760// ----------------------------------------------------------------------------
761// wxBitmapDataObject supports CF_DIB format
762// ----------------------------------------------------------------------------
763
764// TODO: support CF_DIB under Windows CE as well
765
766size_t wxBitmapDataObject::GetDataSize() const
767{
768#if wxUSE_WXDIB && !defined(__WXWINCE__)
769 return wxDIB::ConvertFromBitmap(NULL, GetHbitmapOf(GetBitmap()));
770#else
771 return 0;
772#endif
773}
774
775bool wxBitmapDataObject::GetDataHere(void *buf) const
776{
777#if wxUSE_WXDIB && !defined(__WXWINCE__)
778 BITMAPINFO * const pbi = (BITMAPINFO *)buf;
779
780 return wxDIB::ConvertFromBitmap(pbi, GetHbitmapOf(GetBitmap())) != 0;
781#else
782 wxUnusedVar(buf);
783 return false;
784#endif
785}
786
787bool wxBitmapDataObject::SetData(size_t WXUNUSED(len), const void *buf)
788{
789#if wxUSE_WXDIB && !defined(__WXWINCE__)
790 const BITMAPINFO * const pbmi = (const BITMAPINFO *)buf;
791
792 HBITMAP hbmp = wxDIB::ConvertToBitmap(pbmi);
793
794 wxCHECK_MSG( hbmp, FALSE, wxT("pasting/dropping invalid bitmap") );
795
796 const BITMAPINFOHEADER * const pbmih = &pbmi->bmiHeader;
797 wxBitmap bitmap(pbmih->biWidth, pbmih->biHeight, pbmih->biBitCount);
798 bitmap.SetHBITMAP((WXHBITMAP)hbmp);
799
800 // TODO: create wxPalette if the bitmap has any
801
802 SetBitmap(bitmap);
803
804 return true;
805#else
806 wxUnusedVar(buf);
807 return false;
808#endif
809}
810
811// ----------------------------------------------------------------------------
812// wxBitmapDataObject2 supports CF_BITMAP format
813// ----------------------------------------------------------------------------
814
815// the bitmaps aren't passed by value as other types of data (i.e. by copying
816// the data into a global memory chunk and passing it to the clipboard or
817// another application or whatever), but by handle, so these generic functions
818// don't make much sense to them.
819
820size_t wxBitmapDataObject2::GetDataSize() const
821{
822 return 0;
823}
824
825bool wxBitmapDataObject2::GetDataHere(void *pBuf) const
826{
827 // we put a bitmap handle into pBuf
828 *(WXHBITMAP *)pBuf = GetBitmap().GetHBITMAP();
829
830 return true;
831}
832
833bool wxBitmapDataObject2::SetData(size_t WXUNUSED(len), const void *pBuf)
834{
835 HBITMAP hbmp = *(HBITMAP *)pBuf;
836
837 BITMAP bmp;
838 if ( !GetObject(hbmp, sizeof(BITMAP), &bmp) )
839 {
840 wxLogLastError(wxT("GetObject(HBITMAP)"));
841 }
842
843 wxBitmap bitmap(bmp.bmWidth, bmp.bmHeight, bmp.bmPlanes);
844 bitmap.SetHBITMAP((WXHBITMAP)hbmp);
845
846 if ( !bitmap.Ok() ) {
847 wxFAIL_MSG(wxT("pasting/dropping invalid bitmap"));
848
849 return false;
850 }
851
852 SetBitmap(bitmap);
853
854 return true;
855}
856
857#if 0
858
859size_t wxBitmapDataObject::GetDataSize(const wxDataFormat& format) const
860{
861 if ( format.GetFormatId() == CF_DIB )
862 {
863 // create the DIB
864 ScreenHDC hdc;
865
866 // shouldn't be selected into a DC or GetDIBits() would fail
867 wxASSERT_MSG( !m_bitmap.GetSelectedInto(),
868 wxT("can't copy bitmap selected into wxMemoryDC") );
869
870 // first get the info
871 BITMAPINFO bi;
872 if ( !GetDIBits(hdc, (HBITMAP)m_bitmap.GetHBITMAP(), 0, 0,
873 NULL, &bi, DIB_RGB_COLORS) )
874 {
875 wxLogLastError(wxT("GetDIBits(NULL)"));
876
877 return 0;
878 }
879
880 return sizeof(BITMAPINFO) + bi.bmiHeader.biSizeImage;
881 }
882 else // CF_BITMAP
883 {
884 // no data to copy - we don't pass HBITMAP via global memory
885 return 0;
886 }
887}
888
889bool wxBitmapDataObject::GetDataHere(const wxDataFormat& format,
890 void *pBuf) const
891{
892 wxASSERT_MSG( m_bitmap.Ok(), wxT("copying invalid bitmap") );
893
894 HBITMAP hbmp = (HBITMAP)m_bitmap.GetHBITMAP();
895 if ( format.GetFormatId() == CF_DIB )
896 {
897 // create the DIB
898 ScreenHDC hdc;
899
900 // shouldn't be selected into a DC or GetDIBits() would fail
901 wxASSERT_MSG( !m_bitmap.GetSelectedInto(),
902 wxT("can't copy bitmap selected into wxMemoryDC") );
903
904 // first get the info
905 BITMAPINFO *pbi = (BITMAPINFO *)pBuf;
906 if ( !GetDIBits(hdc, hbmp, 0, 0, NULL, pbi, DIB_RGB_COLORS) )
907 {
908 wxLogLastError(wxT("GetDIBits(NULL)"));
909
910 return 0;
911 }
912
913 // and now copy the bits
914 if ( !GetDIBits(hdc, hbmp, 0, pbi->bmiHeader.biHeight, pbi + 1,
915 pbi, DIB_RGB_COLORS) )
916 {
917 wxLogLastError(wxT("GetDIBits"));
918
919 return false;
920 }
921 }
922 else // CF_BITMAP
923 {
924 // we put a bitmap handle into pBuf
925 *(HBITMAP *)pBuf = hbmp;
926 }
927
928 return true;
929}
930
931bool wxBitmapDataObject::SetData(const wxDataFormat& format,
932 size_t size, const void *pBuf)
933{
934 HBITMAP hbmp;
935 if ( format.GetFormatId() == CF_DIB )
936 {
937 // here we get BITMAPINFO struct followed by the actual bitmap bits and
938 // BITMAPINFO starts with BITMAPINFOHEADER followed by colour info
939 ScreenHDC hdc;
940
941 BITMAPINFO *pbmi = (BITMAPINFO *)pBuf;
942 BITMAPINFOHEADER *pbmih = &pbmi->bmiHeader;
943 hbmp = CreateDIBitmap(hdc, pbmih, CBM_INIT,
944 pbmi + 1, pbmi, DIB_RGB_COLORS);
945 if ( !hbmp )
946 {
947 wxLogLastError(wxT("CreateDIBitmap"));
948 }
949
950 m_bitmap.SetWidth(pbmih->biWidth);
951 m_bitmap.SetHeight(pbmih->biHeight);
952 }
953 else // CF_BITMAP
954 {
955 // it's easy with bitmaps: we pass them by handle
956 hbmp = *(HBITMAP *)pBuf;
957
958 BITMAP bmp;
959 if ( !GetObject(hbmp, sizeof(BITMAP), &bmp) )
960 {
961 wxLogLastError(wxT("GetObject(HBITMAP)"));
962 }
963
964 m_bitmap.SetWidth(bmp.bmWidth);
965 m_bitmap.SetHeight(bmp.bmHeight);
966 m_bitmap.SetDepth(bmp.bmPlanes);
967 }
968
969 m_bitmap.SetHBITMAP((WXHBITMAP)hbmp);
970
971 wxASSERT_MSG( m_bitmap.Ok(), wxT("pasting invalid bitmap") );
972
973 return true;
974}
975
976#endif // 0
977
978// ----------------------------------------------------------------------------
979// wxFileDataObject
980// ----------------------------------------------------------------------------
981
982bool wxFileDataObject::SetData(size_t WXUNUSED(size), const void *pData)
983{
984#ifndef __WXWINCE__
985 m_filenames.Empty();
986
987 // the documentation states that the first member of DROPFILES structure is
988 // a "DWORD offset of double NUL terminated file list". What they mean by
989 // this (I wonder if you see it immediately) is that the list starts at
990 // ((char *)&(pDropFiles.pFiles)) + pDropFiles.pFiles. We're also advised
991 // to use DragQueryFile to work with this structure, but not told where and
992 // how to get HDROP.
993 HDROP hdrop = (HDROP)pData; // NB: it works, but I'm not sure about it
994
995 // get number of files (magic value -1)
996 UINT nFiles = ::DragQueryFile(hdrop, (unsigned)-1, NULL, 0u);
997
998 wxCHECK_MSG ( nFiles != (UINT)-1, FALSE, wxT("wrong HDROP handle") );
999
1000 // for each file get the length, allocate memory and then get the name
1001 wxString str;
1002 UINT len, n;
1003 for ( n = 0; n < nFiles; n++ ) {
1004 // +1 for terminating NUL
1005 len = ::DragQueryFile(hdrop, n, NULL, 0) + 1;
1006
1007 UINT len2 = ::DragQueryFile(hdrop, n, wxStringBuffer(str, len), len);
1008 m_filenames.Add(str);
1009
1010 if ( len2 != len - 1 ) {
1011 wxLogDebug(wxT("In wxFileDropTarget::OnDrop DragQueryFile returned\
1012 %d characters, %d expected."), len2, len - 1);
1013 }
1014 }
1015
1016 return true;
1017#else
1018 wxUnusedVar(pData);
1019 return false;
1020#endif
1021}
1022
1023void wxFileDataObject::AddFile(const wxString& file)
1024{
1025 // just add file to filenames array
1026 // all useful data (such as DROPFILES struct) will be
1027 // created later as necessary
1028 m_filenames.Add(file);
1029}
1030
1031size_t wxFileDataObject::GetDataSize() const
1032{
1033#ifndef __WXWINCE__
1034 // size returned will be the size of the DROPFILES structure,
1035 // plus the list of filesnames (null byte separated), plus
1036 // a double null at the end
1037
1038 // if no filenames in list, size is 0
1039 if ( m_filenames.GetCount() == 0 )
1040 return 0;
1041
1042 // inital size of DROPFILES struct + null byte
1043 size_t sz = sizeof(DROPFILES) + (1 * sizeof(wxChar));
1044
1045 size_t count = m_filenames.GetCount();
1046 for ( size_t i = 0; i < count; i++ )
1047 {
1048 // add filename length plus null byte
1049 sz += (m_filenames[i].Len() + 1) * sizeof(wxChar);
1050 }
1051
1052 return sz;
1053#else
1054 return 0;
1055#endif
1056}
1057
1058bool wxFileDataObject::GetDataHere(void *pData) const
1059{
1060#ifndef __WXWINCE__
1061 // pData points to an externally allocated memory block
1062 // created using the size returned by GetDataSize()
1063
1064 // if pData is NULL, or there are no files, return
1065 if ( !pData || m_filenames.GetCount() == 0 )
1066 return false;
1067
1068 // convert data pointer to a DROPFILES struct pointer
1069 LPDROPFILES pDrop = (LPDROPFILES) pData;
1070
1071 // initialize DROPFILES struct
1072 pDrop->pFiles = sizeof(DROPFILES);
1073 pDrop->fNC = FALSE; // not non-client coords
1074#if wxUSE_UNICODE
1075 pDrop->fWide = TRUE;
1076#else // ANSI
1077 pDrop->fWide = FALSE;
1078#endif // Unicode/Ansi
1079
1080 // set start of filenames list (null separated)
1081 wxChar *pbuf = (wxChar*) ((BYTE *)pDrop + sizeof(DROPFILES));
1082
1083 size_t count = m_filenames.GetCount();
1084 for (size_t i = 0; i < count; i++ )
1085 {
1086 // copy filename to pbuf and add null terminator
1087 size_t len = m_filenames[i].Len();
1088 memcpy(pbuf, m_filenames[i], len*sizeof(wxChar));
1089 pbuf += len;
1090 *pbuf++ = wxT('\0');
1091 }
1092
1093 // add final null terminator
1094 *pbuf = wxT('\0');
1095
1096 return true;
1097#else
1098 wxUnusedVar(pData);
1099 return false;
1100#endif
1101}
1102
1103// ----------------------------------------------------------------------------
1104// wxURLDataObject
1105// ----------------------------------------------------------------------------
1106
1107class CFSTR_SHELLURLDataObject : public wxCustomDataObject
1108{
1109public:
1110 CFSTR_SHELLURLDataObject() : wxCustomDataObject(CFSTR_SHELLURL) {}
1111protected:
1112 virtual size_t GetBufferOffset( const wxDataFormat& WXUNUSED(format) )
1113 {
1114 return 0;
1115 }
1116
1117 virtual const void* GetSizeFromBuffer( const void* buffer, size_t* size,
1118 const wxDataFormat& WXUNUSED(format) )
1119 {
1120 // CFSTR_SHELLURL is _always_ ANSI text
1121 *size = strlen( (const char*)buffer );
1122
1123 return buffer;
1124 }
1125
1126 virtual void* SetSizeInBuffer( void* buffer, size_t WXUNUSED(size),
1127 const wxDataFormat& WXUNUSED(format) )
1128 {
1129 return buffer;
1130 }
1131
1132#if wxUSE_UNICODE
1133 virtual bool GetDataHere( void* buffer ) const
1134 {
1135 // CFSTR_SHELLURL is _always_ ANSI!
1136 wxCharBuffer char_buffer( GetDataSize() );
1137 wxCustomDataObject::GetDataHere( (void*)char_buffer.data() );
1138 wxString unicode_buffer( char_buffer, wxConvLibc );
1139 memcpy( buffer, unicode_buffer.c_str(),
1140 ( unicode_buffer.length() + 1 ) * sizeof(wxChar) );
1141
1142 return true;
1143 }
1144 virtual bool GetDataHere(const wxDataFormat& WXUNUSED(format),
1145 void *buf) const
1146 { return GetDataHere(buf); }
1147#endif
1148
1149 DECLARE_NO_COPY_CLASS(CFSTR_SHELLURLDataObject)
1150};
1151
1152
1153
1154wxURLDataObject::wxURLDataObject()
1155{
1156 // we support CF_TEXT and CFSTR_SHELLURL formats which are basicly the same
1157 // but it seems that some browsers only provide one of them so we have to
1158 // support both
1159 Add(new wxTextDataObject);
1160 Add(new CFSTR_SHELLURLDataObject());
1161
1162 // we don't have any data yet
1163 m_dataObjectLast = NULL;
1164}
1165
1166bool wxURLDataObject::SetData(const wxDataFormat& format,
1167 size_t len,
1168 const void *buf)
1169{
1170 m_dataObjectLast = GetObject(format);
1171
1172 wxCHECK_MSG( m_dataObjectLast, FALSE,
1173 wxT("unsupported format in wxURLDataObject"));
1174
1175 return m_dataObjectLast->SetData(len, buf);
1176}
1177
1178wxString wxURLDataObject::GetURL() const
1179{
1180 wxString url;
1181 wxCHECK_MSG( m_dataObjectLast, url, _T("no data in wxURLDataObject") );
1182
1183 size_t len = m_dataObjectLast->GetDataSize();
1184
1185 m_dataObjectLast->GetDataHere(wxStringBuffer(url, len));
1186
1187 return url;
1188}
1189
1190void wxURLDataObject::SetURL(const wxString& url)
1191{
1192 SetData(wxDataFormat(wxUSE_UNICODE ? wxDF_UNICODETEXT : wxDF_TEXT),
1193 url.Length()+1, url.c_str());
1194
1195 // CFSTR_SHELLURL is always supposed to be ANSI...
1196 wxWX2MBbuf urlA = (wxWX2MBbuf)url.mbc_str();
1197 size_t len = strlen(urlA);
1198 SetData(wxDataFormat(CFSTR_SHELLURL), len+1, (const char*)urlA);
1199}
1200
1201// ----------------------------------------------------------------------------
1202// private functions
1203// ----------------------------------------------------------------------------
1204
1205#ifdef __WXDEBUG__
1206
1207static const wxChar *GetTymedName(DWORD tymed)
1208{
1209 static wxChar s_szBuf[128];
1210 switch ( tymed ) {
1211 case TYMED_HGLOBAL: return wxT("TYMED_HGLOBAL");
1212 case TYMED_FILE: return wxT("TYMED_FILE");
1213 case TYMED_ISTREAM: return wxT("TYMED_ISTREAM");
1214 case TYMED_ISTORAGE: return wxT("TYMED_ISTORAGE");
1215 case TYMED_GDI: return wxT("TYMED_GDI");
1216 case TYMED_MFPICT: return wxT("TYMED_MFPICT");
1217 case TYMED_ENHMF: return wxT("TYMED_ENHMF");
1218 default:
1219 wxSprintf(s_szBuf, wxT("type of media format %ld (unknown)"), tymed);
1220 return s_szBuf;
1221 }
1222}
1223
1224#endif // Debug
1225
1226#else // not using OLE at all
1227
1228// ----------------------------------------------------------------------------
1229// wxDataObject
1230// ----------------------------------------------------------------------------
1231
1232#if wxUSE_DATAOBJ
1233
1234wxDataObject::wxDataObject()
1235{
1236}
1237
1238wxDataObject::~wxDataObject()
1239{
1240}
1241
1242void wxDataObject::SetAutoDelete()
1243{
1244}
1245
1246#ifdef __WXDEBUG__
1247const wxChar *wxDataObject::GetFormatName(wxDataFormat WXUNUSED(format))
1248{
1249 return NULL;
1250}
1251#endif // __WXDEBUG__
1252
1253#endif // wxUSE_DATAOBJ
1254
1255#endif // wxUSE_OLE/!wxUSE_OLE
1256
1257