Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

wxPrivateDataObject works under MSW as well (hopefully it still does under

Browse Source 
GTK too)


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@2578 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
1999-05-26 22:39:42 +00:00
parent 238d735dc2
commit 3f480da37c
14 changed files with 683 additions and 632 deletions
Download Patch File Download Diff File Expand all files Collapse all files

135
include/wx/dataobj.h
View File

@@ -1,19 +1,142 @@
///////////////////////////////////////////////////////////////////////////////
// Name: dataobj.h
// Purpose: common data object classes
// Author: Robert Roebling, Vadim Zeitlin
// Modified by:
// Created: 26.05.99
// RCS-ID: $Id$
// Copyright: (c) wxWindows Team
// Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DATAOBJ_H_BASE_
#define _WX_DATAOBJ_H_BASE_
#if defined(__WXMSW__)
#include "wx/msw/ole/dataobj.h"
// ----------------------------------------------------------------------------
// wxDataFormat identifies the single format of data
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxDataFormat
{
public:
// the clipboard formats under Win32 are UINTs
typedef unsigned int NativeFormat;
wxDataFormat(NativeFormat format = wxDF_INVALID) { m_format = format; }
wxDataFormat& operator=(NativeFormat format)
{ m_format = format; return *this; }
// defautl copy ctor/assignment operators ok
// comparison (must have both versions)
bool operator==(wxDataFormatId format) const
{ return m_format == (NativeFormat)format; }
bool operator!=(wxDataFormatId format) const
{ return m_format != (NativeFormat)format; }
bool operator==(const wxDataFormat& format) const
{ return m_format == format.m_format; }
bool operator!=(const wxDataFormat& format) const
{ return m_format != format.m_format; }
// explicit and implicit conversions to NativeFormat which is one of
// standard data types (implicit conversion is useful for preserving the
// compatibility with old code)
NativeFormat GetFormatId() const { return m_format; }
operator NativeFormat() const { return m_format; }
// this only works with standard ids
void SetId(wxDataFormatId format) { m_format = format; }
// string ids are used for custom types - this SetId() must be used for
// application-specific formats
wxString GetId() const;
void SetId(const wxChar *format);
private:
// returns TRUE if the format is one of those defined in wxDataFormatId
bool IsStandard() const { return m_format > 0 && m_format < wxDF_MAX; }
NativeFormat m_format;
};
#include "wx/msw/ole/dataobj.h"
#elif defined(__WXMOTIF__)
#include "wx/motif/dataobj.h"
#include "wx/motif/dataobj.h"
#elif defined(__WXGTK__)
#include "wx/gtk/dataobj.h"
#include "wx/gtk/dataobj.h"
#elif defined(__WXQT__)
#include "wx/qt/dnd.h"
#include "wx/qt/dnd.h"
#elif defined(__WXMAC__)
#include "wx/mac/dnd.h"
#include "wx/mac/dnd.h"
#elif defined(__WXSTUBS__)
#include "wx/stubs/dnd.h"
#include "wx/stubs/dnd.h"
#endif
// ---------------------------------------------------------------------------
// wxPrivateDataObject is a specialization of wxDataObject for app specific
// data (of some given kind, derive directly from wxDataObject if you wish to
// efficiently support multiple formats)
// ---------------------------------------------------------------------------
class WXDLLEXPORT wxPrivateDataObject : public wxDataObject
{
DECLARE_DYNAMIC_CLASS( wxPrivateDataObject )
public:
wxPrivateDataObject();
virtual ~wxPrivateDataObject() { Free(); }
// get the format object - it is used to decide whether we support the
// given output format or not
wxDataFormat& GetFormat() { return m_format; }
// set data. will make copy of the data
void SetData( const void *data, size_t size );
// returns pointer to data
void *GetData() const { return m_data; }
// get the size of the data
virtual size_t GetSize() const;
// copy data to the given buffer
virtual void WriteData( void *dest ) const;
// these functions are provided for wxGTK compatibility, their usage is
// deprecated - use GetFormat().SetId() instead
void SetId( const wxString& id ) { m_format.SetId(id); }
wxString GetId() const { return m_format.GetId(); }
// implement the base class pure virtuals
virtual wxDataFormat GetPreferredFormat() const
{ return m_format; }
virtual bool IsSupportedFormat(wxDataFormat format) const
{ return m_format == format; }
virtual size_t GetDataSize() const
{ return m_size; }
virtual void GetDataHere(void *dest) const
{ WriteData(dest); }
protected:
// the function which really copies the data - called by WriteData() above
// and uses GetSize() to get the size of the data
//
// VZ: I really wonder why do we need it
void WriteData( const void *data, void *dest ) const;
private:
// free the data
inline void Free();
// the data
size_t m_size;
void *m_data;
// the data format
wxDataFormat m_format;
};
#endif
// _WX_DATAOBJ_H_BASE_

9
include/wx/defs.h
View File

