]>
git.saurik.com Git - wxWidgets.git/blob - src/msw/ole/dataobj.cpp
1 ///////////////////////////////////////////////////////////////////////////////
2 // Name: msw/ole/dataobj.cpp
3 // Purpose: implementation of wx[I]DataObject class
4 // Author: Vadim Zeitlin
8 // Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
9 // Licence: wxWindows license
10 ///////////////////////////////////////////////////////////////////////////////
12 // ============================================================================
14 // ============================================================================
16 // ----------------------------------------------------------------------------
18 // ----------------------------------------------------------------------------
21 #pragma implementation "dataobj.h"
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
27 #if defined(__BORLANDC__)
35 #if defined(__WIN32__) && !defined(__GNUWIN32__) || defined(wxUSE_NORLANDER_HEADERS)
38 #include "wx/dataobj.h"
41 #ifdef wxUSE_NORLANDER_HEADERS
53 #include "wx/msw/ole/oleutils.h"
55 // ----------------------------------------------------------------------------
57 // ----------------------------------------------------------------------------
60 static const wxChar
*GetTymedName(DWORD tymed
);
62 #define GetTymedName(tymed) ""
63 #endif // Debug/!Debug
65 // to be moved into wx/msw/bitmap.h
66 extern size_t wxConvertBitmapToDIB(BITMAPINFO
*pbi
, const wxBitmap
& bitmap
);
67 extern wxBitmap
wxConvertDIBToBitmap(const BITMAPINFO
*bmi
);
69 // ----------------------------------------------------------------------------
70 // wxIEnumFORMATETC interface implementation
71 // ----------------------------------------------------------------------------
73 class wxIEnumFORMATETC
: public IEnumFORMATETC
76 wxIEnumFORMATETC(const wxDataFormat
* formats
, ULONG nCount
);
77 ~wxIEnumFORMATETC() { delete [] m_formats
; }
79 DECLARE_IUNKNOWN_METHODS
;
82 STDMETHODIMP
Next(ULONG celt
, FORMATETC
*rgelt
, ULONG
*pceltFetched
);
83 STDMETHODIMP
Skip(ULONG celt
);
85 STDMETHODIMP
Clone(IEnumFORMATETC
**ppenum
);
88 CLIPFORMAT
*m_formats
; // formats we can provide data in
89 ULONG m_nCount
, // number of formats we support
90 m_nCurrent
; // current enum position
93 // ----------------------------------------------------------------------------
94 // wxIDataObject implementation of IDataObject interface
95 // ----------------------------------------------------------------------------
97 class wxIDataObject
: public IDataObject
100 wxIDataObject(wxDataObject
*pDataObject
);
103 // normally, wxDataObject controls our lifetime (i.e. we're deleted when it
104 // is), but in some cases, the situation is inversed, that is we delete it
105 // when this object is deleted - setting this flag enables such logic
106 void SetDeleteFlag() { m_mustDelete
= TRUE
; }
108 DECLARE_IUNKNOWN_METHODS
;
111 STDMETHODIMP
GetData(FORMATETC
*pformatetcIn
, STGMEDIUM
*pmedium
);
112 STDMETHODIMP
GetDataHere(FORMATETC
*pformatetc
, STGMEDIUM
*pmedium
);
113 STDMETHODIMP
QueryGetData(FORMATETC
*pformatetc
);
114 STDMETHODIMP
GetCanonicalFormatEtc(FORMATETC
*In
, FORMATETC
*pOut
);
115 STDMETHODIMP
SetData(FORMATETC
*pfetc
, STGMEDIUM
*pmedium
, BOOL fRelease
);
116 STDMETHODIMP
EnumFormatEtc(DWORD dwDirection
, IEnumFORMATETC
**ppenumFEtc
);
117 STDMETHODIMP
DAdvise(FORMATETC
*pfetc
, DWORD ad
, IAdviseSink
*p
, DWORD
*pdw
);
118 STDMETHODIMP
DUnadvise(DWORD dwConnection
);
119 STDMETHODIMP
EnumDAdvise(IEnumSTATDATA
**ppenumAdvise
);
122 wxDataObject
*m_pDataObject
; // pointer to C++ class we belong to
127 // ----------------------------------------------------------------------------
128 // small helper class for getting screen DC (we're working with bitmaps and
130 // ----------------------------------------------------------------------------
135 ScreenHDC() { m_hdc
= GetDC(NULL
); }
136 ~ScreenHDC() { ReleaseDC(NULL
, m_hdc
); }
137 operator HDC() const { return m_hdc
; }
143 // ============================================================================
145 // ============================================================================
147 // ----------------------------------------------------------------------------
149 // ----------------------------------------------------------------------------
151 void wxDataFormat::SetId(const wxChar
*format
)
153 m_format
= ::RegisterClipboardFormat(format
);
156 wxLogError(_("Couldn't register clipboard format '%s'."), format
);
160 wxString
wxDataFormat::GetId() const
162 static const int max
= 256;
166 wxCHECK_MSG( !IsStandard(), s
,
167 wxT("name of predefined format cannot be retrieved") );
169 int len
= ::GetClipboardFormatName(m_format
, s
.GetWriteBuf(max
), max
);
174 wxLogError(_("The clipboard format '%d' doesn't exist."), m_format
);
180 // ----------------------------------------------------------------------------
182 // ----------------------------------------------------------------------------
184 BEGIN_IID_TABLE(wxIEnumFORMATETC
)
186 ADD_IID(EnumFORMATETC
)
189 IMPLEMENT_IUNKNOWN_METHODS(wxIEnumFORMATETC
)
191 wxIEnumFORMATETC::wxIEnumFORMATETC(const wxDataFormat
*formats
, ULONG nCount
)
196 m_formats
= new CLIPFORMAT
[nCount
];
197 for ( ULONG n
= 0; n
< nCount
; n
++ ) {
198 m_formats
[n
] = formats
[n
].GetFormatId();
202 STDMETHODIMP
wxIEnumFORMATETC::Next(ULONG celt
,
206 wxLogTrace(wxTRACE_OleCalls
, wxT("wxIEnumFORMATETC::Next"));
209 // we only return 1 element at a time - mainly because I'm too lazy to
210 // implement something which you're never asked for anyhow
214 if ( m_nCurrent
< m_nCount
) {
216 format
.cfFormat
= m_formats
[m_nCurrent
++];
218 format
.dwAspect
= DVASPECT_CONTENT
;
220 format
.tymed
= TYMED_HGLOBAL
;
231 STDMETHODIMP
wxIEnumFORMATETC::Skip(ULONG celt
)
233 wxLogTrace(wxTRACE_OleCalls
, wxT("wxIEnumFORMATETC::Skip"));
236 if ( m_nCurrent
< m_nCount
)
239 // no, can't skip this many elements
245 STDMETHODIMP
wxIEnumFORMATETC::Reset()
247 wxLogTrace(wxTRACE_OleCalls
, wxT("wxIEnumFORMATETC::Reset"));
254 STDMETHODIMP
wxIEnumFORMATETC::Clone(IEnumFORMATETC
**ppenum
)
256 wxLogTrace(wxTRACE_OleCalls
, wxT("wxIEnumFORMATETC::Clone"));
258 // unfortunately, we can't reuse the code in ctor - types are different
259 wxIEnumFORMATETC
*pNew
= new wxIEnumFORMATETC(NULL
, 0);
260 pNew
->m_nCount
= m_nCount
;
261 pNew
->m_formats
= new CLIPFORMAT
[m_nCount
];
262 for ( ULONG n
= 0; n
< m_nCount
; n
++ ) {
263 pNew
->m_formats
[n
] = m_formats
[n
];
271 // ----------------------------------------------------------------------------
273 // ----------------------------------------------------------------------------
275 BEGIN_IID_TABLE(wxIDataObject
)
280 IMPLEMENT_IUNKNOWN_METHODS(wxIDataObject
)
282 wxIDataObject::wxIDataObject(wxDataObject
*pDataObject
)
285 m_pDataObject
= pDataObject
;
286 m_mustDelete
= FALSE
;
289 wxIDataObject::~wxIDataObject()
293 delete m_pDataObject
;
297 // get data functions
298 STDMETHODIMP
wxIDataObject::GetData(FORMATETC
*pformatetcIn
, STGMEDIUM
*pmedium
)
300 wxLogTrace(wxTRACE_OleCalls
, wxT("wxIDataObject::GetData"));
302 // is data is in our format?
303 HRESULT hr
= QueryGetData(pformatetcIn
);
307 // for the bitmaps and metafiles we use the handles instead of global memory
309 wxDataFormat format
= (wxDataFormatId
)pformatetcIn
->cfFormat
;
314 pmedium
->tymed
= TYMED_GDI
;
318 pmedium
->tymed
= TYMED_MFPICT
;
323 size_t size
= m_pDataObject
->GetDataSize(format
);
325 // it probably means that the method is just not implemented
326 wxLogDebug(wxT("Invalid data size - can't be 0"));
328 return DV_E_FORMATETC
;
331 if ( !format
.IsStandard() ) {
332 // for custom formats, put the size with the data - alloc the
334 size
+= sizeof(size_t);
337 HGLOBAL hGlobal
= GlobalAlloc(GMEM_MOVEABLE
| GMEM_SHARE
, size
);
338 if ( hGlobal
== NULL
) {
339 wxLogLastError("GlobalAlloc");
340 return E_OUTOFMEMORY
;
344 pmedium
->tymed
= TYMED_HGLOBAL
;
345 pmedium
->hGlobal
= hGlobal
;
348 pmedium
->pUnkForRelease
= NULL
;
351 hr
= GetDataHere(pformatetcIn
, pmedium
);
353 // free resources we allocated
354 if ( pmedium
->tymed
== TYMED_HGLOBAL
) {
355 GlobalFree(pmedium
->hGlobal
);
364 STDMETHODIMP
wxIDataObject::GetDataHere(FORMATETC
*pformatetc
,
367 wxLogTrace(wxTRACE_OleCalls
, wxT("wxIDataObject::GetDataHere"));
369 // put data in caller provided medium
370 switch ( pmedium
->tymed
)
373 if ( !m_pDataObject
->GetDataHere(wxDF_BITMAP
, &pmedium
->hBitmap
) )
378 // this should be copied on bitmaps - but I don't have time for
380 wxFAIL_MSG(wxT("TODO - no support for metafiles in wxDataObject"));
386 HGLOBAL hGlobal
= pmedium
->hGlobal
;
387 void *pBuf
= GlobalLock(hGlobal
);
388 if ( pBuf
== NULL
) {
389 wxLogLastError(wxT("GlobalLock"));
390 return E_OUTOFMEMORY
;
393 if ( !wxDataFormat(pformatetc
->cfFormat
).IsStandard() ) {
394 // for custom formats, put the size with the data
395 size_t *p
= (size_t *)pBuf
;
396 *p
++ = GlobalSize(hGlobal
);
400 wxDataFormat format
= pformatetc
->cfFormat
;
401 if ( !m_pDataObject
->GetDataHere(format
, pBuf
) )
404 GlobalUnlock(hGlobal
);
415 // set data functions
416 STDMETHODIMP
wxIDataObject::SetData(FORMATETC
*pformatetc
,
420 wxLogTrace(wxTRACE_OleCalls
, wxT("wxIDataObject::SetData"));
422 switch ( pmedium
->tymed
)
425 m_pDataObject
->SetData(wxDF_BITMAP
, 0, &pmedium
->hBitmap
);
429 // this should be copied on bitmaps - but I don't have time for
431 wxFAIL_MSG(wxT("TODO - no support for metafiles in wxDataObject"));
437 void *pBuf
= GlobalLock(pmedium
->hGlobal
);
438 if ( pBuf
== NULL
) {
439 wxLogLastError("GlobalLock");
441 return E_OUTOFMEMORY
;
444 // we've got a problem with SetData() here because the base
445 // class version requires the size parameter which we don't
446 // have anywhere in OLE data transfer - so we need to
447 // synthetise it for known formats and we suppose that all data
448 // in custom formats starts with a DWORD containing the size
450 switch ( pformatetc
->cfFormat
)
454 size
= strlen((const char *)pBuf
);
458 size
= wcslen((const wchar_t *)pBuf
);
463 // these formats don't use size at all, anyhow (but
464 // pass data by handle, which is always a single DWORD)
469 // the handler will calculate size itself (it's too
470 // complicated to do it here)
476 // we suppose that the size precedes the data
477 size_t *p
= (size_t *)pBuf
;
483 wxDataFormat format
= pformatetc
->cfFormat
;
484 bool ok
= m_pDataObject
->SetData(format
, size
, pBuf
);
486 GlobalUnlock(pmedium
->hGlobal
);
499 // we own the medium, so we must release it - but do *not* free the
500 // bitmap handle fi we have it because we have copied it elsewhere
501 if ( pmedium
->tymed
== TYMED_GDI
)
503 pmedium
->hBitmap
= 0;
506 ReleaseStgMedium(pmedium
);
512 // information functions
513 STDMETHODIMP
wxIDataObject::QueryGetData(FORMATETC
*pformatetc
)
515 // do we accept data in this format?
516 if ( pformatetc
== NULL
) {
517 wxLogTrace(wxTRACE_OleCalls
,
518 wxT("wxIDataObject::QueryGetData: invalid ptr."));
523 // the only one allowed by current COM implementation
524 if ( pformatetc
->lindex
!= -1 ) {
525 wxLogTrace(wxTRACE_OleCalls
,
526 wxT("wxIDataObject::QueryGetData: bad lindex %d"),
532 // we don't support anything other (THUMBNAIL, ICON, DOCPRINT...)
533 if ( pformatetc
->dwAspect
!= DVASPECT_CONTENT
) {
534 wxLogTrace(wxTRACE_OleCalls
,
535 wxT("wxIDataObject::QueryGetData: bad dwAspect %d"),
536 pformatetc
->dwAspect
);
538 return DV_E_DVASPECT
;
541 // and now check the type of data requested
542 wxDataFormat format
= pformatetc
->cfFormat
;
543 if ( m_pDataObject
->IsSupportedFormat(format
) ) {
544 wxLogTrace(wxTRACE_OleCalls
, wxT("wxIDataObject::QueryGetData: %s ok"),
545 wxGetFormatName(format
));
548 wxLogTrace(wxTRACE_OleCalls
,
549 wxT("wxIDataObject::QueryGetData: %s unsupported"),
550 wxGetFormatName(format
));
552 return DV_E_FORMATETC
;
555 // we only transfer data by global memory, except for some particular cases
556 DWORD tymed
= pformatetc
->tymed
;
557 if ( (format
== wxDF_BITMAP
&& !(tymed
& TYMED_GDI
)) &&
558 !(tymed
& TYMED_HGLOBAL
) ) {
559 // it's not what we're waiting for
560 wxLogTrace(wxTRACE_OleCalls
,
561 wxT("wxIDataObject::QueryGetData: %s != %s"),
563 GetTymedName(format
== wxDF_BITMAP
? TYMED_GDI
572 STDMETHODIMP
wxIDataObject::GetCanonicalFormatEtc(FORMATETC
*pFormatetcIn
,
573 FORMATETC
*pFormatetcOut
)
575 wxLogTrace(wxTRACE_OleCalls
, wxT("wxIDataObject::GetCanonicalFormatEtc"));
577 // TODO we might want something better than this trivial implementation here
578 if ( pFormatetcOut
!= NULL
)
579 pFormatetcOut
->ptd
= NULL
;
581 return DATA_S_SAMEFORMATETC
;
584 STDMETHODIMP
wxIDataObject::EnumFormatEtc(DWORD dwDir
,
585 IEnumFORMATETC
**ppenumFormatEtc
)
587 wxLogTrace(wxTRACE_OleCalls
, wxT("wxIDataObject::EnumFormatEtc"));
589 wxDataObject::Direction dir
= dwDir
== DATADIR_GET
? wxDataObject::Get
592 size_t nFormatCount
= m_pDataObject
->GetFormatCount(dir
);
593 wxDataFormat format
, *formats
;
594 formats
= nFormatCount
== 1 ? &format
: new wxDataFormat
[nFormatCount
];
595 m_pDataObject
->GetAllFormats(formats
, dir
);
597 wxIEnumFORMATETC
*pEnum
= new wxIEnumFORMATETC(formats
, nFormatCount
);
599 *ppenumFormatEtc
= pEnum
;
601 if ( formats
!= &format
) {
608 // ----------------------------------------------------------------------------
609 // advise sink functions (not implemented)
610 // ----------------------------------------------------------------------------
612 STDMETHODIMP
wxIDataObject::DAdvise(FORMATETC
*pformatetc
,
614 IAdviseSink
*pAdvSink
,
615 DWORD
*pdwConnection
)
617 return OLE_E_ADVISENOTSUPPORTED
;
620 STDMETHODIMP
wxIDataObject::DUnadvise(DWORD dwConnection
)
622 return OLE_E_ADVISENOTSUPPORTED
;
625 STDMETHODIMP
wxIDataObject::EnumDAdvise(IEnumSTATDATA
**ppenumAdvise
)
627 return OLE_E_ADVISENOTSUPPORTED
;
630 // ----------------------------------------------------------------------------
632 // ----------------------------------------------------------------------------
634 wxDataObject::wxDataObject()
636 m_pIDataObject
= new wxIDataObject(this);
637 m_pIDataObject
->AddRef();
640 wxDataObject::~wxDataObject()
642 ReleaseInterface(m_pIDataObject
);
645 void wxDataObject::SetAutoDelete()
647 ((wxIDataObject
*)m_pIDataObject
)->SetDeleteFlag();
648 m_pIDataObject
->Release();
650 // so that the dtor doesnt' crash
651 m_pIDataObject
= NULL
;
654 bool wxDataObject::IsSupportedFormat(const wxDataFormat
& format
) const
656 size_t nFormatCount
= GetFormatCount();
657 if ( nFormatCount
== 1 ) {
658 return format
== GetPreferredFormat();
661 wxDataFormat
*formats
= new wxDataFormat
[nFormatCount
];
662 GetAllFormats(formats
);
665 for ( n
= 0; n
< nFormatCount
; n
++ ) {
666 if ( formats
[n
] == format
)
673 return n
< nFormatCount
;
679 const char *wxDataObject::GetFormatName(wxDataFormat format
)
681 // case 'xxx' is not a valid value for switch of enum 'wxDataFormat'
683 #pragma warning(disable:4063)
686 static char s_szBuf
[128];
688 case CF_TEXT
: return "CF_TEXT";
689 case CF_BITMAP
: return "CF_BITMAP";
690 case CF_METAFILEPICT
: return "CF_METAFILEPICT";
691 case CF_SYLK
: return "CF_SYLK";
692 case CF_DIF
: return "CF_DIF";
693 case CF_TIFF
: return "CF_TIFF";
694 case CF_OEMTEXT
: return "CF_OEMTEXT";
695 case CF_DIB
: return "CF_DIB";
696 case CF_PALETTE
: return "CF_PALETTE";
697 case CF_PENDATA
: return "CF_PENDATA";
698 case CF_RIFF
: return "CF_RIFF";
699 case CF_WAVE
: return "CF_WAVE";
700 case CF_UNICODETEXT
: return "CF_UNICODETEXT";
701 case CF_ENHMETAFILE
: return "CF_ENHMETAFILE";
702 case CF_HDROP
: return "CF_HDROP";
703 case CF_LOCALE
: return "CF_LOCALE";
705 sprintf(s_szBuf
, "clipboard format 0x%x (unknown)", format
);
710 #pragma warning(default:4063)
716 // ----------------------------------------------------------------------------
717 // wxBitmapDataObject supports CF_DIB format
718 // ----------------------------------------------------------------------------
720 size_t wxBitmapDataObject::GetDataSize() const
722 return wxConvertBitmapToDIB(NULL
, GetBitmap());
725 bool wxBitmapDataObject::GetDataHere(void *buf
) const
727 return wxConvertBitmapToDIB((BITMAPINFO
*)buf
, GetBitmap()) != 0;
730 bool wxBitmapDataObject::SetData(size_t len
, const void *buf
)
732 wxBitmap
bitmap(wxConvertDIBToBitmap((const BITMAPINFO
*)buf
));
734 if ( !bitmap
.Ok() ) {
735 wxFAIL_MSG(wxT("pasting/dropping invalid bitmap"));
745 // ----------------------------------------------------------------------------
746 // wxBitmapDataObject2 supports CF_BITMAP format
747 // ----------------------------------------------------------------------------
749 // the bitmaps aren't passed by value as other types of data (i.e. by copying
750 // the data into a global memory chunk and passing it to the clipboard or
751 // another application or whatever), but by handle, so these generic functions
752 // don't make much sense to them.
754 size_t wxBitmapDataObject2::GetDataSize() const
759 bool wxBitmapDataObject2::GetDataHere(void *pBuf
) const
761 // we put a bitmap handle into pBuf
762 *(WXHBITMAP
*)pBuf
= GetBitmap().GetHBITMAP();
767 bool wxBitmapDataObject2::SetData(size_t len
, const void *pBuf
)
769 HBITMAP hbmp
= *(HBITMAP
*)pBuf
;
772 if ( !GetObject(hbmp
, sizeof(BITMAP
), &bmp
) )
774 wxLogLastError("GetObject(HBITMAP)");
777 wxBitmap
bitmap(bmp
.bmWidth
, bmp
.bmHeight
, bmp
.bmPlanes
);
778 bitmap
.SetHBITMAP((WXHBITMAP
)hbmp
);
780 if ( !bitmap
.Ok() ) {
781 wxFAIL_MSG(wxT("pasting/dropping invalid bitmap"));
793 size_t wxBitmapDataObject::GetDataSize(const wxDataFormat
& format
) const
795 if ( format
.GetFormatId() == CF_DIB
)
800 // shouldn't be selected into a DC or GetDIBits() would fail
801 wxASSERT_MSG( !m_bitmap
.GetSelectedInto(),
802 wxT("can't copy bitmap selected into wxMemoryDC") );
804 // first get the info
806 if ( !GetDIBits(hdc
, (HBITMAP
)m_bitmap
.GetHBITMAP(), 0, 0,
807 NULL
, &bi
, DIB_RGB_COLORS
) )
809 wxLogLastError("GetDIBits(NULL)");
814 return sizeof(BITMAPINFO
) + bi
.bmiHeader
.biSizeImage
;
818 // no data to copy - we don't pass HBITMAP via global memory
823 bool wxBitmapDataObject::GetDataHere(const wxDataFormat
& format
,
826 wxASSERT_MSG( m_bitmap
.Ok(), wxT("copying invalid bitmap") );
828 HBITMAP hbmp
= (HBITMAP
)m_bitmap
.GetHBITMAP();
829 if ( format
.GetFormatId() == CF_DIB
)
834 // shouldn't be selected into a DC or GetDIBits() would fail
835 wxASSERT_MSG( !m_bitmap
.GetSelectedInto(),
836 wxT("can't copy bitmap selected into wxMemoryDC") );
838 // first get the info
839 BITMAPINFO
*pbi
= (BITMAPINFO
*)pBuf
;
840 if ( !GetDIBits(hdc
, hbmp
, 0, 0, NULL
, pbi
, DIB_RGB_COLORS
) )
842 wxLogLastError("GetDIBits(NULL)");
847 // and now copy the bits
848 if ( !GetDIBits(hdc
, hbmp
, 0, pbi
->bmiHeader
.biHeight
, pbi
+ 1,
849 pbi
, DIB_RGB_COLORS
) )
851 wxLogLastError("GetDIBits");
858 // we put a bitmap handle into pBuf
859 *(HBITMAP
*)pBuf
= hbmp
;
865 bool wxBitmapDataObject::SetData(const wxDataFormat
& format
,
866 size_t size
, const void *pBuf
)
869 if ( format
.GetFormatId() == CF_DIB
)
871 // here we get BITMAPINFO struct followed by the actual bitmap bits and
872 // BITMAPINFO starts with BITMAPINFOHEADER followed by colour info
875 BITMAPINFO
*pbmi
= (BITMAPINFO
*)pBuf
;
876 BITMAPINFOHEADER
*pbmih
= &pbmi
->bmiHeader
;
877 hbmp
= CreateDIBitmap(hdc
, pbmih
, CBM_INIT
,
878 pbmi
+ 1, pbmi
, DIB_RGB_COLORS
);
881 wxLogLastError("CreateDIBitmap");
884 m_bitmap
.SetWidth(pbmih
->biWidth
);
885 m_bitmap
.SetHeight(pbmih
->biHeight
);
889 // it's easy with bitmaps: we pass them by handle
890 hbmp
= *(HBITMAP
*)pBuf
;
893 if ( !GetObject(hbmp
, sizeof(BITMAP
), &bmp
) )
895 wxLogLastError("GetObject(HBITMAP)");
898 m_bitmap
.SetWidth(bmp
.bmWidth
);
899 m_bitmap
.SetHeight(bmp
.bmHeight
);
900 m_bitmap
.SetDepth(bmp
.bmPlanes
);
903 m_bitmap
.SetHBITMAP((WXHBITMAP
)hbmp
);
905 wxASSERT_MSG( m_bitmap
.Ok(), wxT("pasting invalid bitmap") );
912 // ----------------------------------------------------------------------------
914 // ----------------------------------------------------------------------------
916 bool wxFileDataObject::SetData(size_t WXUNUSED(size
), const void *pData
)
920 // the documentation states that the first member of DROPFILES structure is
921 // a "DWORD offset of double NUL terminated file list". What they mean by
922 // this (I wonder if you see it immediately) is that the list starts at
923 // ((char *)&(pDropFiles.pFiles)) + pDropFiles.pFiles. We're also advised
924 // to use DragQueryFile to work with this structure, but not told where and
926 HDROP hdrop
= (HDROP
)pData
; // NB: it works, but I'm not sure about it
928 // get number of files (magic value -1)
929 UINT nFiles
= ::DragQueryFile(hdrop
, (unsigned)-1, NULL
, 0u);
931 // for each file get the length, allocate memory and then get the name
934 for ( n
= 0; n
< nFiles
; n
++ ) {
935 // +1 for terminating NUL
936 len
= ::DragQueryFile(hdrop
, n
, NULL
, 0) + 1;
938 UINT len2
= ::DragQueryFile(hdrop
, n
, str
.GetWriteBuf(len
), len
);
940 m_filenames
.Add(str
);
942 if ( len2
!= len
- 1 ) {
943 wxLogDebug(wxT("In wxFileDropTarget::OnDrop DragQueryFile returned"
944 " %d characters, %d expected."), len2
, len
- 1);
951 void wxFileDataObject::AddFile(const wxString
& file
)
953 // just add file to filenames array
954 // all useful data (such as DROPFILES struct) will be
955 // created later as necessary
956 m_filenames
.Add(file
);
959 size_t wxFileDataObject::GetDataSize() const
961 // size returned will be the size of the DROPFILES structure,
962 // plus the list of filesnames (null byte separated), plus
963 // a double null at the end
965 // if no filenames in list, size is 0
966 if (m_filenames
.GetCount() == 0) return 0;
968 // inital size of DROPFILES struct + null byte
969 size_t sz
= sizeof(DROPFILES
) + 1;
972 for (i
=0; i
<m_filenames
.GetCount(); ++i
)
974 // add filename length plus null byte
975 sz
+= m_filenames
[i
].Len() + 1;
980 bool wxFileDataObject::GetDataHere(void *pData
) const
982 // pData points to an externally allocated memory block
983 // created using the size returned by GetDataSize()
985 // if pData is NULL, or there are no files, return
986 if (!pData
|| m_filenames
.GetCount() == 0) return FALSE
;
988 // convert data pointer to a DROPFILES struct pointer
989 LPDROPFILES pDrop
= (LPDROPFILES
) pData
;
991 // initialize DROPFILES struct
992 pDrop
->pFiles
= sizeof(DROPFILES
);
994 pDrop
->fWide
= FALSE
;
996 // set start of filenames list (null separated)
997 char *pbuf
= (char*)pDrop
+ sizeof(DROPFILES
);
1000 for (i
=0; i
<m_filenames
.GetCount(); ++i
)
1002 // copy filename to pbuf and add null terminator
1003 size_t len
= m_filenames
[i
].Len();
1004 memcpy(pbuf
, m_filenames
[i
], len
);
1008 *pbuf
= '\0'; // add final null terminator
1013 // ----------------------------------------------------------------------------
1014 // private functions
1015 // ----------------------------------------------------------------------------
1017 static size_t wxGetNumOfBitmapColors(size_t bitsPerPixel
)
1019 switch ( bitsPerPixel
)
1022 // monochrome bitmap, 2 entries
1032 // may be used with 24bit bitmaps, but we don't use it here - fall
1037 // bmiColors not used at all with these bitmaps
1041 wxFAIL_MSG( wxT("unknown bitmap format") );
1046 size_t wxConvertBitmapToDIB(BITMAPINFO
*pbi
, const wxBitmap
& bitmap
)
1048 wxASSERT_MSG( bitmap
.Ok(), wxT("invalid bmp can't be converted to DIB") );
1050 // shouldn't be selected into a DC or GetDIBits() would fail
1051 wxASSERT_MSG( !bitmap
.GetSelectedInto(),
1052 wxT("can't copy bitmap selected into wxMemoryDC") );
1054 // prepare all the info we need
1056 HBITMAP hbmp
= (HBITMAP
)bitmap
.GetHBITMAP();
1057 if ( !GetObject(hbmp
, sizeof(bm
), &bm
) )
1059 wxLogLastError("GetObject(bitmap)");
1064 // calculate the number of bits per pixel and the number of items in
1065 // bmiColors array (whose meaning depends on the bitmap format)
1066 WORD biBits
= bm
.bmPlanes
* bm
.bmBitsPixel
;
1067 WORD biColors
= wxGetNumOfBitmapColors(biBits
);
1071 bool wantSizeOnly
= pbi
== NULL
;
1075 // just for convenience
1076 BITMAPINFOHEADER
& bi
= pbi
->bmiHeader
;
1078 bi
.biSize
= sizeof(BITMAPINFOHEADER
);
1079 bi
.biWidth
= bm
.bmWidth
;
1080 bi
.biHeight
= bm
.bmHeight
;
1082 bi
.biBitCount
= biBits
;
1083 bi
.biCompression
= BI_RGB
;
1085 bi
.biXPelsPerMeter
= 0;
1086 bi
.biYPelsPerMeter
= 0;
1088 bi
.biClrImportant
= 0;
1090 // memory we need for BITMAPINFO only
1091 DWORD dwLen
= bi
.biSize
+ biColors
* sizeof(RGBQUAD
);
1093 // first get the image size
1095 if ( !GetDIBits(hdc
, hbmp
, 0, bi
.biHeight
, NULL
, pbi
, DIB_RGB_COLORS
) )
1097 wxLogLastError("GetDIBits(NULL)");
1104 // size of the header + size of the image
1105 return dwLen
+ bi
.biSizeImage
;
1108 // and now copy the bits
1109 void *image
= (char *)pbi
+ dwLen
;
1110 if ( !GetDIBits(hdc
, hbmp
, 0, bi
.biHeight
, image
, pbi
, DIB_RGB_COLORS
) )
1112 wxLogLastError("GetDIBits");
1117 return dwLen
+ bi
.biSizeImage
;
1120 wxBitmap
wxConvertDIBToBitmap(const BITMAPINFO
*pbmi
)
1122 // here we get BITMAPINFO struct followed by the actual bitmap bits and
1123 // BITMAPINFO starts with BITMAPINFOHEADER followed by colour info
1124 const BITMAPINFOHEADER
*pbmih
= &pbmi
->bmiHeader
;
1126 // offset of image from the beginning of the header
1127 DWORD ofs
= wxGetNumOfBitmapColors(pbmih
->biBitCount
) * sizeof(RGBQUAD
);
1128 void *image
= (char *)pbmih
+ sizeof(BITMAPINFOHEADER
) + ofs
;
1131 HBITMAP hbmp
= CreateDIBitmap(hdc
, pbmih
, CBM_INIT
,
1132 image
, pbmi
, DIB_RGB_COLORS
);
1135 wxLogLastError("CreateDIBitmap");
1138 wxBitmap
bitmap(pbmih
->biWidth
, pbmih
->biHeight
, pbmih
->biBitCount
);
1139 bitmap
.SetHBITMAP((WXHBITMAP
)hbmp
);
1146 static const wxChar
*GetTymedName(DWORD tymed
)
1148 static wxChar s_szBuf
[128];
1150 case TYMED_HGLOBAL
: return wxT("TYMED_HGLOBAL");
1151 case TYMED_FILE
: return wxT("TYMED_FILE");
1152 case TYMED_ISTREAM
: return wxT("TYMED_ISTREAM");
1153 case TYMED_ISTORAGE
: return wxT("TYMED_ISTORAGE");
1154 case TYMED_GDI
: return wxT("TYMED_GDI");
1155 case TYMED_MFPICT
: return wxT("TYMED_MFPICT");
1156 case TYMED_ENHMF
: return wxT("TYMED_ENHMF");
1158 wxSprintf(s_szBuf
, wxT("type of media format %d (unknown)"), tymed
);
1165 #endif // not using OLE at all