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
  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
  95 static bool gs_wxClipboardIsOpen = FALSE;
  96
  97 bool 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
 119 bool 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
 135 bool 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
 147 bool wxIsClipboardOpened()
 148 {
 149   return gs_wxClipboardIsOpen;
 150 }
 151
 152 bool 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
 177 bool 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
 313 void *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
 439 wxDataFormat wxEnumClipboardFormats(wxDataFormat dataFormat)
 440 {
 441   return (wxDataFormat::NativeFormat)::EnumClipboardFormats(dataFormat);
 442 }
 443
 444 int wxRegisterClipboardFormat(wxChar *formatName)
 445 {
 446   return ::RegisterClipboardFormat(formatName);
 447 }
 448
 449 bool 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
 460 IMPLEMENT_DYNAMIC_CLASS(wxClipboard, wxObject)
 461
 462 wxClipboard::wxClipboard()
 463 {
 464     m_clearOnExit = FALSE;
 465 }
 466
 467 wxClipboard::~wxClipboard()
 468 {
 469     if ( m_clearOnExit )
 470     {
 471         Clear();
 472     }
 473 }
 474
 475 void wxClipboard::Clear()
 476 {
 477 #if wxUSE_OLE_CLIPBOARD
 478     if ( FAILED(OleSetClipboard(NULL)) )
 479     {
 480         wxLogLastError(wxT("OleSetClipboard(NULL)"));
 481     }
 482 #endif
 483 }
 484
 485 bool 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
 505 bool 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
 515 bool wxClipboard::IsOpened() const
 516 {
 517 #if wxUSE_OLE_CLIPBOARD
 518     return TRUE;
 519 #else
 520     return wxIsClipboardOpened();
 521 #endif
 522 }
 523
 524 bool 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
 536 bool 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
 620 void wxClipboard::Close()
 621 {
 622     // OLE closes clipboard for us
 623 #if !wxUSE_OLE_CLIPBOARD
 624     wxCloseClipboard();
 625 #endif
 626 }
 627
 628 bool wxClipboard::IsSupported( wxDataFormat format )
 629 {
 630     return wxIsClipboardFormatAvailable(format);
 631 }
 632
 633 bool 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