@@ -778,9 +778,7 @@ typedef enum
// Don't do parent client adjustments (for implementation only)
#define wxSIZE_NO_ADJUSTMENTS 0x0008
#ifndef __WXGTK__
enum wxDataFormat
enum wxDataFormatId
{
wxDF_INVALID = 0,
wxDF_TEXT = 1, /* CF_TEXT */
@@ -799,11 +797,10 @@ enum wxDataFormat
wxDF_ENHMETAFILE = 14,
wxDF_FILENAME = 15, /* CF_HDROP */
wxDF_LOCALE = 16,
wxDF_PRIVATE = 20
wxDF_PRIVATE = 20,
wxDF_MAX
};
#endif
/* Virtual keycodes */
enum wxKeyCode

2
include/wx/dnd.h
View File

@@ -2,9 +2,9 @@
#define _WX_DND_H_BASE_
#if defined(__WXMSW__)
#include "wx/dataobj.h"
#include "wx/msw/ole/dropsrc.h"
#include "wx/msw/ole/droptgt.h"
#include "wx/msw/ole/dataobj.h"
#elif defined(__WXMOTIF__)
#include "wx/motif/dnd.h"
#elif defined(__WXGTK__)

90
include/wx/gtk/dataobj.h
View File

@@ -31,32 +31,6 @@ class wxBitmapDataObject;
class wxPrivateDataObject;
class wxFileDataObject;
//-------------------------------------------------------------------------
// wxDataType (internal)
//-------------------------------------------------------------------------
enum wxDataType
{
wxDF_INVALID = 0,
wxDF_TEXT = 1, /* CF_TEXT */
wxDF_BITMAP = 2, /* CF_BITMAP */
wxDF_METAFILE = 3, /* CF_METAFILEPICT */
wxDF_SYLK = 4,
wxDF_DIF = 5,
wxDF_TIFF = 6,
wxDF_OEMTEXT = 7, /* CF_OEMTEXT */
wxDF_DIB = 8, /* CF_DIB */
wxDF_PALETTE = 9,
wxDF_PENDATA = 10,
wxDF_RIFF = 11,
wxDF_WAVE = 12,
wxDF_UNICODETEXT = 13,
wxDF_ENHMETAFILE = 14,
wxDF_FILENAME = 15, /* CF_HDROP */
wxDF_LOCALE = 16,
wxDF_PRIVATE = 20
};
//-------------------------------------------------------------------------
// wxDataFormat (internal)
//-------------------------------------------------------------------------
@@ -66,25 +40,30 @@ class wxDataFormat : public wxObject
DECLARE_CLASS( wxDataFormat )
public:
wxDataFormat();
wxDataFormat( wxDataType type );
wxDataFormat( wxDataFormatId type );
wxDataFormat( const wxString &id );
wxDataFormat( const wxChar *id );
wxDataFormat( wxDataFormat &format );
wxDataFormat( const GdkAtom atom );
void SetType( wxDataType type );
wxDataType GetType() const;
void SetType( wxDataFormatId type );
wxDataFormatId GetType() const;
/* the string Id identifies the format of clipboard or DnD data. a word
* processor would e.g. add a wxTextDataObject and a wxPrivateDataObject
* to the clipboard - the latter with the Id "application/wxword", an
* image manipulation program would put a wxBitmapDataObject and a
* wxPrivateDataObject to the clipboard - the latter with "image/png". */
wxString GetId() const;
void SetId( const wxChar *id );
GdkAtom GetAtom();
void SetAtom(GdkAtom atom) { m_hasAtom = TRUE; m_atom = atom; }
private:
wxDataType m_type;
private:
wxDataFormatId m_type;
wxString m_id;
bool m_hasAtom;
GdkAtom m_atom;
@@ -162,7 +141,7 @@ public:
wxDataFormat &GetFormat();
wxDataType GetFormatType() const;
wxDataFormatId GetFormatType() const;
wxString GetFormatId() const;
GdkAtom GetFormatAtom() const;
@@ -268,51 +247,6 @@ public:
};
//----------------------------------------------------------------------------
// wxPrivateDataObject is a specialization of wxDataObject for app specific data
//----------------------------------------------------------------------------
class wxPrivateDataObject : public wxDataObject
{
DECLARE_DYNAMIC_CLASS( wxPrivateDataObject )
public:
/* see wxTextDataObject for explanation of functions */
wxPrivateDataObject();
~wxPrivateDataObject();
/* the string Id identifies the format of clipboard or DnD data. a word
* processor would e.g. add a wxTextDataObject and a wxPrivateDataObject
* to the clipboard - the latter with the Id "application/wxword", an
* image manipulation program would put a wxBitmapDataObject and a
* wxPrivateDataObject to the clipboard - the latter with "image/png". */
void SetId( const wxString& id );
/* get id */
wxString GetId() const;
/* set data. will make internal copy. */
void SetData( const char *data, size_t size );
/* returns pointer to data */
char* GetData() const;
virtual void WriteData( void *dest ) const;
virtual size_t GetSize() const;
void WriteData( const char *data, void *dest ) const;
// implementation
size_t m_size;
char* m_data;
wxString m_id;
};
#endif
//__GTKDNDH__

