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

GTK too)


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@2578 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

include/wx/dataobj.h

@@ -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_

include/wx/defs.h

@@ -778,9 +778,7 @@ typedef enum
 // Don't do parent client adjustments (for implementation only)
 #define wxSIZE_NO_ADJUSTMENTS   0x0008
 
-#ifndef __WXGTK__
+enum wxDataFormatId
-
-enum wxDataFormat
 {
   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

include/wx/dnd.h

@@ -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__)

include/wx/gtk/dataobj.h

@@ -31,63 +31,42 @@ 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)
 //-------------------------------------------------------------------------
 
 class wxDataFormat : public wxObject
 {
-  DECLARE_CLASS( wxDataFormat )
+    DECLARE_CLASS( wxDataFormat )
 
 public:
+    wxDataFormat();
+    wxDataFormat( wxDataFormatId type );
+    wxDataFormat( const wxString &id );
+    wxDataFormat( const wxChar *id );
+    wxDataFormat( wxDataFormat &format );
+    wxDataFormat( const GdkAtom atom );
 
-  wxDataFormat();
+    void SetType( wxDataFormatId type );
-  wxDataFormat( wxDataType type );
+    wxDataFormatId GetType() const;
-  wxDataFormat( const wxString &id );
-  wxDataFormat( const wxChar *id );
-  wxDataFormat( wxDataFormat &format );
-  wxDataFormat( const GdkAtom atom );
 
-  void SetType( wxDataType type );    
+    /* the string Id identifies the format of clipboard or DnD data. a word
-  wxDataType GetType() const;
+     * 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;
+    wxString GetId() const;
-  void SetId( const wxChar *id );
+    void SetId( const wxChar *id );
+
+    GdkAtom GetAtom();
+    void SetAtom(GdkAtom atom) { m_hasAtom = TRUE; m_atom = atom; }
 
-  GdkAtom GetAtom();
-  void SetAtom(GdkAtom atom) { m_hasAtom = TRUE; m_atom = atom; }
 private:
-
+    wxDataFormatId  m_type;
-  wxDataType  m_type;
+    wxString    m_id;
-  wxString    m_id;
+    bool        m_hasAtom;
-  bool        m_hasAtom;
+    GdkAtom     m_atom;
-  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__
 

include/wx/gtk1/dataobj.h

@@ -31,63 +31,42 @@ 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)
 //-------------------------------------------------------------------------
 
 class wxDataFormat : public wxObject
 {
-  DECLARE_CLASS( wxDataFormat )
+    DECLARE_CLASS( wxDataFormat )
 
 public:
+    wxDataFormat();
+    wxDataFormat( wxDataFormatId type );
+    wxDataFormat( const wxString &id );
+    wxDataFormat( const wxChar *id );
+    wxDataFormat( wxDataFormat &format );
+    wxDataFormat( const GdkAtom atom );
 
-  wxDataFormat();
+    void SetType( wxDataFormatId type );
-  wxDataFormat( wxDataType type );
+    wxDataFormatId GetType() const;
-  wxDataFormat( const wxString &id );
-  wxDataFormat( const wxChar *id );
-  wxDataFormat( wxDataFormat &format );
-  wxDataFormat( const GdkAtom atom );
 
-  void SetType( wxDataType type );    
+    /* the string Id identifies the format of clipboard or DnD data. a word
-  wxDataType GetType() const;
+     * 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;
+    wxString GetId() const;
-  void SetId( const wxChar *id );
+    void SetId( const wxChar *id );
+
+    GdkAtom GetAtom();
+    void SetAtom(GdkAtom atom) { m_hasAtom = TRUE; m_atom = atom; }
 
-  GdkAtom GetAtom();
-  void SetAtom(GdkAtom atom) { m_hasAtom = TRUE; m_atom = atom; }
 private:
-
+    wxDataFormatId  m_type;
-  wxDataType  m_type;
+    wxString    m_id;
-  wxString    m_id;
+    bool        m_hasAtom;
-  bool        m_hasAtom;
+    GdkAtom     m_atom;
-  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__
 

include/wx/msw/clipbrd.h

@@ -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.

include/wx/msw/ole/dataobj.h

@@ -20,37 +20,14 @@ 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
+//      SetData. We don't support all advise functions neither (but it's easy to
-//     do if we really want them)
+//      do if we really want them)
 // ----------------------------------------------------------------------------
 
 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

src/gtk/dataobj.cpp

@@ -4,11 +4,11 @@
 // Author:      Robert Roebling
 // Id:          $Id$
 // Copyright:   (c) 1998 Robert Roebling
-// Licence:   	wxWindows licence
+// Licence:     wxWindows licence
 ///////////////////////////////////////////////////////////////////////////////
 
 #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/");
+    wxString id = _T("application/");
-    m_id += wxTheApp->GetAppName();
+    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;
-    
+    m_data = malloc(size);
-    if (m_data) delete[] m_data;
-    
-    m_data = new char[size];
 
     memcpy( m_data, data, size );
 }
 
-char* wxPrivateDataObject::GetData() const
-{
-    return m_data;
-}
-
 void wxPrivateDataObject::WriteData( void *dest ) const
 {
     WriteData( m_data, dest );
@@ -475,10 +459,10 @@ void wxPrivateDataObject::WriteData( void *dest ) const
 
 size_t wxPrivateDataObject::GetSize() const
 {
-   return m_size;
+    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() );
 }

src/gtk1/dataobj.cpp

@@ -4,11 +4,11 @@
 // Author:      Robert Roebling
 // Id:          $Id$
 // Copyright:   (c) 1998 Robert Roebling
-// Licence:   	wxWindows licence
+// Licence:     wxWindows licence
 ///////////////////////////////////////////////////////////////////////////////
 
 #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/");
+    wxString id = _T("application/");
-    m_id += wxTheApp->GetAppName();
+    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;
-    
+    m_data = malloc(size);
-    if (m_data) delete[] m_data;
-    
-    m_data = new char[size];
 
     memcpy( m_data, data, size );
 }
 
-char* wxPrivateDataObject::GetData() const
-{
-    return m_data;
-}
-
 void wxPrivateDataObject::WriteData( void *dest ) const
 {
     WriteData( m_data, dest );
@@ -475,10 +459,10 @@ void wxPrivateDataObject::WriteData( void *dest ) const
 
 size_t wxPrivateDataObject::GetSize() const
 {
-   return m_size;
+    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() );
 }

src/msw/clipbrd.cpp

@@ -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 )
@@ -378,9 +414,9 @@ void *wxGetClipboardData(wxDataFormat dataFormat, long *len)
     return retval;
 }
 
-wxDataFormat  wxEnumClipboardFormats(wxDataFormat dataFormat)
+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."),
+            return wxSetClipboardData(data);
-                       wxDataObject::GetFormatName(format));
-
-            return FALSE;
     }
-
+#else // !wxUSE_DRAG_AND_DROP
     return FALSE;
-#else
+#endif // wxUSE_DRAG_AND_DROP/!wxUSE_DRAG_AND_DROP
-    return FALSE;
-#endif
 }
 
 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;
     }

src/msw/ole/dataobj.cpp

@@ -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/log.h"
-#include <wx/msw/ole/dataobj.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
 // ----------------------------------------------------------------------------

src/msw/ole/dropsrc.cpp

@@ -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/log.h"
-#include  <wx/msw/ole/dataobj.h>
+#include "wx/dataobj.h"
-#include  <wx/msw/ole/dropsrc.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

src/msw/ole/droptgt.cpp

@@ -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__
+    #ifndef __GNUWIN32__
-#include  <shlobj.h>            // for DROPFILES structure
+        #include <shlobj.h>            // for DROPFILES structure
-#endif
+    #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 <ole2.h>
-#include <olestd.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
+  // we assume that if QueryGetData() returns S_OK, than we can really get data
-  //    get data in this format, so we remember here the format for which
+  // in this format, so we remember here the format for which QueryGetData()
-  //    QueryGetData() succeeded
+  // 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,22 +214,22 @@ 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
+  //      that it's the same we've already got in DragEnter
   wxASSERT( m_pIDataObject == pIDataSource );
 
   STGMEDIUM stm;
   *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
+    //     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);

src/msw/window.cpp

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