*** empty log message ***

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

include/wx/dataobj.h

@@ -157,7 +157,7 @@ public:
 #elif defined(__WXMAC__)
     #include "wx/mac/dnd.h"
 #elif defined(__WXPM__)
-    #include "wx/os2/dnd.h"
+    #include "wx/os2/dataobj.h"
 #elif defined(__WXSTUBS__)
     #include "wx/stubs/dnd.h"
 #endif
@@ -312,6 +312,16 @@ public:
 
 private:
     wxString m_text;
+
+#if defined(__VISAGECPP__)
+    // Virtual function hiding supression
+    size_t GetDataSize(const wxDataFormat& rFormat) const
+    { return(wxDataObjectSimple::GetDataSize(rFormat)); }
+    bool GetDataHere(const wxDataFormat& WXUNUSED(rFormat), void *pBuf) const
+    { return(GetDataHere(pBuf)); }
+    bool SetData(const wxDataFormat& rFormat, size_t nLen, const void* pBuf)
+    { return(wxDataObjectSimple::SetData(rFormat, nLen, pBuf)); }
+#endif
 };
 
 // ----------------------------------------------------------------------------
@@ -359,6 +369,15 @@ public:
 
 protected:
     wxArrayString m_filenames;
+
+#if defined(__VISAGECPP__)
+private:
+    // Virtual function hiding supression
+    size_t GetDataSize(const wxDataFormat& rFormat) const
+    { return(wxDataObjectSimple::GetDataSize(rFormat)); }
+    bool GetDataHere(const wxDataFormat& WXUNUSED(rformat), void* pBuf) const
+    { return(GetDataHere(pBuf)); }
+#endif
 };
 
 // ----------------------------------------------------------------------------
@@ -405,6 +424,16 @@ public:
 private:
     size_t m_size;
     void  *m_data;
+
+#if defined(__VISAGECPP__)
+    // Virtual function hiding supression
+    size_t GetDataSize(const wxDataFormat& rFormat) const
+    { return(wxDataObjectSimple::GetDataSize(rFormat)); }
+    bool GetDataHere(const wxDataFormat& rFormat, void* pBuf) const
+    { return(wxDataObjectSimple::GetDataHere(rFormat, pBuf)); }
+    bool SetData(const wxDataFormat& rFormat, size_t nLen, const void* pBuf)
+    { return(wxDataObjectSimple::SetData(rFormat, nLen, pBuf)); }
+#endif
 };
 
 // ----------------------------------------------------------------------------
@@ -417,6 +446,8 @@ private:
     // #include "wx/motif/dataobj2.h" -- not yet
 #elif defined(__WXGTK__)
     #include "wx/gtk/dataobj2.h"
+#elif defined(__WXPM__)
+    #include "wx/os2/dataobj2.h"
 #endif
 
 #endif // _WX_DATAOBJ_H_BASE_

include/wx/dnd.h

@@ -44,9 +44,9 @@ public:
     virtual ~wxDropSourceBase() { }
 
     // set the data which is transfered by drag and drop
-    void SetData(wxDataObject& data) 
+    void SetData(wxDataObject& data)
       { m_data = &data; }
-      
+
     wxDataObject *GetDataObject()
       { return m_data; }
 
@@ -94,8 +94,8 @@ public:
     wxDataObject *GetDataObject() const
         { return m_dataObject; }
     void SetDataObject(wxDataObject *dataObject)
-        { if (m_dataObject) delete m_dataObject; 
+        { if (m_dataObject) delete m_dataObject;
-	  m_dataObject = dataObject; }
+    m_dataObject = dataObject; }
 
     // these functions are called when data is moved over position (x, y) and
     // may return either wxDragCopy, wxDragMove or wxDragNone depending on
@@ -115,11 +115,11 @@ public:
     virtual wxDragResult OnDragOver(wxCoord WXUNUSED(x), wxCoord WXUNUSED(y),
                                     wxDragResult def)
         { return def; }
-    
+
     // called when mouse leaves the window: might be used to remove the
     // feedback which was given in OnEnter()
     virtual void OnLeave() { }
-    
+
     // this function is called when data is dropped at position (x, y) - if it
     // returns TRUE, OnData() will be called immediately afterwards which will
     // allow to retrieve the data dropped.

include/wx/os2/clipbrd.h

@@ -65,6 +65,9 @@ public:
     // close the clipboard after SetData() and GetData()
     virtual void Close();
 
+    // query whether the clipboard is opened
+    virtual bool IsOpened() const;
+
     // set the clipboard data. all other formats will be deleted.
     virtual bool SetData( wxDataObject *data );
 

include/wx/os2/dataform.h