90
include/wx/gtk1/dataobj.h
View File

@@ -31,32 +31,6 @@ class wxBitmapDataObject;
class wxPrivateDataObject;
class wxFileDataObject;
//-------------------------------------------------------------------------
// wxDataType (internal)
//-------------------------------------------------------------------------
enum wxDataType
{
wxDF_INVALID = 0,
wxDF_TEXT = 1, /* CF_TEXT */
wxDF_BITMAP = 2, /* CF_BITMAP */
wxDF_METAFILE = 3, /* CF_METAFILEPICT */
wxDF_SYLK = 4,
wxDF_DIF = 5,
wxDF_TIFF = 6,
wxDF_OEMTEXT = 7, /* CF_OEMTEXT */
wxDF_DIB = 8, /* CF_DIB */
wxDF_PALETTE = 9,
wxDF_PENDATA = 10,
wxDF_RIFF = 11,
wxDF_WAVE = 12,
wxDF_UNICODETEXT = 13,
wxDF_ENHMETAFILE = 14,
wxDF_FILENAME = 15, /* CF_HDROP */
wxDF_LOCALE = 16,
wxDF_PRIVATE = 20
};
//-------------------------------------------------------------------------
// wxDataFormat (internal)
//-------------------------------------------------------------------------
@@ -66,25 +40,30 @@ class wxDataFormat : public wxObject
DECLARE_CLASS( wxDataFormat )
public:
wxDataFormat();
wxDataFormat( wxDataType type );
wxDataFormat( wxDataFormatId type );
wxDataFormat( const wxString &id );
wxDataFormat( const wxChar *id );
wxDataFormat( wxDataFormat &format );
wxDataFormat( const GdkAtom atom );
void SetType( wxDataType type );
wxDataType GetType() const;
void SetType( wxDataFormatId type );
wxDataFormatId GetType() const;
/* the string Id identifies the format of clipboard or DnD data. a word
* processor would e.g. add a wxTextDataObject and a wxPrivateDataObject
* to the clipboard - the latter with the Id "application/wxword", an
* image manipulation program would put a wxBitmapDataObject and a
* wxPrivateDataObject to the clipboard - the latter with "image/png". */
wxString GetId() const;
void SetId( const wxChar *id );
GdkAtom GetAtom();
void SetAtom(GdkAtom atom) { m_hasAtom = TRUE; m_atom = atom; }
private:
wxDataType m_type;
private:
wxDataFormatId m_type;
wxString m_id;
bool m_hasAtom;
GdkAtom m_atom;
@@ -162,7 +141,7 @@ public:
wxDataFormat &GetFormat();
wxDataType GetFormatType() const;
wxDataFormatId GetFormatType() const;
wxString GetFormatId() const;
GdkAtom GetFormatAtom() const;
@@ -268,51 +247,6 @@ public:
};
//----------------------------------------------------------------------------
// wxPrivateDataObject is a specialization of wxDataObject for app specific data
//----------------------------------------------------------------------------
class wxPrivateDataObject : public wxDataObject
{
DECLARE_DYNAMIC_CLASS( wxPrivateDataObject )
public:
/* see wxTextDataObject for explanation of functions */
wxPrivateDataObject();
~wxPrivateDataObject();
/* the string Id identifies the format of clipboard or DnD data. a word
* processor would e.g. add a wxTextDataObject and a wxPrivateDataObject
* to the clipboard - the latter with the Id "application/wxword", an
* image manipulation program would put a wxBitmapDataObject and a
* wxPrivateDataObject to the clipboard - the latter with "image/png". */
void SetId( const wxString& id );
/* get id */
wxString GetId() const;
/* set data. will make internal copy. */
void SetData( const char *data, size_t size );
/* returns pointer to data */
char* GetData() const;
virtual void WriteData( void *dest ) const;
virtual size_t GetSize() const;
void WriteData( const char *data, void *dest ) const;
// implementation
size_t m_size;
char* m_data;
wxString m_id;
};
#endif
//__GTKDNDH__

1
include/wx/msw/clipbrd.h
View File

@@ -23,6 +23,7 @@
#include "wx/list.h"
#include "wx/module.h"
#include "wx/dataobj.h" // for wxDataFormat
// These functions superceded by wxClipboard, but retained in order to
// implement wxClipboard, and for compatibility.

35
include/wx/msw/ole/dataobj.h
View File

