src/gtk1/clipbrd.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/gtk1/clipbrd.cpp
// Purpose:
// Author:      Robert Roebling
// Copyright:   (c) 1998 Robert Roebling
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#if wxUSE_CLIPBOARD

#include "wx/clipbrd.h"

#ifndef WX_PRECOMP
    #include "wx/log.h"
    #include "wx/utils.h"
    #include "wx/dataobj.h"
#endif

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

//-----------------------------------------------------------------------------
// 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!)
#define TRACE_CLIPBOARD "clipboard"

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

/* The contents of a selection are returned in a GtkSelectionData
   structure. selection/target identify the request.
   type specifies the type of the return; if length < 0, and
   the data should be ignored. This structure has object semantics -
   no fields should be modified directly, they should not be created
   directly, and pointers to them should not be stored beyond the duration of
   a callback. (If the last is changed, we'll need to add reference
   counting)

struct _GtkSelectionData
{
  GdkAtom selection;
  GdkAtom target;
  GdkAtom type;
  gint    format;
  guchar *data;
  gint    length;
};

*/

//-----------------------------------------------------------------------------
// "selection_received" for targets
//-----------------------------------------------------------------------------

extern "C" {
static void
targets_selection_received( GtkWidget *WXUNUSED(widget),
                            GtkSelectionData *selection_data,
                            guint32 WXUNUSED(time),
                            wxClipboard *clipboard )
{
    if ( wxTheClipboard && selection_data->length > 0 )
    {
        // make sure we got the data in the correct form
        GdkAtom type = selection_data->type;
        if ( type != GDK_SELECTION_TYPE_ATOM )
        {
            gchar* atom_name = gdk_atom_name(type);
            if ( strcmp(atom_name, "TARGETS") )
            {
                wxLogTrace( TRACE_CLIPBOARD,
                            wxT("got unsupported clipboard target") );

                clipboard->m_waiting = false;
                g_free(atom_name);
                return;
            }
            g_free(atom_name);
        }

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

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

        for (unsigned int i=0; i<selection_data->length/sizeof(GdkAtom); i++)
        {
            wxDataFormat format( atoms[i] );

            wxLogTrace( TRACE_CLIPBOARD,
                        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)
            {
                clipboard->m_waiting = false;
                clipboard->m_formatSupported = true;
                return;
            }
        }
    }

    clipboard->m_waiting = false;
}
}

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

extern "C" {
static void
selection_received( GtkWidget *WXUNUSED(widget),
                    GtkSelectionData *selection_data,
                    guint32 WXUNUSED(time),
                    wxClipboard *clipboard )
{
    if (!wxTheClipboard)
    {
        clipboard->m_waiting = false;
        return;
    }

    wxDataObject *data_object = clipboard->m_receivedData;

    if (!data_object)
    {
        clipboard->m_waiting = false;
        return;
    }

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

    wxDataFormat format( selection_data->target );

    // make sure we got the data in the correct format
    if (!data_object->IsSupportedFormat( format ) )
    {
        clipboard->m_waiting = false;
        return;
    }

#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)
    {
        clipboard->m_waiting = false;
        return;
    }
#endif

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

    wxTheClipboard->m_formatSupported = true;
    clipboard->m_waiting = false;
}
}

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

extern "C" {
static gint
selection_clear_clip( GtkWidget *WXUNUSED(widget), GdkEventSelection *event )
{
    if (!wxTheClipboard) return TRUE;

    if (event->selection == GDK_SELECTION_PRIMARY)
    {
        wxTheClipboard->m_ownsPrimarySelection = false;
    }
    else
    if (event->selection == g_clipboardAtom)
    {
        wxTheClipboard->m_ownsClipboard = false;
    }
    else
    {
        wxTheClipboard->m_waiting = false;
        return FALSE;
    }

    if ((!wxTheClipboard->m_ownsPrimarySelection) &&
        (!wxTheClipboard->m_ownsClipboard))
    {
        /* the clipboard is no longer in our hands. we can the delete clipboard data. */
        if (wxTheClipboard->m_data)
        {
            wxLogTrace(TRACE_CLIPBOARD, wxT("wxClipboard will get cleared" ));

            wxDELETE(wxTheClipboard->m_data);
        }
    }

    wxTheClipboard->m_waiting = false;
    return TRUE;
}
}

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

