new makefile
[wxWidgets.git] / src / msw / clipbrd.cpp
0 / 844 (  0%)
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: clipbrd.cpp
3// Purpose: Clipboard functionality
4// Author: Julian Smart
5// Modified by:
6// Created: 04/01/98
7// RCS-ID: $Id$
8// Copyright: (c) Julian Smart and Markus Holzem
9// Licence: wxWindows license
10/////////////////////////////////////////////////////////////////////////////
11
12// ===========================================================================
13// declarations
14// ===========================================================================
15
16// ---------------------------------------------------------------------------
17// headers
18// ---------------------------------------------------------------------------
19
20#ifdef __GNUG__
21 #pragma implementation "clipbrd.h"
22#endif
23
24// For compilers that support precompilation, includes "wx.h".
25#include "wx/wxprec.h"
26
27#ifdef __BORLANDC__
28 #pragma hdrstop
29#endif
30
31#ifndef WX_PRECOMP
32 #include "wx/setup.h"
33#endif
34
35#if wxUSE_CLIPBOARD
36
37#ifndef WX_PRECOMP
38 #include "wx/object.h"
39 #include "wx/event.h"
40 #include "wx/app.h"
41 #include "wx/frame.h"
42 #include "wx/bitmap.h"
43 #include "wx/utils.h"
44 #include "wx/intl.h"
45#endif
46
47#if wxUSE_METAFILE
48 #include "wx/metafile.h"
49#endif
50
51#include "wx/log.h"
52#include "wx/clipbrd.h"
53
54#include <string.h>
55#include <windows.h>
56
57#include "wx/msw/private.h"
58
59#ifndef __WXMICROWIN__
60#include "wx/msw/dib.h"
61#endif
62
63// wxDataObject is tied to OLE/drag and drop implementation, therefore so are
64// the functions using wxDataObject in wxClipboard
65//#define wxUSE_DATAOBJ wxUSE_DRAG_AND_DROP
66
67#if wxUSE_DATAOBJ
68 #include "wx/dataobj.h"
69#endif
70
71#if wxUSE_OLE
72 // use OLE clipboard
73 #define wxUSE_OLE_CLIPBOARD 1
74#else // !wxUSE_DATAOBJ
75 // use Win clipboard API
76 #define wxUSE_OLE_CLIPBOARD 0
77#endif
78
79#if wxUSE_OLE_CLIPBOARD
80 #include <ole2.h>
81#endif // wxUSE_OLE_CLIPBOARD
82
83#ifdef __WIN16__
84 #define memcpy hmemcpy
85#endif
86
87// ===========================================================================
88// implementation
89// ===========================================================================
90
91// ---------------------------------------------------------------------------
92// old-style clipboard functions using Windows API
93// ---------------------------------------------------------------------------
94
95static bool gs_wxClipboardIsOpen = FALSE;
96
97bool wxOpenClipboard()
98{
99 wxCHECK_MSG( !gs_wxClipboardIsOpen, TRUE, wxT("clipboard already opened.") );
100
101 wxWindow *win = wxTheApp->GetTopWindow();
102 if ( win )
103 {
104 gs_wxClipboardIsOpen = ::OpenClipboard((HWND)win->GetHWND()) != 0;
105
106 if ( !gs_wxClipboardIsOpen )
107 wxLogSysError(_("Failed to open the clipboard."));
108
109 return gs_wxClipboardIsOpen;
110 }
111 else
112 {
113 wxLogDebug(wxT("Can not open clipboard without a main window."));
114
115 return FALSE;
116 }
117}
118
119bool wxCloseClipboard()
120{
121 wxCHECK_MSG( gs_wxClipboardIsOpen, FALSE, wxT("clipboard is not opened") );
122
123 gs_wxClipboardIsOpen = FALSE;
124
125 if ( ::CloseClipboard() == 0 )
126 {
127 wxLogSysError(_("Failed to close the clipboard."));
128
129 return FALSE;
130 }
131
132 return TRUE;
133}
134
135bool wxEmptyClipboard()
136{
137 if ( ::EmptyClipboard() == 0 )
138 {
139 wxLogSysError(_("Failed to empty the clipboard."));
140
141 return FALSE;
142 }
143
144 return TRUE;
145}
146
147bool wxIsClipboardOpened()
148{
149 return gs_wxClipboardIsOpen;
150}
151
152bool wxIsClipboardFormatAvailable(wxDataFormat dataFormat)
153{
154 if ( ::IsClipboardFormatAvailable(dataFormat) )
155 {
156 // ok from the first try
157 return TRUE;
158 }
159
160 // for several standard formats, we can convert from some other ones too
161 switch ( dataFormat.GetFormatId() )
162 {
163 // for bitmaps, DIBs will also do
164 case CF_BITMAP:
165 return ::IsClipboardFormatAvailable(CF_DIB) != 0;
166
167#if wxUSE_ENH_METAFILE && !defined(__WIN16__)
168 case CF_METAFILEPICT:
169 return ::IsClipboardFormatAvailable(CF_ENHMETAFILE) != 0;
170#endif // wxUSE_ENH_METAFILE
171
172 default:
173 return FALSE;
174 }
175}
176
177bool wxSetClipboardData(wxDataFormat dataFormat,
178 const void *data,
179 int width, int height)
180{
181 HANDLE handle = 0; // return value of SetClipboardData
182
183 switch (dataFormat)
184 {
185 case wxDF_BITMAP:
186 {
187 wxBitmap *bitmap = (wxBitmap *)data;
188
189 HDC hdcMem = CreateCompatibleDC((HDC) NULL);
190 HDC hdcSrc = CreateCompatibleDC((HDC) NULL);
191 HBITMAP old = (HBITMAP)
192 ::SelectObject(hdcSrc, (HBITMAP)bitmap->GetHBITMAP());
193 HBITMAP hBitmap = CreateCompatibleBitmap(hdcSrc,
194 bitmap->GetWidth(),
195 bitmap->GetHeight());
196 if (!hBitmap)
197 {
198 SelectObject(hdcSrc, old);
199 DeleteDC(hdcMem);
200 DeleteDC(hdcSrc);
201 return FALSE;
202 }
203
204 HBITMAP old1 = (HBITMAP) SelectObject(hdcMem, hBitmap);
205 BitBlt(hdcMem, 0, 0, bitmap->GetWidth(), bitmap->GetHeight(),
206 hdcSrc, 0, 0, SRCCOPY);
207
208 // Select new bitmap out of memory DC
209 SelectObject(hdcMem, old1);
210
211 // Set the data
212 handle = ::SetClipboardData(CF_BITMAP, hBitmap);
213
214 // Clean up
215 SelectObject(hdcSrc, old);
216 DeleteDC(hdcSrc);
217 DeleteDC(hdcMem);
218 break;
219 }
220
221 case wxDF_DIB:
222 {
223#if wxUSE_IMAGE_LOADING_IN_MSW
224 wxBitmap *bitmap = (wxBitmap *)data;
225 HBITMAP hBitmap = (HBITMAP)bitmap->GetHBITMAP();
226 // NULL palette means to use the system one
227 HANDLE hDIB = wxBitmapToDIB(hBitmap, (HPALETTE)NULL);
228 handle = SetClipboardData(CF_DIB, hDIB);
229#endif // wxUSE_IMAGE_LOADING_IN_MSW
230 break;
231 }
232
233 // VZ: I'm told that this code works, but it doesn't seem to work for me
234 // and, anyhow, I'd be highly surprized if it did. So I leave it here
235 // but IMNSHO it is completely broken.
236#if wxUSE_METAFILE && !defined(wxMETAFILE_IS_ENH)
237 case wxDF_METAFILE:
238 {
239 wxMetafile *wxMF = (wxMetafile *)data;
240 HANDLE data = GlobalAlloc(GHND, sizeof(METAFILEPICT) + 1);
241 METAFILEPICT *mf = (METAFILEPICT *)GlobalLock(data);
242
243 mf->mm = wxMF->GetWindowsMappingMode();
244 mf->xExt = width;
245 mf->yExt = height;
246 mf->hMF = (HMETAFILE) wxMF->GetHMETAFILE();
247 GlobalUnlock(data);
248 wxMF->SetHMETAFILE((WXHANDLE) NULL);
249
250 handle = SetClipboardData(CF_METAFILEPICT, data);
251 break;
252 }
253#endif // wxUSE_METAFILE
254
255#if wxUSE_ENH_METAFILE && !defined(__WIN16__)
256 case wxDF_ENHMETAFILE:
257 {
258 wxEnhMetaFile *emf = (wxEnhMetaFile *)data;
259 wxEnhMetaFile emfCopy = *emf;
260
261 handle = SetClipboardData(CF_ENHMETAFILE,
262 (void *)emfCopy.GetHENHMETAFILE());
263 }
264 break;
265#endif // wxUSE_ENH_METAFILE
266
267 case CF_SYLK:
268 case CF_DIF:
269 case CF_TIFF:
270 case CF_PALETTE:
271 default:
272 {
273 wxLogError(_("Unsupported clipboard format."));
274 return FALSE;
275 }
276
277 case wxDF_OEMTEXT:
278 dataFormat = wxDF_TEXT;
279 // fall through
280
281 case wxDF_TEXT:
282 {
283 char *s = (char *)data;
284
285 width = strlen(s) + 1;
286 height = 1;
287 DWORD l = (width * height);
288 HANDLE hGlobalMemory = GlobalAlloc(GHND, l);
289 if ( hGlobalMemory )
290 {
291 LPSTR lpGlobalMemory = (LPSTR)GlobalLock(hGlobalMemory);
292
293 memcpy(lpGlobalMemory, s, l);
294
295 GlobalUnlock(hGlobalMemory);
296 }
297
298 handle = SetClipboardData(dataFormat, hGlobalMemory);
299 break;
300 }
301 }
302
303 if ( handle == 0 )
304 {
305 wxLogSysError(_("Failed to set clipboard data."));
306
307 return FALSE;
308 }
309
310 return TRUE;
311}
312
313void *wxGetClipboardData(wxDataFormat dataFormat, long *len)
314{
315 void *retval = NULL;
316
317 switch ( dataFormat )
318 {
319 case wxDF_BITMAP:
320 {
321 BITMAP bm;
322 HBITMAP hBitmap = (HBITMAP) GetClipboardData(CF_BITMAP);
323 if (!hBitmap)
324 break;
325
326 HDC hdcMem = CreateCompatibleDC((HDC) NULL);
327 HDC hdcSrc = CreateCompatibleDC((HDC) NULL);
328
329 HBITMAP old = (HBITMAP) ::SelectObject(hdcSrc, hBitmap);
330 GetObject(hBitmap, sizeof(BITMAP), (LPSTR)&bm);
331
332 HBITMAP hNewBitmap = CreateBitmapIndirect(&bm);
333
334 if (!hNewBitmap)
335 {
336 SelectObject(hdcSrc, old);
337 DeleteDC(hdcMem);
338 DeleteDC(hdcSrc);
339 break;
340 }
341
342 HBITMAP old1 = (HBITMAP) SelectObject(hdcMem, hNewBitmap);
343 BitBlt(hdcMem, 0, 0, bm.bmWidth, bm.bmHeight,
344 hdcSrc, 0, 0, SRCCOPY);
345
346 // Select new bitmap out of memory DC
347 SelectObject(hdcMem, old1);
348
349 // Clean up
350 SelectObject(hdcSrc, old);
351 DeleteDC(hdcSrc);
352 DeleteDC(hdcMem);
353
354 // Create and return a new wxBitmap
355 wxBitmap *wxBM = new wxBitmap;
356 wxBM->SetHBITMAP((WXHBITMAP) hNewBitmap);
357 wxBM->SetWidth(bm.bmWidth);
358 wxBM->SetHeight(bm.bmHeight);
359 wxBM->SetDepth(bm.bmPlanes);
360#if WXWIN_COMPATIBILITY_2
361 wxBM->SetOk(TRUE);
362#endif // WXWIN_COMPATIBILITY_2
363 retval = wxBM;
364 break;
365 }
366
367 case wxDF_METAFILE:
368 case CF_SYLK:
369 case CF_DIF:
370 case CF_TIFF:
371 case CF_PALETTE:
372 case wxDF_DIB:
373 {
374 wxLogError(_("Unsupported clipboard format."));
375 return FALSE;
376 }
377
378 case wxDF_OEMTEXT:
379 dataFormat = wxDF_TEXT;
380 // fall through
381
382 case wxDF_TEXT:
383 {
384 HANDLE hGlobalMemory = ::GetClipboardData(dataFormat);
385 if (!hGlobalMemory)
386 break;
387
388 DWORD hsize = ::GlobalSize(hGlobalMemory);
389 if (len)
390 *len = hsize;
391
392 char *s = new char[hsize];
393 if (!s)
394 break;
395
396 LPSTR lpGlobalMemory = (LPSTR)::GlobalLock(hGlobalMemory);
397
398 memcpy(s, lpGlobalMemory, hsize);
399
400 ::GlobalUnlock(hGlobalMemory);
401
402 retval = s;
403 break;
404 }
405
406 default:
407 {
408 HANDLE hGlobalMemory = ::GetClipboardData(dataFormat);
409 if ( !hGlobalMemory )
410 break;
411
412 DWORD size = ::GlobalSize(hGlobalMemory);
413 if ( len )
414 *len = size;
415
416 void *buf = malloc(size);
417 if ( !buf )
418 break;
419
420 LPSTR lpGlobalMemory = (LPSTR)::GlobalLock(hGlobalMemory);
421
422 memcpy(buf, lpGlobalMemory, size);
423
424 ::GlobalUnlock(hGlobalMemory);
425
426 retval = buf;
427 break;
428 }
429 }
430
431 if ( !retval )
432 {
433 wxLogSysError(_("Failed to retrieve data from the clipboard."));
434 }
435
436 return retval;
437}
438
439wxDataFormat wxEnumClipboardFormats(wxDataFormat dataFormat)
440{
441 return (wxDataFormat::NativeFormat)::EnumClipboardFormats(dataFormat);
442}
443
444int wxRegisterClipboardFormat(wxChar *formatName)
445{
446 return ::RegisterClipboardFormat(formatName);
447}
448
449bool wxGetClipboardFormatName(wxDataFormat dataFormat,
450 wxChar *formatName,
451 int maxCount)
452{
453 return ::GetClipboardFormatName((int)dataFormat, formatName, maxCount) > 0;
454}
455
456// ---------------------------------------------------------------------------
457// wxClipboard
458// ---------------------------------------------------------------------------
459
460IMPLEMENT_DYNAMIC_CLASS(wxClipboard, wxObject)
461
462wxClipboard::wxClipboard()
463{
464 m_clearOnExit = FALSE;
465}
466
467wxClipboard::~wxClipboard()
468{
469 if ( m_clearOnExit )
470 {
471 Clear();
472 }
473}
474
475void wxClipboard::Clear()
476{
477#if wxUSE_OLE_CLIPBOARD
478 if ( FAILED(OleSetClipboard(NULL)) )
479 {
480 wxLogLastError(wxT("OleSetClipboard(NULL)"));
481 }
482#endif
483}
484
485bool wxClipboard::Flush()
486{
487#if wxUSE_OLE_CLIPBOARD
488 if ( FAILED(OleFlushClipboard()) )
489 {
490 wxLogLastError(wxT("OleFlushClipboard"));
491
492 return FALSE;
493 }
494 else
495 {
496 m_clearOnExit = FALSE;
497
498 return TRUE;
499 }
500#else // !wxUSE_OLE_CLIPBOARD
501 return FALSE;
502#endif // wxUSE_OLE_CLIPBOARD/!wxUSE_OLE_CLIPBOARD
503}
504
505bool wxClipboard::Open()
506{
507 // OLE opens clipboard for us
508#if wxUSE_OLE_CLIPBOARD
509 return TRUE;
510#else
511 return wxOpenClipboard();
512#endif
513}
514
515bool wxClipboard::IsOpened() const
516{
517#if wxUSE_OLE_CLIPBOARD
518 return TRUE;
519#else
520 return wxIsClipboardOpened();
521#endif
522}
523
524bool wxClipboard::SetData( wxDataObject *data )
525{
526#if !wxUSE_OLE_CLIPBOARD
527 (void)wxEmptyClipboard();
528#endif // wxUSE_OLE_CLIPBOARD
529
530 if ( data )
531 return AddData(data);
532 else
533 return TRUE;
534}
535
536bool wxClipboard::AddData( wxDataObject *data )
537{
538 wxCHECK_MSG( data, FALSE, wxT("data is invalid") );
539
540#if wxUSE_OLE_CLIPBOARD
541 HRESULT hr = OleSetClipboard(data->GetInterface());
542 if ( FAILED(hr) )
543 {
544 wxLogSysError(hr, _("Failed to put data on the clipboard"));
545
546 // don't free anything in this case
547
548 return FALSE;
549 }
550
551 // we have a problem here because we should delete wxDataObject, but we
552 // can't do it because IDataObject which we just gave to the clipboard
553 // would try to use it when it will need the data. IDataObject is ref
554 // counted and so doesn't suffer from such problem, so we release it now
555 // and tell it to delete wxDataObject when it is deleted itself.
556 data->SetAutoDelete();
557
558 // we have to call either OleSetClipboard(NULL) or OleFlushClipboard() when
559 // using OLE clipboard when the app terminates - by default, we call
560 // OleSetClipboard(NULL) which won't waste RAM, but the app can call
561 // wxClipboard::Flush() to chaneg this
562 m_clearOnExit = TRUE;
563
564 return TRUE;
565#elif wxUSE_DATAOBJ
566 wxCHECK_MSG( wxIsClipboardOpened(), FALSE, wxT("clipboard not open") );
567
568 wxDataFormat format = data->GetPreferredFormat();
569
570 switch ( format )
571 {
572 case wxDF_TEXT:
573 case wxDF_OEMTEXT:
574 {
575 wxTextDataObject* textDataObject = (wxTextDataObject*) data;
576 wxString str(textDataObject->GetText());
577 return wxSetClipboardData(format, str.c_str());
578 }
579
580 case wxDF_BITMAP:
581 case wxDF_DIB:
582 {
583 wxBitmapDataObject* bitmapDataObject = (wxBitmapDataObject*) data;
584 wxBitmap bitmap(bitmapDataObject->GetBitmap());
585 return wxSetClipboardData(data->GetPreferredFormat(), &bitmap);
586 }
587
588#if wxUSE_METAFILE
589 case wxDF_METAFILE:
590 {
591#if 1
592 // TODO
593 wxLogError("Not implemented because wxMetafileDataObject does not contain width and height values.");
594 return FALSE;
595#else
596 wxMetafileDataObject* metaFileDataObject =
597 (wxMetafileDataObject*) data;
598 wxMetafile metaFile = metaFileDataObject->GetMetafile();
599 return wxSetClipboardData(wxDF_METAFILE, &metaFile,
600 metaFileDataObject->GetWidth(),
601 metaFileDataObject->GetHeight());
602#endif
603 }
604#endif // wxUSE_METAFILE
605
606 default:
607 {
608// This didn't compile, of course
609// return wxSetClipboardData(data);
610 // TODO
611 wxLogError("Not implemented.");
612 return FALSE;
613 }
614 }
615#else // !wxUSE_DATAOBJ
616 return FALSE;
617#endif // wxUSE_DATAOBJ/!wxUSE_DATAOBJ
618}
619
620void wxClipboard::Close()
621{
622 // OLE closes clipboard for us
623#if !wxUSE_OLE_CLIPBOARD
624 wxCloseClipboard();
625#endif
626}
627
628bool wxClipboard::IsSupported( wxDataFormat format )
629{
630 return wxIsClipboardFormatAvailable(format);
631}
632
633bool wxClipboard::GetData( wxDataObject& data )
634{
635#if wxUSE_OLE_CLIPBOARD
636 IDataObject *pDataObject = NULL;
637 HRESULT hr = OleGetClipboard(&pDataObject);
638 if ( FAILED(hr) || !pDataObject )
639 {
640 wxLogSysError(hr, _("Failed to get data from the clipboard"));
641
642 return FALSE;
643 }
644
645 // build the list of supported formats
646 size_t nFormats = data.GetFormatCount(wxDataObject::Set);
647 wxDataFormat format;
648 wxDataFormat *formats;
649 if ( nFormats == 1 )
650 {
651 // the most common case
652 formats = &format;
653 }
654 else
655 {
656 // bad luck, need to alloc mem
657 formats = new wxDataFormat[nFormats];
658 }
659
660 data.GetAllFormats(formats, wxDataObject::Set);
661
662 // get the format enumerator
663 bool result = FALSE;
664 wxArrayInt supportedFormats;
665 IEnumFORMATETC *pEnumFormatEtc = NULL;
666 hr = pDataObject->EnumFormatEtc(DATADIR_GET, &pEnumFormatEtc);
667 if ( FAILED(hr) || !pEnumFormatEtc )
668 {
669 wxLogSysError(hr,
670 _("Failed to retrieve the supported clipboard formats"));
671 }
672 else
673 {
674 // ask for the supported formats and see if there are any we support
675 FORMATETC formatEtc;
676 for ( ;; )
677 {
678 ULONG nCount;
679 hr = pEnumFormatEtc->Next(1, &formatEtc, &nCount);
680
681 // don't use FAILED() because S_FALSE would pass it
682 if ( hr != S_OK )
683 {
684 // no more formats
685 break;
686 }
687
688 CLIPFORMAT cf = formatEtc.cfFormat;
689
690#ifdef __WXDEBUG__
691 wxLogTrace(wxTRACE_OleCalls,
692 wxT("Object on the clipboard supports format %s."),
693 wxDataObject::GetFormatName(cf));
694#endif // Debug
695
696 // is supported?
697 for ( size_t n = 0; n < nFormats; n++ )
698 {
699 if ( formats[n].GetFormatId() == cf )
700 {
701 if ( supportedFormats.Index(cf) == wxNOT_FOUND )
702 {
703 supportedFormats.Add(cf);
704 }
705 }
706 }
707 }
708
709 pEnumFormatEtc->Release();
710 }
711
712 if ( formats != &format )
713 {
714 delete [] formats;
715 }
716 //else: we didn't allocate any memory
717
718 if ( !supportedFormats.IsEmpty() )
719 {
720 FORMATETC formatEtc;
721 formatEtc.ptd = NULL;
722 formatEtc.dwAspect = DVASPECT_CONTENT;
723 formatEtc.lindex = -1;
724
725 size_t nSupportedFormats = supportedFormats.GetCount();
726 for ( size_t n = 0; !result && (n < nSupportedFormats); n++ )
727 {
728 STGMEDIUM medium;
729 formatEtc.cfFormat = supportedFormats[n];
730
731 // use the appropriate tymed
732 switch ( formatEtc.cfFormat )
733 {
734 case CF_BITMAP:
735 formatEtc.tymed = TYMED_GDI;
736 break;
737
738 case CF_METAFILEPICT:
739 formatEtc.tymed = TYMED_MFPICT;
740 break;
741
742 case CF_ENHMETAFILE:
743 formatEtc.tymed = TYMED_ENHMF;
744 break;
745
746 default:
747 formatEtc.tymed = TYMED_HGLOBAL;
748 }
749
750 // try to get data
751 hr = pDataObject->GetData(&formatEtc, &medium);
752 if ( FAILED(hr) )
753 {
754 // try other tymed for GDI objects
755 if ( formatEtc.cfFormat == CF_BITMAP )
756 {
757 formatEtc.tymed = TYMED_HGLOBAL;
758 hr = pDataObject->GetData(&formatEtc, &medium);
759 }
760 }
761
762 if ( SUCCEEDED(hr) )
763 {
764 // pass the data to the data object
765 hr = data.GetInterface()->SetData(&formatEtc, &medium, TRUE);
766 if ( FAILED(hr) )
767 {
768 wxLogDebug(wxT("Failed to set data in wxIDataObject"));
769
770 // IDataObject only takes the ownership of data if it
771 // successfully got it - which is not the case here
772 ReleaseStgMedium(&medium);
773 }
774 else
775 {
776 result = TRUE;
777 }
778 }
779 //else: unsupported tymed?
780 }
781 }
782 //else: unsupported format
783
784 // clean up and return
785 pDataObject->Release();
786
787 return result;
788#elif wxUSE_DATAOBJ
789 wxCHECK_MSG( wxIsClipboardOpened(), FALSE, wxT("clipboard not open") );
790
791 wxDataFormat format = data.GetPreferredFormat();
792 switch ( format )
793 {
794 case wxDF_TEXT:
795 case wxDF_OEMTEXT:
796 {
797 wxTextDataObject& textDataObject = (wxTextDataObject &)data;
798 char* s = (char*)wxGetClipboardData(format);
799 if ( !s )
800 return FALSE;
801
802 textDataObject.SetText(s);
803 delete [] s;
804
805 return TRUE;
806 }
807
808 case wxDF_BITMAP:
809 case wxDF_DIB:
810 {
811 wxBitmapDataObject& bitmapDataObject = (wxBitmapDataObject &)data;
812 wxBitmap* bitmap = (wxBitmap *)wxGetClipboardData(data.GetPreferredFormat());
813 if ( !bitmap )
814 return FALSE;
815
816 bitmapDataObject.SetBitmap(*bitmap);
817 delete bitmap;
818
819 return TRUE;
820 }
821#if wxUSE_METAFILE
822 case wxDF_METAFILE:
823 {
824 wxMetafileDataObject& metaFileDataObject = (wxMetafileDataObject &)data;
825 wxMetafile* metaFile = (wxMetafile *)wxGetClipboardData(wxDF_METAFILE);
826 if ( !metaFile )
827 return FALSE;
828
829 metaFileDataObject.SetMetafile(*metaFile);
830 delete metaFile;
831
832 return TRUE;
833 }
834#endif // wxUSE_METAFILE
835 }
836 return FALSE;
837#else // !wxUSE_DATAOBJ
838 wxFAIL_MSG( wxT("no clipboard implementation") );
839 return FALSE;
840#endif // wxUSE_OLE_CLIPBOARD/wxUSE_DATAOBJ
841}
842
843#endif // wxUSE_CLIPBOARD
844