@@ -20,7 +20,7 @@ struct IDataObject;
// ----------------------------------------------------------------------------
// wxDataObject is a "smart" and polymorphic piece of data.
//
// @@@ it's currently "read-only" from COM point of view, i.e. we don't support
// TODO it's currently "read-only" from COM point of view, i.e. we don't support
// SetData. We don't support all advise functions neither (but it's easy to
// do if we really want them)
// ----------------------------------------------------------------------------
@@ -28,29 +28,6 @@ struct IDataObject;
class WXDLLEXPORT wxDataObject
{
public:
// all data formats (values are the same as in windows.h, do not change!)
enum StdFormat
{
Invalid,
Text,
Bitmap,
MetafilePict,
Sylk,
Dif,
Tiff,
OemText,
Dib,
Palette,
Pendata,
Riff,
Wave,
UnicodeText,
EnhMetafile,
Hdrop,
Locale,
Max
};
// function to return symbolic name of clipboard format (debug messages)
static const char *GetFormatName(wxDataFormat format);
@@ -62,7 +39,7 @@ public:
// get the best suited format for our data
virtual wxDataFormat GetPreferredFormat() const = 0;
// decide if we support this format (should be one of values of
// StdFormat enumerations or a user-defined format)
// wxDataFormatId enumerations or a user-defined format)
virtual bool IsSupportedFormat(wxDataFormat format) const = 0;
// get the (total) size of data
virtual size_t GetDataSize() const = 0;
@@ -93,9 +70,9 @@ public:
// implement base class pure virtuals
virtual wxDataFormat GetPreferredFormat() const
{ return (wxDataFormat) wxDataObject::Text; }
{ return wxDF_TEXT; }
virtual bool IsSupportedFormat(wxDataFormat format) const
{ return format == wxDataObject::Text || format == wxDataObject::Locale; }
{ return format == wxDF_TEXT || format == wxDF_LOCALE; }
virtual size_t GetDataSize() const
{ return m_strText.Len() + 1; } // +1 for trailing '\0'of course
virtual void GetDataHere(void *pBuf) const
@@ -133,9 +110,9 @@ public:
// implement base class pure virtuals
virtual wxDataFormat GetPreferredFormat() const
{ return (wxDataFormat) wxDataObject::Bitmap; }
{ return wxDF_BITMAP; }
virtual bool IsSupportedFormat(wxDataFormat format) const
{ return format == wxDataObject::Bitmap; }
{ return format == wxDF_BITMAP; }
virtual size_t GetDataSize() const
{ wxASSERT(false); return 0; } // BEMIMP
virtual void GetDataHere(void *pBuf) const

54
src/gtk/dataobj.cpp
View File

@@ -8,7 +8,7 @@
///////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "dataobj.h"
#pragma implementation "dataobj.h"
#endif
#include "wx/dataobj.h"
@@ -38,7 +38,7 @@ wxDataFormat::wxDataFormat()
m_atom = (GdkAtom) 0;
}
wxDataFormat::wxDataFormat( wxDataType type )
wxDataFormat::wxDataFormat( wxDataFormatId type )
{
if (!g_textAtom) g_textAtom = gdk_atom_intern( "STRING", FALSE );
SetType( type );
@@ -91,7 +91,7 @@ wxDataFormat::wxDataFormat( const GdkAtom atom )
}
}
void wxDataFormat::SetType( wxDataType type )
void wxDataFormat::SetType( wxDataFormatId type )
{
m_type = type;
@@ -117,7 +117,7 @@ void wxDataFormat::SetType( wxDataType type )
m_hasAtom = FALSE;
}
wxDataType wxDataFormat::GetType() const
wxDataFormatId wxDataFormat::GetType() const
{
return m_type;
}
@@ -285,7 +285,7 @@ wxDataFormat &wxDataObject::GetFormat()
return m_format;
}
wxDataType wxDataObject::GetFormatType() const
wxDataFormatId wxDataObject::GetFormatType() const
{
return m_format.GetType();
}
@@ -425,49 +425,33 @@ void wxBitmapDataObject::WriteBitmap( const wxBitmap &bitmap, void *dest ) const
IMPLEMENT_DYNAMIC_CLASS( wxPrivateDataObject, wxDataObject )
void wxPrivateDataObject::Free()
{
if ( m_data )
free(m_data);
}
wxPrivateDataObject::wxPrivateDataObject()
{
m_id = _T("application/");
m_id += wxTheApp->GetAppName();
wxString id = _T("application/");
id += wxTheApp->GetAppName();
m_format.SetId( m_id );
m_format.SetId( id );
m_size = 0;
m_data = (char*) NULL;
m_data = (void *)NULL;
}
wxPrivateDataObject::~wxPrivateDataObject()
void wxPrivateDataObject::SetData( const void *data, size_t size )
{
if (m_data) delete[] m_data;
}
Free();
void wxPrivateDataObject::SetId( const wxString& id )
{
m_id = id;
m_format.SetId( m_id );
}
wxString wxPrivateDataObject::GetId() const
{
return m_id;
}
void wxPrivateDataObject::SetData( const char *data, size_t size )
{
m_size = size;
if (m_data) delete[] m_data;
m_data = new char[size];
m_data = malloc(size);
memcpy( m_data, data, size );
}
char* wxPrivateDataObject::GetData() const
{
return m_data;
}
void wxPrivateDataObject::WriteData( void *dest ) const
{
WriteData( m_data, dest );
@@ -478,7 +462,7 @@ size_t wxPrivateDataObject::GetSize() const
return m_size;
}
void wxPrivateDataObject::WriteData( const char *data, void *dest ) const
void wxPrivateDataObject::WriteData( const void *data, void *dest ) const
{
memcpy( dest, data, GetSize() );
}

