#pragma hdrstop
#endif
-#if defined(__WIN32__) && !defined(__GNUWIN32_OLD__)
-
#ifndef WX_PRECOMP
#include "wx/intl.h"
#include "wx/log.h"
#include "wx/dataobj.h"
+#if wxUSE_OLE && defined(__WIN32__) && !defined(__GNUWIN32_OLD__)
+
#include "wx/msw/private.h" // includes <windows.h>
-#ifdef wxUSE_NORLANDER_HEADERS
+#if wxUSE_NORLANDER_HEADERS
#include <ole2.h>
#endif
#include <oleauto.h>
#include "wx/msw/dib.h"
+#ifndef CFSTR_SHELLURL
+#define CFSTR_SHELLURL _T("UniformResourceLocator")
+#endif
+
// ----------------------------------------------------------------------------
// functions
// ----------------------------------------------------------------------------
#ifdef __WXDEBUG__
static const wxChar *GetTymedName(DWORD tymed);
#else // !Debug
- #define GetTymedName(tymed) ""
+ #define GetTymedName(tymed) _T("")
#endif // Debug/!Debug
// ----------------------------------------------------------------------------
{
public:
wxIEnumFORMATETC(const wxDataFormat* formats, ULONG nCount);
-
- // to suppress the gcc warning about "class has virtual functions but non
- // virtual dtor"
-#ifdef __GNUG__
- virtual
-#endif
- ~wxIEnumFORMATETC() { delete [] m_formats; }
+ virtual ~wxIEnumFORMATETC() { delete [] m_formats; }
DECLARE_IUNKNOWN_METHODS;
{
public:
wxIDataObject(wxDataObject *pDataObject);
-
- // to suppress the gcc warning about "class has virtual functions but non
- // virtual dtor"
-#ifdef __GNUG__
- virtual
-#endif
- ~wxIDataObject();
+ virtual ~wxIDataObject();
// normally, wxDataObject controls our lifetime (i.e. we're deleted when it
// is), but in some cases, the situation is inversed, that is we delete it
void wxDataFormat::SetId(const wxChar *format)
{
- m_format = ::RegisterClipboardFormat(format);
+ m_format = (wxDataFormat::NativeFormat)::RegisterClipboardFormat(format);
if ( !m_format )
{
wxLogError(_("Couldn't register clipboard format '%s'."), format);
STDMETHODIMP wxIEnumFORMATETC::Next(ULONG celt,
FORMATETC *rgelt,
- ULONG *pceltFetched)
+ ULONG *WXUNUSED(pceltFetched))
{
wxLogTrace(wxTRACE_OleCalls, wxT("wxIEnumFORMATETC::Next"));
pmedium->hGlobal = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE,
sizeof(METAFILEPICT));
if ( !pmedium->hGlobal ) {
- wxLogLastError("GlobalAlloc");
+ wxLogLastError(wxT("GlobalAlloc"));
return E_OUTOFMEMORY;
}
pmedium->tymed = TYMED_MFPICT;
if ( !format.IsStandard() ) {
// for custom formats, put the size with the data - alloc the
// space for it
- size += sizeof(size_t);
+ // MB: not completely sure this is correct,
+ // even if I can't figure out what's wrong
+ size += m_pDataObject->GetBufferOffset( format );
}
HGLOBAL hGlobal = GlobalAlloc(GMEM_MOVEABLE | GMEM_SHARE, size);
if ( hGlobal == NULL ) {
- wxLogLastError("GlobalAlloc");
+ wxLogLastError(wxT("GlobalAlloc"));
return E_OUTOFMEMORY;
}
return E_OUTOFMEMORY;
}
- if ( !wxDataFormat(pformatetc->cfFormat).IsStandard() ) {
+ wxDataFormat format = pformatetc->cfFormat;
+ if ( !format.IsStandard() ) {
// for custom formats, put the size with the data
- size_t *p = (size_t *)pBuf;
- *p++ = GlobalSize(hGlobal);
- pBuf = p;
+ pBuf = m_pDataObject->SetSizeInBuffer( pBuf, GlobalSize(hGlobal), format );
}
- wxDataFormat format = pformatetc->cfFormat;
if ( !m_pDataObject->GetDataHere(format, pBuf) )
return E_UNEXPECTED;
}
// copy data
- void *pBuf = GlobalLock(pmedium->hGlobal);
+ const void *pBuf = GlobalLock(pmedium->hGlobal);
if ( pBuf == NULL ) {
- wxLogLastError("GlobalLock");
+ wxLogLastError(wxT("GlobalLock"));
return E_OUTOFMEMORY;
}
break;
#if !defined(__WATCOMC__) && ! (defined(__BORLANDC__) && (__BORLANDC__ < 0x500))
case CF_UNICODETEXT:
-#if (defined(__BORLANDC__) && (__BORLANDC__ > 0x530))
- size = std::wcslen((const wchar_t *)pBuf);
+#if ( defined(__BORLANDC__) && (__BORLANDC__ > 0x530) ) \
+ || ( defined(__MWERKS__) && defined(__WXMSW__) )
+ size = std::wcslen((const wchar_t *)pBuf) * sizeof(wchar_t);
#else
- size = ::wcslen((const wchar_t *)pBuf);
+ size = ::wcslen((const wchar_t *)pBuf) * sizeof(wchar_t);
#endif
break;
#endif
default:
{
// we suppose that the size precedes the data
- size_t *p = (size_t *)pBuf;
- size = *p++;
- pBuf = p;
+ pBuf = m_pDataObject->GetSizeFromBuffer( pBuf, &size, format );
+ if (! format.IsStandard() ) {
+ // see GetData for coresponding increment
+ size -= m_pDataObject->GetBufferOffset( format );
+ }
}
}
return S_OK;
}
-STDMETHODIMP wxIDataObject::GetCanonicalFormatEtc(FORMATETC *pFormatetcIn,
+STDMETHODIMP wxIDataObject::GetCanonicalFormatEtc(FORMATETC *WXUNUSED(pFormatetcIn),
FORMATETC *pFormatetcOut)
{
wxLogTrace(wxTRACE_OleCalls, wxT("wxIDataObject::GetCanonicalFormatEtc"));
: wxDataObject::Set;
size_t nFormatCount = m_pDataObject->GetFormatCount(dir);
- wxDataFormat format, *formats;
+ wxDataFormat format;
+ wxDataFormat *formats;
formats = nFormatCount == 1 ? &format : new wxDataFormat[nFormatCount];
m_pDataObject->GetAllFormats(formats, dir);
// advise sink functions (not implemented)
// ----------------------------------------------------------------------------
-STDMETHODIMP wxIDataObject::DAdvise(FORMATETC *pformatetc,
- DWORD advf,
- IAdviseSink *pAdvSink,
- DWORD *pdwConnection)
+STDMETHODIMP wxIDataObject::DAdvise(FORMATETC *WXUNUSED(pformatetc),
+ DWORD WXUNUSED(advf),
+ IAdviseSink *WXUNUSED(pAdvSink),
+ DWORD *WXUNUSED(pdwConnection))
{
return OLE_E_ADVISENOTSUPPORTED;
}
-STDMETHODIMP wxIDataObject::DUnadvise(DWORD dwConnection)
+STDMETHODIMP wxIDataObject::DUnadvise(DWORD WXUNUSED(dwConnection))
{
return OLE_E_ADVISENOTSUPPORTED;
}
-STDMETHODIMP wxIDataObject::EnumDAdvise(IEnumSTATDATA **ppenumAdvise)
+STDMETHODIMP wxIDataObject::EnumDAdvise(IEnumSTATDATA **WXUNUSED(ppenumAdvise))
{
return OLE_E_ADVISENOTSUPPORTED;
}
m_pIDataObject = NULL;
}
+size_t wxDataObject::GetBufferOffset( const wxDataFormat& format )
+{
+ return sizeof(size_t);
+}
+
+const void* wxDataObject::GetSizeFromBuffer( const void* buffer, size_t* size,
+ const wxDataFormat& format )
+{
+ size_t* p = (size_t*)buffer;
+ *size = *p;
+
+ return p + 1;
+}
+
+void* wxDataObject::SetSizeInBuffer( void* buffer, size_t size,
+ const wxDataFormat& format )
+{
+ size_t* p = (size_t*)buffer;
+ *p = size;
+
+ return p + 1;
+}
+
#ifdef __WXDEBUG__
-const char *wxDataObject::GetFormatName(wxDataFormat format)
+const wxChar *wxDataObject::GetFormatName(wxDataFormat format)
{
// case 'xxx' is not a valid value for switch of enum 'wxDataFormat'
#ifdef __VISUALC__
#pragma warning(disable:4063)
#endif // VC++
- static char s_szBuf[256];
+ static wxChar s_szBuf[256];
switch ( format ) {
- case CF_TEXT: return "CF_TEXT";
- case CF_BITMAP: return "CF_BITMAP";
- case CF_METAFILEPICT: return "CF_METAFILEPICT";
- case CF_SYLK: return "CF_SYLK";
- case CF_DIF: return "CF_DIF";
- case CF_TIFF: return "CF_TIFF";
- case CF_OEMTEXT: return "CF_OEMTEXT";
- case CF_DIB: return "CF_DIB";
- case CF_PALETTE: return "CF_PALETTE";
- case CF_PENDATA: return "CF_PENDATA";
- case CF_RIFF: return "CF_RIFF";
- case CF_WAVE: return "CF_WAVE";
- case CF_UNICODETEXT: return "CF_UNICODETEXT";
- case CF_ENHMETAFILE: return "CF_ENHMETAFILE";
- case CF_HDROP: return "CF_HDROP";
- case CF_LOCALE: return "CF_LOCALE";
+ case CF_TEXT: return wxT("CF_TEXT");
+ case CF_BITMAP: return wxT("CF_BITMAP");
+ case CF_METAFILEPICT: return wxT("CF_METAFILEPICT");
+ case CF_SYLK: return wxT("CF_SYLK");
+ case CF_DIF: return wxT("CF_DIF");
+ case CF_TIFF: return wxT("CF_TIFF");
+ case CF_OEMTEXT: return wxT("CF_OEMTEXT");
+ case CF_DIB: return wxT("CF_DIB");
+ case CF_PALETTE: return wxT("CF_PALETTE");
+ case CF_PENDATA: return wxT("CF_PENDATA");
+ case CF_RIFF: return wxT("CF_RIFF");
+ case CF_WAVE: return wxT("CF_WAVE");
+ case CF_UNICODETEXT: return wxT("CF_UNICODETEXT");
+ case CF_ENHMETAFILE: return wxT("CF_ENHMETAFILE");
+ case CF_HDROP: return wxT("CF_HDROP");
+ case CF_LOCALE: return wxT("CF_LOCALE");
default:
if ( !::GetClipboardFormatName(format, s_szBuf, WXSIZEOF(s_szBuf)) )
{
// it must be a new predefined format we don't know the name of
- sprintf(s_szBuf, "unknown CF (0x%04x)", format.GetFormatId());
+ wxSprintf(s_szBuf, wxT("unknown CF (0x%04x)"), format.GetFormatId());
}
return s_szBuf;
return wxConvertBitmapToDIB((LPBITMAPINFO)buf, GetBitmap()) != 0;
}
-bool wxBitmapDataObject::SetData(size_t len, const void *buf)
+bool wxBitmapDataObject::SetData(size_t WXUNUSED(len), const void *buf)
{
wxBitmap bitmap(wxConvertDIBToBitmap((const LPBITMAPINFO)buf));
BITMAP bmp;
if ( !GetObject(hbmp, sizeof(BITMAP), &bmp) )
{
- wxLogLastError("GetObject(HBITMAP)");
+ wxLogLastError(wxT("GetObject(HBITMAP)"));
}
wxBitmap bitmap(bmp.bmWidth, bmp.bmHeight, bmp.bmPlanes);
if ( !GetDIBits(hdc, (HBITMAP)m_bitmap.GetHBITMAP(), 0, 0,
NULL, &bi, DIB_RGB_COLORS) )
{
- wxLogLastError("GetDIBits(NULL)");
+ wxLogLastError(wxT("GetDIBits(NULL)"));
return 0;
}
BITMAPINFO *pbi = (BITMAPINFO *)pBuf;
if ( !GetDIBits(hdc, hbmp, 0, 0, NULL, pbi, DIB_RGB_COLORS) )
{
- wxLogLastError("GetDIBits(NULL)");
+ wxLogLastError(wxT("GetDIBits(NULL)"));
return 0;
}
if ( !GetDIBits(hdc, hbmp, 0, pbi->bmiHeader.biHeight, pbi + 1,
pbi, DIB_RGB_COLORS) )
{
- wxLogLastError("GetDIBits");
+ wxLogLastError(wxT("GetDIBits"));
return FALSE;
}
pbmi + 1, pbmi, DIB_RGB_COLORS);
if ( !hbmp )
{
- wxLogLastError("CreateDIBitmap");
+ wxLogLastError(wxT("CreateDIBitmap"));
}
m_bitmap.SetWidth(pbmih->biWidth);
BITMAP bmp;
if ( !GetObject(hbmp, sizeof(BITMAP), &bmp) )
{
- wxLogLastError("GetObject(HBITMAP)");
+ wxLogLastError(wxT("GetObject(HBITMAP)"));
}
m_bitmap.SetWidth(bmp.bmWidth);
m_filenames.Add(str);
if ( len2 != len - 1 ) {
- wxLogDebug(wxT("In wxFileDropTarget::OnDrop DragQueryFile returned"
- " %d characters, %d expected."), len2, len - 1);
+ wxLogDebug(wxT("In wxFileDropTarget::OnDrop DragQueryFile returned\
+ %d characters, %d expected."), len2, len - 1);
}
}
*pbuf++ = wxT('\0');
}
- *pbuf = wxT('\0'); // add final null terminator
+ // add final null terminator
+ *pbuf = wxT('\0');
return TRUE;
}
+// ----------------------------------------------------------------------------
+// wxURLDataObject
+// ----------------------------------------------------------------------------
+
+class CFSTR_SHELLURLDataObject:public wxCustomDataObject
+{
+public:
+ CFSTR_SHELLURLDataObject() : wxCustomDataObject(CFSTR_SHELLURL) {}
+protected:
+ virtual size_t GetBufferOffset( const wxDataFormat& format )
+ {
+ return 0;
+ }
+
+ virtual const void* GetSizeFromBuffer( const void* buffer, size_t* size,
+ const wxDataFormat& format )
+ {
+ // CFSTR_SHELLURL is _always_ ANSI text
+ *size = strlen( (const char*)buffer );
+
+ return buffer;
+ }
+
+ virtual void* SetSizeInBuffer( void* buffer, size_t size,
+ const wxDataFormat& format )
+ {
+ return buffer;
+ }
+#if wxUSE_UNICODE
+ virtual bool GetDataHere( void* buffer ) const
+ {
+ // CFSTR_SHELLURL is _always_ ANSI!
+ wxCharBuffer char_buffer( GetDataSize() );
+ wxCustomDataObject::GetDataHere( (void*)char_buffer.data() );
+ wxString unicode_buffer( char_buffer );
+ memcpy( buffer, unicode_buffer.c_str(),
+ ( unicode_buffer.length() + 1 ) * sizeof(wxChar) );
+
+ return TRUE;
+ }
+#endif
+};
+
+wxURLDataObject::wxURLDataObject()
+{
+ // we support CF_TEXT and CFSTR_SHELLURL formats which are basicly the same
+ // but it seems that some browsers only provide one of them so we have to
+ // support both
+ Add(new wxTextDataObject);
+ Add(new CFSTR_SHELLURLDataObject());
+
+ // we don't have any data yet
+ m_dataObjectLast = NULL;
+}
+
+bool wxURLDataObject::SetData(const wxDataFormat& format,
+ size_t len,
+ const void *buf)
+{
+ m_dataObjectLast = GetObject(format);
+
+ wxCHECK_MSG( m_dataObjectLast, FALSE,
+ wxT("unsupported format in wxURLDataObject"));
+
+ return m_dataObjectLast->SetData(len, buf);
+}
+
+wxString wxURLDataObject::GetURL() const
+{
+ wxString url;
+ wxCHECK_MSG( m_dataObjectLast, url, _T("no data in wxURLDataObject") );
+
+ size_t len = m_dataObjectLast->GetDataSize();
+
+ m_dataObjectLast->GetDataHere(url.GetWriteBuf(len));
+ url.UngetWriteBuf();
+
+ return url;
+}
+
+void wxURLDataObject::SetURL(const wxString& url)
+{
+ SetData(wxDataFormat(wxDF_TEXT), url.Length()+1, url.c_str());
+ SetData(wxDataFormat(CFSTR_SHELLURL), url.Length()+1, url.c_str());
+}
+
// ----------------------------------------------------------------------------
// private functions
// ----------------------------------------------------------------------------
HBITMAP hbmp = (HBITMAP)bitmap.GetHBITMAP();
if ( !GetObject(hbmp, sizeof(bm), &bm) )
{
- wxLogLastError("GetObject(bitmap)");
+ wxLogLastError(wxT("GetObject(bitmap)"));
return 0;
}
// calculate the number of bits per pixel and the number of items in
// bmiColors array (whose meaning depends on the bitmap format)
WORD biBits = bm.bmPlanes * bm.bmBitsPixel;
- WORD biColors = wxGetNumOfBitmapColors(biBits);
+ WORD biColors = (WORD)wxGetNumOfBitmapColors(biBits);
BITMAPINFO bi2;
ScreenHDC hdc;
if ( !GetDIBits(hdc, hbmp, 0, bi.biHeight, NULL, pbi, DIB_RGB_COLORS) )
{
- wxLogLastError("GetDIBits(NULL)");
+ wxLogLastError(wxT("GetDIBits(NULL)"));
return 0;
}
void *image = (char *)pbi + dwLen;
if ( !GetDIBits(hdc, hbmp, 0, bi.biHeight, image, pbi, DIB_RGB_COLORS) )
{
- wxLogLastError("GetDIBits");
+ wxLogLastError(wxT("GetDIBits"));
return 0;
}
image, pbmi, DIB_RGB_COLORS);
if ( !hbmp )
{
- wxLogLastError("CreateDIBitmap");
+ wxLogLastError(wxT("CreateDIBitmap"));
}
wxBitmap bitmap(pbmih->biWidth, pbmih->biHeight, pbmih->biBitCount);
#endif // Debug
-#endif // not using OLE at all
+#else // not using OLE at all
+// ----------------------------------------------------------------------------
+// wxDataObject
+// ----------------------------------------------------------------------------
+
+wxDataObject::wxDataObject()
+{
+}
+
+wxDataObject::~wxDataObject()
+{
+}
+
+void wxDataObject::SetAutoDelete()
+{
+}
+
+#ifdef __WXDEBUG__
+const wxChar *wxDataObject::GetFormatName(wxDataFormat format)
+{
+ return NULL;
+}
+#endif
+
+#endif
projects / wxWidgets.git / blobdiff