extern "C" {
static void
selection_handler( GtkWidget *WXUNUSED(widget),
                   GtkSelectionData *selection_data,
                   guint WXUNUSED(info),
                   guint WXUNUSED(time),
                   gpointer signal_data )
{
    if (!wxTheClipboard) return;

    if (!wxTheClipboard->m_data) return;

    wxDataObject *data = wxTheClipboard->m_data;

    // 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)
    {
        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;
    }

    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;

    void *d = malloc(size);

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

    gtk_selection_data_set(
            selection_data,
            GDK_SELECTION_TYPE_STRING,
            8 * sizeof(gchar),
            (unsigned char*) d,
            size );

    free(d);
}
}

//-----------------------------------------------------------------------------
// wxClipboard
//-----------------------------------------------------------------------------

IMPLEMENT_DYNAMIC_CLASS(wxClipboard,wxObject)

wxClipboard::wxClipboard()
{
    m_open = false;
    m_waiting = false;

    m_ownsClipboard = false;
    m_ownsPrimarySelection = false;

    m_data = NULL;
    m_receivedData = NULL;

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

    m_targetsWidget = gtk_window_new( GTK_WINDOW_POPUP );
    gtk_widget_realize( m_targetsWidget );

    gtk_signal_connect( GTK_OBJECT(m_targetsWidget),
                        "selection_received",
                        GTK_SIGNAL_FUNC( targets_selection_received ),
                        (gpointer) this );

    /* we use m_clipboardWidget to get and to offer data */

    m_clipboardWidget = gtk_window_new( GTK_WINDOW_POPUP );
    gtk_widget_realize( m_clipboardWidget );

    gtk_signal_connect( GTK_OBJECT(m_clipboardWidget),
                        "selection_received",
                        GTK_SIGNAL_FUNC( selection_received ),
                        (gpointer) this );

    gtk_signal_connect( GTK_OBJECT(m_clipboardWidget),
                        "selection_clear_event",
                        GTK_SIGNAL_FUNC( selection_clear_clip ),
                        (gpointer) NULL );

    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_targetRequested = 0;
}

wxClipboard::~wxClipboard()
{
    Clear();

    if (m_clipboardWidget) gtk_widget_destroy( m_clipboardWidget );
    if (m_targetsWidget) gtk_widget_destroy( m_targetsWidget );
}

void wxClipboard::Clear()
{
    if (m_data)
    {
#if wxUSE_THREADS
        /* disable GUI threads */
#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
        if (gdk_selection_owner_get( g_clipboardAtom ) == m_clipboardWidget->window)
        {
            m_waiting = true;

            gtk_selection_owner_set( NULL, g_clipboardAtom,
                                     (guint32) GDK_CURRENT_TIME );

            while (m_waiting) gtk_main_iteration();
        }

        if (gdk_selection_owner_get( GDK_SELECTION_PRIMARY ) == m_clipboardWidget->window)
        {
            m_waiting = true;

            gtk_selection_owner_set( NULL, GDK_SELECTION_PRIMARY,
                                     (guint32) GDK_CURRENT_TIME );

            while (m_waiting) gtk_main_iteration();
        }

        wxDELETE(m_data);

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

    m_targetRequested = 0;
    m_formatSupported = false;
}

bool wxClipboard::Open()
{
    wxCHECK_MSG( !m_open, false, wxT("clipboard already open") );

    m_open = true;

    return true;
}

bool wxClipboard::SetData( wxDataObject *data )
{
    wxCHECK_MSG( m_open, false, wxT("clipboard not open") );

    wxCHECK_MSG( data, false, wxT("data is invalid") );

    Clear();

    return AddData( data );
}

bool wxClipboard::AddData( wxDataObject *data )
{
    wxCHECK_MSG( m_open, false, wxT("clipboard not open") );

    wxCHECK_MSG( data, false, wxT("data is invalid") );

    // we can only store one wxDataObject
    Clear();

    m_data = data;

    // get formats from wxDataObjects
    wxDataFormat *array = new wxDataFormat[ m_data->GetFormatCount() ];
    m_data->GetAllFormats( array );

    // primary selection or clipboard
    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++)
    {
        wxLogTrace( TRACE_CLIPBOARD,
                    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],
                                  0 );  /* what is info ? */
    }

    delete[] array;

    gtk_signal_connect( GTK_OBJECT(m_clipboardWidget),
                        "selection_get",
                        GTK_SIGNAL_FUNC(selection_handler),
                        GUINT_TO_POINTER( gdk_event_get_time(gtk_get_current_event()) ) );

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

    /* Tell the world we offer clipboard data */
    bool res = (gtk_selection_owner_set( m_clipboardWidget,
                                         clipboard,
                                         (guint32) GDK_CURRENT_TIME ));

    if (m_usePrimary)
        m_ownsPrimarySelection = res;
    else
        m_ownsClipboard = res;

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

    return res;
}