54
src/gtk1/dataobj.cpp
View File

@@ -8,7 +8,7 @@
///////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "dataobj.h"
#pragma implementation "dataobj.h"
#endif
#include "wx/dataobj.h"
@@ -38,7 +38,7 @@ wxDataFormat::wxDataFormat()
m_atom = (GdkAtom) 0;
}
wxDataFormat::wxDataFormat( wxDataType type )
wxDataFormat::wxDataFormat( wxDataFormatId type )
{
if (!g_textAtom) g_textAtom = gdk_atom_intern( "STRING", FALSE );
SetType( type );
@@ -91,7 +91,7 @@ wxDataFormat::wxDataFormat( const GdkAtom atom )
}
}
void wxDataFormat::SetType( wxDataType type )
void wxDataFormat::SetType( wxDataFormatId type )
{
m_type = type;
@@ -117,7 +117,7 @@ void wxDataFormat::SetType( wxDataType type )
m_hasAtom = FALSE;
}
wxDataType wxDataFormat::GetType() const
wxDataFormatId wxDataFormat::GetType() const
{
return m_type;
}
@@ -285,7 +285,7 @@ wxDataFormat &wxDataObject::GetFormat()
return m_format;
}
wxDataType wxDataObject::GetFormatType() const
wxDataFormatId wxDataObject::GetFormatType() const
{
return m_format.GetType();
}
@@ -425,49 +425,33 @@ void wxBitmapDataObject::WriteBitmap( const wxBitmap &bitmap, void *dest ) const
IMPLEMENT_DYNAMIC_CLASS( wxPrivateDataObject, wxDataObject )
void wxPrivateDataObject::Free()
{
if ( m_data )
free(m_data);
}
wxPrivateDataObject::wxPrivateDataObject()
{
m_id = _T("application/");
m_id += wxTheApp->GetAppName();
wxString id = _T("application/");
id += wxTheApp->GetAppName();
m_format.SetId( m_id );
m_format.SetId( id );
m_size = 0;
m_data = (char*) NULL;
m_data = (void *)NULL;
}
wxPrivateDataObject::~wxPrivateDataObject()
void wxPrivateDataObject::SetData( const void *data, size_t size )
{
if (m_data) delete[] m_data;
}
Free();
void wxPrivateDataObject::SetId( const wxString& id )
{
m_id = id;
m_format.SetId( m_id );
}
wxString wxPrivateDataObject::GetId() const
{
return m_id;
}
void wxPrivateDataObject::SetData( const char *data, size_t size )
{
m_size = size;
if (m_data) delete[] m_data;
m_data = new char[size];
m_data = malloc(size);
memcpy( m_data, data, size );
}
char* wxPrivateDataObject::GetData() const
{
return m_data;
}
void wxPrivateDataObject::WriteData( void *dest ) const
{
WriteData( m_data, dest );
@@ -478,7 +462,7 @@ size_t wxPrivateDataObject::GetSize() const
return m_size;
}
void wxPrivateDataObject::WriteData( const char *data, void *dest ) const
void wxPrivateDataObject::WriteData( const void *data, void *dest ) const
{
memcpy( dest, data, GetSize() );
}

115
src/msw/clipbrd.cpp
View File

