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
   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 "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
  56 #include "wx/msw/private.h"
  57
  58 #if wxUSE_WXDIB
  59 #include "wx/msw/dib.h"
  60 #endif
  61
  62 // wxDataObject is tied to OLE/drag and drop implementation, therefore so are
  63 // the functions using wxDataObject in wxClipboard
  64 //#define wxUSE_DATAOBJ wxUSE_DRAG_AND_DROP
  65
  66 #if wxUSE_DATAOBJ
  67     #include "wx/dataobj.h"
  68 #endif
  69
  70 #if wxUSE_OLE && !defined(__WXWINCE__)
  71     // use OLE clipboard
  72     #define wxUSE_OLE_CLIPBOARD 1
  73 #else // !wxUSE_DATAOBJ
  74     // use Win clipboard API
  75     #define wxUSE_OLE_CLIPBOARD 0
  76 #endif
  77
  78 #if wxUSE_OLE_CLIPBOARD
  79     #include <ole2.h>
  80 #endif // wxUSE_OLE_CLIPBOARD
  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__) && !defined(__WXWINCE__)
 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
 173 bool wxSetClipboardData(wxDataFormat dataFormat,
 174                         const void *data,
 175                         int width, int height)
 176 {
 177     HANDLE handle = 0; // return value of SetClipboardData
 178
 179     switch (dataFormat)
 180     {
 181         case wxDF_BITMAP:
 182             {
 183                 wxBitmap *bitmap = (wxBitmap *)data;
 184
 185                 HDC hdcMem = CreateCompatibleDC((HDC) NULL);
 186                 HDC hdcSrc = CreateCompatibleDC((HDC) NULL);
 187                 HBITMAP old = (HBITMAP)
 188                     ::SelectObject(hdcSrc, (HBITMAP)bitmap->GetHBITMAP());
 189                 HBITMAP hBitmap = CreateCompatibleBitmap(hdcSrc,
 190                                                          bitmap->GetWidth(),
 191                                                          bitmap->GetHeight());
 192                 if (!hBitmap)
 193                 {
 194                     SelectObject(hdcSrc, old);
 195                     DeleteDC(hdcMem);
 196                     DeleteDC(hdcSrc);
 197                     return FALSE;
 198                 }
 199
 200                 HBITMAP old1 = (HBITMAP) SelectObject(hdcMem, hBitmap);
 201                 BitBlt(hdcMem, 0, 0, bitmap->GetWidth(), bitmap->GetHeight(),
 202                        hdcSrc, 0, 0, SRCCOPY);
 203
 204                 // Select new bitmap out of memory DC
 205                 SelectObject(hdcMem, old1);
 206
 207                 // Set the data
 208                 handle = ::SetClipboardData(CF_BITMAP, hBitmap);
 209
 210                 // Clean up
 211                 SelectObject(hdcSrc, old);
 212                 DeleteDC(hdcSrc);
 213                 DeleteDC(hdcMem);
 214                 break;
 215             }
 216
 217 #if wxUSE_WXDIB
 218         case wxDF_DIB:
 219             {
 220                 wxBitmap *bitmap = (wxBitmap *)data;
 221
 222                 HGLOBAL hDIB = wxDIB::ConvertFromBitmap(GetHbitmapOf(*bitmap));
 223                 if ( hDIB )
 224                 {
 225                     handle = ::SetClipboardData(CF_DIB, hDIB);
 226                 }
 227                 break;
 228             }
 229 #endif
 230
 231     // VZ: I'm told that this code works, but it doesn't seem to work for me
 232     //     and, anyhow, I'd be highly surprised if it did. So I leave it here
 233     //     but IMNSHO it is completely broken.
 234 #if wxUSE_METAFILE && !defined(wxMETAFILE_IS_ENH) && !defined(__WXWINCE__)
 235         case wxDF_METAFILE:
 236             {
 237                 wxMetafile *wxMF = (wxMetafile *)data;
 238                 HANDLE data = GlobalAlloc(GHND, sizeof(METAFILEPICT) + 1);
 239                 METAFILEPICT *mf = (METAFILEPICT *)GlobalLock(data);
 240
 241                 mf->mm = wxMF->GetWindowsMappingMode();
 242                 mf->xExt = width;
 243                 mf->yExt = height;
 244                 mf->hMF = (HMETAFILE) wxMF->GetHMETAFILE();
 245                 GlobalUnlock(data);
 246                 wxMF->SetHMETAFILE((WXHANDLE) NULL);
 247
 248                 handle = SetClipboardData(CF_METAFILEPICT, data);
 249                 break;
 250             }
 251 #endif // wxUSE_METAFILE
 252
 253 #if wxUSE_ENH_METAFILE && !defined(__WIN16__) && !defined(__WXWINCE__)
 254         case wxDF_ENHMETAFILE:
 255             {
 256                 wxEnhMetaFile *emf = (wxEnhMetaFile *)data;
 257                 wxEnhMetaFile emfCopy = *emf;
 258
 259                 handle = SetClipboardData(CF_ENHMETAFILE,
 260                                           (void *)emfCopy.GetHENHMETAFILE());
 261             }
 262             break;
 263 #endif // wxUSE_ENH_METAFILE
 264
 265         case CF_SYLK:
 266         case CF_DIF:
 267         case CF_TIFF:
 268         case CF_PALETTE:
 269         default:
 270             {
 271                 wxLogError(_("Unsupported clipboard format."));
 272                 return FALSE;
 273             }
 274
 275         case wxDF_OEMTEXT:
 276             dataFormat = wxDF_TEXT;
 277             // fall through
 278
 279         case wxDF_TEXT:
 280             {
 281                 char *s = (char *)data;
 282
 283                 width = strlen(s) + 1;
 284                 height = 1;
 285                 DWORD l = (width * height);
 286                 HANDLE hGlobalMemory = GlobalAlloc(GHND, l);
 287                 if ( hGlobalMemory )
 288                 {
 289                     LPSTR lpGlobalMemory = (LPSTR)GlobalLock(hGlobalMemory);
 290
 291                     memcpy(lpGlobalMemory, s, l);
 292
 293                     GlobalUnlock(hGlobalMemory);
 294                 }
 295
 296                 handle = SetClipboardData(dataFormat, hGlobalMemory);
 297                 break;
 298             }
 299             // Only tested with non-Unicode, Visual C++ 6.0 so far
 300 #if defined(__VISUALC__) && !defined(UNICODE)
 301         case wxDF_HTML:
 302             {
 303                 char* html = (char *)data;
 304
 305                 // Create temporary buffer for HTML header...
 306                 char *buf = new char [400 + strlen(html)];
 307                 if(!buf) return FALSE;
 308
 309                 // Get clipboard id for HTML format...
 310                 static int cfid = 0;
 311                 if(!cfid) cfid = RegisterClipboardFormat(wxT("HTML Format"));
 312
 313                 // Create a template string for the HTML header...
 314                 strcpy(buf,
 315                     "Version:0.9\r\n"
 316                     "StartHTML:00000000\r\n"
 317                     "EndHTML:00000000\r\n"
 318                     "StartFragment:00000000\r\n"
 319                     "EndFragment:00000000\r\n"
 320                     "<html><body>\r\n"
 321                     "<!--StartFragment -->\r\n");
 322
 323                 // Append the HTML...
 324                 strcat(buf, html);
 325                 strcat(buf, "\r\n");
 326                 // Finish up the HTML format...
 327                 strcat(buf,
 328                     "<!--EndFragment-->\r\n"
 329                     "</body>\r\n"
 330                     "</html>");
 331
 332                 // Now go back, calculate all the lengths, and write out the
 333                 // necessary header information. Note, wsprintf() truncates the
 334                 // string when you overwrite it so you follow up with code to replace
 335                 // the 0 appended at the end with a '\r'...
 336                 char *ptr = strstr(buf, "StartHTML");
 337                 wsprintf(ptr+10, "%08u", strstr(buf, "<html>") - buf);
 338                 *(ptr+10+8) = '\r';
 339
 340                 ptr = strstr(buf, "EndHTML");
 341                 wsprintf(ptr+8, "%08u", strlen(buf));
 342                 *(ptr+8+8) = '\r';
 343
 344                 ptr = strstr(buf, "StartFragment");
 345                 wsprintf(ptr+14, "%08u", strstr(buf, "<!--StartFrag") - buf);
 346                 *(ptr+14+8) = '\r';
 347
 348                 ptr = strstr(buf, "EndFragment");
 349                 wsprintf(ptr+12, "%08u", strstr(buf, "<!--EndFrag") - buf);
 350                 *(ptr+12+8) = '\r';
 351
 352                 // Now you have everything in place ready to put on the
 353                 // clipboard.
 354
 355                 // Allocate global memory for transfer...
 356                 HGLOBAL hText = GlobalAlloc(GMEM_MOVEABLE |GMEM_DDESHARE, strlen(buf)+4);
 357
 358                 // Put your string in the global memory...
 359                 ptr = (char *)GlobalLock(hText);
 360                 strcpy(ptr, buf);
 361                 GlobalUnlock(hText);
 362
 363                 handle = ::SetClipboardData(cfid, hText);
 364
 365                 // Free memory...
 366                 GlobalFree(hText);
 367
 368                 // Clean up...
 369                 delete [] buf;
 370                 break;
 371             }
 372 #endif
 373     }
 374
 375     if ( handle == 0 )
 376     {
 377         wxLogSysError(_("Failed to set clipboard data."));
 378
 379         return FALSE;
 380     }
 381
 382     return TRUE;
 383 }
 384
 385 void *wxGetClipboardData(wxDataFormat dataFormat, long *len)
 386 {
 387     void *retval = NULL;
 388
 389     switch ( dataFormat )
 390     {
 391 #ifndef __WXWINCE__
 392         case wxDF_BITMAP:
 393             {
 394                 BITMAP bm;
 395                 HBITMAP hBitmap = (HBITMAP) GetClipboardData(CF_BITMAP);
 396                 if (!hBitmap)
 397                     break;
 398
 399                 HDC hdcMem = CreateCompatibleDC((HDC) NULL);
 400                 HDC hdcSrc = CreateCompatibleDC((HDC) NULL);
 401
 402                 HBITMAP old = (HBITMAP) ::SelectObject(hdcSrc, hBitmap);
 403                 GetObject(hBitmap, sizeof(BITMAP), (LPSTR)&bm);
 404
 405                 HBITMAP hNewBitmap = CreateBitmapIndirect(&bm);
 406
 407                 if (!hNewBitmap)
 408                 {
 409                     SelectObject(hdcSrc, old);
 410                     DeleteDC(hdcMem);
 411                     DeleteDC(hdcSrc);
 412                     break;
 413                 }
 414
 415                 HBITMAP old1 = (HBITMAP) SelectObject(hdcMem, hNewBitmap);
 416                 BitBlt(hdcMem, 0, 0, bm.bmWidth, bm.bmHeight,
 417                        hdcSrc, 0, 0, SRCCOPY);
 418
 419                 // Select new bitmap out of memory DC
 420                 SelectObject(hdcMem, old1);
 421
 422                 // Clean up
 423                 SelectObject(hdcSrc, old);
 424                 DeleteDC(hdcSrc);
 425                 DeleteDC(hdcMem);
 426
 427                 // Create and return a new wxBitmap
 428                 wxBitmap *wxBM = new wxBitmap;
 429                 wxBM->SetHBITMAP((WXHBITMAP) hNewBitmap);
 430                 wxBM->SetWidth(bm.bmWidth);
 431                 wxBM->SetHeight(bm.bmHeight);
 432                 wxBM->SetDepth(bm.bmPlanes);
 433 #if WXWIN_COMPATIBILITY_2
 434                 wxBM->SetOk(TRUE);
 435 #endif // WXWIN_COMPATIBILITY_2
 436                 retval = wxBM;
 437                 break;
 438             }
 439 #endif
 440         case wxDF_METAFILE:
 441         case CF_SYLK:
 442         case CF_DIF:
 443         case CF_TIFF:
 444         case CF_PALETTE:
 445         case wxDF_DIB:
 446             wxLogError(_("Unsupported clipboard format."));
 447             return NULL;
 448
 449         case wxDF_OEMTEXT:
 450             dataFormat = wxDF_TEXT;
 451             // fall through
 452
 453         case wxDF_TEXT:
 454             {
 455                 HANDLE hGlobalMemory = ::GetClipboardData(dataFormat);
 456                 if (!hGlobalMemory)
 457                     break;
 458
 459                 DWORD hsize = ::GlobalSize(hGlobalMemory);
 460                 if (len)
 461                     *len = hsize;
 462
 463                 char *s = new char[hsize];
 464                 if (!s)
 465                     break;
 466
 467                 LPSTR lpGlobalMemory = (LPSTR) GlobalLock(hGlobalMemory);
 468
 469                 memcpy(s, lpGlobalMemory, hsize);
 470
 471                 GlobalUnlock(hGlobalMemory);
 472
 473                 retval = s;
 474                 break;
 475             }
 476
 477         default:
 478             {
 479                 HANDLE hGlobalMemory = ::GetClipboardData(dataFormat);
 480                 if ( !hGlobalMemory )
 481                     break;
 482
 483                 DWORD size = ::GlobalSize(hGlobalMemory);
 484                 if ( len )
 485                     *len = size;
 486
 487                 void *buf = malloc(size);
 488                 if ( !buf )
 489                     break;
 490
 491                 LPSTR lpGlobalMemory = (LPSTR) GlobalLock(hGlobalMemory);
 492
 493                 memcpy(buf, lpGlobalMemory, size);
 494
 495                 GlobalUnlock(hGlobalMemory);
 496
 497                 retval = buf;
 498                 break;
 499             }
 500     }
 501
 502     if ( !retval )
 503     {
 504         wxLogSysError(_("Failed to retrieve data from the clipboard."));
 505     }
 506
 507     return retval;
 508 }
 509
 510 wxDataFormat wxEnumClipboardFormats(wxDataFormat dataFormat)
 511 {
 512   return (wxDataFormat::NativeFormat)::EnumClipboardFormats(dataFormat);
 513 }
 514
 515 int wxRegisterClipboardFormat(wxChar *formatName)
 516 {
 517   return ::RegisterClipboardFormat(formatName);
 518 }
 519
 520 bool wxGetClipboardFormatName(wxDataFormat dataFormat,
 521                               wxChar *formatName,
 522                               int maxCount)
 523 {
 524   return ::GetClipboardFormatName((int)dataFormat, formatName, maxCount) > 0;
 525 }
 526
 527 // ---------------------------------------------------------------------------
 528 // wxClipboard
 529 // ---------------------------------------------------------------------------
 530
 531 IMPLEMENT_DYNAMIC_CLASS(wxClipboard, wxObject)
 532
 533 wxClipboard::wxClipboard()
 534 {
 535     m_clearOnExit = FALSE;
 536     m_isOpened = FALSE;
 537 }
 538
 539 wxClipboard::~wxClipboard()
 540 {
 541     if ( m_clearOnExit )
 542     {
 543         Clear();
 544     }
 545 }
 546
 547 void wxClipboard::Clear()
 548 {
 549 #if wxUSE_OLE_CLIPBOARD
 550     if ( FAILED(OleSetClipboard(NULL)) )
 551     {
 552         wxLogLastError(wxT("OleSetClipboard(NULL)"));
 553     }
 554 #endif
 555 }
 556
 557 bool wxClipboard::Flush()
 558 {
 559 #if wxUSE_OLE_CLIPBOARD
 560     if ( FAILED(OleFlushClipboard()) )
 561     {
 562         wxLogLastError(wxT("OleFlushClipboard"));
 563
 564         return FALSE;
 565     }
 566     else
 567     {
 568         m_clearOnExit = FALSE;
 569
 570         return TRUE;
 571     }
 572 #else // !wxUSE_OLE_CLIPBOARD
 573     return FALSE;
 574 #endif // wxUSE_OLE_CLIPBOARD/!wxUSE_OLE_CLIPBOARD
 575 }
 576
 577 bool wxClipboard::Open()
 578 {
 579     // OLE opens clipboard for us
 580     m_isOpened = TRUE;
 581 #if wxUSE_OLE_CLIPBOARD
 582     return TRUE;
 583 #else
 584     return wxOpenClipboard();
 585 #endif
 586 }
 587
 588 bool wxClipboard::IsOpened() const
 589 {
 590 #if wxUSE_OLE_CLIPBOARD
 591     return m_isOpened;
 592 #else
 593     return wxIsClipboardOpened();
 594 #endif
 595 }
 596
 597 bool wxClipboard::SetData( wxDataObject *data )
 598 {
 599 #if !wxUSE_OLE_CLIPBOARD
 600     (void)wxEmptyClipboard();
 601 #endif // wxUSE_OLE_CLIPBOARD
 602
 603     if ( data )
 604         return AddData(data);
 605     else
 606         return TRUE;
 607 }
 608
 609 bool wxClipboard::AddData( wxDataObject *data )
 610 {
 611     wxCHECK_MSG( data, FALSE, wxT("data is invalid") );
 612
 613 #if wxUSE_OLE_CLIPBOARD
 614     HRESULT hr = OleSetClipboard(data->GetInterface());
 615     if ( FAILED(hr) )
 616     {
 617         wxLogSysError(hr, _("Failed to put data on the clipboard"));
 618
 619         // don't free anything in this case
 620
 621         return FALSE;
 622     }
 623
 624     // we have a problem here because we should delete wxDataObject, but we
 625     // can't do it because IDataObject which we just gave to the clipboard
 626     // would try to use it when it will need the data. IDataObject is ref
 627     // counted and so doesn't suffer from such problem, so we release it now
 628     // and tell it to delete wxDataObject when it is deleted itself.
 629     data->SetAutoDelete();
 630
 631     // we have to call either OleSetClipboard(NULL) or OleFlushClipboard() when
 632     // using OLE clipboard when the app terminates - by default, we call
 633     // OleSetClipboard(NULL) which won't waste RAM, but the app can call
 634     // wxClipboard::Flush() to chaneg this
 635     m_clearOnExit = TRUE;
 636
 637     return TRUE;
 638 #elif wxUSE_DATAOBJ
 639     wxCHECK_MSG( wxIsClipboardOpened(), FALSE, wxT("clipboard not open") );
 640
 641     wxDataFormat format = data->GetPreferredFormat();
 642
 643     switch ( format )
 644     {
 645         case wxDF_TEXT:
 646         case wxDF_OEMTEXT:
 647         {
 648             wxTextDataObject* textDataObject = (wxTextDataObject*) data;
 649             wxString str(textDataObject->GetText());
 650             return wxSetClipboardData(format, str.c_str());
 651         }
 652
 653         case wxDF_BITMAP:
 654         case wxDF_DIB:
 655         {
 656             wxBitmapDataObject* bitmapDataObject = (wxBitmapDataObject*) data;
 657             wxBitmap bitmap(bitmapDataObject->GetBitmap());
 658             return wxSetClipboardData(data->GetPreferredFormat(), &bitmap);
 659         }
 660
 661 #if wxUSE_METAFILE
 662         case wxDF_METAFILE:
 663         {
 664 #if 1
 665             // TODO
 666             wxLogError("Not implemented because wxMetafileDataObject does not contain width and height values.");
 667             return FALSE;
 668 #else
 669             wxMetafileDataObject* metaFileDataObject =
 670                 (wxMetafileDataObject*) data;
 671             wxMetafile metaFile = metaFileDataObject->GetMetafile();
 672             return wxSetClipboardData(wxDF_METAFILE, &metaFile,
 673                                       metaFileDataObject->GetWidth(),
 674                                       metaFileDataObject->GetHeight());
 675 #endif
 676         }
 677 #endif // wxUSE_METAFILE
 678
 679         default:
 680         {
 681 // This didn't compile, of course
 682 //            return wxSetClipboardData(data);
 683             // TODO
 684             wxLogError(wxT("Not implemented."));
 685             return FALSE;
 686         }
 687     }
 688 #else // !wxUSE_DATAOBJ
 689     return FALSE;
 690 #endif // wxUSE_DATAOBJ/!wxUSE_DATAOBJ
 691 }
 692
 693 void wxClipboard::Close()
 694 {
 695     m_isOpened = FALSE;
 696     // OLE closes clipboard for us
 697 #if !wxUSE_OLE_CLIPBOARD
 698     wxCloseClipboard();
 699 #endif
 700 }
 701
 702 bool wxClipboard::IsSupported( wxDataFormat format )
 703 {
 704     return wxIsClipboardFormatAvailable(format);
 705 }
 706
 707 bool wxClipboard::GetData( wxDataObject& data )
 708 {
 709 #if wxUSE_OLE_CLIPBOARD
 710     IDataObject *pDataObject = NULL;
 711     HRESULT hr = OleGetClipboard(&pDataObject);
 712     if ( FAILED(hr) || !pDataObject )
 713     {
 714         wxLogSysError(hr, _("Failed to get data from the clipboard"));
 715
 716         return FALSE;
 717     }
 718
 719     // build the list of supported formats
 720     size_t nFormats = data.GetFormatCount(wxDataObject::Set);
 721     wxDataFormat format;
 722     wxDataFormat *formats;
 723     if ( nFormats == 1 )
 724     {
 725         // the most common case
 726         formats = &format;
 727     }
 728     else
 729     {
 730         // bad luck, need to alloc mem
 731         formats = new wxDataFormat[nFormats];
 732     }
 733
 734     data.GetAllFormats(formats, wxDataObject::Set);
 735
 736     // get the format enumerator
 737     bool result = FALSE;
 738     wxArrayInt supportedFormats;
 739     IEnumFORMATETC *pEnumFormatEtc = NULL;
 740     hr = pDataObject->EnumFormatEtc(DATADIR_GET, &pEnumFormatEtc);
 741     if ( FAILED(hr) || !pEnumFormatEtc )
 742     {
 743         wxLogSysError(hr,
 744                       _("Failed to retrieve the supported clipboard formats"));
 745     }
 746     else
 747     {
 748         // ask for the supported formats and see if there are any we support
 749         FORMATETC formatEtc;
 750         for ( ;; )
 751         {
 752             ULONG nCount;
 753             hr = pEnumFormatEtc->Next(1, &formatEtc, &nCount);
 754
 755             // don't use FAILED() because S_FALSE would pass it
 756             if ( hr != S_OK )
 757             {
 758                 // no more formats
 759                 break;
 760             }
 761
 762             CLIPFORMAT cf = formatEtc.cfFormat;
 763
 764 #ifdef __WXDEBUG__
 765             wxLogTrace(wxTRACE_OleCalls,
 766                        wxT("Object on the clipboard supports format %s."),
 767                        wxDataObject::GetFormatName(cf));
 768 #endif // Debug
 769
 770             // is supported?
 771             for ( size_t n = 0; n < nFormats; n++ )
 772             {
 773                 if ( formats[n].GetFormatId() == cf )
 774                 {
 775                     if ( supportedFormats.Index(cf) == wxNOT_FOUND )
 776                     {
 777                         supportedFormats.Add(cf);
 778                     }
 779                 }
 780             }
 781         }
 782
 783         pEnumFormatEtc->Release();
 784     }
 785
 786     if ( formats != &format )
 787     {
 788         delete [] formats;
 789     }
 790     //else: we didn't allocate any memory
 791
 792     if ( !supportedFormats.IsEmpty() )
 793     {
 794         FORMATETC formatEtc;
 795         formatEtc.ptd      = NULL;
 796         formatEtc.dwAspect = DVASPECT_CONTENT;
 797         formatEtc.lindex   = -1;
 798
 799         size_t nSupportedFormats = supportedFormats.GetCount();
 800         for ( size_t n = 0; !result && (n < nSupportedFormats); n++ )
 801         {
 802             STGMEDIUM medium;
 803             formatEtc.cfFormat = supportedFormats[n];
 804
 805             // use the appropriate tymed
 806             switch ( formatEtc.cfFormat )
 807             {
 808                 case CF_BITMAP:
 809                     formatEtc.tymed = TYMED_GDI;
 810                     break;
 811 #ifndef __WXWINCE__
 812                 case CF_METAFILEPICT:
 813                     formatEtc.tymed = TYMED_MFPICT;
 814                     break;
 815
 816                 case CF_ENHMETAFILE:
 817                     formatEtc.tymed = TYMED_ENHMF;
 818                     break;
 819 #endif
 820                 default:
 821                     formatEtc.tymed = TYMED_HGLOBAL;
 822             }
 823
 824             // try to get data
 825             hr = pDataObject->GetData(&formatEtc, &medium);
 826             if ( FAILED(hr) )
 827             {
 828                 // try other tymed for GDI objects
 829                 if ( formatEtc.cfFormat == CF_BITMAP )
 830                 {
 831                     formatEtc.tymed = TYMED_HGLOBAL;
 832                     hr = pDataObject->GetData(&formatEtc, &medium);
 833                 }
 834             }
 835
 836             if ( SUCCEEDED(hr) )
 837             {
 838                 // pass the data to the data object
 839                 hr = data.GetInterface()->SetData(&formatEtc, &medium, TRUE);
 840                 if ( FAILED(hr) )
 841                 {
 842                     wxLogDebug(wxT("Failed to set data in wxIDataObject"));
 843
 844                     // IDataObject only takes the ownership of data if it
 845                     // successfully got it - which is not the case here
 846                     ReleaseStgMedium(&medium);
 847                 }
 848                 else
 849                 {
 850                     result = TRUE;
 851                 }
 852             }
 853             //else: unsupported tymed?
 854         }
 855     }
 856     //else: unsupported format
 857
 858     // clean up and return
 859     pDataObject->Release();
 860
 861     return result;
 862 #elif wxUSE_DATAOBJ
 863     wxCHECK_MSG( wxIsClipboardOpened(), FALSE, wxT("clipboard not open") );
 864
 865     wxDataFormat format = data.GetPreferredFormat();
 866     switch ( format )
 867     {
 868         case wxDF_TEXT:
 869         case wxDF_OEMTEXT:
 870         {
 871             wxTextDataObject& textDataObject = (wxTextDataObject &)data;
 872             char* s = (char*)wxGetClipboardData(format);
 873             if ( !s )
 874                 return FALSE;
 875
 876             textDataObject.SetText(wxString::FromAscii(s));
 877             delete [] s;
 878
 879             return TRUE;
 880         }
 881
 882         case wxDF_BITMAP:
 883         case wxDF_DIB:
 884         {
 885             wxBitmapDataObject& bitmapDataObject = (wxBitmapDataObject &)data;
 886             wxBitmap* bitmap = (wxBitmap *)wxGetClipboardData(data.GetPreferredFormat());
 887             if ( !bitmap )
 888                 return FALSE;
 889
 890             bitmapDataObject.SetBitmap(*bitmap);
 891             delete bitmap;
 892
 893             return TRUE;
 894         }
 895 #if wxUSE_METAFILE
 896         case wxDF_METAFILE:
 897         {
 898             wxMetafileDataObject& metaFileDataObject = (wxMetafileDataObject &)data;
 899             wxMetafile* metaFile = (wxMetafile *)wxGetClipboardData(wxDF_METAFILE);
 900             if ( !metaFile )
 901                 return FALSE;
 902
 903             metaFileDataObject.SetMetafile(*metaFile);
 904             delete metaFile;
 905
 906             return TRUE;
 907         }
 908 #endif // wxUSE_METAFILE
 909     }
 910     return FALSE;
 911 #else // !wxUSE_DATAOBJ
 912     wxFAIL_MSG( wxT("no clipboard implementation") );
 913     return FALSE;
 914 #endif // wxUSE_OLE_CLIPBOARD/wxUSE_DATAOBJ
 915 }
 916
 917 #endif // wxUSE_CLIPBOARD
 918