src/motif/clipbrd.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        clipbrd.cpp
// Purpose:     Clipboard functionality
// Author:      Julian Smart
// Modified by: Mattia Barbon (added support for generic wxDataObjects)
// Created:     17/09/98
// RCS-ID:      $Id$
// Copyright:   (c) Julian Smart
// Licence:   	wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#ifdef __GNUG__
#pragma implementation
#pragma implementation "clipbrd.h"
#endif

#include "wx/defs.h"

#if wxUSE_CLIPBOARD

#include "wx/app.h"
#include "wx/bitmap.h"
#include "wx/utils.h"
#include "wx/clipbrd.h"
#include "wx/dataobj.h"
#include "wx/ptr_scpd.h"

#ifdef __VMS__
#pragma message disable nosimpint
#endif
#include <Xm/Xm.h>
#include <Xm/CutPaste.h>
#ifdef __VMS__
#pragma message enable nosimpint
#endif

#include "wx/motif/private.h"

bool wxOpenClipboard()
{
    return wxTheClipboard->Open();
}

bool wxCloseClipboard()
{
    wxTheClipboard->Close();

    return true;
}

bool wxEmptyClipboard()
{
    wxTheClipboard->Clear();
    return true;
}

bool wxClipboardOpen()
{
    return wxTheClipboard->IsOpened();
}

bool wxIsClipboardFormatAvailable(wxDataFormat dataFormat)
{
    return wxTheClipboard->IsSupported( dataFormat );
}

bool wxSetClipboardData(wxDataFormat dataFormat, wxObject *obj,
                        int WXUNUSED(width), int WXUNUSED(height))
{
    wxDataObject* dobj = NULL;

    if( dataFormat == wxDF_TEXT )
    {
        wxChar* data = (wxChar*)obj;
        dobj = new wxTextDataObject( data );
    }
    else if( dataFormat = wxDF_BITMAP )
    {
        wxBitmap* data = (wxBitmap*)obj;
        dobj = new wxBitmapDataObject( *data );
    }

    if( !dobj )
        return false;

    return wxTheClipboard->SetData( dobj );
}

wxObject *wxGetClipboardData(wxDataFormat dataFormat, long *len)
{
    wxDataObject* dobj = NULL;
    wxTextDataObject* tobj = NULL;
    wxBitmapDataObject* bobj = NULL;

    if( dataFormat == wxDF_TEXT )
    {
        dobj = tobj = new wxTextDataObject;
    }
    else if( dataFormat = wxDF_BITMAP )
    {
        dobj = bobj = new wxBitmapDataObject;
    }

    if( !dobj || !wxTheClipboard->GetData( *dobj ) )
        return NULL;

    if( tobj )
    {
        wxString text = tobj->GetText();
        wxChar* buf = new wxChar[text.length() + 1];

        if( len ) *len = text.length();
        return (wxObject*)wxStrcpy( buf, text.c_str() );
    }
    else if( bobj )
    {
        if( len ) *len = 0;
        return new wxBitmap( bobj->GetBitmap() );
    }

    return NULL; // just in case...
}

wxDataFormat wxEnumClipboardFormats(wxDataFormat dataFormat)
{
    // Only wxDF_TEXT supported
    if (dataFormat == wxDF_TEXT)
       return wxDF_TEXT;
    else
       return wxDF_INVALID;
}

wxDataFormat wxRegisterClipboardFormat(char *WXUNUSED(formatName))
{
    // Not supported
    return wxDF_INVALID;
}

bool wxGetClipboardFormatName(wxDataFormat dataFormat, char *formatName,
                              int maxCount)
{
    wxStrncpy( formatName, dataFormat.GetId().c_str(), maxCount );

    return true;
}

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

struct wxDataIdToDataObject
{
    wxDataIdToDataObject( wxDataObject* o, long d, size_t s )
        : object( o ), size( s ), dataId( d ) { }

    wxDataObject* object;
    size_t        size;
    long          dataId;
};

#include "wx/listimpl.cpp"

WX_DEFINE_LIST(wxDataObjectList);
WX_DEFINE_LIST(wxDataIdToDataObjectList);