@@ -50,6 +50,7 @@
#include "wx/log.h"
#include "wx/clipbrd.h"
#include <string.h>
#include <windows.h>
#include "wx/msw/private.h"
@@ -59,9 +60,13 @@
// therefore so is wxClipboard :-(
#if wxUSE_DRAG_AND_DROP
#include "wx/dataobj.h"
static bool wxSetClipboardData(wxDataObject *data);
#endif
#include <string.h>
#ifdef __WIN16__
#define memcpy hmemcpy
#endif
// ===========================================================================
// implementation
@@ -133,6 +138,38 @@ bool wxIsClipboardFormatAvailable(wxDataFormat dataFormat)
return ::IsClipboardFormatAvailable(dataFormat) != 0;
}
#if wxUSE_DRAG_AND_DROP
static bool wxSetClipboardData(wxDataObject *data)
{
size_t size = data->GetDataSize();
HANDLE hGlobal = ::GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, size);
if ( !hGlobal )
{
wxLogSysError(_("Failed to allocate %dKb of memory for clipboard "
"transfer."), size / 1024);
return FALSE;
}
LPVOID lpGlobalMemory = ::GlobalLock(hGlobal);
data->GetDataHere(lpGlobalMemory);
GlobalUnlock(hGlobal);
wxDataFormat format = data->GetPreferredFormat();
if ( !::SetClipboardData(format, hGlobal) )
{
wxLogSysError(_("Failed to set clipboard data in format %s"),
wxDataObject::GetFormatName(format));
return FALSE;
}
return TRUE;
}
#endif // wxUSE_DRAG_AND_DROP
bool wxSetClipboardData(wxDataFormat dataFormat,
const void *data,
int width, int height)
@@ -194,11 +231,7 @@ bool wxSetClipboardData(wxDataFormat dataFormat,
{
wxMetafile *wxMF = (wxMetafile *)data;
HANDLE data = GlobalAlloc(GHND, sizeof(METAFILEPICT) + 1);
#ifdef __WINDOWS_386__
METAFILEPICT *mf = (METAFILEPICT *)MK_FP32(GlobalLock(data));
#else
METAFILEPICT *mf = (METAFILEPICT *)GlobalLock(data);
#endif
mf->mm = wxMF->GetWindowsMappingMode();
mf->xExt = width;
@@ -235,19 +268,9 @@ bool wxSetClipboardData(wxDataFormat dataFormat,
HANDLE hGlobalMemory = GlobalAlloc(GHND, l);
if ( hGlobalMemory )
{
#ifdef __WINDOWS_386__
LPSTR lpGlobalMemory = (LPSTR)MK_FP32(GlobalLock(hGlobalMemory));
#else
LPSTR lpGlobalMemory = (LPSTR)GlobalLock(hGlobalMemory);
#endif
#ifdef __WIN32__
memcpy(lpGlobalMemory, s, l);
#elif defined(__WATCOMC__) && defined(__WINDOWS_386__)
memcpy(lpGlobalMemory, s, l);
#else
hmemcpy(lpGlobalMemory, s, l);
#endif
GlobalUnlock(hGlobalMemory);
}
@@ -325,7 +348,6 @@ void *wxGetClipboardData(wxDataFormat dataFormat, long *len)
case CF_TIFF:
case CF_PALETTE:
case wxDF_DIB:
default:
{
wxLogError(_("Unsupported clipboard format."));
return FALSE;
@@ -349,25 +371,39 @@ void *wxGetClipboardData(wxDataFormat dataFormat, long *len)
if (!s)
break;
#ifdef __WINDOWS_386__
LPSTR lpGlobalMemory = (LPSTR)MK_FP32(GlobalLock(hGlobalMemory));
#else
LPSTR lpGlobalMemory = (LPSTR)::GlobalLock(hGlobalMemory);
#endif
#ifdef __WIN32__
memcpy(s, lpGlobalMemory, hsize);
#elif __WATCOMC__ && defined(__WINDOWS_386__)
memcpy(s, lpGlobalMemory, hsize);
#else
hmemcpy(s, lpGlobalMemory, hsize);
#endif
::GlobalUnlock(hGlobalMemory);
retval = s;
break;
}
default:
{
HANDLE hGlobalMemory = ::GetClipboardData(dataFormat);
if ( !hGlobalMemory )
break;
DWORD size = ::GlobalSize(hGlobalMemory);
if ( len )
*len = size;
void *buf = malloc(size);
if ( !buf )
break;
LPSTR lpGlobalMemory = (LPSTR)::GlobalLock(hGlobalMemory);
memcpy(buf, lpGlobalMemory, size);
::GlobalUnlock(hGlobalMemory);
retval = buf;
break;
}
}
if ( !retval )
@@ -380,7 +416,7 @@ void *wxGetClipboardData(wxDataFormat dataFormat, long *len)
wxDataFormat wxEnumClipboardFormats(wxDataFormat dataFormat)
{
return (wxDataFormat)::EnumClipboardFormats(dataFormat);
return ::EnumClipboardFormats(dataFormat);
}
int wxRegisterClipboardFormat(char *formatName)
@@ -471,16 +507,11 @@ bool wxClipboard::AddData( wxDataObject *data )
#endif // wxUSE_METAFILE
default:
wxLogError(_("Can not put data in format '%s' on clipboard."),
wxDataObject::GetFormatName(format));
return FALSE;
return wxSetClipboardData(data);
}
#else // !wxUSE_DRAG_AND_DROP
return FALSE;
#else
return FALSE;
#endif
#endif // wxUSE_DRAG_AND_DROP/!wxUSE_DRAG_AND_DROP
}
void wxClipboard::Close()
@@ -546,8 +577,18 @@ bool wxClipboard::GetData( wxDataObject *data )
}
#endif
default:
wxLogError(_("Can not get data in format '%s' from clipboard."),
wxDataObject::GetFormatName(format));
{
long len;
void *buf = wxGetClipboardData(format, &len);
if ( buf )
{
// FIXME this is for testing only!!
((wxPrivateDataObject *)data)->SetData(buf, len);
free(buf);
return TRUE;
}
}
return FALSE;
}

