src/motif/clipbrd.cpp

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