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
/////////////////////////////////////////////////////////////////////////////

#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
#pragma implementation
#pragma implementation "clipbrd.h"
#endif

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

#ifdef __VMS
#include "wx/vms_x_fix.h"
#define XtWindow XTWINDOW
#define XtScreen XTSCREEN
#define XtParent XTPARENT
#define XtIsRealized XTISREALIZED
#define XtDisplay XTDISPLAY
#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);

extern "C"
{
#if wxCHECK_LESSTIF()
static void wxClipboardCallback( Widget widget, int* data_id,
                                 int* priv, int* reason );
#else // Motif
static void wxClipboardCallback( Widget widget, long* data_id,
                                 long* priv, int* reason );
#endif // Less/Motif
}

IMPLEMENT_DYNAMIC_CLASS(wxClipboard,wxObject)

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

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

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

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