#if wxCHECK_LESSTIF()
static void wxClipboardCallback( Widget widget, int* data_id,
                                 int* priv, int* reason );
#else
static void wxClipboardCallback( Widget widget, long* data_id,
                                 long* priv, int* reason );
#endif

IMPLEMENT_DYNAMIC_CLASS(wxClipboard,wxObject)

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

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

void wxClipboard::Clear()
{
    wxDataObjectList::Node* node = m_data.GetFirst();
    while (node)
    {
        delete node->GetData();
        node = node->GetNext();
    }
    m_data.Clear();

    for( wxDataIdToDataObjectList::Node* node2 = m_idToObject.GetFirst();
         node2; node2 = node2->GetNext() )
        delete node->GetData();
    m_idToObject.Clear();
}

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

    m_open = true;

    return true;
}

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

    Clear();

    return AddData( data );
}

wxDECLARE_SCOPED_ARRAY( wxDataFormat, wxDataFormatScopedArray );
wxDEFINE_SCOPED_ARRAY( wxDataFormat, wxDataFormatScopedArray );

#if wxCHECK_LESSTIF()
void wxClipboardCallback( Widget xwidget, int* data_id,
                          int* priv, int* reason )
#else
void wxClipboardCallback( Widget xwidget, long* data_id,
                          long* priv, int* reason )
#endif
{
    Display* xdisplay = XtDisplay( xwidget );
    Window xwindow = XtWindow( xwidget );
    wxDataObject* dobj = NULL;
    size_t size = 0;

    for( wxDataIdToDataObjectList::Node* node2 =
             wxTheClipboard->m_idToObject.GetFirst();
         node2; node2 = node2->GetNext() )
    {
        wxDataIdToDataObject* dido = node2->GetData();
        if( dido->dataId == *data_id )
        {
            dobj = dido->object;
            size = dido->size;
            break;
        }
    }

    if( !dobj ) return;

    wxCharBuffer buffer(size);
    size_t count = dobj->GetFormatCount( wxDataObject::Get );
    wxDataFormatScopedArray dfarr( new wxDataFormat[count] );
    dobj->GetAllFormats( dfarr.get(), wxDataObject::Get );

    if( !dobj->GetDataHere( dfarr[*priv], buffer.data() ) )
        return;

    while( XmClipboardCopyByName( xdisplay, xwindow, *data_id,
                                  buffer.data(), size, 0 )
           == XmClipboardLocked );
}

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

    m_data.Append( data );

    Display* xdisplay = wxGlobalDisplay();
    Widget xwidget = (Widget)wxTheApp->GetTopLevelWidget();
    Window xwindow = XtWindow( xwidget );
    wxXmString label( wxTheApp->GetAppName() );
    Time timestamp = XtLastTimestampProcessed( xdisplay );
    long itemId;

    int retval;

    while( ( retval = XmClipboardStartCopy( xdisplay, xwindow, label(),
                                            timestamp, xwidget,
                                            wxClipboardCallback,
                                            &itemId ) )
           == XmClipboardLocked );
    if( retval != XmClipboardSuccess )
        return false;

    size_t count = data->GetFormatCount( wxDataObject::Get );
    wxDataFormatScopedArray dfarr( new wxDataFormat[count] );
    data->GetAllFormats( dfarr.get(), wxDataObject::Get );

    for( size_t i = 0; i < count; ++i )
    {
        size_t size = data->GetDataSize( dfarr[i] );
        long data_id;
        wxString id = dfarr[i].GetId();

        while( ( retval = XmClipboardCopy( xdisplay, xwindow, itemId,
                                           wxConstCast(id.c_str(), char),
                                           NULL, size, i, &data_id ) )
               == XmClipboardLocked );

        m_idToObject.Append( new wxDataIdToDataObject( data, data_id, size ) );
    }

    while( XmClipboardEndCopy( xdisplay, xwindow, itemId )
           == XmClipboardLocked );

    return true;
}

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

    m_open = false;
}