@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////
-// Name:        gtk/dataform.h
+// Name:        os2/dataform.h
 // Purpose:     declaration of the wxDataFormat class
 // Author:      David Webster (lifted from dnd.h)
 // Modified by:

include/wx/os2/dataobj.h

@@ -0,0 +1,32 @@
+///////////////////////////////////////////////////////////////////////////////
+// Name:        os2/dataobj.h
+// Purpose:     declaration of the wxDataObject
+// Author:      David Webster (adapted from Robert Roebling's gtk port)
+// Modified by:
+// Created:     10/21/99
+// RCS-ID:      $Id$
+// Copyright:   (c) 1998, 1999 Vadim Zeitlin, Robert Roebling
+// Licence:     wxWindows license
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_GTK_DATAOBJ_H_
+#define _WX_GTK_DATAOBJ_H_
+
+#ifdef __GNUG__
+    #pragma interface "dataobj.h"
+#endif
+
+// ----------------------------------------------------------------------------
+// wxDataObject is the same as wxDataObjectBase under wxGTK
+// ----------------------------------------------------------------------------
+
+class wxDataObject : public wxDataObjectBase
+{
+public:
+    wxDataObject();
+
+    virtual bool IsSupportedFormat( const wxDataFormat& format, Direction dir = Get ) const;
+};
+
+#endif // _WX_GTK_DATAOBJ_H_
+

include/wx/os2/dataobj2.h

@@ -0,0 +1,90 @@
+///////////////////////////////////////////////////////////////////////////////
+// Name:        os2/dataobj2.h
+// Purpose:     declaration of standard wxDataObjectSimple-derived classes
+// Author:      David Webster (adapted from Robert Roebling's gtk port
+// Modified by:
+// Created:     10/21/99
+// RCS-ID:      $Id$
+// Copyright:   (c) 1998, 1999 Vadim Zeitlin, Robert Roebling
+// Licence:     wxWindows license
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef _WX_GTK_DATAOBJ2_H_
+#define _WX_GTK_DATAOBJ2_H_
+
+#ifdef __GNUG__
+    #pragma interface "dataobj.h"
+#endif
+
+// ----------------------------------------------------------------------------
+// wxBitmapDataObject is a specialization of wxDataObject for bitmaps
+// ----------------------------------------------------------------------------
+
+class wxBitmapDataObject : public wxBitmapDataObjectBase
+{
+public:
+    // ctors
+    wxBitmapDataObject();
+    wxBitmapDataObject(const wxBitmap& bitmap);
+
+    // destr
+    ~wxBitmapDataObject();
+
+    // override base class virtual to update PNG data too
+    virtual void SetBitmap(const wxBitmap& bitmap);
+
+    // implement base class pure virtuals
+    // ----------------------------------
+
+    virtual size_t GetDataSize() const { return m_pngSize; }
+    virtual bool GetDataHere(void *buf) const;
+    virtual bool SetData(size_t len, const void *buf);
+
+protected:
+    void Init() { m_pngData = (void *)NULL; m_pngSize = 0; }
+    void Clear() { free(m_pngData); }
+    void ClearAll() { Clear(); Init(); }
+
+    size_t      m_pngSize;
+    void       *m_pngData;
+
+    void DoConvertToPng();
+
+private:
+    // Virtual function hiding supression
+    size_t GetDataSize(const wxDataFormat& rFormat) const
+    { return(wxDataObjectSimple::GetDataSize(rFormat)); }
+    bool GetDataHere(const wxDataFormat& rFormat, void* pBuf) const
+    { return(wxDataObjectSimple::GetDataHere(rFormat, pBuf)); }
+    bool SetData(const wxDataFormat& rFormat, size_t nLen, const void* pBuf)
+    { return(wxDataObjectSimple::SetData(rFormat, nLen, pBuf)); }
+};
+
+// ----------------------------------------------------------------------------
+// wxFileDataObject is a specialization of wxDataObject for file names
+// ----------------------------------------------------------------------------
+
+class wxFileDataObject : public wxFileDataObjectBase
+{
+public:
+    // implement base class pure virtuals
+    // ----------------------------------
+
+    void AddFile( const wxString &filename );
+
+    virtual size_t GetDataSize() const;
+    virtual bool GetDataHere(void *buf) const;
+    virtual bool SetData(size_t len, const void *buf);
+
+private:
+    // Virtual function hiding supression
+    size_t GetDataSize(const wxDataFormat& rFormat) const
+    { return(wxDataObjectSimple::GetDataSize(rFormat)); }
+    bool GetDataHere(const wxDataFormat& rFormat, void* pBuf) const
+    { return(wxDataObjectSimple::GetDataHere(rFormat, pBuf)); }
+    bool SetData(const wxDataFormat& rFormat, size_t nLen, const void* pBuf)
+    { return(wxDataObjectSimple::SetData(rFormat, nLen, pBuf)); }
+};
+
+#endif // _WX_GTK_DATAOBJ2_H_
+

