src/msw/clipbrd.cpp

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