Add missing WXK constants for the control keys

[wxWidgets.git] / src / gtk1 / clipbrd.cpp

diff --git a/src/gtk1/clipbrd.cpp b/src/gtk1/clipbrd.cpp
index 58b1952e1708befa571095c6b1d320f43825183b..2c5b0ff8859c0448a076200bde02c5f357b36849 100644 (file)
--- a/src/gtk1/clipbrd.cpp
+++ b/src/gtk1/clipbrd.cpp
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        gtk/clipbrd.cpp
+// Name:        src/gtk1/clipbrd.cpp

 // Purpose:
 // Author:      Robert Roebling
 // Id:          $Id$
 // Purpose:
 // Author:      Robert Roebling
 // Id:          $Id$


@@ -7,42 +7,35 @@
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 

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

 
 #if wxUSE_CLIPBOARD
 
 
 #if wxUSE_CLIPBOARD
 

-#include "wx/dataobj.h"
-#include "wx/utils.h"
-#include "wx/log.h"
-
-#include "glib.h"
-#include "gdk/gdk.h"
-#include "gtk/gtk.h"
-
-//-----------------------------------------------------------------------------
-// thread system
-//-----------------------------------------------------------------------------
+#include "wx/clipbrd.h"

 
 

-#if wxUSE_THREADS
-extern void wxapp_install_thread_wakeup();
-extern void wxapp_uninstall_thread_wakeup();
+#ifndef WX_PRECOMP
+    #include "wx/log.h"
+    #include "wx/utils.h"
+    #include "wx/dataobj.h"

 #endif
 
 #endif
 

+#include <glib.h>
+#include <gdk/gdk.h>
+#include <gtk/gtk.h>
+

 //-----------------------------------------------------------------------------
 // data
 //-----------------------------------------------------------------------------
 
 GdkAtom  g_clipboardAtom   = 0;
 GdkAtom  g_targetsAtom     = 0;
 //-----------------------------------------------------------------------------
 // data
 //-----------------------------------------------------------------------------
 
 GdkAtom  g_clipboardAtom   = 0;
 GdkAtom  g_targetsAtom     = 0;

+GdkAtom  g_timestampAtom   = 0;

 
 // the trace mask we use with wxLogTrace() - call
 // wxLog::AddTraceMask(TRACE_CLIPBOARD) to enable the trace messages from here
 // (there will be a *lot* of them!)
 
 // the trace mask we use with wxLogTrace() - call
 // wxLog::AddTraceMask(TRACE_CLIPBOARD) to enable the trace messages from here
 // (there will be a *lot* of them!)

-static const char *TRACE_CLIPBOARD = _T("clipboard");
+#define TRACE_CLIPBOARD "clipboard"

 
 //-----------------------------------------------------------------------------
 // reminder
 
 //-----------------------------------------------------------------------------
 // reminder


@@ -73,36 +66,36 @@ struct _GtkSelectionData
 // "selection_received" for targets
 //-----------------------------------------------------------------------------
 
 // "selection_received" for targets
 //-----------------------------------------------------------------------------
 