include/wx/os2/dnd.h

@@ -1,257 +1,126 @@
 ///////////////////////////////////////////////////////////////////////////////
 // Name:        dnd.h
-// Purpose:     Declaration of the wxDropTarget, wxDropSource class etc.
+// Purpose:     declaration of the wxDropTarget class
-// Author:      AUTHOR
+// Author:      David Webster
+// Modified by:
+// Created:     10/21/99
 // RCS-ID:      $Id$
-// Copyright:   (c) 1998 AUTHOR
+// Copyright:   (c) 1999 David Webster
-// Licence:     wxWindows licence
+// Licence:     wxWindows license
 ///////////////////////////////////////////////////////////////////////////////
 
-#ifndef _WX_DND_H_
+
-#define _WX_DND_H_
+#ifndef __OS2DNDH__
+#define __OS2DNDH__
 
 #ifdef __GNUG__
-#pragma interface "dnd.h"
+#pragma interface
 #endif
 
-#include "wx/defs.h"
+#if !wxUSE_DRAG_AND_DROP
-#include "wx/object.h"
+    #error  "You should #define wxUSE_DRAG_AND_DROP to 1 to compile this file!"
-#include "wx/string.h"
+#endif  //WX_DRAG_DROP
-#include "wx/cursor.h"
 
 //-------------------------------------------------------------------------
-// classes
+// wxDropSource
 //-------------------------------------------------------------------------
 