void wxClipboard::Close()
{
    wxCHECK_RET( m_open, wxT("clipboard not open") );

    m_open = false;
}

bool wxClipboard::IsOpened() const
{
    return m_open;
}

bool wxClipboard::IsSupported( const wxDataFormat& format )
{
    /* reentrance problems */
    if (m_waiting) return false;

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

    wxLogTrace( TRACE_CLIPBOARD,
                wxT("wxClipboard:IsSupported: requested format: %s"),
                format.GetId().c_str() );

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

    m_formatSupported = false;

    /* perform query. this will set 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.
       therefore we set m_waiting = true here and wait
       until the callback "targets_selection_received"
       sets it to false */

    m_waiting = true;

    gtk_selection_convert( m_targetsWidget,
                           m_usePrimary ? (GdkAtom)GDK_SELECTION_PRIMARY
                                        : g_clipboardAtom,
                           g_targetsAtom,
                           (guint32) GDK_CURRENT_TIME );

    while (m_waiting) gtk_main_iteration();

    return m_formatSupported;
}

bool wxClipboard::GetData( wxDataObject& data )
{
    wxCHECK_MSG( m_open, false, wxT("clipboard not open") );

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

    for (size_t i = 0; i < data.GetFormatCount(); i++)
    {
        wxDataFormat format( array[i] );

        wxLogTrace( TRACE_CLIPBOARD,
                    wxT("wxClipboard::GetData: requested format: %s"),
                    format.GetId().c_str() );

        /* is data supported by clipboard ? */

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

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

        m_formatSupported = false;

       /* perform query. this will set 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.
          therefore we set m_waiting = true here and wait
          until the callback "targets_selection_received"
          sets it to false */

        m_waiting = true;

        gtk_selection_convert( m_targetsWidget,
                           m_usePrimary ? (GdkAtom)GDK_SELECTION_PRIMARY
                                        : g_clipboardAtom,
                           g_targetsAtom,
                           (guint32) GDK_CURRENT_TIME );

        while (m_waiting) gtk_main_iteration();

        if (!m_formatSupported) continue;

        /* store pointer to data object to be filled up by callbacks */
        m_receivedData = &data;

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

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

        /* start query */
        m_formatSupported = false;

        /* ask for clipboard contents.  this will set
           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.
           therefore we set m_waiting = true here and wait
           until the callback "targets_selection_received"
           sets it to false */

        m_waiting = true;

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

        gtk_selection_convert( m_clipboardWidget,
                               m_usePrimary ? (GdkAtom)GDK_SELECTION_PRIMARY
                                            : g_clipboardAtom,
                               m_targetRequested,
                               (guint32) GDK_CURRENT_TIME );

        while (m_waiting) gtk_main_iteration();

        /*
           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 true;
    }

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

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

#endif
  // wxUSE_CLIPBOARD
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: src/gtk1/clipbrd.cpp
	3	// Purpose:
	4	// Author: Robert Roebling
	5	// Copyright: (c) 1998 Robert Roebling
	6	// Licence: wxWindows licence
	7	/////////////////////////////////////////////////////////////////////////////
	8
	9	// For compilers that support precompilation, includes "wx.h".
	10	#include "wx/wxprec.h"
	11
	12	#if wxUSE_CLIPBOARD
	13
	14	#include "wx/clipbrd.h"
	15
	16	#ifndef WX_PRECOMP
	17	#include "wx/log.h"
	18	#include "wx/utils.h"
	19	#include "wx/dataobj.h"
	20	#endif
	21
	22	#include <glib.h>
	23	#include <gdk/gdk.h>
	24	#include <gtk/gtk.h>
	25
	26	//-----------------------------------------------------------------------------
	27	// data
	28	//-----------------------------------------------------------------------------
	29
	30	GdkAtom g_clipboardAtom = 0;
	31	GdkAtom g_targetsAtom = 0;
	32	GdkAtom g_timestampAtom = 0;
	33
	34	// the trace mask we use with wxLogTrace() - call
	35	// wxLog::AddTraceMask(TRACE_CLIPBOARD) to enable the trace messages from here
	36	// (there will be a lot of them!)
	37	#define TRACE_CLIPBOARD "clipboard"
	38
	39	//-----------------------------------------------------------------------------
	40	// reminder
	41	//-----------------------------------------------------------------------------
	42
	43	/* The contents of a selection are returned in a GtkSelectionData
	44	structure. selection/target identify the request.
	45	type specifies the type of the return; if length < 0, and
	46	the data should be ignored. This structure has object semantics -
	47	no fields should be modified directly, they should not be created
	48	directly, and pointers to them should not be stored beyond the duration of
	49	a callback. (If the last is changed, we'll need to add reference
	50	counting)
	51
	52	struct _GtkSelectionData
	53	{
	54	GdkAtom selection;
	55	GdkAtom target;
	56	GdkAtom type;
	57	gint format;
	58	guchar *data;
	59	gint length;
	60	};
	61
	62	*/
	63
	64	//-----------------------------------------------------------------------------
	65	// "selection_received" for targets
	66	//-----------------------------------------------------------------------------
	67
	68	extern "C" {
	69	static void
	70	targets_selection_received( GtkWidget *WXUNUSED(widget),
	71	GtkSelectionData *selection_data,
	72	guint32 WXUNUSED(time),
	73	wxClipboard *clipboard )
	74	{
	75	if ( wxTheClipboard && selection_data->length > 0 )
	76	{
	77	// make sure we got the data in the correct form
	78	GdkAtom type = selection_data->type;
	79	if ( type != GDK_SELECTION_TYPE_ATOM )
	80	{
	81	gchar* atom_name = gdk_atom_name(type);
	82	if ( strcmp(atom_name, "TARGETS") )
	83	{
	84	wxLogTrace( TRACE_CLIPBOARD,
	85	wxT("got unsupported clipboard target") );
	86
	87	clipboard->m_waiting = false;
	88	g_free(atom_name);
	89	return;
	90	}
	91	g_free(atom_name);
	92	}
	93
	94	wxDataFormat clip( selection_data->selection );
	95	wxLogTrace( TRACE_CLIPBOARD,
	96	wxT("selection received for targets, clipboard %s"),
	97	clip.GetId().c_str() );
	98
	99	// the atoms we received, holding a list of targets (= formats)
	100	GdkAtom atoms = (GdkAtom )selection_data->data;
	101
	102	for (unsigned int i=0; i<selection_data->length/sizeof(GdkAtom); i++)
	103	{
	104	wxDataFormat format( atoms[i] );
	105
	106	wxLogTrace( TRACE_CLIPBOARD,
	107	wxT("selection received for targets, format %s"),
	108	format.GetId().c_str() );
	109
	110	// printf( "format %s requested %s\n",
	111	// gdk_atom_name( atoms[i] ),
	112	// gdk_atom_name( clipboard->m_targetRequested ) );
	113
	114	if (format == clipboard->m_targetRequested)
	115	{
	116	clipboard->m_waiting = false;
	117	clipboard->m_formatSupported = true;
	118	return;
	119	}
	120	}
	121	}
	122
	123	clipboard->m_waiting = false;
	124	}
	125	}
	126
	127	//-----------------------------------------------------------------------------
	128	// "selection_received" for the actual data
	129	//-----------------------------------------------------------------------------
	130
	131	extern "C" {
	132	static void
	133	selection_received( GtkWidget *WXUNUSED(widget),
	134	GtkSelectionData *selection_data,
	135	guint32 WXUNUSED(time),
	136	wxClipboard *clipboard )
	137	{
	138	if (!wxTheClipboard)
	139	{
	140	clipboard->m_waiting = false;
	141	return;
	142	}
	143
	144	wxDataObject *data_object = clipboard->m_receivedData;
	145
	146	if (!data_object)
	147	{
	148	clipboard->m_waiting = false;
	149	return;
	150	}
	151
	152	if (selection_data->length <= 0)
	153	{
	154	clipboard->m_waiting = false;
	155	return;
	156	}
	157
	158	wxDataFormat format( selection_data->target );
	159
	160	// make sure we got the data in the correct format
	161	if (!data_object->IsSupportedFormat( format ) )
	162	{
	163	clipboard->m_waiting = false;
	164	return;
	165	}
	166
	167	#if 0
	168	This seems to cause problems somehow
	169	// make sure we got the data in the correct form (selection type).
	170	// if so, copy data to target object
	171	if (selection_data->type != GDK_SELECTION_TYPE_STRING)
	172	{
	173	clipboard->m_waiting = false;
	174	return;
	175	}
	176	#endif
	177
	178	data_object->SetData( format, (size_t) selection_data->length, (const char*) selection_data->data );
	179
	180	wxTheClipboard->m_formatSupported = true;
	181	clipboard->m_waiting = false;
	182	}
	183	}
	184
	185	//-----------------------------------------------------------------------------
	186	// "selection_clear"
	187	//-----------------------------------------------------------------------------
	188
	189	extern "C" {
	190	static gint
	191	selection_clear_clip( GtkWidget WXUNUSED(widget), GdkEventSelection event )
	192	{
	193	if (!wxTheClipboard) return TRUE;
	194
	195	if (event->selection == GDK_SELECTION_PRIMARY)
	196	{
	197	wxTheClipboard->m_ownsPrimarySelection = false;
	198	}
	199	else
	200	if (event->selection == g_clipboardAtom)
	201	{
	202	wxTheClipboard->m_ownsClipboard = false;
	203	}
	204	else
	205	{
	206	wxTheClipboard->m_waiting = false;
	207	return FALSE;
	208	}
	209
	210	if ((!wxTheClipboard->m_ownsPrimarySelection) &&
	211	(!wxTheClipboard->m_ownsClipboard))
	212	{
	213	/* the clipboard is no longer in our hands. we can the delete clipboard data. */
	214	if (wxTheClipboard->m_data)
	215	{
	216	wxLogTrace(TRACE_CLIPBOARD, wxT("wxClipboard will get cleared" ));
	217
	218	wxDELETE(wxTheClipboard->m_data);
	219	}
	220	}
	221
	222	wxTheClipboard->m_waiting = false;
	223	return TRUE;
	224	}
	225	}
	226
	227	//-----------------------------------------------------------------------------
	228	// selection handler for supplying data
	229	//-----------------------------------------------------------------------------
	230
	231	extern "C" {
	232	static void
	233	selection_handler( GtkWidget *WXUNUSED(widget),
	234	GtkSelectionData *selection_data,
	235	guint WXUNUSED(info),
	236	guint WXUNUSED(time),
	237	gpointer signal_data )
	238	{
	239	if (!wxTheClipboard) return;
	240
	241	if (!wxTheClipboard->m_data) return;
	242
	243	wxDataObject *data = wxTheClipboard->m_data;
	244
	245	// ICCCM says that TIMESTAMP is a required atom.
	246	// In particular, it satisfies Klipper, which polls
	247	// TIMESTAMP to see if the clipboards content has changed.
	248	// It shall return the time which was used to set the data.
	249	if (selection_data->target == g_timestampAtom)
	250	{
	251	guint timestamp = GPOINTER_TO_UINT (signal_data);
	252	gtk_selection_data_set(selection_data,
	253	GDK_SELECTION_TYPE_INTEGER,
	254	32,
	255	(guchar*)&(timestamp),
	256	sizeof(timestamp));
	257	wxLogTrace(TRACE_CLIPBOARD,
	258	wxT("Clipboard TIMESTAMP requested, returning timestamp=%u"),
	259	timestamp);
	260	return;
	261	}
	262
	263	wxDataFormat format( selection_data->target );
	264
	265	wxLogTrace(TRACE_CLIPBOARD,
	266	wxT("clipboard data in format %s, GtkSelectionData is target=%s type=%s selection=%s timestamp=%u"),
	267	format.GetId().c_str(),
	268	wxString::FromAscii(gdk_atom_name(selection_data->target)).c_str(),
	269	wxString::FromAscii(gdk_atom_name(selection_data->type)).c_str(),
	270	wxString::FromAscii(gdk_atom_name(selection_data->selection)).c_str(),
	271	GPOINTER_TO_UINT( signal_data )
	272	);
	273
	274	if (!data->IsSupportedFormat( format )) return;
	275
	276	int size = data->GetDataSize( format );
	277
	278	if (size == 0) return;
	279
	280	void *d = malloc(size);
	281
	282	// Text data will be in UTF8 in Unicode mode.
	283	data->GetDataHere( selection_data->target, d );
	284
	285	gtk_selection_data_set(
	286	selection_data,
	287	GDK_SELECTION_TYPE_STRING,
	288	8 * sizeof(gchar),
	289	(unsigned char*) d,
	290	size );
	291
	292	free(d);
	293	}
	294	}
	295
	296	//-----------------------------------------------------------------------------
	297	// wxClipboard
	298	//-----------------------------------------------------------------------------
	299
	300	IMPLEMENT_DYNAMIC_CLASS(wxClipboard,wxObject)
	301
	302	wxClipboard::wxClipboard()
	303	{
	304	m_open = false;
	305	m_waiting = false;
	306
	307	m_ownsClipboard = false;
	308	m_ownsPrimarySelection = false;
	309
	310	m_data = NULL;
	311	m_receivedData = NULL;
	312
	313	/* we use m_targetsWidget to query what formats are available */
	314
	315	m_targetsWidget = gtk_window_new( GTK_WINDOW_POPUP );
	316	gtk_widget_realize( m_targetsWidget );
	317
	318	gtk_signal_connect( GTK_OBJECT(m_targetsWidget),
	319	"selection_received",
	320	GTK_SIGNAL_FUNC( targets_selection_received ),
	321	(gpointer) this );
	322
	323	/* we use m_clipboardWidget to get and to offer data */
	324
	325	m_clipboardWidget = gtk_window_new( GTK_WINDOW_POPUP );
	326	gtk_widget_realize( m_clipboardWidget );
	327
	328	gtk_signal_connect( GTK_OBJECT(m_clipboardWidget),
	329	"selection_received",
	330	GTK_SIGNAL_FUNC( selection_received ),
	331	(gpointer) this );
	332
	333	gtk_signal_connect( GTK_OBJECT(m_clipboardWidget),
	334	"selection_clear_event",
	335	GTK_SIGNAL_FUNC( selection_clear_clip ),
	336	(gpointer) NULL );
	337
	338	if (!g_clipboardAtom) g_clipboardAtom = gdk_atom_intern( "CLIPBOARD", FALSE );
	339	if (!g_targetsAtom) g_targetsAtom = gdk_atom_intern ("TARGETS", FALSE);
	340	if (!g_timestampAtom) g_timestampAtom = gdk_atom_intern ("TIMESTAMP", FALSE);
	341
	342	m_formatSupported = false;
	343	m_targetRequested = 0;
	344	}
	345
	346	wxClipboard::~wxClipboard()
	347	{
	348	Clear();
	349
	350	if (m_clipboardWidget) gtk_widget_destroy( m_clipboardWidget );
	351	if (m_targetsWidget) gtk_widget_destroy( m_targetsWidget );
	352	}
	353
	354	void wxClipboard::Clear()
	355	{
	356	if (m_data)
	357	{
	358	#if wxUSE_THREADS
	359	/* disable GUI threads */
	360	#endif
	361
	362	// As we have data we also own the clipboard. Once we no longer own
	363	// it, clear_selection is called which will set m_data to zero
	364	if (gdk_selection_owner_get( g_clipboardAtom ) == m_clipboardWidget->window)
	365	{
	366	m_waiting = true;
	367
	368	gtk_selection_owner_set( NULL, g_clipboardAtom,
	369	(guint32) GDK_CURRENT_TIME );
	370
	371	while (m_waiting) gtk_main_iteration();
	372	}
	373
	374	if (gdk_selection_owner_get( GDK_SELECTION_PRIMARY ) == m_clipboardWidget->window)
	375	{
	376	m_waiting = true;
	377
	378	gtk_selection_owner_set( NULL, GDK_SELECTION_PRIMARY,
	379	(guint32) GDK_CURRENT_TIME );
	380
	381	while (m_waiting) gtk_main_iteration();
	382	}
	383
	384	wxDELETE(m_data);
	385
	386	#if wxUSE_THREADS
	387	/* re-enable GUI threads */
	388	#endif
	389	}
	390
	391	m_targetRequested = 0;
	392	m_formatSupported = false;
	393	}
	394
	395	bool wxClipboard::Open()
	396	{
	397	wxCHECK_MSG( !m_open, false, wxT("clipboard already open") );
	398
	399	m_open = true;
	400
	401	return true;
	402	}
	403
	404	bool wxClipboard::SetData( wxDataObject *data )
	405	{
	406	wxCHECK_MSG( m_open, false, wxT("clipboard not open") );
	407
	408	wxCHECK_MSG( data, false, wxT("data is invalid") );
	409
	410	Clear();
	411
	412	return AddData( data );
	413	}
	414
	415	bool wxClipboard::AddData( wxDataObject *data )
	416	{
	417	wxCHECK_MSG( m_open, false, wxT("clipboard not open") );
	418
	419	wxCHECK_MSG( data, false, wxT("data is invalid") );
	420
	421	// we can only store one wxDataObject
	422	Clear();
	423
	424	m_data = data;
	425
	426	// get formats from wxDataObjects
	427	wxDataFormat *array = new wxDataFormat[ m_data->GetFormatCount() ];
	428	m_data->GetAllFormats( array );
	429
	430	// primary selection or clipboard
	431	GdkAtom clipboard = m_usePrimary ? (GdkAtom)GDK_SELECTION_PRIMARY
	432	: g_clipboardAtom;
	433
	434	// by default provide TIMESTAMP as a target
	435	gtk_selection_add_target( GTK_WIDGET(m_clipboardWidget),
	436	clipboard,
	437	g_timestampAtom,
	438	0 );
	439
	440	for (size_t i = 0; i < m_data->GetFormatCount(); i++)
	441	{
	442	wxLogTrace( TRACE_CLIPBOARD,
	443	wxT("wxClipboard now supports atom %s"),
	444	array[i].GetId().c_str() );
	445
	446	// printf( "added %s\n",
	447	// gdk_atom_name( array[i].GetFormatId() ) );
	448
	449	gtk_selection_add_target( GTK_WIDGET(m_clipboardWidget),
	450	clipboard,
	451	array[i],
	452	0 ); /* what is info ? */
	453	}
	454
	455	delete[] array;
	456
	457	gtk_signal_connect( GTK_OBJECT(m_clipboardWidget),
	458	"selection_get",
	459	GTK_SIGNAL_FUNC(selection_handler),
	460	GUINT_TO_POINTER( gdk_event_get_time(gtk_get_current_event()) ) );
	461
	462	#if wxUSE_THREADS
	463	/* disable GUI threads */
	464	#endif
	465
	466	/* Tell the world we offer clipboard data */
	467	bool res = (gtk_selection_owner_set( m_clipboardWidget,
	468	clipboard,
	469	(guint32) GDK_CURRENT_TIME ));
	470
	471	if (m_usePrimary)
	472	m_ownsPrimarySelection = res;
	473	else
	474	m_ownsClipboard = res;
	475
	476	#if wxUSE_THREADS
	477	/* re-enable GUI threads */
	478	#endif
	479
	480	return res;
	481	}
	482
	483	void wxClipboard::Close()
	484	{
	485	wxCHECK_RET( m_open, wxT("clipboard not open") );
	486
	487	m_open = false;
	488	}
	489
	490	bool wxClipboard::IsOpened() const
	491	{
	492	return m_open;
	493	}
	494
	495	bool wxClipboard::IsSupported( const wxDataFormat& format )
	496	{
	497	/* reentrance problems */
	498	if (m_waiting) return false;
	499
	500	/* store requested format to be asked for by callbacks */
	501	m_targetRequested = format;
	502
	503	wxLogTrace( TRACE_CLIPBOARD,
	504	wxT("wxClipboard:IsSupported: requested format: %s"),
	505	format.GetId().c_str() );
	506
	507	wxCHECK_MSG( m_targetRequested, false, wxT("invalid clipboard format") );
	508
	509	m_formatSupported = false;
	510
	511	/* perform query. this will set m_formatSupported to
	512	true if m_targetRequested is supported.
	513	also, we have to wait for the "answer" from the
	514	clipboard owner which is an asynchronous process.
	515	therefore we set m_waiting = true here and wait
	516	until the callback "targets_selection_received"
	517	sets it to false */
	518
	519	m_waiting = true;
	520
	521	gtk_selection_convert( m_targetsWidget,
	522	m_usePrimary ? (GdkAtom)GDK_SELECTION_PRIMARY
	523	: g_clipboardAtom,
	524	g_targetsAtom,
	525	(guint32) GDK_CURRENT_TIME );
	526
	527	while (m_waiting) gtk_main_iteration();
	528
	529	return m_formatSupported;
	530	}
	531
	532	bool wxClipboard::GetData( wxDataObject& data )
	533	{
	534	wxCHECK_MSG( m_open, false, wxT("clipboard not open") );
	535
	536	/* get formats from wxDataObjects */
	537	wxDataFormat *array = new wxDataFormat[ data.GetFormatCount() ];
	538	data.GetAllFormats( array );
	539
	540	for (size_t i = 0; i < data.GetFormatCount(); i++)
	541	{
	542	wxDataFormat format( array[i] );
	543
	544	wxLogTrace( TRACE_CLIPBOARD,
	545	wxT("wxClipboard::GetData: requested format: %s"),
	546	format.GetId().c_str() );
	547
	548	/* is data supported by clipboard ? */
	549
	550	/* store requested format to be asked for by callbacks */
	551	m_targetRequested = format;
	552
	553	wxCHECK_MSG( m_targetRequested, false, wxT("invalid clipboard format") );
	554
	555	m_formatSupported = false;
	556
	557	/* perform query. this will set m_formatSupported to
	558	true if m_targetRequested is supported.
	559	also, we have to wait for the "answer" from the
	560	clipboard owner which is an asynchronous process.
	561	therefore we set m_waiting = true here and wait
	562	until the callback "targets_selection_received"
	563	sets it to false */
	564
	565	m_waiting = true;
	566
	567	gtk_selection_convert( m_targetsWidget,
	568	m_usePrimary ? (GdkAtom)GDK_SELECTION_PRIMARY
	569	: g_clipboardAtom,
	570	g_targetsAtom,
	571	(guint32) GDK_CURRENT_TIME );
	572
	573	while (m_waiting) gtk_main_iteration();
	574
	575	if (!m_formatSupported) continue;
	576
	577	/* store pointer to data object to be filled up by callbacks */
	578	m_receivedData = &data;
	579
	580	/* store requested format to be asked for by callbacks */
	581	m_targetRequested = format;
	582
	583	wxCHECK_MSG( m_targetRequested, false, wxT("invalid clipboard format") );
	584
	585	/* start query */
	586	m_formatSupported = false;
	587
	588	/* ask for clipboard contents. this will set
	589	m_formatSupported to true if m_targetRequested
	590	is supported.
	591	also, we have to wait for the "answer" from the
	592	clipboard owner which is an asynchronous process.
	593	therefore we set m_waiting = true here and wait
	594	until the callback "targets_selection_received"
	595	sets it to false */
	596
	597	m_waiting = true;
	598
	599	wxLogTrace( TRACE_CLIPBOARD,
	600	wxT("wxClipboard::GetData: format found, start convert") );
	601
	602	gtk_selection_convert( m_clipboardWidget,
	603	m_usePrimary ? (GdkAtom)GDK_SELECTION_PRIMARY
	604	: g_clipboardAtom,
	605	m_targetRequested,
	606	(guint32) GDK_CURRENT_TIME );
	607
	608	while (m_waiting) gtk_main_iteration();
	609
	610	/*
	611	Normally this is a true error as we checked for the presence of such
	612	data before, but there are applications that may return an empty
	613	string (e.g. Gnumeric-1.6.1 on Linux if an empty cell is copied)
	614	which would produce a false error message here, so we check for the
	615	size of the string first. In ansi, GetDataSize returns an extra
	616	value (for the closing null?), with unicode, the exact number of
	617	tokens is given (that is more than 1 for special characters)
	618	(tested with Gnumeric-1.6.1 and OpenOffice.org-2.0.2)
	619	*/
	620	#if wxUSE_UNICODE
	621	if ( format != wxDF_UNICODETEXT \|\| data.GetDataSize(format) > 0 )
	622	#else // !UNICODE
	623	if ( format != wxDF_TEXT \|\| data.GetDataSize(format) > 1 )
	624	#endif // UNICODE / !UNICODE
	625	{
	626	wxCHECK_MSG( m_formatSupported, false,
	627	wxT("error retrieving data from clipboard") );
	628	}
	629
	630	/* return success */
	631	delete[] array;
	632	return true;
	633	}
	634
	635	wxLogTrace( TRACE_CLIPBOARD,
	636	wxT("wxClipboard::GetData: format not found") );
	637
	638	/* return failure */
	639	delete[] array;
	640	return false;
	641	}
	642
	643	#endif
	644	// wxUSE_CLIPBOARD