88
src/msw/ole/dataobj.cpp
View File

@@ -28,12 +28,12 @@
#pragma hdrstop
#endif
#include <wx/defs.h>
#include "wx/defs.h"
#if defined(__WIN32__) && !defined(__GNUWIN32__)
#include <wx/log.h>
#include <wx/msw/ole/dataobj.h>
#include "wx/log.h"
#include "wx/dataobj.h"
#include <windows.h>
#include <oleauto.h>
@@ -43,7 +43,7 @@
#include <olestd.h>
#endif
#include <wx/msw/ole/oleutils.h>
#include "wx/msw/ole/oleutils.h"
// ----------------------------------------------------------------------------
// functions
@@ -101,6 +101,39 @@ private:
// implementation
// ============================================================================
// ----------------------------------------------------------------------------
// wxDataFormat
// ----------------------------------------------------------------------------
void wxDataFormat::SetId(const wxChar *format)
{
m_format = ::RegisterClipboardFormat(format);
if ( !m_format )
{
wxLogError(_("Couldn't register clipboard format '%s'."), format);
}
}
wxString wxDataFormat::GetId() const
{
static const int max = 256;
wxString s;
wxCHECK_MSG( !IsStandard(), s,
_T("name of predefined format cannot be retrieved") );
int len = ::GetClipboardFormatName(m_format, s.GetWriteBuf(max), max);
s.UngetWriteBuf();
if ( !len )
{
wxLogError(_("The clipboard format '%d' doesn't exist."), m_format);
}
return s;
}
// ----------------------------------------------------------------------------
// wxIEnumFORMATETC
// ----------------------------------------------------------------------------
@@ -284,14 +317,14 @@ STDMETHODIMP wxIDataObject::QueryGetData(FORMATETC *pformatetc)
}
// and now check the type of data requested
if ( m_pDataObject->IsSupportedFormat((wxDataFormat) pformatetc->cfFormat) ) {
if ( m_pDataObject->IsSupportedFormat((wxDataFormatId)pformatetc->cfFormat) ) {
wxLogTrace("wxIDataObject::QueryGetData: %s ok",
wxDataObject::GetFormatName((wxDataFormat) pformatetc->cfFormat));
wxDataObject::GetFormatName((wxDataFormatId)pformatetc->cfFormat));
return S_OK;
}
else {
wxLogTrace("wxIDataObject::QueryGetData: %s unsupported",
wxDataObject::GetFormatName((wxDataFormat) pformatetc->cfFormat));
wxDataObject::GetFormatName((wxDataFormatId)pformatetc->cfFormat));
return DV_E_FORMATETC;
}
}
@@ -399,6 +432,47 @@ const char *wxDataObject::GetFormatName(wxDataFormat format)
#endif // Debug
}
// ----------------------------------------------------------------------------
// wxPrivateDataObject
// ----------------------------------------------------------------------------
wxPrivateDataObject::wxPrivateDataObject()
{
m_size = 0;
m_data = NULL;
}
void wxPrivateDataObject::Free()
{
if ( m_data )
free(m_data);
}
void wxPrivateDataObject::SetData( const void *data, size_t size )
{
Free();
m_size = size;
m_data = malloc(size);
memcpy( m_data, data, size );
}
void wxPrivateDataObject::WriteData( void *dest ) const
{
WriteData( m_data, dest );
}
size_t wxPrivateDataObject::GetSize() const
{
return m_size;
}
void wxPrivateDataObject::WriteData( const void *data, void *dest ) const
{
memcpy( dest, data, GetSize() );
}
// ----------------------------------------------------------------------------
// private functions
// ----------------------------------------------------------------------------

10
src/msw/ole/dropsrc.cpp
View File

@@ -28,13 +28,13 @@
#pragma hdrstop
#endif
#include <wx/setup.h>
#include "wx/setup.h"
#if wxUSE_DRAG_AND_DROP
#include <wx/log.h>
#include <wx/msw/ole/dataobj.h>
#include <wx/msw/ole/dropsrc.h>
#include "wx/log.h"
#include "wx/dataobj.h"
#include "wx/msw/ole/dropsrc.h"
#include <windows.h>
@@ -45,7 +45,7 @@
#include <oleauto.h>
#include <wx/msw/ole/oleutils.h>
#include "wx/msw/ole/oleutils.h"
// ----------------------------------------------------------------------------
// wxIDropSource implementation of IDropSource interface

43
src/msw/ole/droptgt.cpp
View File