+extern "C" {

 static void
 targets_selection_received( GtkWidget *WXUNUSED(widget),
                             GtkSelectionData *selection_data,
 static void
 targets_selection_received( GtkWidget *WXUNUSED(widget),
                             GtkSelectionData *selection_data,

-#if (GTK_MINOR_VERSION > 0)

                             guint32 WXUNUSED(time),
                             guint32 WXUNUSED(time),

-#endif

                             wxClipboard *clipboard )
 {
     if ( wxTheClipboard && selection_data->length > 0 )
     {
                             wxClipboard *clipboard )
 {
     if ( wxTheClipboard && selection_data->length > 0 )
     {

-        /* make sure we got the data in the correct form */
+        // make sure we got the data in the correct form

         GdkAtom type = selection_data->type;
         if ( type != GDK_SELECTION_TYPE_ATOM )
         {
         GdkAtom type = selection_data->type;
         if ( type != GDK_SELECTION_TYPE_ATOM )
         {

-            if ( strcmp(gdk_atom_name(type), "TARGETS") )
+            gchar* atom_name = gdk_atom_name(type);
+            if ( strcmp(atom_name, "TARGETS") )

             {
                 wxLogTrace( TRACE_CLIPBOARD,
             {
                 wxLogTrace( TRACE_CLIPBOARD,

-                            _T("got unsupported clipboard target") );
+                            wxT("got unsupported clipboard target") );

 
 

-                clipboard->m_waiting = FALSE;
+                clipboard->m_waiting = false;
+                g_free(atom_name);

                 return;
             }
                 return;
             }

+            g_free(atom_name);

         }
 
         }
 

-#ifdef __WXDEBUG__

         wxDataFormat clip( selection_data->selection );
         wxLogTrace( TRACE_CLIPBOARD,
                     wxT("selection received for targets, clipboard %s"),
                     clip.GetId().c_str() );
         wxDataFormat clip( selection_data->selection );
         wxLogTrace( TRACE_CLIPBOARD,
                     wxT("selection received for targets, clipboard %s"),
                     clip.GetId().c_str() );

-#endif // __WXDEBUG__

 
         // the atoms we received, holding a list of targets (= formats)
         GdkAtom *atoms = (GdkAtom *)selection_data->data;
 
         // the atoms we received, holding a list of targets (= formats)
         GdkAtom *atoms = (GdkAtom *)selection_data->data;


@@ -115,33 +108,37 @@ targets_selection_received( GtkWidget *WXUNUSED(widget),
                         wxT("selection received for targets, format %s"),
                         format.GetId().c_str() );
 
                         wxT("selection received for targets, format %s"),
                         format.GetId().c_str() );
 

+//            printf( "format %s requested %s\n",
+//                    gdk_atom_name( atoms[i] ),
+//                    gdk_atom_name( clipboard->m_targetRequested ) );
+

             if (format == clipboard->m_targetRequested)
             {
             if (format == clipboard->m_targetRequested)
             {

-                clipboard->m_waiting = FALSE;
-                clipboard->m_formatSupported = TRUE;
+                clipboard->m_waiting = false;
+                clipboard->m_formatSupported = true;

                 return;
             }
         }
     }
 
                 return;
             }
         }
     }
 

-    clipboard->m_waiting = FALSE;
+    clipboard->m_waiting = false;
+}

 }
 
 //-----------------------------------------------------------------------------
 // "selection_received" for the actual data
 //-----------------------------------------------------------------------------
 
 }
 
 //-----------------------------------------------------------------------------
 // "selection_received" for the actual data
 //-----------------------------------------------------------------------------
 