-class WXDLLEXPORT wxWindow;
+class WXDLLEXPORT wxDropSource: public wxDropSourceBase
-
-class WXDLLEXPORT wxDataObject;
-class WXDLLEXPORT wxTextDataObject;
-class WXDLLEXPORT wxFileDataObject;
-
-class WXDLLEXPORT wxDropTarget;
-class WXDLLEXPORT wxTextDropTarget;
-class WXDLLEXPORT wxFileDropTarget;
-
-class WXDLLEXPORT wxDropSource;
-
-//-------------------------------------------------------------------------
-// wxDataBroker (internal)
-//-------------------------------------------------------------------------
-
-class wxDataBroker : public wxObject
-{
-  DECLARE_CLASS( wxDataBroker )
-
-public:
-
-  /* constructor */
-  wxDataBroker();
-
-  /* add data object */
-  void Add( wxDataObject *dataObject, bool preferred = FALSE );
-
-private:
-
-  /* OLE implementation, the methods don't need to be overridden */
-
-  /* get number of supported formats */
-  virtual size_t GetFormatCount() const;
-
-  /* return nth supported format */
-  virtual wxDataFormat &GetNthFormat( size_t nth ) const;
-
-  /* return preferrd/best supported format */
-  virtual wxDataFormatId GetPreferredFormat() const;
-
-  /* search through m_dataObjects, return TRUE if found */
-  virtual bool IsSupportedFormat( wxDataFormat &format ) const;
-
-  /* search through m_dataObjects and call child's GetSize() */
-  virtual size_t GetSize( wxDataFormat& format ) const;
-
-  /* search through m_dataObjects and call child's WriteData(dest) */
-  virtual void WriteData( wxDataFormat& format, void *dest ) const;
-
-  /* implementation */
-
-public:
-
-  wxList    m_dataObjects;
-  size_t    m_preferred;
-};
-
-//-------------------------------------------------------------------------
-// wxDataObject
-//-------------------------------------------------------------------------
-
-class WXDLLEXPORT wxDataObject: public wxDataObjectBase
 {
 public:
-  // all data formats (values are the same as in windows.h, do not change!)
+    /* constructor. set data later with SetData() */
-  enum StdFormat
+    wxDropSource( wxWindow*     pWin
-  {
+                 ,const wxIcon& rGo = wxNullIcon
-    Invalid,
+                 ,const wxIcon& rStop = wxNullIcon
-    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)
+    /* constructor for setting one data object */
-  static const char *GetFormatName(wxDataFormat format);
+    wxDropSource( wxDataObject& rData,
+                  wxWindow*     pWin,
+                  const wxIcon& rGo = wxNullIcon,
+                  const wxIcon& rStop = wxNullIcon
+                );
+    virtual ~wxDropSource();
 
-  // ctor & dtor
+    /* start drag action */
-  wxDataObject() {};
+    virtual wxDragResult DoDragDrop(bool bAllowMove = FALSE);
-  ~wxDataObject() {};
 
-  // pure virtuals to override
+protected:
-    // get the best suited format for our data
+    void Init(void);
-  virtual wxDataFormat GetPreferredFormat() const = 0;
+    bool                            m_bLazyDrag;
-    // decide if we support this format (should be one of values of
-    // StdFormat 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;
-    // copy raw data to provided pointer
-  virtual bool GetDataHere(void *pBuf) const = 0;
 
+    DRAGIMAGE*                      m_pDragImage;
+    DRAGINFO*                       m_pDragInfo;
+    DRAGTRANSFER*                   m_pDragTransfer;
 };
 
-// ----------------------------------------------------------------------------
-// wxFileDataObject is a specialization of wxDataObject for file names
-// ----------------------------------------------------------------------------
-
-class WXDLLEXPORT wxFileDataObject : public wxDataObject
-{
-public:
-
-  wxFileDataObject(void) { }
-  void AddFile( const wxString &file )
-    { m_files += file; m_files += ";"; }
-
-  // implement base class pure virtuals
-  virtual wxDataFormat GetPreferredFormat() const
-    { return wxDF_FILENAME; }
-  virtual bool IsSupportedFormat(wxDataFormat format) const
-    { return format == (unsigned short)wxDF_FILENAME; }
-  virtual size_t GetDataSize() const
-    { return m_files.Len() + 1; } // +1 for trailing '\0'of course
-  virtual bool GetDataHere(void *pBuf) const
-    { memcpy(pBuf, m_files.c_str(), GetDataSize()); }
-
-private:
-  wxString  m_files;
-
-};
 //-------------------------------------------------------------------------
 // wxDropTarget
 //-------------------------------------------------------------------------
 
-class WXDLLEXPORT wxDropTarget: public wxObject
+class WXDLLEXPORT wxDropTarget: public wxDropTargetBase
 {
-  public:
+public:
+    wxDropTarget(wxDataObject *dataObject = (wxDataObject*)NULL);
+    virtual ~wxDropTarget();
 
-    wxDropTarget();
+    void Register(WXHWND hwnd);
-    ~wxDropTarget();
+    void Revoke(WXHWND hwnd);
 
-    virtual void OnEnter() { }
+    virtual wxDragResult OnDragOver(wxCoord x, wxCoord y, wxDragResult def);
-    virtual void OnLeave() { }
+    virtual bool OnDrop(wxCoord x, wxCoord y);
-    virtual bool OnDrop( long x, long y, const void *pData ) = 0;
+    virtual bool OnData(wxCoord x, wxCoord y);
+    virtual bool GetData();
 
-//  protected:
+  // implementation
+protected:
+    virtual bool IsAcceptable(DRAGINFO* pInfo);
 
-    friend wxWindow;
+    DRAGINFO*                       m_pDragInfo;
-
+    DRAGTRANSFER*                   m_pDragTransfer;
-    // Override these to indicate what kind of data you support:
-
-    virtual size_t GetFormatCount() const = 0;
-    virtual wxDataFormat GetFormat(size_t n) const = 0;
 };
 
-//-------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
-// wxTextDropTarget
+// A simple wxDropTarget derived class for text data: you only need to
-//-------------------------------------------------------------------------
+// override OnDropText() to get something working
+// ----------------------------------------------------------------------------
 
-class WXDLLEXPORT wxTextDropTarget: public wxDropTarget
+class WXDLLEXPORT wxTextDropTarget : public wxDropTarget
 {
-  public:
+public:
+    wxTextDropTarget();
+    virtual ~wxTextDropTarget();
 
-    wxTextDropTarget() {};
+    virtual bool OnDropText( wxCoord         x
-    virtual bool OnDrop( long x, long y, const void *pData );
+                            ,wxCoord         y
-    virtual bool OnDropText( long x, long y, const char *psz );
+                            ,const wxString& rText
+                           ) = 0;
 
-  protected:
+    virtual bool OnData( wxCoord x
-
+                        ,wxCoord y
-    virtual size_t GetFormatCount() const;
+                       );
-    virtual wxDataFormat GetFormat(size_t n) const;
 };
 
 // ----------------------------------------------------------------------------
 // A drop target which accepts files (dragged from File Manager or Explorer)
 // ----------------------------------------------------------------------------
 
-class WXDLLEXPORT wxFileDropTarget: public wxDropTarget
+class WXDLLEXPORT wxFileDropTarget : public wxDropTarget
 {
-  public:
+public:
+    wxFileDropTarget();
+    virtual ~wxFileDropTarget();
 
-    wxFileDropTarget() {};
+    // parameters are the number of files and the array of file names
+    virtual bool OnDropFiles( wxCoord              x
+                             ,wxCoord              y
+                             ,const wxArrayString& rFilenames
+                            ) = 0;
 
-    virtual bool OnDrop(long x, long y, const void *pData);
+    virtual bool OnData( wxCoord x
-    virtual bool OnDropFiles( long x, long y,
+                        ,wxCoord y
-                              size_t nFiles, const char * const aszFiles[]);
+                       );
-
-  protected:
-
-    virtual size_t GetFormatCount() const;
-    virtual wxDataFormat GetFormat(size_t n) const;
 };
 
-//-------------------------------------------------------------------------
+#endif //__OS2DNDH__
-// 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
-    wxDragCancel    // the operation was cancelled by user (not an error)
-  };
-
-class WXDLLEXPORT wxDropSource: public wxObject
-{
-  public:
-
-    wxDropSource( wxWindow *win );
-    wxDropSource( wxDataObject &data, wxWindow *win );
-
-    ~wxDropSource(void);
-
-    void SetData( wxDataObject &data  );
-    wxDragResult DoDragDrop( bool bAllowMove = FALSE );
-
-    virtual bool GiveFeedback( wxDragResult WXUNUSED(effect), bool WXUNUSED(bScrolling) ) { return TRUE; };
-
-  protected:
-
-    wxDataObject  *m_data;
-};
-
-#endif
-       //_WX_DND_H_
 

