src/msw/ole/dataobj.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        msw/ole/dataobj.cpp
   3 // Purpose:     implementation of wx[I]DataObject class
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     10.05.98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
   9 // Licence:     wxWindows license
  10 ///////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  21   #pragma implementation "dataobj.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #if defined(__BORLANDC__)
  28   #pragma hdrstop
  29 #endif
  30 #ifndef WX_PRECOMP
  31 #include "wx/intl.h"
  32 #endif
  33 #include "wx/defs.h"
  34
  35 #if defined(__WIN32__) && !defined(__GNUWIN32__) || defined(wxUSE_NORLANDER_HEADERS)
  36
  37 #include "wx/log.h"
  38 #include "wx/dataobj.h"
  39
  40 #include <windows.h>
  41 #ifdef wxUSE_NORLANDER_HEADERS
  42   #include <ole2.h>
  43 #endif
  44 #include <oleauto.h>
  45
  46 #ifndef __WIN32__
  47   #include <ole2.h>
  48   #include <olestd.h>
  49 #endif
  50
  51 #include  "wx/msw/ole/oleutils.h"
  52
  53 // ----------------------------------------------------------------------------
  54 // functions
  55 // ----------------------------------------------------------------------------
  56
  57 #ifdef __WXDEBUG__
  58     static const wxChar *GetTymedName(DWORD tymed);
  59 #endif // Debug
  60
  61 // to be moved into wx/msw/bitmap.h
  62 extern size_t wxConvertBitmapToDIB(BITMAPINFO *pbi, const wxBitmap& bitmap);
  63 extern wxBitmap wxConvertDIBToBitmap(const BITMAPINFO *bmi);
  64
  65 // ----------------------------------------------------------------------------
  66 // wxIEnumFORMATETC interface implementation
  67 // ----------------------------------------------------------------------------
  68
  69 class wxIEnumFORMATETC : public IEnumFORMATETC
  70 {
  71 public:
  72     wxIEnumFORMATETC(const wxDataFormat* formats, ULONG nCount);
  73     ~wxIEnumFORMATETC() { delete [] m_formats; }
  74
  75     DECLARE_IUNKNOWN_METHODS;
  76
  77     // IEnumFORMATETC
  78     STDMETHODIMP Next(ULONG celt, FORMATETC *rgelt, ULONG *pceltFetched);
  79     STDMETHODIMP Skip(ULONG celt);
  80     STDMETHODIMP Reset();
  81     STDMETHODIMP Clone(IEnumFORMATETC **ppenum);
  82
  83 private:
  84     CLIPFORMAT *m_formats;  // formats we can provide data in
  85     ULONG       m_nCount,   // number of formats we support
  86                 m_nCurrent; // current enum position
  87 };
  88
  89 // ----------------------------------------------------------------------------
  90 // wxIDataObject implementation of IDataObject interface
  91 // ----------------------------------------------------------------------------
  92
  93 class wxIDataObject : public IDataObject
  94 {
  95 public:
  96     wxIDataObject(wxDataObject *pDataObject);
  97     ~wxIDataObject();
  98
  99     // normally, wxDataObject controls our lifetime (i.e. we're deleted when it
 100     // is), but in some cases, the situation is inversed, that is we delete it
 101     // when this object is deleted - setting this flag enables such logic
 102     void SetDeleteFlag() { m_mustDelete = TRUE; }
 103
 104     DECLARE_IUNKNOWN_METHODS;
 105
 106     // IDataObject
 107     STDMETHODIMP GetData(FORMATETC *pformatetcIn, STGMEDIUM *pmedium);
 108     STDMETHODIMP GetDataHere(FORMATETC *pformatetc, STGMEDIUM *pmedium);
 109     STDMETHODIMP QueryGetData(FORMATETC *pformatetc);
 110     STDMETHODIMP GetCanonicalFormatEtc(FORMATETC *In, FORMATETC *pOut);
 111     STDMETHODIMP SetData(FORMATETC *pfetc, STGMEDIUM *pmedium, BOOL fRelease);
 112     STDMETHODIMP EnumFormatEtc(DWORD dwDirection, IEnumFORMATETC **ppenumFEtc);
 113     STDMETHODIMP DAdvise(FORMATETC *pfetc, DWORD ad, IAdviseSink *p, DWORD *pdw);
 114     STDMETHODIMP DUnadvise(DWORD dwConnection);
 115     STDMETHODIMP EnumDAdvise(IEnumSTATDATA **ppenumAdvise);
 116
 117 private:
 118     wxDataObject *m_pDataObject;      // pointer to C++ class we belong to
 119
 120     bool m_mustDelete;
 121 };
 122
 123 // ----------------------------------------------------------------------------
 124 // small helper class for getting screen DC (we're working with bitmaps and
 125 // DIBs here)
 126 // ----------------------------------------------------------------------------
 127
 128 class ScreenHDC
 129 {
 130 public:
 131     ScreenHDC() { m_hdc = GetDC(NULL);    }
 132    ~ScreenHDC() { ReleaseDC(NULL, m_hdc); }
 133     operator HDC() const { return m_hdc;  }
 134
 135 private:
 136     HDC m_hdc;
 137 };
 138
 139 // ============================================================================
 140 // implementation
 141 // ============================================================================
 142
 143 // ----------------------------------------------------------------------------
 144 // wxDataFormat
 145 // ----------------------------------------------------------------------------
 146
 147 void wxDataFormat::SetId(const wxChar *format)
 148 {
 149     m_format = ::RegisterClipboardFormat(format);
 150     if ( !m_format )
 151     {
 152         wxLogError(_("Couldn't register clipboard format '%s'."), format);
 153     }
 154 }
 155
 156 wxString wxDataFormat::GetId() const
 157 {
 158     static const int max = 256;
 159
 160     wxString s;
 161
 162     wxCHECK_MSG( !IsStandard(), s,
 163                  wxT("name of predefined format cannot be retrieved") );
 164
 165     int len = ::GetClipboardFormatName(m_format, s.GetWriteBuf(max), max);
 166     s.UngetWriteBuf();
 167
 168     if ( !len )
 169     {
 170         wxLogError(_("The clipboard format '%d' doesn't exist."), m_format);
 171     }
 172
 173     return s;
 174 }
 175
 176 // ----------------------------------------------------------------------------
 177 // wxIEnumFORMATETC
 178 // ----------------------------------------------------------------------------
 179
 180 BEGIN_IID_TABLE(wxIEnumFORMATETC)
 181     ADD_IID(Unknown)
 182     ADD_IID(EnumFORMATETC)
 183 END_IID_TABLE;
 184
 185 IMPLEMENT_IUNKNOWN_METHODS(wxIEnumFORMATETC)
 186
 187 wxIEnumFORMATETC::wxIEnumFORMATETC(const wxDataFormat *formats, ULONG nCount)
 188 {
 189     m_cRef = 0;
 190     m_nCurrent = 0;
 191     m_nCount = nCount;
 192     m_formats = new CLIPFORMAT[nCount];
 193     for ( ULONG n = 0; n < nCount; n++ ) {
 194         m_formats[n] = formats[n].GetFormatId();
 195     }
 196 }
 197
 198 STDMETHODIMP wxIEnumFORMATETC::Next(ULONG      celt,
 199                                     FORMATETC *rgelt,
 200                                     ULONG     *pceltFetched)
 201 {
 202     wxLogTrace(wxTRACE_OleCalls, wxT("wxIEnumFORMATETC::Next"));
 203
 204     if ( celt > 1 ) {
 205         // we only return 1 element at a time - mainly because I'm too lazy to
 206         // implement something which you're never asked for anyhow
 207         return S_FALSE;
 208     }
 209
 210     if ( m_nCurrent < m_nCount ) {
 211         FORMATETC format;
 212         format.cfFormat = m_formats[m_nCurrent++];
 213         format.ptd      = NULL;
 214         format.dwAspect = DVASPECT_CONTENT;
 215         format.lindex   = -1;
 216         format.tymed    = TYMED_HGLOBAL;
 217         *rgelt = format;
 218
 219         return S_OK;
 220     }
 221     else {
 222         // bad index
 223         return S_FALSE;
 224     }
 225 }
 226
 227 STDMETHODIMP wxIEnumFORMATETC::Skip(ULONG celt)
 228 {
 229     wxLogTrace(wxTRACE_OleCalls, wxT("wxIEnumFORMATETC::Skip"));
 230
 231     m_nCurrent += celt;
 232     if ( m_nCurrent < m_nCount )
 233         return S_OK;
 234
 235     // no, can't skip this many elements
 236     m_nCurrent -= celt;
 237
 238     return S_FALSE;
 239 }
 240
 241 STDMETHODIMP wxIEnumFORMATETC::Reset()
 242 {
 243     wxLogTrace(wxTRACE_OleCalls, wxT("wxIEnumFORMATETC::Reset"));
 244
 245     m_nCurrent = 0;
 246
 247     return S_OK;
 248 }
 249
 250 STDMETHODIMP wxIEnumFORMATETC::Clone(IEnumFORMATETC **ppenum)
 251 {
 252     wxLogTrace(wxTRACE_OleCalls, wxT("wxIEnumFORMATETC::Clone"));
 253
 254     // unfortunately, we can't reuse the code in ctor - types are different
 255     wxIEnumFORMATETC *pNew = new wxIEnumFORMATETC(NULL, 0);
 256     pNew->m_nCount = m_nCount;
 257     pNew->m_formats = new CLIPFORMAT[m_nCount];
 258     for ( ULONG n = 0; n < m_nCount; n++ ) {
 259         pNew->m_formats[n] = m_formats[n];
 260     }
 261     pNew->AddRef();
 262     *ppenum = pNew;
 263
 264     return S_OK;
 265 }
 266
 267 // ----------------------------------------------------------------------------
 268 // wxIDataObject
 269 // ----------------------------------------------------------------------------
 270
 271 BEGIN_IID_TABLE(wxIDataObject)
 272     ADD_IID(Unknown)
 273     ADD_IID(DataObject)
 274 END_IID_TABLE;
 275
 276 IMPLEMENT_IUNKNOWN_METHODS(wxIDataObject)
 277
 278 wxIDataObject::wxIDataObject(wxDataObject *pDataObject)
 279 {
 280     m_cRef = 0;
 281     m_pDataObject = pDataObject;
 282     m_mustDelete = FALSE;
 283 }
 284
 285 wxIDataObject::~wxIDataObject()
 286 {
 287     if ( m_mustDelete )
 288     {
 289         delete m_pDataObject;
 290     }
 291 }
 292
 293 // get data functions
 294 STDMETHODIMP wxIDataObject::GetData(FORMATETC *pformatetcIn, STGMEDIUM *pmedium)
 295 {
 296     wxLogTrace(wxTRACE_OleCalls, wxT("wxIDataObject::GetData"));
 297
 298     // is data is in our format?
 299     HRESULT hr = QueryGetData(pformatetcIn);
 300     if ( FAILED(hr) )
 301         return hr;
 302
 303     // for the bitmaps and metafiles we use the handles instead of global memory
 304     // to pass the data
 305     wxDataFormat format = (wxDataFormatId)pformatetcIn->cfFormat;
 306
 307     switch ( format )
 308     {
 309         case wxDF_BITMAP:
 310             pmedium->tymed = TYMED_GDI;
 311             break;
 312
 313         case wxDF_METAFILE:
 314             pmedium->tymed = TYMED_MFPICT;
 315             break;
 316
 317         default:
 318             // alloc memory
 319             size_t size = m_pDataObject->GetDataSize(format);
 320             if ( !size ) {
 321                 // it probably means that the method is just not implemented
 322                 wxLogDebug(wxT("Invalid data size - can't be 0"));
 323
 324                 return DV_E_FORMATETC;
 325             }
 326
 327             if ( !format.IsStandard() ) {
 328                 // for custom formats, put the size with the data - alloc the
 329                 // space for it
 330                 size += sizeof(size_t);
 331             }
 332
 333             HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE, size);
 334             if ( hGlobal == NULL ) {
 335                 wxLogLastError("GlobalAlloc");
 336                 return E_OUTOFMEMORY;
 337             }
 338
 339             // copy data
 340             pmedium->tymed   = TYMED_HGLOBAL;
 341             pmedium->hGlobal = hGlobal;
 342     }
 343
 344     pmedium->pUnkForRelease = NULL;
 345
 346     // do copy the data
 347     hr = GetDataHere(pformatetcIn, pmedium);
 348     if ( FAILED(hr) ) {
 349         // free resources we allocated
 350         if ( pmedium->tymed == TYMED_HGLOBAL ) {
 351             GlobalFree(pmedium->hGlobal);
 352         }
 353
 354         return hr;
 355     }
 356
 357     return S_OK;
 358 }
 359
 360 STDMETHODIMP wxIDataObject::GetDataHere(FORMATETC *pformatetc,
 361                                         STGMEDIUM *pmedium)
 362 {
 363     wxLogTrace(wxTRACE_OleCalls, wxT("wxIDataObject::GetDataHere"));
 364
 365     // put data in caller provided medium
 366     switch ( pmedium->tymed )
 367     {
 368         case TYMED_GDI:
 369             if ( !m_pDataObject->GetDataHere(wxDF_BITMAP, &pmedium->hBitmap) )
 370                 return E_UNEXPECTED;
 371             break;
 372
 373         case TYMED_MFPICT:
 374             // this should be copied on bitmaps - but I don't have time for
 375             // this now
 376             wxFAIL_MSG(wxT("TODO - no support for metafiles in wxDataObject"));
 377             break;
 378
 379         case TYMED_HGLOBAL:
 380             {
 381                 // copy data
 382                 HGLOBAL hGlobal = pmedium->hGlobal;
 383                 void *pBuf = GlobalLock(hGlobal);
 384                 if ( pBuf == NULL ) {
 385                     wxLogLastError(wxT("GlobalLock"));
 386                     return E_OUTOFMEMORY;
 387                 }
 388
 389                 if ( !wxDataFormat(pformatetc->cfFormat).IsStandard() ) {
 390                     // for custom formats, put the size with the data
 391                     size_t *p = (size_t *)pBuf;
 392                     *p++ = GlobalSize(hGlobal);
 393                     pBuf = p;
 394                 }
 395
 396                 wxDataFormat format = pformatetc->cfFormat;
 397                 if ( !m_pDataObject->GetDataHere(format, pBuf) )
 398                     return E_UNEXPECTED;
 399
 400                 GlobalUnlock(hGlobal);
 401             }
 402             break;
 403
 404         default:
 405             return DV_E_TYMED;
 406     }
 407
 408     return S_OK;
 409 }
 410
 411 // set data functions
 412 STDMETHODIMP wxIDataObject::SetData(FORMATETC *pformatetc,
 413                                     STGMEDIUM *pmedium,
 414                                     BOOL       fRelease)
 415 {
 416     wxLogTrace(wxTRACE_OleCalls, wxT("wxIDataObject::SetData"));
 417
 418     switch ( pmedium->tymed )
 419     {
 420         case TYMED_GDI:
 421             m_pDataObject->SetData(wxDF_BITMAP, 0, &pmedium->hBitmap);
 422             break;
 423
 424         case TYMED_MFPICT:
 425             // this should be copied on bitmaps - but I don't have time for
 426             // this now
 427             wxFAIL_MSG(wxT("TODO - no support for metafiles in wxDataObject"));
 428             break;
 429
 430         case TYMED_HGLOBAL:
 431             {
 432                 // copy data
 433                 void *pBuf = GlobalLock(pmedium->hGlobal);
 434                 if ( pBuf == NULL ) {
 435                     wxLogLastError("GlobalLock");
 436
 437                     return E_OUTOFMEMORY;
 438                 }
 439
 440                 // we've got a problem with SetData() here because the base
 441                 // class version requires the size parameter which we don't
 442                 // have anywhere in OLE data transfer - so we need to
 443                 // synthetise it for known formats and we suppose that all data
 444                 // in custom formats starts with a DWORD containing the size
 445                 size_t size;
 446                 switch ( pformatetc->cfFormat )
 447                 {
 448                     case CF_TEXT:
 449                     case CF_OEMTEXT:
 450                         size = strlen((const char *)pBuf);
 451                         break;
 452
 453                     case CF_UNICODETEXT:
 454                         size = wcslen((const wchar_t *)pBuf);
 455                         break;
 456
 457                     case CF_BITMAP:
 458                     case CF_HDROP:
 459                         // these formats don't use size at all, anyhow (but
 460                         // pass data by handle, which is always a single DWORD)
 461                         size = 0;
 462                         break;
 463
 464                     default:
 465                         {
 466                             // we suppose that the size precedes the data
 467                             size_t *p = (size_t *)pBuf;
 468                             size = *p++;
 469                             pBuf = p;
 470                         }
 471                 }
 472
 473                 wxDataFormat format = pformatetc->cfFormat;
 474                 bool ok = m_pDataObject->SetData(format, size, pBuf);
 475
 476                 GlobalUnlock(pmedium->hGlobal);
 477
 478                 if ( !ok ) {
 479                     return E_UNEXPECTED;
 480                 }
 481             }
 482             break;
 483
 484         default:
 485             return DV_E_TYMED;
 486     }
 487
 488     if ( fRelease ) {
 489         // we own the medium, so we must release it - but do *not* free the
 490         // bitmap handle fi we have it because we have copied it elsewhere
 491         if ( pmedium->tymed == TYMED_GDI )
 492         {
 493             pmedium->hBitmap = 0;
 494         }
 495
 496         ReleaseStgMedium(pmedium);
 497     }
 498
 499     return S_OK;
 500 }
 501
 502 // information functions
 503 STDMETHODIMP wxIDataObject::QueryGetData(FORMATETC *pformatetc)
 504 {
 505     // do we accept data in this format?
 506     if ( pformatetc == NULL ) {
 507         wxLogTrace(wxTRACE_OleCalls,
 508                    wxT("wxIDataObject::QueryGetData: invalid ptr."));
 509
 510         return E_INVALIDARG;
 511     }
 512
 513     // the only one allowed by current COM implementation
 514     if ( pformatetc->lindex != -1 ) {
 515         wxLogTrace(wxTRACE_OleCalls,
 516                    wxT("wxIDataObject::QueryGetData: bad lindex %d"),
 517                    pformatetc->lindex);
 518
 519         return DV_E_LINDEX;
 520     }
 521
 522     // we don't support anything other (THUMBNAIL, ICON, DOCPRINT...)
 523     if ( pformatetc->dwAspect != DVASPECT_CONTENT ) {
 524         wxLogTrace(wxTRACE_OleCalls,
 525                    wxT("wxIDataObject::QueryGetData: bad dwAspect %d"),
 526                    pformatetc->dwAspect);
 527
 528         return DV_E_DVASPECT;
 529     }
 530
 531     // and now check the type of data requested
 532     wxDataFormat format = pformatetc->cfFormat;
 533     if ( m_pDataObject->IsSupportedFormat(format) ) {
 534 #ifdef __WXDEBUG__
 535         wxLogTrace(wxTRACE_OleCalls, wxT("wxIDataObject::QueryGetData: %s ok"),
 536                    wxDataObject::GetFormatName(format));
 537 #endif // Debug
 538     }
 539     else {
 540         wxLogTrace(wxTRACE_OleCalls,
 541                    wxT("wxIDataObject::QueryGetData: %s unsupported"),
 542                    wxDataObject::GetFormatName(format));
 543
 544         return DV_E_FORMATETC;
 545     }
 546
 547     // we only transfer data by global memory, except for some particular cases
 548     DWORD tymed = pformatetc->tymed;
 549     if ( (format == wxDF_BITMAP && !(tymed & TYMED_GDI)) &&
 550          !(tymed & TYMED_HGLOBAL) ) {
 551         // it's not what we're waiting for
 552 #ifdef __WXDEBUG__
 553         wxLogTrace(wxTRACE_OleCalls,
 554                    wxT("wxIDataObject::QueryGetData: %s != %s"),
 555                    GetTymedName(tymed),
 556                    GetTymedName(format == wxDF_BITMAP ? TYMED_GDI
 557                                                       : TYMED_HGLOBAL));
 558 #endif // Debug
 559
 560         return DV_E_TYMED;
 561     }
 562
 563     return S_OK;
 564 }
 565
 566 STDMETHODIMP wxIDataObject::GetCanonicalFormatEtc(FORMATETC *pFormatetcIn,
 567                                                   FORMATETC *pFormatetcOut)
 568 {
 569     wxLogTrace(wxTRACE_OleCalls, wxT("wxIDataObject::GetCanonicalFormatEtc"));
 570
 571     // TODO we might want something better than this trivial implementation here
 572     if ( pFormatetcOut != NULL )
 573         pFormatetcOut->ptd = NULL;
 574
 575     return DATA_S_SAMEFORMATETC;
 576 }
 577
 578 STDMETHODIMP wxIDataObject::EnumFormatEtc(DWORD dwDir,
 579                                           IEnumFORMATETC **ppenumFormatEtc)
 580 {
 581     wxLogTrace(wxTRACE_OleCalls, wxT("wxIDataObject::EnumFormatEtc"));
 582
 583     wxDataObject::Direction dir = dwDir == DATADIR_GET ? wxDataObject::Get
 584                                                        : wxDataObject::Set;
 585
 586     size_t nFormatCount = m_pDataObject->GetFormatCount(dir);
 587     wxDataFormat format, *formats;
 588     formats = nFormatCount == 1 ? &format : new wxDataFormat[nFormatCount];
 589     m_pDataObject->GetAllFormats(formats, dir);
 590
 591     wxIEnumFORMATETC *pEnum = new wxIEnumFORMATETC(formats, nFormatCount);
 592     pEnum->AddRef();
 593     *ppenumFormatEtc = pEnum;
 594
 595     if ( formats != &format ) {
 596         delete [] formats;
 597     }
 598
 599     return S_OK;
 600 }
 601
 602 // ----------------------------------------------------------------------------
 603 // advise sink functions (not implemented)
 604 // ----------------------------------------------------------------------------
 605
 606 STDMETHODIMP wxIDataObject::DAdvise(FORMATETC   *pformatetc,
 607                                     DWORD        advf,
 608                                     IAdviseSink *pAdvSink,
 609                                     DWORD       *pdwConnection)
 610 {
 611   return OLE_E_ADVISENOTSUPPORTED;
 612 }
 613
 614 STDMETHODIMP wxIDataObject::DUnadvise(DWORD dwConnection)
 615 {
 616   return OLE_E_ADVISENOTSUPPORTED;
 617 }
 618
 619 STDMETHODIMP wxIDataObject::EnumDAdvise(IEnumSTATDATA **ppenumAdvise)
 620 {
 621   return OLE_E_ADVISENOTSUPPORTED;
 622 }
 623
 624 // ----------------------------------------------------------------------------
 625 // wxDataObject
 626 // ----------------------------------------------------------------------------
 627
 628 wxDataObject::wxDataObject()
 629 {
 630     m_pIDataObject = new wxIDataObject(this);
 631     m_pIDataObject->AddRef();
 632 }
 633
 634 wxDataObject::~wxDataObject()
 635 {
 636     ReleaseInterface(m_pIDataObject);
 637 }
 638
 639 void wxDataObject::SetAutoDelete()
 640 {
 641     ((wxIDataObject *)m_pIDataObject)->SetDeleteFlag();
 642     m_pIDataObject->Release();
 643
 644     // so that the dtor doesnt' crash
 645     m_pIDataObject = NULL;
 646 }
 647
 648 bool wxDataObject::IsSupportedFormat(const wxDataFormat& format) const
 649 {
 650     size_t nFormatCount = GetFormatCount();
 651     if ( nFormatCount == 1 ) {
 652         return format == GetPreferredFormat();
 653     }
 654     else {
 655         wxDataFormat *formats = new wxDataFormat[nFormatCount];
 656         GetAllFormats(formats);
 657
 658         size_t n;
 659         for ( n = 0; n < nFormatCount; n++ ) {
 660             if ( formats[n] == format )
 661                 break;
 662         }
 663
 664         delete [] formats;
 665
 666         // found?
 667         return n < nFormatCount;
 668     }
 669 }
 670
 671 #ifdef __WXDEBUG__
 672 const char *wxDataObject::GetFormatName(wxDataFormat format)
 673 {
 674   // case 'xxx' is not a valid value for switch of enum 'wxDataFormat'
 675   #ifdef __VISUALC__
 676     #pragma warning(disable:4063)
 677   #endif // VC++
 678
 679   static char s_szBuf[128];
 680   switch ( format ) {
 681     case CF_TEXT:         return "CF_TEXT";
 682     case CF_BITMAP:       return "CF_BITMAP";
 683     case CF_METAFILEPICT: return "CF_METAFILEPICT";
 684     case CF_SYLK:         return "CF_SYLK";
 685     case CF_DIF:          return "CF_DIF";
 686     case CF_TIFF:         return "CF_TIFF";
 687     case CF_OEMTEXT:      return "CF_OEMTEXT";
 688     case CF_DIB:          return "CF_DIB";
 689     case CF_PALETTE:      return "CF_PALETTE";
 690     case CF_PENDATA:      return "CF_PENDATA";
 691     case CF_RIFF:         return "CF_RIFF";
 692     case CF_WAVE:         return "CF_WAVE";
 693     case CF_UNICODETEXT:  return "CF_UNICODETEXT";
 694     case CF_ENHMETAFILE:  return "CF_ENHMETAFILE";
 695     case CF_HDROP:        return "CF_HDROP";
 696     case CF_LOCALE:       return "CF_LOCALE";
 697     default:
 698       sprintf(s_szBuf, "clipboard format 0x%x (unknown)", format);
 699       return s_szBuf;
 700   }
 701
 702   #ifdef __VISUALC__
 703     #pragma warning(default:4063)
 704   #endif // VC++
 705 }
 706 #endif // Debug
 707
 708 // ----------------------------------------------------------------------------
 709 // wxBitmapDataObject supports CF_DIB format
 710 // ----------------------------------------------------------------------------
 711
 712 size_t wxBitmapDataObject::GetDataSize() const
 713 {
 714     return wxConvertBitmapToDIB(NULL, GetBitmap());
 715 }
 716
 717 bool wxBitmapDataObject::GetDataHere(void *buf) const
 718 {
 719     return wxConvertBitmapToDIB((BITMAPINFO *)buf, GetBitmap()) != 0;
 720 }
 721
 722 bool wxBitmapDataObject::SetData(size_t len, const void *buf)
 723 {
 724     wxBitmap bitmap(wxConvertDIBToBitmap((const BITMAPINFO *)buf));
 725
 726     if ( !bitmap.Ok() ) {
 727         wxFAIL_MSG(wxT("pasting/dropping invalid bitmap"));
 728
 729         return FALSE;
 730     }
 731
 732     SetBitmap(bitmap);
 733
 734     return TRUE;
 735 }
 736
 737 // ----------------------------------------------------------------------------
 738 // wxBitmapDataObject2 supports CF_BITMAP format
 739 // ----------------------------------------------------------------------------
 740
 741 // the bitmaps aren't passed by value as other types of data (i.e. by copying
 742 // the data into a global memory chunk and passing it to the clipboard or
 743 // another application or whatever), but by handle, so these generic functions
 744 // don't make much sense to them.
 745
 746 size_t wxBitmapDataObject2::GetDataSize() const
 747 {
 748     return 0;
 749 }
 750
 751 bool wxBitmapDataObject2::GetDataHere(void *pBuf) const
 752 {
 753     // we put a bitmap handle into pBuf
 754     *(WXHBITMAP *)pBuf = GetBitmap().GetHBITMAP();
 755
 756     return TRUE;
 757 }
 758
 759 bool wxBitmapDataObject2::SetData(size_t len, const void *pBuf)
 760 {
 761     HBITMAP hbmp = *(HBITMAP *)pBuf;
 762
 763     BITMAP bmp;
 764     if ( !GetObject(hbmp, sizeof(BITMAP), &bmp) )
 765     {
 766         wxLogLastError("GetObject(HBITMAP)");
 767     }
 768
 769     wxBitmap bitmap(bmp.bmWidth, bmp.bmHeight, bmp.bmPlanes);
 770     bitmap.SetHBITMAP((WXHBITMAP)hbmp);
 771
 772     if ( !bitmap.Ok() ) {
 773         wxFAIL_MSG(wxT("pasting/dropping invalid bitmap"));
 774
 775         return FALSE;
 776     }
 777
 778     SetBitmap(bitmap);
 779
 780     return TRUE;
 781 }
 782
 783 #if 0
 784
 785 size_t wxBitmapDataObject::GetDataSize(const wxDataFormat& format) const
 786 {
 787     if ( format.GetFormatId() == CF_DIB )
 788     {
 789         // create the DIB
 790         ScreenHDC hdc;
 791
 792         // shouldn't be selected into a DC or GetDIBits() would fail
 793         wxASSERT_MSG( !m_bitmap.GetSelectedInto(),
 794                       wxT("can't copy bitmap selected into wxMemoryDC") );
 795
 796         // first get the info
 797         BITMAPINFO bi;
 798         if ( !GetDIBits(hdc, (HBITMAP)m_bitmap.GetHBITMAP(), 0, 0,
 799                         NULL, &bi, DIB_RGB_COLORS) )
 800         {
 801             wxLogLastError("GetDIBits(NULL)");
 802
 803             return 0;
 804         }
 805
 806         return sizeof(BITMAPINFO) + bi.bmiHeader.biSizeImage;
 807     }
 808     else // CF_BITMAP
 809     {
 810         // no data to copy - we don't pass HBITMAP via global memory
 811         return 0;
 812     }
 813 }
 814
 815 bool wxBitmapDataObject::GetDataHere(const wxDataFormat& format,
 816                                      void *pBuf) const
 817 {
 818     wxASSERT_MSG( m_bitmap.Ok(), wxT("copying invalid bitmap") );
 819
 820     HBITMAP hbmp = (HBITMAP)m_bitmap.GetHBITMAP();
 821     if ( format.GetFormatId() == CF_DIB )
 822     {
 823         // create the DIB
 824         ScreenHDC hdc;
 825
 826         // shouldn't be selected into a DC or GetDIBits() would fail
 827         wxASSERT_MSG( !m_bitmap.GetSelectedInto(),
 828                       wxT("can't copy bitmap selected into wxMemoryDC") );
 829
 830         // first get the info
 831         BITMAPINFO *pbi = (BITMAPINFO *)pBuf;
 832         if ( !GetDIBits(hdc, hbmp, 0, 0, NULL, pbi, DIB_RGB_COLORS) )
 833         {
 834             wxLogLastError("GetDIBits(NULL)");
 835
 836             return 0;
 837         }
 838
 839         // and now copy the bits
 840         if ( !GetDIBits(hdc, hbmp, 0, pbi->bmiHeader.biHeight, pbi + 1,
 841                         pbi, DIB_RGB_COLORS) )
 842         {
 843             wxLogLastError("GetDIBits");
 844
 845             return FALSE;
 846         }
 847     }
 848     else // CF_BITMAP
 849     {
 850         // we put a bitmap handle into pBuf
 851         *(HBITMAP *)pBuf = hbmp;
 852     }
 853
 854     return TRUE;
 855 }
 856
 857 bool wxBitmapDataObject::SetData(const wxDataFormat& format,
 858                                  size_t size, const void *pBuf)
 859 {
 860     HBITMAP hbmp;
 861     if ( format.GetFormatId() == CF_DIB )
 862     {
 863         // here we get BITMAPINFO struct followed by the actual bitmap bits and
 864         // BITMAPINFO starts with BITMAPINFOHEADER followed by colour info
 865         ScreenHDC hdc;
 866
 867         BITMAPINFO *pbmi = (BITMAPINFO *)pBuf;
 868         BITMAPINFOHEADER *pbmih = &pbmi->bmiHeader;
 869         hbmp = CreateDIBitmap(hdc, pbmih, CBM_INIT,
 870                               pbmi + 1, pbmi, DIB_RGB_COLORS);
 871         if ( !hbmp )
 872         {
 873             wxLogLastError("CreateDIBitmap");
 874         }
 875
 876         m_bitmap.SetWidth(pbmih->biWidth);
 877         m_bitmap.SetHeight(pbmih->biHeight);
 878     }
 879     else // CF_BITMAP
 880     {
 881         // it's easy with bitmaps: we pass them by handle
 882         hbmp = *(HBITMAP *)pBuf;
 883
 884         BITMAP bmp;
 885         if ( !GetObject(hbmp, sizeof(BITMAP), &bmp) )
 886         {
 887             wxLogLastError("GetObject(HBITMAP)");
 888         }
 889
 890         m_bitmap.SetWidth(bmp.bmWidth);
 891         m_bitmap.SetHeight(bmp.bmHeight);
 892         m_bitmap.SetDepth(bmp.bmPlanes);
 893     }
 894
 895     m_bitmap.SetHBITMAP((WXHBITMAP)hbmp);
 896
 897     wxASSERT_MSG( m_bitmap.Ok(), wxT("pasting invalid bitmap") );
 898
 899     return TRUE;
 900 }
 901
 902 #endif // 0
 903
 904 // ----------------------------------------------------------------------------
 905 // wxFileDataObject
 906 // ----------------------------------------------------------------------------
 907
 908 bool wxFileDataObject::SetData(size_t WXUNUSED(size), const void *pData)
 909 {
 910     m_filenames.Empty();
 911
 912     // the documentation states that the first member of DROPFILES structure is
 913     // a "DWORD offset of double NUL terminated file list". What they mean by
 914     // this (I wonder if you see it immediately) is that the list starts at
 915     // ((char *)&(pDropFiles.pFiles)) + pDropFiles.pFiles. We're also advised
 916     // to use DragQueryFile to work with this structure, but not told where and
 917     // how to get HDROP.
 918     HDROP hdrop = (HDROP)pData;   // NB: it works, but I'm not sure about it
 919
 920     // get number of files (magic value -1)
 921     UINT nFiles = ::DragQueryFile(hdrop, (unsigned)-1, NULL, 0u);
 922
 923     // for each file get the length, allocate memory and then get the name
 924     wxString str;
 925     UINT len, n;
 926     for ( n = 0; n < nFiles; n++ ) {
 927         // +1 for terminating NUL
 928         len = ::DragQueryFile(hdrop, n, NULL, 0) + 1;
 929
 930         UINT len2 = ::DragQueryFile(hdrop, n, str.GetWriteBuf(len), len);
 931         str.UngetWriteBuf();
 932         m_filenames.Add(str);
 933
 934         if ( len2 != len - 1 ) {
 935             wxLogDebug(wxT("In wxFileDropTarget::OnDrop DragQueryFile returned"
 936                            " %d characters, %d expected."), len2, len - 1);
 937         }
 938     }
 939
 940     return TRUE;
 941 }
 942
 943 // ----------------------------------------------------------------------------
 944 // private functions
 945 // ----------------------------------------------------------------------------
 946
 947 // otherwise VC++ would give here:
 948 //  "local variable 'bi' may be used without having been initialized"
 949 // even though in fact it may not
 950 #ifdef __VISUALC__
 951     #pragma warning(disable:4701)
 952 #endif // __VISUALC__
 953
 954 size_t wxConvertBitmapToDIB(BITMAPINFO *pbi, const wxBitmap& bitmap)
 955 {
 956     // shouldn't be selected into a DC or GetDIBits() would fail
 957     wxASSERT_MSG( !bitmap.GetSelectedInto(),
 958                   wxT("can't copy bitmap selected into wxMemoryDC") );
 959
 960     HBITMAP hbmp = (HBITMAP)bitmap.GetHBITMAP();
 961
 962     BITMAPINFO bi;
 963
 964     // first get the info
 965     ScreenHDC hdc;
 966     if ( !GetDIBits(hdc, hbmp, 0, 0, NULL, pbi ? pbi : &bi, DIB_RGB_COLORS) )
 967     {
 968         wxLogLastError("GetDIBits(NULL)");
 969
 970         return 0;
 971     }
 972
 973     if ( !pbi )
 974     {
 975         // we were only asked for size needed for the buffer, not to actually
 976         // copy the data
 977         return sizeof(BITMAPINFO) + bi.bmiHeader.biSizeImage;
 978     }
 979
 980     // and now copy the bits
 981     if ( !GetDIBits(hdc, hbmp, 0, pbi->bmiHeader.biHeight, pbi + 1,
 982                     pbi, DIB_RGB_COLORS) )
 983     {
 984         wxLogLastError("GetDIBits");
 985
 986         return 0;
 987     }
 988
 989     return sizeof(BITMAPINFO) + pbi->bmiHeader.biSizeImage;
 990 }
 991
 992 #ifdef __VISUALC__
 993     #pragma warning(default:4701)
 994 #endif // __VISUALC__
 995
 996 wxBitmap wxConvertDIBToBitmap(const BITMAPINFO *pbmi)
 997 {
 998     // here we get BITMAPINFO struct followed by the actual bitmap bits and
 999     // BITMAPINFO starts with BITMAPINFOHEADER followed by colour info
1000     const BITMAPINFOHEADER *pbmih = &pbmi->bmiHeader;
1001
1002     ScreenHDC hdc;
1003     HBITMAP hbmp = CreateDIBitmap(hdc, pbmih, CBM_INIT,
1004                                   pbmi + 1, pbmi, DIB_RGB_COLORS);
1005     if ( !hbmp )
1006     {
1007         wxLogLastError("CreateDIBitmap");
1008     }
1009
1010     wxBitmap bitmap(pbmih->biWidth, pbmih->biHeight, pbmih->biBitCount);
1011     bitmap.SetHBITMAP((WXHBITMAP)hbmp);
1012
1013     return bitmap;
1014 }
1015
1016 #ifdef __WXDEBUG__
1017
1018 static const wxChar *GetTymedName(DWORD tymed)
1019 {
1020     static wxChar s_szBuf[128];
1021     switch ( tymed ) {
1022         case TYMED_HGLOBAL:   return wxT("TYMED_HGLOBAL");
1023         case TYMED_FILE:      return wxT("TYMED_FILE");
1024         case TYMED_ISTREAM:   return wxT("TYMED_ISTREAM");
1025         case TYMED_ISTORAGE:  return wxT("TYMED_ISTORAGE");
1026         case TYMED_GDI:       return wxT("TYMED_GDI");
1027         case TYMED_MFPICT:    return wxT("TYMED_MFPICT");
1028         case TYMED_ENHMF:     return wxT("TYMED_ENHMF");
1029         default:
1030             wxSprintf(s_szBuf, wxT("type of media format %d (unknown)"), tymed);
1031             return s_szBuf;
1032     }
1033 }
1034
1035 #endif // Debug
1036
1037 #endif // not using OLE at all
1038