+extern "C" {

 static void
 selection_received( GtkWidget *WXUNUSED(widget),
                     GtkSelectionData *selection_data,
 static void
 selection_received( GtkWidget *WXUNUSED(widget),
                     GtkSelectionData *selection_data,

-#if (GTK_MINOR_VERSION > 0)

                     guint32 WXUNUSED(time),
                     guint32 WXUNUSED(time),

-#endif

                     wxClipboard *clipboard )
 {
     if (!wxTheClipboard)
     {
                     wxClipboard *clipboard )
 {
     if (!wxTheClipboard)
     {

-        clipboard->m_waiting = FALSE;
+        clipboard->m_waiting = false;

         return;
     }
 
         return;
     }
 


@@ -149,43 +146,48 @@ selection_received( GtkWidget *WXUNUSED(widget),
 
     if (!data_object)
     {
 
     if (!data_object)
     {

-        clipboard->m_waiting = FALSE;
+        clipboard->m_waiting = false;

         return;
     }
 
     if (selection_data->length <= 0)
     {
         return;
     }
 
     if (selection_data->length <= 0)
     {

-        clipboard->m_waiting = FALSE;
+        clipboard->m_waiting = false;

         return;
     }
 
     wxDataFormat format( selection_data->target );
 
         return;
     }
 
     wxDataFormat format( selection_data->target );
 

-    /* make sure we got the data in the correct format */
+    // make sure we got the data in the correct format

     if (!data_object->IsSupportedFormat( format ) )
     {
     if (!data_object->IsSupportedFormat( format ) )
     {

-        clipboard->m_waiting = FALSE;
+        clipboard->m_waiting = false;

         return;
     }
 
         return;
     }
 

-    /* make sure we got the data in the correct form (selection type).
-       if so, copy data to target object */
+#if 0
+    This seems to cause problems somehow
+    // make sure we got the data in the correct form (selection type).
+    // if so, copy data to target object

     if (selection_data->type != GDK_SELECTION_TYPE_STRING)
     {
     if (selection_data->type != GDK_SELECTION_TYPE_STRING)
     {

-        clipboard->m_waiting = FALSE;
+        clipboard->m_waiting = false;

         return;
     }
         return;
     }

+#endif

 
     data_object->SetData( format, (size_t) selection_data->length, (const char*) selection_data->data );
 
 
     data_object->SetData( format, (size_t) selection_data->length, (const char*) selection_data->data );
 

-    wxTheClipboard->m_formatSupported = TRUE;
-    clipboard->m_waiting = FALSE;
+    wxTheClipboard->m_formatSupported = true;
+    clipboard->m_waiting = false;
+}

 }
 
 //-----------------------------------------------------------------------------
 // "selection_clear"
 //-----------------------------------------------------------------------------
 
 }
 
 //-----------------------------------------------------------------------------
 // "selection_clear"
 //-----------------------------------------------------------------------------
 

+extern "C" {

 static gint
 selection_clear_clip( GtkWidget *WXUNUSED(widget), GdkEventSelection *event )
 {
 static gint
 selection_clear_clip( GtkWidget *WXUNUSED(widget), GdkEventSelection *event )
 {


@@ -193,16 +195,16 @@ selection_clear_clip( GtkWidget *WXUNUSED(widget), GdkEventSelection *event )
 
     if (event->selection == GDK_SELECTION_PRIMARY)
     {
 
     if (event->selection == GDK_SELECTION_PRIMARY)
     {

-        wxTheClipboard->m_ownsPrimarySelection = FALSE;
+        wxTheClipboard->m_ownsPrimarySelection = false;

     }
     else
     if (event->selection == g_clipboardAtom)
     {
     }
     else
     if (event->selection == g_clipboardAtom)
     {

-        wxTheClipboard->m_ownsClipboard = FALSE;
+        wxTheClipboard->m_ownsClipboard = false;

     }
     else
     {
     }
     else
     {

-        wxTheClipboard->m_waiting = FALSE;
+        wxTheClipboard->m_waiting = false;

         return FALSE;
     }
 
         return FALSE;
     }
 


@@ -212,27 +214,28 @@ selection_clear_clip( GtkWidget *WXUNUSED(widget), GdkEventSelection *event )
         /* the clipboard is no longer in our hands. we can the delete clipboard data. */
         if (wxTheClipboard->m_data)
         {
         /* the clipboard is no longer in our hands. we can the delete clipboard data. */
         if (wxTheClipboard->m_data)
         {

-            wxLogDebug( wxT("wxClipboard will get cleared" ) );
+            wxLogTrace(TRACE_CLIPBOARD, wxT("wxClipboard will get cleared" ));

 
 

-            delete wxTheClipboard->m_data;
-            wxTheClipboard->m_data = (wxDataObject*) NULL;
+            wxDELETE(wxTheClipboard->m_data);

         }
     }
 
         }
     }
 

-    wxTheClipboard->m_waiting = FALSE;
+    wxTheClipboard->m_waiting = false;

     return TRUE;
 }
     return TRUE;
 }

+}

 
 //-----------------------------------------------------------------------------
 // selection handler for supplying data
 //-----------------------------------------------------------------------------
 
 
 //-----------------------------------------------------------------------------
 // selection handler for supplying data
 //-----------------------------------------------------------------------------
 