src/os2/clipbrd.cpp

@@ -451,11 +451,22 @@ void wxClipboard::Clear()
 {
 }
 
+bool wxClipboard::Flush()
+{
+    // TODO:
+    return FALSE;
+}
+
 bool wxClipboard::Open()
 {
     return wxOpenClipboard();
 }
 
+bool wxClipboard::IsOpened() const
+{
+    return wxIsClipboardOpened();
+}
+
 bool wxClipboard::SetData( wxDataObject *data )
 {
     (void)wxEmptyClipboard();
@@ -604,25 +615,6 @@ bool wxClipboard::GetData( wxDataObject *data )
 #endif
 }
 
-//-----------------------------------------------------------------------------
-// wxClipboardModule
-//-----------------------------------------------------------------------------
-
-IMPLEMENT_DYNAMIC_CLASS(wxClipboardModule,wxModule)
-
-bool wxClipboardModule::OnInit()
-{
-    wxTheClipboard = new wxClipboard();
-
-    return TRUE;
-}
-
-void wxClipboardModule::OnExit()
-{
-    if (wxTheClipboard) delete wxTheClipboard;
-    wxTheClipboard = (wxClipboard*) NULL;
-}
-
 #else
     #error "Please turn wxUSE_CLIPBOARD on to compile this file."
 #endif // wxUSE_CLIPBOARD

src/os2/dataobj.cpp

