]> git.saurik.com Git - wxWidgets.git/blob - src/msw/ole/dataobj.cpp
projects / wxWidgets.git / blob
? search:


73924fa3e2e2b01f3a3c453dd97b931ba0fc6f03
[wxWidgets.git] / src / msw / ole / dataobj.cpp
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
76 class wxIEnumFORMATETC : public IEnumFORMATETC
77 {
78 public:
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
90 private:
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
102 class wxIDataObject : public IDataObject
103 {
104 public:
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
126 private:
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
142 void 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
151 wxString 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
174 BEGIN_IID_TABLE(wxIEnumFORMATETC)
175 ADD_IID(Unknown)
176 ADD_IID(EnumFORMATETC)
177 END_IID_TABLE;
178
179 IMPLEMENT_IUNKNOWN_METHODS(wxIEnumFORMATETC)
180
181 wxIEnumFORMATETC::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
191 STDMETHODIMP 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
216 STDMETHODIMP 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
230 STDMETHODIMP wxIEnumFORMATETC::Reset()
231 {
232 wxLogTrace(wxTRACE_OleCalls, wxT("wxIEnumFORMATETC::Reset"));
233
234 m_nCurrent = 0;
235
236 return S_OK;
237 }
238
239 STDMETHODIMP 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
260 BEGIN_IID_TABLE(wxIDataObject)
261 ADD_IID(Unknown)
262 ADD_IID(DataObject)
263 END_IID_TABLE;
264
265 IMPLEMENT_IUNKNOWN_METHODS(wxIDataObject)
266
267 wxIDataObject::wxIDataObject(wxDataObject *pDataObject)
268 {
269 m_pDataObject = pDataObject;
270 m_mustDelete = false;
271 }
272
273 wxIDataObject::~wxIDataObject()
274 {
275 if ( m_mustDelete )
276 {
277 delete m_pDataObject;
278 }
279 }
280
281 // get data functions
282 STDMETHODIMP 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
361 STDMETHODIMP 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
415 STDMETHODIMP 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
548 STDMETHODIMP 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
607 STDMETHODIMP 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
619 STDMETHODIMP 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
648 STDMETHODIMP 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
656 STDMETHODIMP wxIDataObject::DUnadvise(DWORD WXUNUSED(dwConnection))
657 {
658 return OLE_E_ADVISENOTSUPPORTED;
659 }
660
661 STDMETHODIMP wxIDataObject::EnumDAdvise(IEnumSTATDATA **WXUNUSED(ppenumAdvise))
662 {
663 return OLE_E_ADVISENOTSUPPORTED;
664 }
665
666 // ----------------------------------------------------------------------------
667 // wxDataObject
668 // ----------------------------------------------------------------------------
669
670 wxDataObject::wxDataObject()
671 {
672 m_pIDataObject = new wxIDataObject(this);
673 m_pIDataObject->AddRef();
674 }
675
676 wxDataObject::~wxDataObject()
677 {
678 ReleaseInterface(m_pIDataObject);
679 }
680
681 void 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
690 size_t wxDataObject::GetBufferOffset( const wxDataFormat& WXUNUSED(format) )
691 {
692 return sizeof(size_t);
693 }
694
695 const 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
704 void* 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
715 const 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
766 size_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
775 bool 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
787 bool 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
820 size_t wxBitmapDataObject2::GetDataSize() const
821 {
822 return 0;
823 }
824
825 bool 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
833 bool 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
859 size_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
889 bool 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
931 bool 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
982 bool wxFileDataObject::SetData(size_t WXUNUSED(size),
983 const void *WXUNUSED_IN_WINCE(pData))
984 {
985 #ifndef __WXWINCE__
986 m_filenames.Empty();
987
988 // the documentation states that the first member of DROPFILES structure is
989 // a "DWORD offset of double NUL terminated file list". What they mean by
990 // this (I wonder if you see it immediately) is that the list starts at
991 // ((char *)&(pDropFiles.pFiles)) + pDropFiles.pFiles. We're also advised
992 // to use DragQueryFile to work with this structure, but not told where and
993 // how to get HDROP.
994 HDROP hdrop = (HDROP)pData; // NB: it works, but I'm not sure about it
995
996 // get number of files (magic value -1)
997 UINT nFiles = ::DragQueryFile(hdrop, (unsigned)-1, NULL, 0u);
998
999 wxCHECK_MSG ( nFiles != (UINT)-1, FALSE, wxT("wrong HDROP handle") );
1000
1001 // for each file get the length, allocate memory and then get the name
1002 wxString str;
1003 UINT len, n;
1004 for ( n = 0; n < nFiles; n++ ) {
1005 // +1 for terminating NUL
1006 len = ::DragQueryFile(hdrop, n, NULL, 0) + 1;
1007
1008 UINT len2 = ::DragQueryFile(hdrop, n, wxStringBuffer(str, len), len);
1009 m_filenames.Add(str);
1010
1011 if ( len2 != len - 1 ) {
1012 wxLogDebug(wxT("In wxFileDropTarget::OnDrop DragQueryFile returned\
1013 %d characters, %d expected."), len2, len - 1);
1014 }
1015 }
1016
1017 return true;
1018 #else
1019 return false;
1020 #endif
1021 }
1022
1023 void 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
1031 size_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
1058 bool wxFileDataObject::GetDataHere(void *WXUNUSED_IN_WINCE(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 return false;
1099 #endif
1100 }
1101
1102 // ----------------------------------------------------------------------------
1103 // wxURLDataObject
1104 // ----------------------------------------------------------------------------
1105
1106 class CFSTR_SHELLURLDataObject : public wxCustomDataObject
1107 {
1108 public:
1109 CFSTR_SHELLURLDataObject() : wxCustomDataObject(CFSTR_SHELLURL) {}
1110 protected:
1111 virtual size_t GetBufferOffset( const wxDataFormat& WXUNUSED(format) )
1112 {
1113 return 0;
1114 }
1115
1116 virtual const void* GetSizeFromBuffer( const void* buffer, size_t* size,
1117 const wxDataFormat& WXUNUSED(format) )
1118 {
1119 // CFSTR_SHELLURL is _always_ ANSI text
1120 *size = strlen( (const char*)buffer );
1121
1122 return buffer;
1123 }
1124
1125 virtual void* SetSizeInBuffer( void* buffer, size_t WXUNUSED(size),
1126 const wxDataFormat& WXUNUSED(format) )
1127 {
1128 return buffer;
1129 }
1130
1131 #if wxUSE_UNICODE
1132 virtual bool GetDataHere( void* buffer ) const
1133 {
1134 // CFSTR_SHELLURL is _always_ ANSI!
1135 wxCharBuffer char_buffer( GetDataSize() );
1136 wxCustomDataObject::GetDataHere( (void*)char_buffer.data() );
1137 wxString unicode_buffer( char_buffer, wxConvLibc );
1138 memcpy( buffer, unicode_buffer.c_str(),
1139 ( unicode_buffer.length() + 1 ) * sizeof(wxChar) );
1140
1141 return true;
1142 }
1143 virtual bool GetDataHere(const wxDataFormat& WXUNUSED(format),
1144 void *buf) const
1145 { return GetDataHere(buf); }
1146 #endif
1147
1148 DECLARE_NO_COPY_CLASS(CFSTR_SHELLURLDataObject)
1149 };
1150
1151
1152
1153 wxURLDataObject::wxURLDataObject()
1154 {
1155 // we support CF_TEXT and CFSTR_SHELLURL formats which are basicly the same
1156 // but it seems that some browsers only provide one of them so we have to
1157 // support both
1158 Add(new wxTextDataObject);
1159 Add(new CFSTR_SHELLURLDataObject());
1160
1161 // we don't have any data yet
1162 m_dataObjectLast = NULL;
1163 }
1164
1165 bool wxURLDataObject::SetData(const wxDataFormat& format,
1166 size_t len,
1167 const void *buf)
1168 {
1169 m_dataObjectLast = GetObject(format);
1170
1171 wxCHECK_MSG( m_dataObjectLast, FALSE,
1172 wxT("unsupported format in wxURLDataObject"));
1173
1174 return m_dataObjectLast->SetData(len, buf);
1175 }
1176
1177 wxString wxURLDataObject::GetURL() const
1178 {
1179 wxString url;
1180 wxCHECK_MSG( m_dataObjectLast, url, _T("no data in wxURLDataObject") );
1181
1182 size_t len = m_dataObjectLast->GetDataSize();
1183
1184 m_dataObjectLast->GetDataHere(wxStringBuffer(url, len));
1185
1186 return url;
1187 }
1188
1189 void wxURLDataObject::SetURL(const wxString& url)
1190 {
1191 SetData(wxDataFormat(wxUSE_UNICODE ? wxDF_UNICODETEXT : wxDF_TEXT),
1192 url.Length()+1, url.c_str());
1193
1194 // CFSTR_SHELLURL is always supposed to be ANSI...
1195 wxWX2MBbuf urlA = (wxWX2MBbuf)url.mbc_str();
1196 size_t len = strlen(urlA);
1197 SetData(wxDataFormat(CFSTR_SHELLURL), len+1, (const char*)urlA);
1198 }
1199
1200 // ----------------------------------------------------------------------------
1201 // private functions
1202 // ----------------------------------------------------------------------------
1203
1204 #ifdef __WXDEBUG__
1205
1206 static const wxChar *GetTymedName(DWORD tymed)
1207 {
1208 static wxChar s_szBuf[128];
1209 switch ( tymed ) {
1210 case TYMED_HGLOBAL: return wxT("TYMED_HGLOBAL");
1211 case TYMED_FILE: return wxT("TYMED_FILE");
1212 case TYMED_ISTREAM: return wxT("TYMED_ISTREAM");
1213 case TYMED_ISTORAGE: return wxT("TYMED_ISTORAGE");
1214 case TYMED_GDI: return wxT("TYMED_GDI");
1215 case TYMED_MFPICT: return wxT("TYMED_MFPICT");
1216 case TYMED_ENHMF: return wxT("TYMED_ENHMF");
1217 default:
1218 wxSprintf(s_szBuf, wxT("type of media format %ld (unknown)"), tymed);
1219 return s_szBuf;
1220 }
1221 }
1222
1223 #endif // Debug
1224
1225 #else // not using OLE at all
1226
1227 // ----------------------------------------------------------------------------
1228 // wxDataObject
1229 // ----------------------------------------------------------------------------
1230
1231 #if wxUSE_DATAOBJ
1232
1233 wxDataObject::wxDataObject()
1234 {
1235 }
1236
1237 wxDataObject::~wxDataObject()
1238 {
1239 }
1240
1241 void wxDataObject::SetAutoDelete()
1242 {
1243 }
1244
1245 #ifdef __WXDEBUG__
1246 const wxChar *wxDataObject::GetFormatName(wxDataFormat WXUNUSED(format))
1247 {
1248 return NULL;
1249 }
1250 #endif // __WXDEBUG__
1251
1252 #endif // wxUSE_DATAOBJ
1253
1254 #endif // wxUSE_OLE/!wxUSE_OLE
1255
1256
wxWidgets (Impactor)