Don't use "Cancel" button in the about dialog of the listctrl sample.

[wxWidgets.git] / src / x11 / dataobj.cpp

diff --git a/src/x11/dataobj.cpp b/src/x11/dataobj.cpp
index f9120e6be4c3a590466070f603a3e4fad8320532..01e5cd9ed02d66f16ac9292ca0a39e6e9bc31fbf 100644 (file)
--- a/src/x11/dataobj.cpp
+++ b/src/x11/dataobj.cpp
@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////
 ///////////////////////////////////////////////////////////////////////////////

-// Name:        dataobj.cpp
+// Name:        src/x11/dataobj.cpp

 // Purpose:     wxDataObject class
 // Author:      Julian Smart
 // Id:          $Id$
 // Purpose:     wxDataObject class
 // Author:      Julian Smart
 // Id:          $Id$


@@ -7,24 +7,23 @@
 // Licence:     wxWindows licence
 ///////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 ///////////////////////////////////////////////////////////////////////////////
 

-#ifdef __GNUG__
-#pragma implementation "dataobj.h"
-#endif
-
-#include "wx/defs.h"
+// for compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"

 
 

-#if wxUSE_CLIPBOARD
+#if wxUSE_DATAOBJ

 
 #include "wx/dataobj.h"
 
 #include "wx/dataobj.h"

-#include "wx/app.h"

 
 

-#ifdef __VMS__
-#pragma message disable nosimpint
-#endif
-#ifdef __VMS__
-#pragma message enable nosimpint
+#ifndef WX_PRECOMP
+    #include "wx/log.h"
+    #include "wx/app.h"
+    #include "wx/utils.h"
+    #include "wx/image.h"

 #endif
 #endif

-#include "wx/utils.h"
+
+#include "wx/mstream.h"
+
+#include "wx/x11/private.h"

 
 //-------------------------------------------------------------------------
 // global data
 
 //-------------------------------------------------------------------------
 // global data


@@ -58,12 +57,6 @@ wxDataFormat::wxDataFormat( wxDataFormatId type )
     SetType( type );
 }
 
     SetType( type );
 }
 

-wxDataFormat::wxDataFormat( const wxChar *id )
-{
-    PrepareFormats();
-    SetId( id );
-}
-

 wxDataFormat::wxDataFormat( const wxString &id )
 {
     PrepareFormats();
 wxDataFormat::wxDataFormat( const wxString &id )
 {
     PrepareFormats();


@@ -81,7 +74,7 @@ void wxDataFormat::SetType( wxDataFormatId type )
     PrepareFormats();
     m_type = type;
 
     PrepareFormats();
     m_type = type;
 

-    if (m_type == wxDF_TEXT)
+    if (m_type == wxDF_TEXT || m_type == wxDF_UNICODETEXT)

         m_format = g_textAtom;
     else
     if (m_type == wxDF_BITMAP)
         m_format = g_textAtom;
     else
     if (m_type == wxDF_BITMAP)


@@ -102,11 +95,15 @@ wxDataFormatId wxDataFormat::GetType() const
 
 wxString wxDataFormat::GetId() const
 {
 
 wxString wxDataFormat::GetId() const
 {

+#if wxUSE_NANOX
+    return wxEmptyString;
+#else

     char *t = XGetAtomName ((Display*) wxGetDisplay(), m_format);
     char *t = XGetAtomName ((Display*) wxGetDisplay(), m_format);

-    wxString ret( t );  // this will convert from ascii to Unicode
-    if (t) 
+    wxString ret = wxString::FromAscii( t );
+    if (t)

         XFree( t );
     return ret;
         XFree( t );
     return ret;

+#endif

 }
 
 void wxDataFormat::SetId( NativeFormat format )
 }
 
 void wxDataFormat::SetId( NativeFormat format )


@@ -126,74 +123,256 @@ void wxDataFormat::SetId( NativeFormat format )
         m_type = wxDF_PRIVATE;
 }
 
         m_type = wxDF_PRIVATE;
 }
 