@@ -0,0 +1,347 @@
+///////////////////////////////////////////////////////////////////////////////
+// Name:        os2/dataobj.cpp
+// Purpose:     implementation of wx[I]DataObject class
+// Author:      David Webster
+// Modified by:
+// Created:     10/21/99
+// RCS-ID:      $Id$
+// Copyright:   (c) 1999 David Webster
+// Licence:     wxWindows license
+///////////////////////////////////////////////////////////////////////////////
+
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
+#ifdef __GNUG__
+  #pragma implementation "dataobj.h"
+#endif
+
+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+
+#ifndef WX_PRECOMP
+#include "wx/intl.h"
+#endif
+#include "wx/defs.h"
+
+#include "wx/log.h"
+#include "wx/dataobj.h"
+
+#define INCL_DOS
+#include <os2.h>
+
+// ----------------------------------------------------------------------------
+// functions
+// ----------------------------------------------------------------------------
+
+#ifdef __WXDEBUG__
+    static const wxChar *GetTymedName(DWORD tymed);
+#endif // Debug
+
+// ----------------------------------------------------------------------------
+// wxDataFormat
+// ----------------------------------------------------------------------------
+
+wxDataFormat::wxDataFormat(
+  wxDataFormatId                    vType
+)
+{
+    PrepareFormats();
+    m_vType = wxDF_INVALID;
+    m_vFormat = 0;
+}
+
+wxDataFormat::wxDataFormat(
+  wxDataFormatId                    vType
+)
+{
+    PrepareFormats();
+    SetType(vType);
+}
+
+wxDataFormat::wxDataFormat(
+  const wxChar*                     zId
+)
+{
+    PrepareFormats();
+    SetId(zId);
+}
+
+wxDataFormat::wxDataFormat(
+  const wxString&                   rId
+)
+{
+    PrepareFormats();
+    SetId(rId);
+}
+
+wxDataFormat::wxDataFormat(
+  NativeFormat                      vFormat
+)
+{
+    PrepareFormats();
+    SetId(vFormat);
+}
+
+void wxDataFormat::SetType(
+  wxDataFormatId                    vType
+)
+{
+    m_vType = vType;
+
+    if (m_vType == wxDF_TEXT)
+        m_vFormat = 0;
+    else
+    if (m_vType == wxDF_BITMAP)
+        m_vFormat = 0;
+    else
+    if (m_vType == wxDF_FILENAME)
+        m_vFormat = 0;
+    else
+    {
+       wxFAIL_MSG( wxT("invalid dataformat") );
+    }
+}
+
+wxDataFormatId wxDataFormat::GetType() const
+{
+    return m_vType;
+}
+
+wxString wxDataFormat::GetId() const
+{
+    wxString                        sRet("");  // TODO: gdk_atom_name( m_format ) );
+    return sRet;
+}
+
+void wxDataFormat::SetId(
+  NativeFormat                      vFormat
+)
+{
+    m_vFormat = vFormat;
+// TODO:
+/*
+    if (m_format == g_textAtom)
+        m_type = wxDF_TEXT;
+    else
+    if (m_format == g_pngAtom)
+        m_type = wxDF_BITMAP;
+    else
+    if (m_format == g_fileAtom)
+        m_type = wxDF_FILENAME;
+    else
+        m_type = wxDF_PRIVATE;
+*/
+}
+
+void wxDataFormat::SetId(
+  const wxChar*                     zId
+)
+{
+    wxString                        tmp(zId);
+
+    m_vType = wxDF_PRIVATE;
+    m_vFormat = 0;// TODO: get the format gdk_atom_intern( wxMBSTRINGCAST tmp.mbc_str(), FALSE );
+}
+
+void wxDataFormat::PrepareFormats()
+{
+// TODO:
+/*
+    if (!g_textAtom)
+        g_textAtom = gdk_atom_intern( "STRING", FALSE );
+    if (!g_pngAtom)
+        g_pngAtom = gdk_atom_intern( "image/png", FALSE );
+    if (!g_fileAtom)
+        g_fileAtom = gdk_atom_intern( "file:ALL", FALSE );
+*/
+}
+
+//-------------------------------------------------------------------------
+// wxDataObject
+//-------------------------------------------------------------------------
+
+wxDataObject::wxDataObject()
+{
+}
+
+bool wxDataObject::IsSupportedFormat(
+  const wxDataFormat&               rFormat
+, Direction                         vDir
+) const
+{
+    size_t                          nFormatCount = GetFormatCount(vDir);
+
+    if (nFormatCount == 1)
+    {
+        return rFormat == GetPreferredFormat();
+    }
+    else
+    {
+        wxDataFormat*               pFormats = new wxDataFormat[nFormatCount];
+        GetAllFormats( rFormats
+                      ,vDir
+                     );
+
+        size_t                      n;
+
+        for (n = 0; n < nFormatCount; n++)
+        {
+            if (rFormats[n] == rFormat)
+                break;
+        }
+
+        delete [] rFormats;
+
+        // found?
+        return n < nFormatCount;
+    }
+}
+
+// ----------------------------------------------------------------------------
+// wxFileDataObject
+// ----------------------------------------------------------------------------
+
+bool wxFileDataObject::GetDataHere(
+  void*                             pBuf
+) const
+{
+    wxString                        sFilenames;
+
+    for (size_t i = 0; i < m_filenames.GetCount(); i++)
+    {
+        filenames += m_filenames[i];
+        filenames += (wxChar)0;
+    }
+
+    memcpy(pBuf, filenames.mbc_str(), filenames.Len() + 1);
+    return TRUE;
+}
+
+size_t wxFileDataObject::GetDataSize() const
+{
+    size_t                          nRes = 0;
+
+    for (size_t i = 0; i < m_filenames.GetCount(); i++)
+    {
+        nRes += m_filenames[i].Len();
+        nRes += 1;
+    }
+
+    return nRes + 1;
+}
+
+bool wxFileDataObject::SetData(
+  size_t                            WXUNUSED(nSize)
+, const void*                       pBuf
+)
+{
+    /* TODO */
+
+    wxString                        sFile( (const char *)pBuf);  /* char, not wxChar */
+
+    AddFile(sFile);
+
+    return TRUE;
+}
+
+void wxFileDataObject::AddFile(
+  const wxString&                   rFilename
+)
+{
+    m_filenames.Add(rFilename);
+}
+
+// ----------------------------------------------------------------------------
+// wxBitmapDataObject
+// ----------------------------------------------------------------------------
+
+wxBitmapDataObject::wxBitmapDataObject()
+{
+    Init();
+}
+
+wxBitmapDataObject::wxBitmapDataObject(
+  const wxBitmap&                   rBitmap
+)
+: wxBitmapDataObjectBase(rBitmap)
+{
+    Init();
+
+    DoConvertToPng();
+}
+
+wxBitmapDataObject::~wxBitmapDataObject()
+{
+    Clear();
+}
+
+void wxBitmapDataObject::SetBitmap(
+  const wxBitmap&                   rBitmap
+)
+{
+    ClearAll();
+    wxBitmapDataObjectBase::SetBitmap(rBitmap);
+    DoConvertToPng();
+}
+
+bool wxBitmapDataObject::GetDataHere(
+  void*                             pBuf
+) const
+{
+    if (!m_pngSize)
+    {
+        wxFAIL_MSG(wxT("attempt to copy empty bitmap failed"));
+        return FALSE;
+    }
+    memcpy(pBuf, m_pngData, m_pngSize);
+    return TRUE;
+}
+
+bool wxBitmapDataObject::SetData(
+  size_t                            nSize
+, const void*                       pBuf
+)
+{
+    Clear();
+    m_pngSize = nSize;
+    m_pngData = malloc(m_pngSize);
+
+    memcpy(m_pngData, pBuf, m_pngSize);
+
+    wxMemoryInputStream             vMstream((char*)m_pngData, m_pngSize);
+    wxImage                         vImage;
+    wxPNGHandler                    vHandler;
+
+    if (!vHandler.LoadFile(&vImage, vMstream))
+    {
+        return FALSE;
+    }
+
+    m_bitmap = vImage.ConvertToBitmap();
+    return m_bitmap.Ok();
+}
+
+void wxBitmapDataObject::DoConvertToPng()
+{
+    if (!m_bitmap.Ok())
+        return;
+
+    wxImage                         vImage(m_bitmap);
+    wxPNGHandler                    vHandler;
+    wxCountingOutputStream          vCount;
+
+    vHandler.SaveFile(&rImage, vCount);
+
+    m_pngSize = vCount.GetSize() + 100; // sometimes the size seems to vary ???
+    m_pngData = malloc(m_pngSize);
+
+    wxMemoryOutputStream mstream((char*) m_pngData, m_pngSize);
+    vHandler.SaveFile(&vImage, vMstream );
+}
+