@@ -28,28 +28,29 @@
#pragma hdrstop
#endif
#include <wx/setup.h>
#include "wx/setup.h"
#if wxUSE_DRAG_AND_DROP
#include <wx/log.h>
#include "wx/log.h"
#ifdef __WIN32__
#ifndef __GNUWIN32__
#include <shlobj.h> // for DROPFILES structure
#endif
#ifndef __GNUWIN32__
#include <shlobj.h> // for DROPFILES structure
#endif
#else
#include <shellapi.h>
#include <shellapi.h>
#endif
#include <wx/msw/ole/droptgt.h>
#include "wx/dataobj.h"
#include "wx/msw/ole/droptgt.h"
#ifndef __WIN32__
#include <ole2.h>
#include <olestd.h>
#include <ole2.h>
#include <olestd.h>
#endif
#include <wx/msw/ole/oleutils.h>
#include "wx/msw/ole/oleutils.h"
// ----------------------------------------------------------------------------
// IDropTarget interface: forward all interesting things to wxDropTarget
@@ -69,9 +70,9 @@ public:
STDMETHODIMP DragLeave(void);
STDMETHODIMP Drop(LPDATAOBJECT, DWORD, POINTL, LPDWORD);
// @@ we assume that if QueryGetData() returns S_OK, than we can really
// get data in this format, so we remember here the format for which
// QueryGetData() succeeded
// we assume that if QueryGetData() returns S_OK, than we can really get data
// in this format, so we remember here the format for which QueryGetData()
// succeeded
void SetSupportedFormat(wxDataFormat cfFormat) { m_cfFormat = cfFormat; }
DECLARE_IUNKNOWN_METHODS;
@@ -107,7 +108,7 @@ wxIDropTarget::wxIDropTarget(wxDropTarget *pTarget)
{
m_cRef = 0;
m_pTarget = pTarget;
m_cfFormat = (wxDataFormat) 0;
m_cfFormat = wxDF_INVALID;
m_pIDataObject = NULL;
}
@@ -146,7 +147,7 @@ STDMETHODIMP wxIDropTarget::DragEnter(IDataObject *pIDataSource,
return S_OK;
}
// @@ should check the point also?
// TODO should check the point also?
*pdwEffect = GetDropEffect(grfKeyState);
@@ -213,7 +214,7 @@ STDMETHODIMP wxIDropTarget::Drop(IDataObject *pIDataSource,
{
wxLogDebug("IDropTarget::Drop");
// @@ I don't know why there is this parameter, but so far I assume
// TODO I don't know why there is this parameter, but so far I assume
// that it's the same we've already got in DragEnter
wxASSERT( m_pIDataObject == pIDataSource );
@@ -221,14 +222,14 @@ STDMETHODIMP wxIDropTarget::Drop(IDataObject *pIDataSource,
*pdwEffect = DROPEFFECT_NONE;
// should be set by SetSupportedFormat() call
wxASSERT( m_cfFormat != 0 );
wxASSERT( m_cfFormat != wxDF_INVALID );
FORMATETC fmtMemory;
fmtMemory.cfFormat = m_cfFormat;
fmtMemory.ptd = NULL;
fmtMemory.dwAspect = DVASPECT_CONTENT;
fmtMemory.lindex = -1;
fmtMemory.tymed = TYMED_HGLOBAL; // @@@@ to add other media
fmtMemory.tymed = TYMED_HGLOBAL; // TODO to add other media
HRESULT hr = pIDataSource->GetData(&fmtMemory, &stm);
if ( SUCCEEDED(hr) ) {
@@ -325,11 +326,11 @@ bool wxDropTarget::IsAcceptedData(IDataObject *pIDataSource) const
// cycle thorugh all supported formats
for ( size_t n = 0; n < GetFormatCount(); n++ ) {
s_fmtMemory.cfFormat = GetFormat(n);
// @ don't use SUCCEEDED macro here: QueryGetData returns 1 (whatever it
// NB: don't use SUCCEEDED macro here: QueryGetData returns 1 (whatever it
// means) for file drag and drop
if ( pIDataSource->QueryGetData(&s_fmtMemory) == S_OK ) {
// remember this format: we'll later ask for data in it
m_pIDropTarget->SetSupportedFormat((wxDataFormat) s_fmtMemory.cfFormat);
m_pIDropTarget->SetSupportedFormat((unsigned int)s_fmtMemory.cfFormat);
return TRUE;
}
}
@@ -368,7 +369,7 @@ bool wxFileDropTarget::OnDrop(long x, long y, const void *pData)
// ((char *)&(pDropFiles.pFiles)) + pDropFiles.pFiles. We're also advised to
// use DragQueryFile to work with this structure, but not told where and how
// to get HDROP.
HDROP hdrop = (HDROP)pData; // @@ it works, but I'm not sure about it
HDROP hdrop = (HDROP)pData; // NB: it works, but I'm not sure about it
// get number of files (magic value -1)
UINT nFiles = ::DragQueryFile(hdrop, (unsigned)-1, NULL, 0u);

1
src/msw/window.cpp
View File

@@ -51,6 +51,7 @@
#endif
#if wxUSE_DRAG_AND_DROP
#include "wx/dataobj.h"
#include "wx/msw/ole/droptgt.h"
#endif