-void wxDataFormat::SetId( const wxChar *id )
+void wxDataFormat::SetId( const wxString& id )

 {
 {

+#if !wxUSE_NANOX

     PrepareFormats();
     m_type = wxDF_PRIVATE;
     PrepareFormats();
     m_type = wxDF_PRIVATE;

-    wxString tmp( id );
-    m_format = XInternAtom( (Display*) wxGetDisplay(), wxMBSTRINGCAST tmp.mbc_str(), FALSE );  // what is the string cast for?
+    m_format = XInternAtom( (Display*) wxGetDisplay(), id.ToAscii(), FALSE );
+#endif

 }
 
 void wxDataFormat::PrepareFormats()
 {
 }
 
 void wxDataFormat::PrepareFormats()
 {

+#if !wxUSE_NANOX

     if (!g_textAtom)
         g_textAtom = XInternAtom( (Display*) wxGetDisplay(), "STRING", FALSE );
     if (!g_pngAtom)
         g_pngAtom = XInternAtom( (Display*) wxGetDisplay(), "image/png", FALSE );
     if (!g_fileAtom)
     if (!g_textAtom)
         g_textAtom = XInternAtom( (Display*) wxGetDisplay(), "STRING", FALSE );
     if (!g_pngAtom)
         g_pngAtom = XInternAtom( (Display*) wxGetDisplay(), "image/png", FALSE );
     if (!g_fileAtom)

-        g_fileAtom = XInternAtom( (Display*) wxGetDisplay(), "file:ALL", FALSE );
+        g_fileAtom = XInternAtom( (Display*) wxGetDisplay(), "text/uri-list", FALSE );
+#endif

 }
 
 }
 

-#if 0
+//-------------------------------------------------------------------------
+// wxDataObject
+//-------------------------------------------------------------------------
+
+wxDataObject::wxDataObject()
+{
+}
+
+bool wxDataObject::IsSupportedFormat(const wxDataFormat& format, Direction dir) const
+{
+    size_t nFormatCount = GetFormatCount(dir);
+    if ( nFormatCount == 1 )
+    {
+        return format == GetPreferredFormat();
+    }
+    else
+    {
+        wxDataFormat *formats = new wxDataFormat[nFormatCount];
+        GetAllFormats(formats,dir);
+
+        size_t n;
+        for ( n = 0; n < nFormatCount; n++ )
+        {
+            if ( formats[n] == format )
+                break;
+        }
+
+        delete [] formats;
+
+        // found?
+        return n < nFormatCount;
+    }
+}

 
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------

-// wxPrivateDataObject
+// wxFileDataObject

 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 

-IMPLEMENT_DYNAMIC_CLASS( wxPrivateDataObject, wxDataObject )
+bool wxFileDataObject::GetDataHere(void *buf) const
+{
+    wxString filenames;
+
+    for (size_t i = 0; i < m_filenames.GetCount(); i++)
+    {
+        filenames += m_filenames[i];
+        filenames += (wxChar) 0;
+    }
+
+    memcpy( buf, filenames.mbc_str(), filenames.length() + 1 );
+
+    return true;
+}
+
+size_t wxFileDataObject::GetDataSize() const
+{
+    size_t res = 0;
+
+    for (size_t i = 0; i < m_filenames.GetCount(); i++)
+    {
+        res += m_filenames[i].length();
+        res += 1;
+    }
+
+    return res + 1;
+}

 
 

-void wxPrivateDataObject::Free()
+bool wxFileDataObject::SetData(size_t WXUNUSED(size), const void *buf)

 {
 {

-    if ( m_data )
-        free(m_data);
+    // VZ: old format
+#if 0
+    // filenames are stores as a string with #0 as deliminators
+    const char *filenames = (const char*) buf;
+    size_t pos = 0;
+    for(;;)
+    {
+        if (filenames[0] == 0)
+            break;
+        if (pos >= size)
+            break;
+        wxString file( filenames );  // this returns the first file
+        AddFile( file );
+        pos += file.length()+1;
+        filenames += file.length()+1;
+    }
+#else // 1
+    m_filenames.Empty();
+
+    // the text/uri-list format is a sequence of URIs (filenames prefixed by
+    // "file:" as far as I see) delimited by "\r\n" of total length size
+    // (I wonder what happens if the file has '\n' in its filename??)
+    wxString filename;
+    for ( const char *p = (const char *)buf; ; p++ )
+    {
+        // some broken programs (testdnd GTK+ sample!) omit the trailing
+        // "\r\n", so check for '\0' explicitly here instead of doing it in
+        // the loop statement to account for it
+        if ( (*p == '\r' && *(p+1) == '\n') || !*p )
+        {
+            size_t lenPrefix = 5; // strlen("file:")
+            if ( filename.Left(lenPrefix).MakeLower() == wxT("file:") )
+            {
+                // sometimes the syntax is "file:filename", sometimes it's
+                // URL-like: "file://filename" - deal with both
+                if ( filename[lenPrefix] == wxT('/') &&
+                     filename[lenPrefix + 1] == wxT('/') )
+                {
+                    // skip the slashes
+                    lenPrefix += 2;
+                }
+
+                AddFile(filename.c_str() + lenPrefix);
+                filename.Empty();
+            }
+            else
+            {
+                wxLogDebug(wxT("Unsupported URI '%s' in wxFileDataObject"),
+                           filename.c_str());
+            }
+
+            if ( !*p )
+                break;
+
+            // skip '\r'
+            p++;
+        }
+        else
+        {
+            filename += *p;
+        }
+    }
+#endif // 0/1
+
+    return true;

 }
 
 }
 