bool wxClipboard::IsSupported(const wxDataFormat& format)
{
    Display* xdisplay = wxGlobalDisplay();
    Window xwindow = XtWindow( (Widget)wxTheApp->GetTopLevelWidget() );
    bool isSupported = false;
    int retval, count;
    unsigned long  max_name_length;
    wxString id = format.GetId();

    while( ( retval = XmClipboardLock( xdisplay, xwindow ) )
           == XmClipboardLocked );
    if( retval != XmClipboardSuccess )
        return false;

    if( XmClipboardInquireCount( xdisplay, xwindow, &count, &max_name_length )
        == XmClipboardSuccess )
    {
        wxCharBuffer buf( max_name_length + 1 );
        unsigned long copied;

        for( int i = 0; i < count; ++i )
        {
            if( XmClipboardInquireFormat( xdisplay, xwindow, i + 1,
                                          (XtPointer)buf.data(),
                                          max_name_length, &copied )
                != XmClipboardSuccess )
                continue;

            buf.data()[copied] = '\0';

            if( buf == id )
            {
                isSupported = true;
                break;
            }
        }
    }

    XmClipboardUnlock( xdisplay, xwindow, False );

    return isSupported;
}

class wxClipboardEndRetrieve
{
public:
    wxClipboardEndRetrieve( Display* display, Window window )
        : m_display( display ), m_window( window ) { }
    ~wxClipboardEndRetrieve()
    {
        while( XmClipboardEndRetrieve( m_display, m_window )
               == XmClipboardLocked );
    }
private:
    Display* m_display;
    Window m_window;
};

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

    Display* xdisplay = wxGlobalDisplay();
    Window xwindow = XtWindow( (Widget)wxTheApp->GetTopLevelWidget() );
    Time timestamp = XtLastTimestampProcessed( xdisplay );

    wxDataFormat chosenFormat;
    int retval;

    ///////////////////////////////////////////////////////////////////////////
    // determine if the cliboard holds any format we like
    ///////////////////////////////////////////////////////////////////////////
    while( ( retval = XmClipboardStartRetrieve( xdisplay, xwindow,
                                                timestamp ) )
           == XmClipboardLocked );
    if( retval != XmClipboardSuccess )
        return false;

    wxClipboardEndRetrieve endRetrieve( xdisplay, xwindow );

    int count;
    unsigned long max_name_length;
    size_t dfcount = data.GetFormatCount( wxDataObject::Set );
    wxDataFormatScopedArray dfarr( new wxDataFormat[dfcount] );
    data.GetAllFormats( dfarr.get(), wxDataObject::Set );

    if( XmClipboardInquireCount( xdisplay, xwindow, &count, &max_name_length )
        == XmClipboardSuccess )
    {
        wxCharBuffer buf( max_name_length + 1 );
        unsigned long copied;

        for( int i = 0; i < count; ++i )
        {
            if( XmClipboardInquireFormat( xdisplay, xwindow, i + 1,
                                          (XtPointer)buf.data(),
                                          max_name_length, &copied )
                != XmClipboardSuccess )
                continue;

            buf.data()[copied] = '\0';

            // try preferred format
            if( buf == data.GetPreferredFormat( wxDataObject::Set ).GetId() )
            {
                chosenFormat = data.GetPreferredFormat( wxDataObject::Set );
                break;
            }

            // try all other formats
            for( size_t i = 0; i < dfcount; ++i )
            {
                if( buf == dfarr[i].GetId() )
                    chosenFormat = dfarr[i];
            }
        }
    }

    if( chosenFormat == wxDF_INVALID )
        return false;

    ///////////////////////////////////////////////////////////////////////////
    // now retrieve the data
    ///////////////////////////////////////////////////////////////////////////
    unsigned long length, dummy1;
    long dummy2;
    wxString id = chosenFormat.GetId();

    while( ( retval = XmClipboardInquireLength( xdisplay, xwindow,
                                                wxConstCast(id.c_str(), char),
                                                &length ) )
           == XmClipboardLocked );
    if( retval != XmClipboardSuccess )
        return false;

    wxCharBuffer buf(length);

    while( ( retval = XmClipboardRetrieve( xdisplay, xwindow,
                                           wxConstCast(id.c_str(), char),
                                           (XtPointer)buf.data(),
                                           length, &dummy1, &dummy2 ) )
           == XmClipboardLocked );
    if( retval != XmClipboardSuccess )
        return false;

    if( !data.SetData( chosenFormat, length, buf.data() ) )
        return false;

    return true;
}