src/os2/dnd.cpp

@@ -1,9 +1,9 @@
 ///////////////////////////////////////////////////////////////////////////////
 // Name:        dnd.cpp
 // Purpose:     wxDropTarget, wxDropSource, wxDataObject implementation
-// Author:      AUTHOR
+// Author:      David Webster
 // Modified by:
-// Created:     ??/??/98
+// Created:     10/21/99
 // RCS-ID:      $Id$
 // Copyright:   (c) 1998 AUTHOR
 // Licence:     wxWindows licence
@@ -26,108 +26,153 @@
 // wxDropTarget
 // ----------------------------------------------------------------------------
 
-wxDropTarget::wxDropTarget()
+wxDropTarget::wxDropTarget(
+  wxDataObject*                     pDataObject
+)
 {
+    // TODO:
 };
 
 wxDropTarget::~wxDropTarget()
 {
 };
 
+void wxDropTarget::Register(
+  WXHWND                            hwnd
+)
+{
+    //TODO:
+};
+
+void wxDropTarget::Revoke(
+  WXHWND                            hwnd
+)
+{
+    //TODO:
+};
+
+wxDragResult wxDropTarget::OnDragOver(
+  wxCoord                           x
+, wxCoord                           y
+, wxDragResult                      vDef
+)
+{
+    //TODO:
+    return vDef;
+};
+
+bool wxDropTarget::OnDrop(
+  wxCoord                           x
+, wxCoord                           y
+)
+{
+    //TODO:
+    return FALSE;
+};
+
+bool wxDropTarget::OnData(
+  wxCoord                           x
+, wxCoord                           y
+)
+{
+    //TODO:
+    return FALSE;
+};
+
+bool wxDropTarget::GetData()
+{
+    //TODO:
+    return FALSE;
+};
+
+bool wxDropTarget::IsAcceptable(
+  DRAGINFO*                         pInfo
+)
+{
+    //TODO:
+    return FALSE;
+};
+
 // ----------------------------------------------------------------------------
 // wxTextDropTarget
 // ----------------------------------------------------------------------------
 
