src/msw/clipbrd.cpp

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