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

wxDataObject changes - ok for MSW, still not for GTK/Motif/...

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@4090 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
1999-10-21 01:58:57 +00:00
parent e1ee679c2e
commit 9e2896e5c8
17 changed files with 852 additions and 589 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/wx/clipbrd.h
View File

@@ -115,7 +115,7 @@ class wxClipboardModule : public wxModule
{
public:
bool OnInit()
{ wxTheClipboard = new wxClipboard; }
{ wxTheClipboard = new wxClipboard; return TRUE; }
void OnExit()
{ delete wxTheClipboard; wxTheClipboard = (wxClipboard *)NULL; }

31
include/wx/dataobj.h
View File

@@ -134,7 +134,10 @@ public:
// get data from the buffer of specified length (in the given format),
// return TRUE if the data was read successfully, FALSE otherwise
virtual bool SetData(const wxDataFormat& format,
size_t len, const void *buf) = 0;
size_t len, const void *buf)
{
return FALSE;
}
};
// ----------------------------------------------------------------------------
@@ -334,31 +337,25 @@ private:
// ----------------------------------------------------------------------------
// wxFileDataObject contains a list of filenames
//
// NB: notice that this is a "write only" object, it can only be filled with
// data from drag and drop operation.
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxFileDataObjectBase : public wxDataObjectSimple
{
public:
// ctor: you can specify the bitmap here or in SetBitmap(), or override
// GetBitmap()
// ctor: use AddFile() later to fill the array
wxFileDataObjectBase() : wxDataObjectSimple(wxDF_FILENAME) { }
// get a reference to our array - you may modify it (i.e. add/remove
// filenames to it then)
wxArrayString& GetFilenames() { return m_filenames; }
// get a reference to our array
const wxArrayString& GetFilenames() { return m_filenames; }
// a helper function
void AddFile(const wxString& filename) { m_filenames.Add(filename); }
// the Get() functions do nothing for us
virtual size_t GetDataSize() const { return 0; }
virtual bool GetDataHere(void *WXUNUSED(buf)) const { return FALSE; }
// virtual functions which you may override if you want to provide data on
// demand only - otherwise, the trivial default versions will be used.
//
// they work with a NUL-separated string of filenames, the base class
// versions concatenate/extract filenames from this string
virtual wxString GetFilenames() const;
virtual void SetFilenames(const wxChar* filenames);
private:
protected:
wxArrayString m_filenames;
};

42
include/wx/defs.h
View File

@@ -1243,29 +1243,29 @@ typedef enum
#define wxTOOL_LEFT 3
#define wxTOOL_RIGHT 4
// tyhe ids of standard data formats
// the values of the format constants should be the same as correspondign
// CF_XXX constants in Windows API
enum wxDataFormatId
{
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,
wxDF_MAX
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,
wxDF_MAX
};
/* Virtual keycodes */

18
include/wx/dnd.h
View File

@@ -49,7 +49,7 @@ public:
// start drag action, see enum wxDragResult for return value description
//
// if bAllowMove is TRUE, data can be moved, if not - only copied
virtual wxDragResult DoDragDrop( bool bAllowMove = FALSE );
virtual wxDragResult DoDragDrop(bool bAllowMove = FALSE) = 0;
// override to give feedback depending on the current operation result
// "effect"
@@ -65,7 +65,13 @@ protected:
// ----------------------------------------------------------------------------
// wxDropTarget should be associated with a window if it wants to be able to
// receive data via drag and drop
// receive data via drag and drop.
//
// To use this class, you should derive from wxDropTarget and implement
// OnData() pure virtual method. You may also wish to override OnDrop() if you
// want to accept the data only inside some region of the window (this may
// avoid having to copy the data to this application which happens only when
// OnData() is called)
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxDropTargetBase
@@ -99,7 +105,7 @@ public:
// called after OnDrop() returns TRUE: you will usually just call
// GetData() from here and, probably, also refresh something to update the
// new data
virtual bool OnData() = 0;
virtual bool OnData(wxCoord x, wxCoord y) = 0;
// may be called *only* from inside OnData() and will fill m_dataObject
// with the data from the drop source if it returns TRUE
@@ -109,12 +115,16 @@ protected:
wxDataObject *m_dataObject;
};
// ----------------------------------------------------------------------------
// the platform-specific headers also define standard wxDropTarget
// implementations wxTextDropTarget and wxFileDropTarget
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// include platform dependent class declarations
// ----------------------------------------------------------------------------
#if defined(__WXMSW__)
#include "wx/dataobj.h"
#include "wx/msw/ole/dropsrc.h"
#include "wx/msw/ole/droptgt.h"
#elif defined(__WXMOTIF__)