-bool wxTextDropTarget::OnDrop( long x, long y, const void *pData )
+wxTextDropTarget::wxTextDropTarget()
 {
-  OnDropText( x, y, (const char*)pData );
+    // TODO:
-  return TRUE;
-};
-
-bool wxTextDropTarget::OnDropText( long x, long y, const char *psz )
-{
-  printf( "Got dropped text: %s.\n", psz );
-  printf( "At x: %d, y: %d.\n", (int)x, (int)y );
-  return TRUE;
-};
-
-size_t wxTextDropTarget::GetFormatCount() const
-{
-  return 1;
 }
 
-wxDataFormat wxTextDropTarget::GetFormat(size_t WXUNUSED(n)) const
+wxTextDropTarget::~wxTextDropTarget()
 {
-  return wxDF_TEXT;
+    // TODO:
 }
 
+bool wxTextDropTarget::OnData(
+  wxCoord                           x
+, wxCoord                           y
+)
+{
+    // TODO:
+    return FALSE;
+};
+
 // ----------------------------------------------------------------------------
 // wxFileDropTarget
 // ----------------------------------------------------------------------------
 
-bool wxFileDropTarget::OnDropFiles( long x, long y, size_t nFiles, const char * const WXUNUSED(aszFiles)[] )
+wxFileDropTarget::wxFileDropTarget()
 {
-  printf( "Got %d dropped files.\n", (int)nFiles );
+    // TODO:
-  printf( "At x: %d, y: %d.\n", (int)x, (int)y );
-  return TRUE;
 }
 
-bool wxFileDropTarget::OnDrop(long x, long y, const void *WXUNUSED(pData) )
+wxFileDropTarget::~wxFileDropTarget()
 {
-  char *str = "/this/is/a/path.txt";
+    // TODO:
-
-  return OnDropFiles(x, y, 1, &str ); 
 }
 
-size_t wxFileDropTarget::GetFormatCount() const
+bool wxFileDropTarget::OnData(
+  wxCoord                           x
+, wxCoord                           y
+)
 {
-  return 1;
+    // TODO:
-}
+    return FALSE;
-
+};
-wxDataFormat wxFileDropTarget::GetFormat(size_t WXUNUSED(n)) const
-{
-  return wxDF_FILENAME;
-}
 
 //-------------------------------------------------------------------------
 // wxDropSource
 //-------------------------------------------------------------------------
 
-//-----------------------------------------------------------------------------
+wxDropSource::wxDropSource(
-// drag request
+  wxWindow*                         pWin
-
+)
-wxDropSource::wxDropSource( wxWindow *win )
 {
     // TODO
-  //    m_window = win;
-    m_data = NULL;
-
-    //    m_defaultCursor = wxCursor( wxCURSOR_NO_ENTRY );
-    //    m_goaheadCursor = wxCursor( wxCURSOR_HAND );
 };
 
-wxDropSource::wxDropSource( wxDataObject &data, wxWindow *win )
+wxDropSource::wxDropSource(
+  wxDataObject&                     rData
+, wxWindow*                         pWin
+)
 {
     // TODO
-  //    m_window = win;
-    m_data = &data;
-
-    //    m_defaultCursor = wxCursor( wxCURSOR_NO_ENTRY );
-    //    m_goaheadCursor = wxCursor( wxCURSOR_HAND );
 };
 
-void wxDropSource::SetData( wxDataObject &data )
+wxDropSource::~wxDropSource()
 {
-    m_data = &data;
+    // TODO
 };
 
-wxDropSource::~wxDropSource(void)
+wxDragResult wxDropSource::DoDragDrop(
-{
+  bool                              WXUNUSED(bAllowMove)
-};
+)
-   
-wxDragResult wxDropSource::DoDragDrop( bool WXUNUSED(bAllowMove) )
 {
     // TODO
     return wxDragError;
 };
 
+void wxDropSource::Init()
+{
+    // TODO
+};
+

src/os2/makefile.va

@@ -339,6 +339,7 @@ OS2OBJS = \
   ..\os2\$D\control.obj \
   ..\os2\$D\cursor.obj \
   ..\os2\$D\data.obj \
+  ..\os2\$D\dataobj.obj \
   ..\os2\$D\dc.obj \
   ..\os2\$D\dcclient.obj \
   ..\os2\$D\dcmemory.obj \
@@ -416,6 +417,7 @@ OS2LIBOBJS1 = \
   control.obj \
   cursor.obj \
   data.obj \
+  dataobj.obj \
   dc.obj \
   dcclient.obj \
   dcmemory.obj \
@@ -444,10 +446,10 @@ OS2LIBOBJS1 = \
   menuitem.obj \
   metafile.obj \
   minifram.obj \
-  msgdlg.obj \
+  msgdlg.obj
-  nativdlg.obj
 
 OS2LIBOBJS2 = \
+  nativdlg.obj \
   notebook.obj \
   ownerdrw.obj \
   palette.obj \