-wxPrivateDataObject::wxPrivateDataObject()
+void wxFileDataObject::AddFile( const wxString &filename )

 {
 {

-    wxString id = wxT("application/");
-    id += wxTheApp->GetAppName();
+   m_filenames.Add( filename );
+}

 
 

-    m_format.SetId( id );
+// ----------------------------------------------------------------------------
+// wxBitmapDataObject
+// ----------------------------------------------------------------------------

 
 

-    m_size = 0;
-    m_data = (void *)NULL;
+wxBitmapDataObject::wxBitmapDataObject()
+{
+    Init();

 }
 
 }
 

-void wxPrivateDataObject::SetData( const void *data, size_t size )
+wxBitmapDataObject::wxBitmapDataObject( const wxBitmap& bitmap )
+                  : wxBitmapDataObjectBase(bitmap)

 {
 {

-    Free();
+    Init();

 
 

-    m_size = size;
-    m_data = malloc(size);
+    DoConvertToPng();
+}

 
 

-    memcpy( m_data, data, size );
+wxBitmapDataObject::~wxBitmapDataObject()
+{
+    Clear();

 }
 
 }
 

-void wxPrivateDataObject::WriteData( void *dest ) const
+void wxBitmapDataObject::SetBitmap( const wxBitmap &bitmap )

 {
 {

-    WriteData( m_data, dest );
+    ClearAll();
+
+    wxBitmapDataObjectBase::SetBitmap(bitmap);
+
+    DoConvertToPng();

 }
 
 }
 

-size_t wxPrivateDataObject::GetSize() const
+bool wxBitmapDataObject::GetDataHere(void *buf) const

 {
 {

-    return m_size;
+    if ( !m_pngSize )
+    {
+        wxFAIL_MSG( wxT("attempt to copy empty bitmap failed") );
+
+        return false;
+    }
+
+    memcpy(buf, m_pngData, m_pngSize);
+
+    return true;

 }
 
 }
 

-void wxPrivateDataObject::WriteData( const void *data, void *dest ) const
+bool wxBitmapDataObject::SetData(size_t size, const void *buf)

 {
 {

-    memcpy( dest, data, GetSize() );
+    Clear();
+
+#if wxUSE_LIBPNG
+    m_pngSize = size;
+    m_pngData = malloc(m_pngSize);
+
+    memcpy( m_pngData, buf, m_pngSize );
+
+    wxMemoryInputStream mstream( (char*) m_pngData, m_pngSize );
+    wxImage image;
+    wxPNGHandler handler;
+    if ( !handler.LoadFile( &image, mstream ) )
+    {
+        return false;
+    }
+
+    m_bitmap = image;
+
+    return m_bitmap.IsOk();
+#else
+    return false;
+#endif

 }
 
 }
 

-#endif // 0
+void wxBitmapDataObject::DoConvertToPng()
+{
+#if wxUSE_LIBPNG
+    if (!m_bitmap.IsOk())
+        return;
+
+    wxImage image = m_bitmap.ConvertToImage();
+    wxPNGHandler handler;
+
+    wxCountingOutputStream count;
+    handler.SaveFile( &image, count );
+
+    m_pngSize = count.GetSize() + 100; // sometimes the size seems to vary ???
+    m_pngData = malloc(m_pngSize);
+
+    wxMemoryOutputStream mstream( (char*) m_pngData, m_pngSize );
+    handler.SaveFile( &image, mstream );
+#endif
+}

 
 

-#endif // wxUSE_CLIPBOARD
+#endif // wxUSE_DATAOBJ