190
include/wx/gtk/dnd.h
View File

@@ -15,8 +15,6 @@
#pragma interface
#endif
#include "wx/defs.h"
#if wxUSE_DRAG_AND_DROP
#include "wx/object.h"
@@ -46,87 +44,153 @@ class wxDropSource;
class wxDropTarget: public wxObject
{
public:
wxDropTarget( wxDataObject *data );
~wxDropTarget();
/* may be overridden to react to events */
virtual bool OnEnter( int x, int y );
wxDropTarget();
~wxDropTarget();
/* may be overridden to react to events */
virtual void OnEnter();
virtual void OnLeave();
/* may be overridden to reject certain formats or drops
on certain areas. always returns TRUE by default
indicating that you'd accept the data from the drag. */
virtual bool OnMove( long x, long y );
/* has to be overridden to accept a drop event. call
IsSupported() to ask which formats are available
and then call RequestData() to indicate the format
you request. */
virtual bool OnDrop( long x, long y );
/* this gets called once the data has actually arrived. get
it with GetData(). this has to be overridden. */
virtual bool OnData( long x, long y );
/* called from within OnDrop() to request a certain format
from the drop event. */
bool RequestData( wxDataFormat format );
/* called to query what formats are available */
bool IsSupported( wxDataFormat format );
/* fill data with data from the dragging source */
bool GetData( wxDataObject *data );
virtual size_t GetFormatCount() const = 0;
virtual wxDataFormat GetFormat(size_t n) const = 0;
virtual void OnLeave();
/* may be overridden to reject certain formats or drops
on certain areas. always returns TRUE by default
indicating that you'd accept the data from the drag. */
virtual bool OnMove( int x, int y );
/* has to be overridden to accept a drop event. call
IsSupported() to ask which formats are available
and then call RequestData() to indicate the format
you request. */
virtual bool OnDrop( int x, int y );
/* this gets called once the data has actually arrived.
it will call GetData() to fill up its wxDataObject */
virtual bool OnData( int x, int y );
/* fill data with data from the dragging source */
bool GetData();
// implementation
GdkAtom GetMatchingPair();
void RegisterWidget( GtkWidget *widget );
void UnregisterWidget( GtkWidget *widget );
void RegisterWidget( GtkWidget *widget );
void UnregisterWidget( GtkWidget *widget );
GdkDragContext *m_dragContext;
GtkWidget *m_dragWidget;
GtkSelectionData *m_dragData;
guint m_dragTime;
bool m_firstMotion; /* gdk has no "gdk_drag_enter" event */
wxDataObject *m_data;
GdkDragContext *m_dragContext;
GtkWidget *m_dragWidget;
GtkSelectionData *m_dragData;
guint m_dragTime;
bool m_firstMotion; /* gdk has no "gdk_drag_enter" event */
void SetDragContext( GdkDragContext *dc ) { m_dragContext = dc; }
void SetDragWidget( GtkWidget *w ) { m_dragWidget = w; }
void SetDragData( GtkSelectionData *sd ) { m_dragData = sd; }
void SetDragTime( guint time ) { m_dragTime = time; }
};
void SetDragContext( GdkDragContext *dc ) { m_dragContext = dc; }
void SetDragWidget( GtkWidget *w ) { m_dragWidget = w; }
void SetDragData( GtkSelectionData *sd ) { m_dragData = sd; }
void SetDragTime( guint time ) { m_dragTime = time; }
//-------------------------------------------------------------------------
// wxTextDropTarget
//-------------------------------------------------------------------------
class wxTextDropTarget: public wxDropTarget
{
public:
wxTextDropTarget() {}
virtual bool OnData( long x, long y );
/* you have to override OnDropData to get at the text */
virtual bool OnDropText( long x, long y, const wxChar *text ) = 0;
virtual size_t GetFormatCount() const
{ return 1; }
virtual wxDataFormat GetFormat(size_t n) const
{ return wxDF_TEXT; }
};
//-------------------------------------------------------------------------
// wxPrivateDropTarget
//-------------------------------------------------------------------------
/*
class wxPrivateDropTarget: public wxDropTarget
{
public:
wxPrivateDropTarget();
wxPrivateDropTarget( const wxString &id );
virtual bool OnMove( long x, long y );
virtual bool OnDrop( long x, long y );
virtual bool OnData( long x, long y );
virtual bool OnDropData( long x, long y, void *data, size_t size ) = 0;
void SetId( const wxString& id ) { m_id = id; }
wxString GetId() { return m_id; }
private:
wxString m_id;
};
*/
//----------------------------------------------------------------------------
// A drop target which accepts files (dragged from File Manager or Explorer)
//----------------------------------------------------------------------------
class wxFileDropTarget: public wxDropTarget
{
public:
wxFileDropTarget() {}
virtual bool OnData( long x, long y );
virtual bool OnDropFiles( long x, long y, size_t nFiles, const wxChar * const aszFiles[] ) = 0;
virtual size_t GetFormatCount() const
{ return 1; }
virtual wxDataFormat GetFormat(size_t n) const
{ return wxDF_FILENAME; }
};
//-------------------------------------------------------------------------
// wxDropSource
//-------------------------------------------------------------------------
enum wxDragResult
{
wxDragError, // error prevented the d&d operation from completing
wxDragNone, // drag target didn't accept the data
wxDragCopy, // the data was successfully copied
wxDragMove, // the data was successfully moved (MSW only)
wxDragCancel // the operation was cancelled by user (not an error)
};
class wxDropSource: public wxObject
{
public:
/* constructor. set data later with SetData() */
wxDropSource( wxWindow *win,
const wxIcon &go = wxNullIcon,
const wxIcon &stop = wxNullIcon );
/* constructor. set data later with SetData() */
wxDropSource( wxWindow *win, const wxIcon &go = wxNullIcon, const wxIcon &stop = wxNullIcon );
/* constructor for setting one data object */
wxDropSource( wxDataObject& data,
wxWindow *win,
const wxIcon &go = wxNullIcon,
const wxIcon &stop = wxNullIcon );
wxDropSource( wxDataObject& data, wxWindow *win, const wxIcon &go = wxNullIcon, const wxIcon &stop = wxNullIcon );
~wxDropSource();
~wxDropSource();
void SetData( wxDataObject& data );
/* start drag action */
virtual wxDragResult DoDragDrop( bool bAllowMove = FALSE );
/* start drag action */
wxDragResult DoDragDrop( bool bAllowMove = FALSE );
/* override to give feedback */
virtual bool GiveFeedback( wxDragResult WXUNUSED(effect), bool WXUNUSED(bScrolling) ) { return TRUE; }
/* GTK implementation */
void RegisterWindow();
void UnregisterWindow();
/* GTK implementation */
void RegisterWindow();
void UnregisterWindow();
GtkWidget *m_widget;
wxWindow *m_window;

190
include/wx/gtk1/dnd.h
View File

@@ -15,8 +15,6 @@
#pragma interface
#endif
#include "wx/defs.h"
#if wxUSE_DRAG_AND_DROP
#include "wx/object.h"
@@ -46,87 +44,153 @@ class wxDropSource;
class wxDropTarget: public wxObject
{
public:
wxDropTarget( wxDataObject *data );
~wxDropTarget();
/* may be overridden to react to events */
virtual bool OnEnter( int x, int y );
wxDropTarget();
~wxDropTarget();
/* may be overridden to react to events */
virtual void OnEnter();
virtual void OnLeave();
/* may be overridden to reject certain formats or drops
on certain areas. always returns TRUE by default
indicating that you'd accept the data from the drag. */
virtual bool OnMove( long x, long y );
/* has to be overridden to accept a drop event. call
IsSupported() to ask which formats are available
and then call RequestData() to indicate the format
you request. */
virtual bool OnDrop( long x, long y );
/* this gets called once the data has actually arrived. get
it with GetData(). this has to be overridden. */
virtual bool OnData( long x, long y );
/* called from within OnDrop() to request a certain format
from the drop event. */
bool RequestData( wxDataFormat format );
/* called to query what formats are available */
bool IsSupported( wxDataFormat format );
/* fill data with data from the dragging source */
bool GetData( wxDataObject *data );
virtual size_t GetFormatCount() const = 0;
virtual wxDataFormat GetFormat(size_t n) const = 0;
virtual void OnLeave();
/* may be overridden to reject certain formats or drops
on certain areas. always returns TRUE by default
indicating that you'd accept the data from the drag. */
virtual bool OnMove( int x, int y );
/* has to be overridden to accept a drop event. call
IsSupported() to ask which formats are available
and then call RequestData() to indicate the format
you request. */
virtual bool OnDrop( int x, int y );
/* this gets called once the data has actually arrived.
it will call GetData() to fill up its wxDataObject */
virtual bool OnData( int x, int y );
/* fill data with data from the dragging source */
bool GetData();
// implementation
GdkAtom GetMatchingPair();
void RegisterWidget( GtkWidget *widget );
void UnregisterWidget( GtkWidget *widget );
void RegisterWidget( GtkWidget *widget );
void UnregisterWidget( GtkWidget *widget );
GdkDragContext *m_dragContext;
GtkWidget *m_dragWidget;
GtkSelectionData *m_dragData;
guint m_dragTime;
bool m_firstMotion; /* gdk has no "gdk_drag_enter" event */
wxDataObject *m_data;
GdkDragContext *m_dragContext;
GtkWidget *m_dragWidget;
GtkSelectionData *m_dragData;
guint m_dragTime;
bool m_firstMotion; /* gdk has no "gdk_drag_enter" event */
void SetDragContext( GdkDragContext *dc ) { m_dragContext = dc; }
void SetDragWidget( GtkWidget *w ) { m_dragWidget = w; }
void SetDragData( GtkSelectionData *sd ) { m_dragData = sd; }
void SetDragTime( guint time ) { m_dragTime = time; }
};
void SetDragContext( GdkDragContext *dc ) { m_dragContext = dc; }
void SetDragWidget( GtkWidget *w ) { m_dragWidget = w; }
void SetDragData( GtkSelectionData *sd ) { m_dragData = sd; }
void SetDragTime( guint time ) { m_dragTime = time; }
//-------------------------------------------------------------------------
// wxTextDropTarget
//-------------------------------------------------------------------------
class wxTextDropTarget: public wxDropTarget
{
public:
wxTextDropTarget() {}
virtual bool OnData( long x, long y );
/* you have to override OnDropData to get at the text */
virtual bool OnDropText( long x, long y, const wxChar *text ) = 0;
virtual size_t GetFormatCount() const
{ return 1; }
virtual wxDataFormat GetFormat(size_t n) const
{ return wxDF_TEXT; }
};
//-------------------------------------------------------------------------
// wxPrivateDropTarget
//-------------------------------------------------------------------------
/*
class wxPrivateDropTarget: public wxDropTarget
{
public:
wxPrivateDropTarget();
wxPrivateDropTarget( const wxString &id );
virtual bool OnMove( long x, long y );
virtual bool OnDrop( long x, long y );
virtual bool OnData( long x, long y );
virtual bool OnDropData( long x, long y, void *data, size_t size ) = 0;
void SetId( const wxString& id ) { m_id = id; }
wxString GetId() { return m_id; }
private:
wxString m_id;
};
*/
//----------------------------------------------------------------------------
// A drop target which accepts files (dragged from File Manager or Explorer)
//----------------------------------------------------------------------------
class wxFileDropTarget: public wxDropTarget
{
public:
wxFileDropTarget() {}
virtual bool OnData( long x, long y );
virtual bool OnDropFiles( long x, long y, size_t nFiles, const wxChar * const aszFiles[] ) = 0;
virtual size_t GetFormatCount() const
{ return 1; }
virtual wxDataFormat GetFormat(size_t n) const
{ return wxDF_FILENAME; }
};
//-------------------------------------------------------------------------
// wxDropSource
//-------------------------------------------------------------------------
enum wxDragResult
{
wxDragError, // error prevented the d&d operation from completing
wxDragNone, // drag target didn't accept the data
wxDragCopy, // the data was successfully copied
wxDragMove, // the data was successfully moved (MSW only)
wxDragCancel // the operation was cancelled by user (not an error)
};
class wxDropSource: public wxObject
{
public:
/* constructor. set data later with SetData() */
wxDropSource( wxWindow *win,
const wxIcon &go = wxNullIcon,
const wxIcon &stop = wxNullIcon );
/* constructor. set data later with SetData() */
wxDropSource( wxWindow *win, const wxIcon &go = wxNullIcon, const wxIcon &stop = wxNullIcon );
/* constructor for setting one data object */
wxDropSource( wxDataObject& data,
wxWindow *win,
const wxIcon &go = wxNullIcon,
const wxIcon &stop = wxNullIcon );
wxDropSource( wxDataObject& data, wxWindow *win, const wxIcon &go = wxNullIcon, const wxIcon &stop = wxNullIcon );
~wxDropSource();
~wxDropSource();
void SetData( wxDataObject& data );
/* start drag action */
virtual wxDragResult DoDragDrop( bool bAllowMove = FALSE );
/* start drag action */
wxDragResult DoDragDrop( bool bAllowMove = FALSE );
/* override to give feedback */
virtual bool GiveFeedback( wxDragResult WXUNUSED(effect), bool WXUNUSED(bScrolling) ) { return TRUE; }
/* GTK implementation */
void RegisterWindow();
void UnregisterWindow();
/* GTK implementation */
void RegisterWindow();
void UnregisterWindow();
GtkWidget *m_widget;
wxWindow *m_window;

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

@@ -22,54 +22,23 @@ struct IDataObject;
// wxDataObject is a "smart" and polymorphic piece of data.
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxDataObject
class WXDLLEXPORT wxDataObject : public wxDataObjectBase
{
public:
// ctor & dtor
wxDataObject();
virtual ~wxDataObject();
// pure virtuals to override
// get the best suited format for rendering our data
virtual wxDataFormat GetPreferredFormat() const = 0;
// get the number of formats we support: it is understood that if we
// can accept data in some format, then we can render data in this
// format as well, but the contrary is not necessarily true. For the
// default value of the argument, all formats we support should be
// returned, but if outputOnlyToo == FALSE, then we should only return
// the formats which our SetData() understands
virtual size_t GetFormatCount(bool outputOnlyToo = TRUE) const
{ return 1; }
// return all formats in the provided array (of size GetFormatCount())
virtual void GetAllFormats(wxDataFormat *formats,
bool outputOnlyToo = TRUE) const
{ formats[0] = GetPreferredFormat(); }
// get the (total) size of data for the given format
virtual size_t GetDataSize(const wxDataFormat& format) const = 0;
// copy raw data (in the specified format) to provided pointer
virtual bool GetDataHere(const wxDataFormat& format, void *buf) const = 0;
// get data from the buffer (in the given format)
virtual bool SetData(const wxDataFormat& format, const void *buf) = 0;
// accessors
// retrieve IDataObject interface (for other OLE related classes)
// retrieve IDataObject interface (for other OLE related classes)
IDataObject *GetInterface() const { return m_pIDataObject; }
// a simpler name which makes more sense for data objects supporting
// only one format
wxDataFormat GetFormat() const { return GetPreferredFormat(); }
// old interface
// decide if we support this format (can be either standard or custom
// format) -- now uses GetAllFormats()
virtual bool IsSupportedFormat(const wxDataFormat& format) const;
// implementation only from now on
// -------------------------------
// tell the object that it should be now owned by IDataObject - i.e. when
// it is deleted, it should delete us as well
void SetAutoDelete();
// return TRUE if we support this format in "Get" direction
bool IsSupportedFormat(const wxDataFormat& format) const;
#ifdef __WXDEBUG__
// function to return symbolic name of clipboard format (for debug messages)
static const char *GetFormatName(wxDataFormat format);
@@ -79,73 +48,4 @@ private:
IDataObject *m_pIDataObject; // pointer to the COM interface
};
// ----------------------------------------------------------------------------
// wxTextDataObject is a specialization of wxDataObject for text data
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxTextDataObject : public wxDataObject
{
public:
// ctors
wxTextDataObject() { }
wxTextDataObject(const wxString& strText) : m_strText(strText) { }
void Init(const wxString& strText) { m_strText = strText; }
// implement base class pure virtuals
virtual wxDataFormat GetPreferredFormat() const
{ return wxDF_TEXT; }
virtual bool IsSupportedFormat(const wxDataFormat& format) const
{ return format == wxDF_TEXT || format == wxDF_LOCALE; }
virtual size_t GetDataSize(const wxDataFormat& format) const
{ return m_strText.Len() + 1; } // +1 for trailing '\0'of course
virtual bool GetDataHere(const wxDataFormat& format, void *buf) const
{ memcpy(buf, m_strText.c_str(), GetDataSize(format)); return TRUE; }
virtual bool SetData(const wxDataFormat& format, const void *buf)
{ m_strText = (const wxChar *)buf; return TRUE; }
// additional helpers
void SetText(const wxString& strText) { m_strText = strText; }
wxString GetText() const { return m_strText; }
private:
wxString m_strText;
};
// ----------------------------------------------------------------------------
// wxBitmapDataObject is a specialization of wxDataObject for bitmap data
// ----------------------------------------------------------------------------
#include "wx/bitmap.h"
class WXDLLEXPORT wxBitmapDataObject : public wxDataObject
{
public:
// ctors
wxBitmapDataObject() { }
wxBitmapDataObject(const wxBitmap& bitmap): m_bitmap(bitmap) { }
// set/get our bitmap
void SetBitmap(const wxBitmap& bitmap) { m_bitmap = bitmap; }
const wxBitmap GetBitmap() const { return m_bitmap; }
// implement base class pure virtuals
virtual wxDataFormat GetPreferredFormat() const { return wxDF_BITMAP; }
virtual size_t GetFormatCount(bool outputOnlyToo = TRUE) const;
virtual void GetAllFormats(wxDataFormat *formats,
bool outputOnlyToo = TRUE) const;
virtual size_t GetDataSize(const wxDataFormat& format) const;
virtual bool GetDataHere(const wxDataFormat& format, void *buf) const;
virtual bool SetData(const wxDataFormat& format, const void *buf);
private:
wxBitmap m_bitmap;
};
// ----------------------------------------------------------------------------
// wxMetaFileDataObject: see metafile.h is a specialization of wxDataObject for bitmap data
// ----------------------------------------------------------------------------
// TODO: wxFileDataObject.
#endif //_WX_MSW_OLE_DATAOBJ_H

2
include/wx/msw/ole/dropsrc.h
View File

@@ -33,7 +33,7 @@ class WXDLLEXPORT wxWindow;
// wxDataObject object. It's responsible for giving UI feedback while dragging.
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxDropSource
class WXDLLEXPORT wxDropSource : public wxDropSourceBase
{
public:
// ctors: if you use default ctor you must call SetData() later!

70
include/wx/msw/ole/droptgt.h
View File

@@ -9,9 +9,6 @@
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
// ============================================================================
// prolog
// ============================================================================
#ifndef _WX_OLEDROPTGT_H
#define _WX_OLEDROPTGT_H
@@ -20,12 +17,13 @@
#endif
#if !wxUSE_DRAG_AND_DROP
#error "You should #define wxUSE_DRAG_AND_DROP to 1 to compile this file!"
#error "You should #define wxUSE_DRAG_AND_DROP to 1 to compile this file!"
#endif //WX_DRAG_DROP
// ----------------------------------------------------------------------------
// forward declarations
// ----------------------------------------------------------------------------
class wxIDropTarget;
struct IDataObject;
@@ -38,11 +36,12 @@ struct IDataObject;
// your own class from it implementing pure virtual function in order to use it
// (all of them, including protected ones which are called by the class itself)
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxDropTarget
class WXDLLEXPORT wxDropTarget : public wxDropTargetBase
{
public:
// ctor & dtor
wxDropTarget();
wxDropTarget(wxDataObject *dataObject = NULL);
virtual ~wxDropTarget();
// normally called by wxWindow on window creation/destruction, but might be
@@ -50,62 +49,57 @@ public:
bool Register(WXHWND hwnd);
void Revoke(WXHWND hwnd);
// provide default implementation for base class pure virtuals
virtual bool OnDrop(wxCoord x, wxCoord y);
virtual bool GetData();
// implementation only from now on
// -------------------------------
// do we accept this kind of data?
virtual bool IsAcceptedData(IDataObject *pIDataSource) const;
bool IsAcceptedData(IDataObject *pIDataSource) const;
// called when mouse enters/leaves the window: might be used to give
// some visual feedback to the user
virtual void OnEnter() { }
virtual void OnLeave() { }
// this function is called when data is dropped.
// (x, y) are the coordinates of the drop
virtual bool OnDrop(long x, long y, const void *pData) = 0;
protected:
// Override these to indicate what kind of data you support: the first
// format to which data can be converted is used. The classes below show
// how it can be done in the simplest cases.
// how many different (clipboard) formats do you support?
virtual size_t GetFormatCount() const = 0;
// return the n-th supported format
virtual wxDataFormat GetFormat(size_t n) const = 0;
// give us the data source from IDropTarget::Drop() - this is later used by
// GetData() when it's called from inside OnData()
void SetDataSource(IDataObject *pIDataSource);
private:
wxIDropTarget *m_pIDropTarget; // the pointer to COM interface
// helper used by IsAcceptedData() and GetData()
wxDataFormat GetSupportedFormat(IDataObject *pIDataSource) const;
wxIDropTarget *m_pIDropTarget; // the pointer to our COM interface
IDataObject *m_pIDataSource; // the pointer to the source data object
};
// ----------------------------------------------------------------------------
// A simple wxDropTarget derived class for text data: you only need to
// override OnDropText() to get something working
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxTextDropTarget : public wxDropTarget
{
public:
virtual bool OnDrop(long x, long y, const void *pData);
virtual bool OnDropText(long x, long y, const wxChar *psz) = 0;
wxTextDropTarget();
protected:
virtual size_t GetFormatCount() const;
virtual wxDataFormat GetFormat(size_t n) const;
virtual bool OnDropText(wxCoord x, wxCoord y, const wxString& text) = 0;
virtual bool OnData(wxCoord x, wxCoord y);
};
// ----------------------------------------------------------------------------
// A drop target which accepts files (dragged from File Manager or Explorer)
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxFileDropTarget : public wxDropTarget
{
public:
virtual bool OnDrop(long x, long y, const void *pData);
wxFileDropTarget();
// params: the number of files and the array of file names
virtual bool OnDropFiles(long x, long y,
size_t nFiles, const wxChar * const aszFiles[]) = 0;
// parameters are the number of files and the array of file names
virtual bool OnDropFiles(wxCoord x, wxCoord y,
const wxArrayString& filenames) = 0;
protected:
virtual size_t GetFormatCount() const;
virtual wxDataFormat GetFormat(size_t n) const;
virtual bool OnData(wxCoord x, wxCoord y);
};
// ============================================================================
#endif //_WX_OLEDROPTGT_H