+extern "C" {

 static void
 selection_handler( GtkWidget *WXUNUSED(widget),
                    GtkSelectionData *selection_data,
                    guint WXUNUSED(info),
                    guint WXUNUSED(time),
 static void
 selection_handler( GtkWidget *WXUNUSED(widget),
                    GtkSelectionData *selection_data,
                    guint WXUNUSED(info),
                    guint WXUNUSED(time),

-                   gpointer WXUNUSED(data) )
+                   gpointer signal_data )

 {
     if (!wxTheClipboard) return;
 
 {
     if (!wxTheClipboard) return;
 


@@ -240,47 +243,55 @@ selection_handler( GtkWidget *WXUNUSED(widget),
 
     wxDataObject *data = wxTheClipboard->m_data;
 
 
     wxDataObject *data = wxTheClipboard->m_data;
 

-    wxDataFormat format( selection_data->target );
-
-    if (!data->IsSupportedFormat( format )) return;
-
-    /* this will fail for composite formats */
-    if (format.GetType() == wxDF_TEXT)
+    // ICCCM says that TIMESTAMP is a required atom.
+    // In particular, it satisfies Klipper, which polls
+    // TIMESTAMP to see if the clipboards content has changed.
+    // It shall return the time which was used to set the data.
+    if (selection_data->target == g_timestampAtom)

     {
     {

-        wxTextDataObject *text_object = (wxTextDataObject*) data;
-        wxString text( text_object->GetText() );
-
-#if wxUSE_UNICODE
-        const wxWX2MBbuf s = text.mbc_str();
-        int len = strlen(s);
-#else // more efficient in non-Unicode
-        const char *s = text.c_str();
-        int len = (int) text.Length();
-#endif
-        gtk_selection_data_set(
-            selection_data,
-            GDK_SELECTION_TYPE_STRING,
-            8*sizeof(gchar),
-            (unsigned char*) (const char*) s,
-            len );
-
+        guint timestamp = GPOINTER_TO_UINT (signal_data);
+        gtk_selection_data_set(selection_data,
+                               GDK_SELECTION_TYPE_INTEGER,
+                               32,
+                               (guchar*)&(timestamp),
+                               sizeof(timestamp));
+        wxLogTrace(TRACE_CLIPBOARD,
+                   wxT("Clipboard TIMESTAMP requested, returning timestamp=%u"),
+                   timestamp);

         return;
     }
 
         return;
     }
 

+    wxDataFormat format( selection_data->target );
+
+    wxLogTrace(TRACE_CLIPBOARD,
+               wxT("clipboard data in format %s, GtkSelectionData is target=%s type=%s selection=%s timestamp=%u"),
+               format.GetId().c_str(),
+               wxString::FromAscii(gdk_atom_name(selection_data->target)).c_str(),
+               wxString::FromAscii(gdk_atom_name(selection_data->type)).c_str(),
+               wxString::FromAscii(gdk_atom_name(selection_data->selection)).c_str(),
+               GPOINTER_TO_UINT( signal_data )
+               );
+
+    if (!data->IsSupportedFormat( format )) return;
+

     int size = data->GetDataSize( format );
 
     if (size == 0) return;
 
     int size = data->GetDataSize( format );
 
     if (size == 0) return;
 

-    char *d = new char[size];
+    void *d = malloc(size);

 
 

-    data->GetDataHere( selection_data->target, (void*) d );
+    // Text data will be in UTF8 in Unicode mode.
+    data->GetDataHere( selection_data->target, d );

 
     gtk_selection_data_set(
 
     gtk_selection_data_set(

-        selection_data,
-        GDK_SELECTION_TYPE_STRING,
-        8*sizeof(gchar),
-        (unsigned char*) d,
-        size );
+            selection_data,
+            GDK_SELECTION_TYPE_STRING,
+            8 * sizeof(gchar),
+            (unsigned char*) d,
+            size );
+
+    free(d);
+}

 }
 
 //-----------------------------------------------------------------------------
 }
 
 //-----------------------------------------------------------------------------


@@ -291,13 +302,14 @@ IMPLEMENT_DYNAMIC_CLASS(wxClipboard,wxObject)
 
 wxClipboard::wxClipboard()
 {
 
 wxClipboard::wxClipboard()
 {

-    m_open = FALSE;
+    m_open = false;
+    m_waiting = false;

 
 

-    m_ownsClipboard = FALSE;
-    m_ownsPrimarySelection = FALSE;
+    m_ownsClipboard = false;
+    m_ownsPrimarySelection = false;

 
 

-    m_data = (wxDataObject*) NULL;
-    m_receivedData = (wxDataObject*) NULL;
+    m_data = NULL;
+    m_receivedData = NULL;

 
     /* we use m_targetsWidget to query what formats are available */
 
 
     /* we use m_targetsWidget to query what formats are available */
 


@@ -326,11 +338,10 @@ wxClipboard::wxClipboard()
 
     if (!g_clipboardAtom) g_clipboardAtom = gdk_atom_intern( "CLIPBOARD", FALSE );
     if (!g_targetsAtom) g_targetsAtom = gdk_atom_intern ("TARGETS", FALSE);
 
     if (!g_clipboardAtom) g_clipboardAtom = gdk_atom_intern( "CLIPBOARD", FALSE );
     if (!g_targetsAtom) g_targetsAtom = gdk_atom_intern ("TARGETS", FALSE);

+    if (!g_timestampAtom) g_timestampAtom = gdk_atom_intern ("TIMESTAMP", FALSE);

 
 

-    m_formatSupported = FALSE;
+    m_formatSupported = false;

     m_targetRequested = 0;
     m_targetRequested = 0;

-
-    m_usePrimary = FALSE;

 }
 
 wxClipboard::~wxClipboard()
 }
 
 wxClipboard::~wxClipboard()


@@ -347,16 +358,15 @@ void wxClipboard::Clear()
     {
 #if wxUSE_THREADS
         /* disable GUI threads */
     {
 #if wxUSE_THREADS
         /* disable GUI threads */

-        wxapp_uninstall_thread_wakeup();

 #endif
 
 #endif
 

-        /*  As we have data we also own the clipboard. Once we no longer own
-            it, clear_selection is called which will set m_data to zero */
+        //  As we have data we also own the clipboard. Once we no longer own
+        //  it, clear_selection is called which will set m_data to zero

         if (gdk_selection_owner_get( g_clipboardAtom ) == m_clipboardWidget->window)
         {
         if (gdk_selection_owner_get( g_clipboardAtom ) == m_clipboardWidget->window)
         {

-            m_waiting = TRUE;
+            m_waiting = true;

 
 

-            gtk_selection_owner_set( (GtkWidget*) NULL, g_clipboardAtom,
+            gtk_selection_owner_set( NULL, g_clipboardAtom,

                                      (guint32) GDK_CURRENT_TIME );
 
             while (m_waiting) gtk_main_iteration();
                                      (guint32) GDK_CURRENT_TIME );
 
             while (m_waiting) gtk_main_iteration();


@@ -364,44 +374,39 @@ void wxClipboard::Clear()
 
         if (gdk_selection_owner_get( GDK_SELECTION_PRIMARY ) == m_clipboardWidget->window)
         {
 
         if (gdk_selection_owner_get( GDK_SELECTION_PRIMARY ) == m_clipboardWidget->window)
         {

-            m_waiting = TRUE;
+            m_waiting = true;

 
 

-            gtk_selection_owner_set( (GtkWidget*) NULL, GDK_SELECTION_PRIMARY,
+            gtk_selection_owner_set( NULL, GDK_SELECTION_PRIMARY,

                                      (guint32) GDK_CURRENT_TIME );
 
             while (m_waiting) gtk_main_iteration();
         }
 
                                      (guint32) GDK_CURRENT_TIME );
 
             while (m_waiting) gtk_main_iteration();
         }
 

-        if (m_data)
-        {
-            delete m_data;
-            m_data = (wxDataObject*) NULL;
-        }
+        wxDELETE(m_data);

 
 #if wxUSE_THREADS
         /* re-enable GUI threads */
 
 #if wxUSE_THREADS
         /* re-enable GUI threads */

-        wxapp_install_thread_wakeup();

 #endif
     }
 
     m_targetRequested = 0;
 #endif
     }
 
     m_targetRequested = 0;

-    m_formatSupported = FALSE;
+    m_formatSupported = false;

 }
 
 bool wxClipboard::Open()
 {
 }
 
 bool wxClipboard::Open()
 {

-    wxCHECK_MSG( !m_open, FALSE, wxT("clipboard already open") );
+    wxCHECK_MSG( !m_open, false, wxT("clipboard already open") );

 
 

-    m_open = TRUE;
+    m_open = true;

 
 

-    return TRUE;
+    return true;

 }
 
 bool wxClipboard::SetData( wxDataObject *data )
 {
 }
 
 bool wxClipboard::SetData( wxDataObject *data )
 {

-    wxCHECK_MSG( m_open, FALSE, wxT("clipboard not open") );
+    wxCHECK_MSG( m_open, false, wxT("clipboard not open") );

 
 

-    wxCHECK_MSG( data, FALSE, wxT("data is invalid") );
+    wxCHECK_MSG( data, false, wxT("data is invalid") );

 
     Clear();
 
 
     Clear();
 


@@ -410,23 +415,28 @@ bool wxClipboard::SetData( wxDataObject *data )
 
 bool wxClipboard::AddData( wxDataObject *data )
 {
 
 bool wxClipboard::AddData( wxDataObject *data )
 {

-    wxCHECK_MSG( m_open, FALSE, wxT("clipboard not open") );
+    wxCHECK_MSG( m_open, false, wxT("clipboard not open") );

 
 

-    wxCHECK_MSG( data, FALSE, wxT("data is invalid") );
+    wxCHECK_MSG( data, false, wxT("data is invalid") );

 
 

-    /* we can only store one wxDataObject */
+    // we can only store one wxDataObject

     Clear();
 
     m_data = data;
 
     Clear();
 
     m_data = data;
 

-    /* get formats from wxDataObjects */
+    // get formats from wxDataObjects

     wxDataFormat *array = new wxDataFormat[ m_data->GetFormatCount() ];
     m_data->GetAllFormats( array );
 
     wxDataFormat *array = new wxDataFormat[ m_data->GetFormatCount() ];
     m_data->GetAllFormats( array );
 

-    /* primary selection or clipboard */
+    // primary selection or clipboard

     GdkAtom clipboard = m_usePrimary ? (GdkAtom)GDK_SELECTION_PRIMARY
                                      : g_clipboardAtom;
 
     GdkAtom clipboard = m_usePrimary ? (GdkAtom)GDK_SELECTION_PRIMARY
                                      : g_clipboardAtom;
 

+    // by default provide TIMESTAMP as a target
+    gtk_selection_add_target( GTK_WIDGET(m_clipboardWidget),
+                              clipboard,
+                              g_timestampAtom,
+                              0 );

 
     for (size_t i = 0; i < m_data->GetFormatCount(); i++)
     {
 
     for (size_t i = 0; i < m_data->GetFormatCount(); i++)
     {


@@ -434,6 +444,9 @@ bool wxClipboard::AddData( wxDataObject *data )
                     wxT("wxClipboard now supports atom %s"),
                     array[i].GetId().c_str() );
 
                     wxT("wxClipboard now supports atom %s"),
                     array[i].GetId().c_str() );
 

+//        printf( "added %s\n",
+//                    gdk_atom_name( array[i].GetFormatId() ) );
+

         gtk_selection_add_target( GTK_WIDGET(m_clipboardWidget),
                                   clipboard,
                                   array[i],
         gtk_selection_add_target( GTK_WIDGET(m_clipboardWidget),
                                   clipboard,
                                   array[i],


@@ -445,11 +458,10 @@ bool wxClipboard::AddData( wxDataObject *data )
     gtk_signal_connect( GTK_OBJECT(m_clipboardWidget),
                         "selection_get",
                         GTK_SIGNAL_FUNC(selection_handler),
     gtk_signal_connect( GTK_OBJECT(m_clipboardWidget),
                         "selection_get",
                         GTK_SIGNAL_FUNC(selection_handler),

-                        (gpointer) NULL );
+                        GUINT_TO_POINTER( gdk_event_get_time(gtk_get_current_event()) ) );

 
 #if wxUSE_THREADS
     /* disable GUI threads */
 
 #if wxUSE_THREADS
     /* disable GUI threads */

-    wxapp_uninstall_thread_wakeup();

 #endif
 
     /* Tell the world we offer clipboard data */
 #endif
 
     /* Tell the world we offer clipboard data */


@@ -464,7 +476,6 @@ bool wxClipboard::AddData( wxDataObject *data )
 
 #if wxUSE_THREADS
     /* re-enable GUI threads */
 
 #if wxUSE_THREADS
     /* re-enable GUI threads */

-    wxapp_install_thread_wakeup();

 #endif
 
     return res;
 #endif
 
     return res;


@@ -474,7 +485,7 @@ void wxClipboard::Close()
 {
     wxCHECK_RET( m_open, wxT("clipboard not open") );
 
 {
     wxCHECK_RET( m_open, wxT("clipboard not open") );
 

-    m_open = FALSE;
+    m_open = false;

 }
 
 bool wxClipboard::IsOpened() const
 }
 
 bool wxClipboard::IsOpened() const


@@ -485,7 +496,7 @@ bool wxClipboard::IsOpened() const
 bool wxClipboard::IsSupported( const wxDataFormat& format )
 {
     /* reentrance problems */
 bool wxClipboard::IsSupported( const wxDataFormat& format )
 {
     /* reentrance problems */

-    if (m_waiting) return FALSE;
+    if (m_waiting) return false;

 
     /* store requested format to be asked for by callbacks */
     m_targetRequested = format;
 
     /* store requested format to be asked for by callbacks */
     m_targetRequested = format;


@@ -494,19 +505,19 @@ bool wxClipboard::IsSupported( const wxDataFormat& format )
                 wxT("wxClipboard:IsSupported: requested format: %s"),
                 format.GetId().c_str() );
 
                 wxT("wxClipboard:IsSupported: requested format: %s"),
                 format.GetId().c_str() );
 

-    wxCHECK_MSG( m_targetRequested, FALSE, wxT("invalid clipboard format") );
+    wxCHECK_MSG( m_targetRequested, false, wxT("invalid clipboard format") );

 
 

-    m_formatSupported = FALSE;
+    m_formatSupported = false;

 
     /* perform query. this will set m_formatSupported to
 
     /* perform query. this will set m_formatSupported to

-       TRUE if m_targetRequested is supported.
+       true if m_targetRequested is supported.

        also, we have to wait for the "answer" from the
        clipboard owner which is an asynchronous process.
        also, we have to wait for the "answer" from the
        clipboard owner which is an asynchronous process.

-       therefore we set m_waiting = TRUE here and wait
+       therefore we set m_waiting = true here and wait

        until the callback "targets_selection_received"
        until the callback "targets_selection_received"

-       sets it to FALSE */
+       sets it to false */

 
 

-    m_waiting = TRUE;
+    m_waiting = true;

 
     gtk_selection_convert( m_targetsWidget,
                            m_usePrimary ? (GdkAtom)GDK_SELECTION_PRIMARY
 
     gtk_selection_convert( m_targetsWidget,
                            m_usePrimary ? (GdkAtom)GDK_SELECTION_PRIMARY


@@ -516,14 +527,12 @@ bool wxClipboard::IsSupported( const wxDataFormat& format )
 
     while (m_waiting) gtk_main_iteration();
 
 
     while (m_waiting) gtk_main_iteration();
 

-    if (!m_formatSupported) return FALSE;
-
-    return TRUE;
+    return m_formatSupported;

 }
 
 bool wxClipboard::GetData( wxDataObject& data )
 {
 }
 
 bool wxClipboard::GetData( wxDataObject& data )
 {

-    wxCHECK_MSG( m_open, FALSE, wxT("clipboard not open") );
+    wxCHECK_MSG( m_open, false, wxT("clipboard not open") );

 
     /* get formats from wxDataObjects */
     wxDataFormat *array = new wxDataFormat[ data.GetFormatCount() ];
 
     /* get formats from wxDataObjects */
     wxDataFormat *array = new wxDataFormat[ data.GetFormatCount() ];


@@ -542,19 +551,19 @@ bool wxClipboard::GetData( wxDataObject& data )
         /* store requested format to be asked for by callbacks */
         m_targetRequested = format;
 
         /* store requested format to be asked for by callbacks */
         m_targetRequested = format;
 

-        wxCHECK_MSG( m_targetRequested, FALSE, wxT("invalid clipboard format") );
+        wxCHECK_MSG( m_targetRequested, false, wxT("invalid clipboard format") );

 
 

-        m_formatSupported = FALSE;
+        m_formatSupported = false;

 
        /* perform query. this will set m_formatSupported to
 
        /* perform query. this will set m_formatSupported to

-          TRUE if m_targetRequested is supported.
+          true if m_targetRequested is supported.

           also, we have to wait for the "answer" from the
           clipboard owner which is an asynchronous process.
           also, we have to wait for the "answer" from the
           clipboard owner which is an asynchronous process.

-          therefore we set m_waiting = TRUE here and wait
+          therefore we set m_waiting = true here and wait

           until the callback "targets_selection_received"
           until the callback "targets_selection_received"

-          sets it to FALSE */
+          sets it to false */

 
 

-        m_waiting = TRUE;
+        m_waiting = true;

 
         gtk_selection_convert( m_targetsWidget,
                            m_usePrimary ? (GdkAtom)GDK_SELECTION_PRIMARY
 
         gtk_selection_convert( m_targetsWidget,
                            m_usePrimary ? (GdkAtom)GDK_SELECTION_PRIMARY


@@ -572,23 +581,24 @@ bool wxClipboard::GetData( wxDataObject& data )
         /* store requested format to be asked for by callbacks */
         m_targetRequested = format;
 
         /* store requested format to be asked for by callbacks */
         m_targetRequested = format;
 

-        wxCHECK_MSG( m_targetRequested, FALSE, wxT("invalid clipboard format") );
+        wxCHECK_MSG( m_targetRequested, false, wxT("invalid clipboard format") );

 
         /* start query */
 
         /* start query */

-        m_formatSupported = FALSE;
+        m_formatSupported = false;

 
         /* ask for clipboard contents.  this will set
 
         /* ask for clipboard contents.  this will set

-           m_formatSupported to TRUE if m_targetRequested
+           m_formatSupported to true if m_targetRequested

            is supported.
            also, we have to wait for the "answer" from the
            clipboard owner which is an asynchronous process.
            is supported.
            also, we have to wait for the "answer" from the
            clipboard owner which is an asynchronous process.

-           therefore we set m_waiting = TRUE here and wait
+           therefore we set m_waiting = true here and wait

            until the callback "targets_selection_received"
            until the callback "targets_selection_received"

-           sets it to FALSE */
+           sets it to false */

 
 

-        m_waiting = TRUE;
+        m_waiting = true;

 
 

-        wxLogDebug( wxT("wxClipboard::GetData: format found, start convert") );
+        wxLogTrace( TRACE_CLIPBOARD,
+                    wxT("wxClipboard::GetData: format found, start convert") );

 
         gtk_selection_convert( m_clipboardWidget,
                                m_usePrimary ? (GdkAtom)GDK_SELECTION_PRIMARY
 
         gtk_selection_convert( m_clipboardWidget,
                                m_usePrimary ? (GdkAtom)GDK_SELECTION_PRIMARY


@@ -598,21 +608,38 @@ bool wxClipboard::GetData( wxDataObject& data )
 
         while (m_waiting) gtk_main_iteration();
 
 
         while (m_waiting) gtk_main_iteration();
 

-        /* this is a true error as we checked for the presence of such data before */
-        wxCHECK_MSG( m_formatSupported, FALSE, wxT("error retrieving data from clipboard") );
+        /*
+           Normally this is a true error as we checked for the presence of such
+           data before, but there are applications that may return an empty
+           string (e.g. Gnumeric-1.6.1 on Linux if an empty cell is copied)
+           which would produce a false error message here, so we check for the
+           size of the string first. In ansi, GetDataSize returns an extra
+           value (for the closing null?), with unicode, the exact number of
+           tokens is given (that is more than 1 for special characters)
+           (tested with Gnumeric-1.6.1 and OpenOffice.org-2.0.2)
+         */
+#if wxUSE_UNICODE
+        if ( format != wxDF_UNICODETEXT || data.GetDataSize(format) > 0 )
+#else // !UNICODE
+        if ( format != wxDF_TEXT || data.GetDataSize(format) > 1 )
+#endif // UNICODE / !UNICODE
+        {
+            wxCHECK_MSG( m_formatSupported, false,
+                         wxT("error retrieving data from clipboard") );
+        }

 
         /* return success */
         delete[] array;
 
         /* return success */
         delete[] array;

-        return TRUE;
+        return true;

     }
 
     }
 

-    wxLogDebug( wxT("wxClipboard::GetData: format not found") );
+    wxLogTrace( TRACE_CLIPBOARD,
+                wxT("wxClipboard::GetData: format not found") );

 
     /* return failure */
     delete[] array;
 
     /* return failure */
     delete[] array;

-    return FALSE;
+    return false;

 }
 
 #endif
   // wxUSE_CLIPBOARD
 }
 
 #endif
   // wxUSE_CLIPBOARD

-