#endif // wxUSE_CLIPBOARD
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: clipbrd.cpp
	3	// Purpose: Clipboard functionality
	4	// Author: Julian Smart
	5	// Modified by: Mattia Barbon (added support for generic wxDataObjects)
	6	// Created: 17/09/98
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Julian Smart
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	#ifdef __GNUG__
	13	#pragma implementation
	14	#pragma implementation "clipbrd.h"
	15	#endif
	16
	17	#include "wx/defs.h"
	18
	19	#if wxUSE_CLIPBOARD
	20
	21	#include "wx/app.h"
	22	#include "wx/bitmap.h"
	23	#include "wx/utils.h"
	24	#include "wx/clipbrd.h"
	25	#include "wx/dataobj.h"
	26	#include "wx/ptr_scpd.h"
	27
	28	#ifdef __VMS__
	29	#pragma message disable nosimpint
	30	#endif
	31	#include <Xm/Xm.h>
	32	#include <Xm/CutPaste.h>
	33	#ifdef __VMS__
	34	#pragma message enable nosimpint
	35	#endif
	36
	37	#include "wx/motif/private.h"
	38
	39	bool wxOpenClipboard()
	40	{
	41	return wxTheClipboard->Open();
	42	}
	43
	44	bool wxCloseClipboard()
	45	{
	46	wxTheClipboard->Close();
	47
	48	return true;
	49	}
	50
	51	bool wxEmptyClipboard()
	52	{
	53	wxTheClipboard->Clear();
	54	return true;
	55	}
	56
	57	bool wxClipboardOpen()
	58	{
	59	return wxTheClipboard->IsOpened();
	60	}
	61
	62	bool wxIsClipboardFormatAvailable(wxDataFormat dataFormat)
	63	{
	64	return wxTheClipboard->IsSupported( dataFormat );
	65	}
	66
	67	bool wxSetClipboardData(wxDataFormat dataFormat, wxObject *obj,
	68	int WXUNUSED(width), int WXUNUSED(height))
	69	{
	70	wxDataObject* dobj = NULL;
	71
	72	if( dataFormat == wxDF_TEXT )
	73	{
	74	wxChar* data = (wxChar*)obj;
	75	dobj = new wxTextDataObject( data );
	76	}
	77	else if( dataFormat = wxDF_BITMAP )
	78	{
	79	wxBitmap* data = (wxBitmap*)obj;
	80	dobj = new wxBitmapDataObject( *data );
	81	}
	82
	83	if( !dobj )
	84	return false;
	85
	86	return wxTheClipboard->SetData( dobj );
	87	}
	88
	89	wxObject wxGetClipboardData(wxDataFormat dataFormat, long len)
	90	{
	91	wxDataObject* dobj = NULL;
	92	wxTextDataObject* tobj = NULL;
	93	wxBitmapDataObject* bobj = NULL;
	94
	95	if( dataFormat == wxDF_TEXT )
	96	{
	97	dobj = tobj = new wxTextDataObject;
	98	}
	99	else if( dataFormat = wxDF_BITMAP )
	100	{
	101	dobj = bobj = new wxBitmapDataObject;
	102	}
	103
	104	if( !dobj \|\| !wxTheClipboard->GetData( *dobj ) )
	105	return NULL;
	106
	107	if( tobj )
	108	{
	109	wxString text = tobj->GetText();
	110	wxChar* buf = new wxChar[text.length() + 1];
	111
	112	if( len ) *len = text.length();
	113	return (wxObject*)wxStrcpy( buf, text.c_str() );
	114	}
	115	else if( bobj )
	116	{
	117	if( len ) *len = 0;
	118	return new wxBitmap( bobj->GetBitmap() );
	119	}
	120
	121	return NULL; // just in case...
	122	}
	123
	124	wxDataFormat wxEnumClipboardFormats(wxDataFormat dataFormat)
	125	{
	126	// Only wxDF_TEXT supported
	127	if (dataFormat == wxDF_TEXT)
	128	return wxDF_TEXT;
	129	else
	130	return wxDF_INVALID;
	131	}
	132
	133	wxDataFormat wxRegisterClipboardFormat(char *WXUNUSED(formatName))
	134	{
	135	// Not supported
	136	return wxDF_INVALID;
	137	}
	138
	139	bool wxGetClipboardFormatName(wxDataFormat dataFormat, char *formatName,
	140	int maxCount)
	141	{
	142	wxStrncpy( formatName, dataFormat.GetId().c_str(), maxCount );
	143
	144	return true;
	145	}
	146
	147	//-----------------------------------------------------------------------------
	148	// wxClipboard
	149	//-----------------------------------------------------------------------------
	150
	151	struct wxDataIdToDataObject
	152	{
	153	wxDataIdToDataObject( wxDataObject* o, long d, size_t s )
	154	: object( o ), size( s ), dataId( d ) { }
	155
	156	wxDataObject* object;
	157	size_t size;
	158	long dataId;
	159	};
	160
	161	#include "wx/listimpl.cpp"
	162
	163	WX_DEFINE_LIST(wxDataObjectList);
	164	WX_DEFINE_LIST(wxDataIdToDataObjectList);
	165
	166	#if wxCHECK_LESSTIF()
	167	static void wxClipboardCallback( Widget widget, int* data_id,
	168	int* priv, int* reason );
	169	#else
	170	static void wxClipboardCallback( Widget widget, long* data_id,
	171	long* priv, int* reason );
	172	#endif
	173
	174	IMPLEMENT_DYNAMIC_CLASS(wxClipboard,wxObject)
	175
	176	wxClipboard::wxClipboard()
	177	{
	178	m_open = false;
	179	}
	180
	181	wxClipboard::~wxClipboard()
	182	{
	183	Clear();
	184	}
	185
	186	void wxClipboard::Clear()
	187	{
	188	wxDataObjectList::Node* node = m_data.GetFirst();
	189	while (node)
	190	{
	191	delete node->GetData();
	192	node = node->GetNext();
	193	}
	194	m_data.Clear();
	195
	196	for( wxDataIdToDataObjectList::Node* node2 = m_idToObject.GetFirst();
	197	node2; node2 = node2->GetNext() )
	198	delete node->GetData();
	199	m_idToObject.Clear();
	200	}
	201
	202	bool wxClipboard::Open()
	203	{
	204	wxCHECK_MSG( !m_open, false, "clipboard already open" );
	205
	206	m_open = true;
	207
	208	return true;
	209	}
	210
	211	bool wxClipboard::SetData( wxDataObject *data )
	212	{
	213	wxCHECK_MSG( data, false, "data is invalid" );
	214	wxCHECK_MSG( m_open, false, "clipboard not open" );
	215
	216	Clear();
	217
	218	return AddData( data );
	219	}
	220
	221	wxDECLARE_SCOPED_ARRAY( wxDataFormat, wxDataFormatScopedArray );
	222	wxDEFINE_SCOPED_ARRAY( wxDataFormat, wxDataFormatScopedArray );
	223
	224	#if wxCHECK_LESSTIF()
	225	void wxClipboardCallback( Widget xwidget, int* data_id,
	226	int* priv, int* reason )
	227	#else
	228	void wxClipboardCallback( Widget xwidget, long* data_id,
	229	long* priv, int* reason )
	230	#endif
	231	{
	232	Display* xdisplay = XtDisplay( xwidget );
	233	Window xwindow = XtWindow( xwidget );
	234	wxDataObject* dobj = NULL;
	235	size_t size = 0;
	236
	237	for( wxDataIdToDataObjectList::Node* node2 =
	238	wxTheClipboard->m_idToObject.GetFirst();
	239	node2; node2 = node2->GetNext() )
	240	{
	241	wxDataIdToDataObject* dido = node2->GetData();
	242	if( dido->dataId == *data_id )
	243	{
	244	dobj = dido->object;
	245	size = dido->size;
	246	break;
	247	}
	248	}
	249
	250	if( !dobj ) return;
	251
	252	wxCharBuffer buffer(size);
	253	size_t count = dobj->GetFormatCount( wxDataObject::Get );
	254	wxDataFormatScopedArray dfarr( new wxDataFormat[count] );
	255	dobj->GetAllFormats( dfarr.get(), wxDataObject::Get );
	256
	257	if( !dobj->GetDataHere( dfarr[*priv], buffer.data() ) )
	258	return;
	259
	260	while( XmClipboardCopyByName( xdisplay, xwindow, *data_id,
	261	buffer.data(), size, 0 )
	262	== XmClipboardLocked );
	263	}
	264
	265	bool wxClipboard::AddData( wxDataObject *data )
	266	{
	267	wxCHECK_MSG( data, false, "data is invalid" );
	268	wxCHECK_MSG( m_open, false, "clipboard not open" );
	269
	270	m_data.Append( data );
	271
	272	Display* xdisplay = wxGlobalDisplay();
	273	Widget xwidget = (Widget)wxTheApp->GetTopLevelWidget();
	274	Window xwindow = XtWindow( xwidget );
	275	wxXmString label( wxTheApp->GetAppName() );
	276	Time timestamp = XtLastTimestampProcessed( xdisplay );
	277	long itemId;
	278
	279	int retval;
	280
	281	while( ( retval = XmClipboardStartCopy( xdisplay, xwindow, label(),
	282	timestamp, xwidget,
	283	wxClipboardCallback,
	284	&itemId ) )
	285	== XmClipboardLocked );
	286	if( retval != XmClipboardSuccess )
	287	return false;
	288
	289	size_t count = data->GetFormatCount( wxDataObject::Get );
	290	wxDataFormatScopedArray dfarr( new wxDataFormat[count] );
	291	data->GetAllFormats( dfarr.get(), wxDataObject::Get );
	292
	293	for( size_t i = 0; i < count; ++i )
	294	{
	295	size_t size = data->GetDataSize( dfarr[i] );
	296	long data_id;
	297	wxString id = dfarr[i].GetId();
	298
	299	while( ( retval = XmClipboardCopy( xdisplay, xwindow, itemId,
	300	wxConstCast(id.c_str(), char),
	301	NULL, size, i, &data_id ) )
	302	== XmClipboardLocked );
	303
	304	m_idToObject.Append( new wxDataIdToDataObject( data, data_id, size ) );
	305	}
	306
	307	while( XmClipboardEndCopy( xdisplay, xwindow, itemId )
	308	== XmClipboardLocked );
	309
	310	return true;
	311	}
	312
	313	void wxClipboard::Close()
	314	{
	315	wxCHECK_RET( m_open, "clipboard not open" );
	316
	317	m_open = false;
	318	}
	319
	320	bool wxClipboard::IsSupported(const wxDataFormat& format)
	321	{
	322	Display* xdisplay = wxGlobalDisplay();
	323	Window xwindow = XtWindow( (Widget)wxTheApp->GetTopLevelWidget() );
	324	bool isSupported = false;
	325	int retval, count;
	326	unsigned long max_name_length;
	327	wxString id = format.GetId();
	328
	329	while( ( retval = XmClipboardLock( xdisplay, xwindow ) )
	330	== XmClipboardLocked );
	331	if( retval != XmClipboardSuccess )
	332	return false;
	333
	334	if( XmClipboardInquireCount( xdisplay, xwindow, &count, &max_name_length )
	335	== XmClipboardSuccess )
	336	{
	337	wxCharBuffer buf( max_name_length + 1 );
	338	unsigned long copied;
	339
	340	for( int i = 0; i < count; ++i )
	341	{
	342	if( XmClipboardInquireFormat( xdisplay, xwindow, i + 1,
	343	(XtPointer)buf.data(),
	344	max_name_length, &copied )
	345	!= XmClipboardSuccess )
	346	continue;
	347
	348	buf.data()[copied] = '\0';
	349
	350	if( buf == id )
	351	{
	352	isSupported = true;
	353	break;
	354	}
	355	}
	356	}
	357
	358	XmClipboardUnlock( xdisplay, xwindow, False );
	359
	360	return isSupported;
	361	}
	362
	363	class wxClipboardEndRetrieve
	364	{
	365	public:
	366	wxClipboardEndRetrieve( Display* display, Window window )
	367	: m_display( display ), m_window( window ) { }
	368	~wxClipboardEndRetrieve()
	369	{
	370	while( XmClipboardEndRetrieve( m_display, m_window )
	371	== XmClipboardLocked );
	372	}
	373	private:
	374	Display* m_display;
	375	Window m_window;
	376	};
	377
	378	bool wxClipboard::GetData( wxDataObject& data )
	379	{
	380	wxCHECK_MSG( m_open, false, "clipboard not open" );
	381
	382	Display* xdisplay = wxGlobalDisplay();
	383	Window xwindow = XtWindow( (Widget)wxTheApp->GetTopLevelWidget() );
	384	Time timestamp = XtLastTimestampProcessed( xdisplay );
	385
	386	wxDataFormat chosenFormat;
	387	int retval;
	388
	389	///////////////////////////////////////////////////////////////////////////
	390	// determine if the cliboard holds any format we like
	391	///////////////////////////////////////////////////////////////////////////
	392	while( ( retval = XmClipboardStartRetrieve( xdisplay, xwindow,
	393	timestamp ) )
	394	== XmClipboardLocked );
	395	if( retval != XmClipboardSuccess )
	396	return false;
	397
	398	wxClipboardEndRetrieve endRetrieve( xdisplay, xwindow );
	399
	400	int count;
	401	unsigned long max_name_length;
	402	size_t dfcount = data.GetFormatCount( wxDataObject::Set );
	403	wxDataFormatScopedArray dfarr( new wxDataFormat[dfcount] );
	404	data.GetAllFormats( dfarr.get(), wxDataObject::Set );
	405
	406	if( XmClipboardInquireCount( xdisplay, xwindow, &count, &max_name_length )
	407	== XmClipboardSuccess )
	408	{
	409	wxCharBuffer buf( max_name_length + 1 );
	410	unsigned long copied;
	411
	412	for( int i = 0; i < count; ++i )
	413	{
	414	if( XmClipboardInquireFormat( xdisplay, xwindow, i + 1,
	415	(XtPointer)buf.data(),
	416	max_name_length, &copied )
	417	!= XmClipboardSuccess )
	418	continue;
	419
	420	buf.data()[copied] = '\0';
	421
	422	// try preferred format
	423	if( buf == data.GetPreferredFormat( wxDataObject::Set ).GetId() )
	424	{
	425	chosenFormat = data.GetPreferredFormat( wxDataObject::Set );
	426	break;
	427	}
	428
	429	// try all other formats
	430	for( size_t i = 0; i < dfcount; ++i )
	431	{
	432	if( buf == dfarr[i].GetId() )
	433	chosenFormat = dfarr[i];
	434	}
	435	}
	436	}
	437
	438	if( chosenFormat == wxDF_INVALID )
	439	return false;
	440
	441	///////////////////////////////////////////////////////////////////////////
	442	// now retrieve the data
	443	///////////////////////////////////////////////////////////////////////////
	444	unsigned long length, dummy1;
	445	long dummy2;
	446	wxString id = chosenFormat.GetId();
	447
	448	while( ( retval = XmClipboardInquireLength( xdisplay, xwindow,
	449	wxConstCast(id.c_str(), char),
	450	&length ) )
	451	== XmClipboardLocked );
	452	if( retval != XmClipboardSuccess )
	453	return false;
	454
	455	wxCharBuffer buf(length);
	456
	457	while( ( retval = XmClipboardRetrieve( xdisplay, xwindow,
	458	wxConstCast(id.c_str(), char),
	459	(XtPointer)buf.data(),
	460	length, &dummy1, &dummy2 ) )
	461	== XmClipboardLocked );
	462	if( retval != XmClipboardSuccess )
	463	return false;
	464
	465	if( !data.SetData( chosenFormat, length, buf.data() ) )
	466	return false;
	467
	468	return true;
	469	}
	470
	471	#endif // wxUSE_CLIPBOARD