src/motif/clipbrd.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        clipbrd.cpp
   3 // Purpose:     Clipboard functionality
   4 // Author:      Julian Smart
   5 // Modified by:
   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/frame.h"
  23 #include "wx/bitmap.h"
  24 #include "wx/utils.h"
  25 #include "wx/metafile.h"
  26 #include "wx/clipbrd.h"
  27 #include "wx/dataobj.h"
  28
  29 #include <Xm/Xm.h>
  30 #include <Xm/CutPaste.h>
  31
  32 #include <string.h>
  33
  34 #if !USE_SHARED_LIBRARY
  35 // IMPLEMENT_DYNAMIC_CLASS(wxClipboard, wxObject)
  36 // IMPLEMENT_ABSTRACT_CLASS(wxClipboardClient, wxObject)
  37 #endif
  38
  39 static bool gs_clipboardIsOpen = FALSE;
  40
  41 bool wxOpenClipboard()
  42 {
  43     if (!gs_clipboardIsOpen)
  44     {
  45         gs_clipboardIsOpen = TRUE;
  46         return TRUE;
  47     }
  48     else
  49         return FALSE;
  50 }
  51
  52 bool wxCloseClipboard()
  53 {
  54     if (gs_clipboardIsOpen)
  55     {
  56         gs_clipboardIsOpen = FALSE;
  57         return TRUE;
  58     }
  59     else
  60         return FALSE;
  61 }
  62
  63 bool wxEmptyClipboard()
  64 {
  65     // No equivalent in Motif
  66     return TRUE;
  67 }
  68
  69 bool wxClipboardOpen()
  70 {
  71     return gs_clipboardIsOpen;
  72 }
  73
  74 bool wxIsClipboardFormatAvailable(wxDataFormat dataFormat)
  75 {
  76     // Only text is supported.
  77     if (dataFormat != wxDF_TEXT)
  78         return FALSE;
  79
  80     unsigned long numBytes = 0;
  81     long privateId = 0;
  82
  83     Window window = (Window) 0;
  84     if (wxTheApp->GetTopWindow())
  85         window = XtWindow( (Widget) wxTheApp->GetTopWindow()->GetTopWidget() );
  86
  87     int success = XmClipboardRetrieve((Display*) wxGetDisplay(),
  88       window, "TEXT", (XtPointer) 0, 0, & numBytes, & privateId) ;
  89
  90     // Assume only text is supported. If we have anything at all,
  91     // or the clipboard is locked so we're not sure, we say we support it.
  92     if (success == ClipboardNoData)
  93         return FALSE;
  94     else
  95         return TRUE;
  96 }
  97
  98 bool wxSetClipboardData(wxDataFormat dataFormat, wxObject *obj, int WXUNUSED(width), int WXUNUSED(height))
  99 {
 100     if (dataFormat != wxDF_TEXT)
 101         return FALSE;
 102
 103     char* data = (char*) obj;
 104
 105     XmString text = XmStringCreateSimple ("CLIPBOARD");
 106     Window window = (Window) 0;
 107     if (wxTheApp->GetTopWindow())
 108         window = XtWindow( (Widget) wxTheApp->GetTopWindow()->GetTopWidget() );
 109
 110     long itemId = 0;
 111     int result = 0;
 112
 113     while ((result =
 114       XmClipboardStartCopy((Display*) wxGetDisplay(),
 115        window,
 116        text,
 117        XtLastTimestampProcessed((Display*) wxGetDisplay()),
 118        (Widget) 0,
 119        (XmCutPasteProc) 0,
 120        & itemId)) != ClipboardSuccess)
 121
 122        ;
 123
 124     XmStringFree (text);
 125
 126     long dataId = 0;
 127     while ((result =
 128       XmClipboardCopy((Display*) wxGetDisplay(),
 129        window,
 130        itemId,
 131        "TEXT",
 132        (XtPointer) data,
 133        strlen(data) + 1,
 134        0,
 135        & dataId)) != ClipboardSuccess)
 136
 137        ;
 138
 139     while (( result =
 140        XmClipboardEndCopy((Display*) wxGetDisplay(),
 141          window, itemId) ) != ClipboardSuccess)
 142
 143        ;
 144
 145     return TRUE;
 146 }
 147
 148 wxObject *wxGetClipboardData(wxDataFormat dataFormat, long *len)
 149 {
 150     if (dataFormat != wxDF_TEXT)
 151         return (wxObject*) NULL;
 152
 153     bool done = FALSE;
 154     long id = 0;
 155     unsigned long numBytes = 0;
 156     int result = 0;
 157     Window window = (Window) 0;
 158     if (wxTheApp->GetTopWindow())
 159         window = XtWindow( (Widget) wxTheApp->GetTopWindow()->GetTopWidget() );
 160
 161     int currentDataSize = 256;
 162     char* data = new char[currentDataSize];
 163
 164     while (!done)
 165     {
 166         if (result == ClipboardTruncate)
 167         {
 168             delete[] data;
 169             currentDataSize = 2*currentDataSize;
 170             data = new char[currentDataSize];
 171         }
 172         result = XmClipboardRetrieve((Display*) wxGetDisplay(),
 173           window,
 174           "TEXT",
 175           (XtPointer) data,
 176           currentDataSize,
 177           &numBytes,
 178           &id);
 179
 180         switch (result)
 181           {
 182           case ClipboardSuccess:
 183             {
 184               if (len)
 185                 *len = strlen(data) + 1;
 186               return (wxObject*) data;
 187               break;
 188             }
 189           case ClipboardTruncate:
 190           case ClipboardLocked:
 191             {
 192               break;
 193             }
 194           default:
 195           case ClipboardNoData:
 196             {
 197               return (wxObject*) NULL;
 198               break;
 199             }
 200           }
 201
 202     }
 203
 204     return NULL;
 205 }
 206
 207 wxDataFormat  wxEnumClipboardFormats(wxDataFormat dataFormat)
 208 {
 209     // Only wxDF_TEXT supported
 210     if (dataFormat == wxDF_TEXT)
 211        return wxDF_TEXT;
 212     else
 213        return wxDF_INVALID;
 214 }
 215
 216 wxDataFormat  wxRegisterClipboardFormat(char *WXUNUSED(formatName))
 217 {
 218     // Not supported
 219     return (wxDataFormat) wxDF_INVALID;
 220 }
 221
 222 bool wxGetClipboardFormatName(wxDataFormat dataFormat, char *formatName, int WXUNUSED(maxCount))
 223 {
 224     // Only wxDF_TEXT supported
 225     if (dataFormat == wxDF_TEXT)
 226     {
 227        strcpy(formatName, "TEXT");
 228        return TRUE;
 229     }
 230     else
 231        return FALSE;
 232 }
 233
 234 //-----------------------------------------------------------------------------
 235 // wxClipboard
 236 //-----------------------------------------------------------------------------
 237
 238 IMPLEMENT_DYNAMIC_CLASS(wxClipboard,wxObject)
 239
 240 wxClipboard::wxClipboard()
 241 {
 242     m_open = FALSE;
 243 }
 244
 245 wxClipboard::~wxClipboard()
 246 {
 247     Clear();
 248 }
 249
 250 void wxClipboard::Clear()
 251 {
 252     wxNode* node = m_data.First();
 253     while (node)
 254     {
 255         wxDataObject* data = (wxDataObject*) node->Data();
 256         delete data;
 257         node = node->Next();
 258     }
 259     m_data.Clear();
 260 }
 261
 262 bool wxClipboard::Open()
 263 {
 264     wxCHECK_MSG( !m_open, FALSE, "clipboard already open" );
 265
 266     m_open = TRUE;
 267
 268     return wxOpenClipboard();
 269 }
 270
 271 bool wxClipboard::SetData( wxDataObject *data )
 272 {
 273     wxCHECK_MSG( data, FALSE, "data is invalid" );
 274     wxCHECK_MSG( m_open, FALSE, "clipboard not open" );
 275
 276     Clear();
 277
 278     return AddData( data );
 279 }
 280
 281 bool wxClipboard::AddData( wxDataObject *data )
 282 {
 283     wxCHECK_MSG( data, FALSE, "data is invalid" );
 284     wxCHECK_MSG( m_open, FALSE, "clipboard not open" );
 285
 286     wxDataFormat::NativeFormat format = data->GetPreferredFormat().GetType();
 287     switch ( format )
 288     {
 289         case wxDF_TEXT:
 290         case wxDF_OEMTEXT:
 291         {
 292             wxTextDataObject* textDataObject = (wxTextDataObject*) data;
 293             wxString str(textDataObject->GetText());
 294             return wxSetClipboardData(format, (wxObject*) (const char*) str);
 295         }
 296 #if 0
 297         case wxDF_BITMAP:
 298         case wxDF_DIB:
 299         {
 300             wxBitmapDataObject* bitmapDataObject = (wxBitmapDataObject*) data;
 301             wxBitmap bitmap(bitmapDataObject->GetBitmap());
 302             return wxSetClipboardData(data->GetType(), & bitmap);
 303             break;
 304         }
 305 #endif // 0
 306     }
 307
 308     return FALSE;
 309 }
 310
 311 void wxClipboard::Close()
 312 {
 313     wxCHECK_RET( m_open, "clipboard not open" );
 314
 315     m_open = FALSE;
 316     wxCloseClipboard();
 317 }
 318
 319 bool wxClipboard::IsSupported( const wxDataFormat& format)
 320 {
 321     return wxIsClipboardFormatAvailable(format);
 322 }
 323
 324 bool wxClipboard::GetData( wxDataObject& data )
 325 {
 326     wxCHECK_MSG( m_open, FALSE, "clipboard not open" );
 327
 328     wxDataFormat::NativeFormat format = data.GetPreferredFormat().GetType();
 329     switch ( format )
 330     {
 331         case wxDF_TEXT:
 332         case wxDF_OEMTEXT:
 333         {
 334             wxTextDataObject& textDataObject = (wxTextDataObject &) data;
 335             char* s = (char*) wxGetClipboardData(format);
 336             if (s)
 337             {
 338                 textDataObject.SetText(s);
 339                 delete[] s;
 340                 return TRUE;
 341             }
 342             else
 343                 return FALSE;
 344             break;
 345         }
 346 /*
 347         case wxDF_BITMAP:
 348         case wxDF_DIB:
 349         {
 350             wxBitmapDataObject* bitmapDataObject = (wxBitmapDataObject*) data;
 351             wxBitmap* bitmap = (wxBitmap*) wxGetClipboardData(data->GetType());
 352             if (bitmap)
 353             {
 354                 bitmapDataObject->SetBitmap(* bitmap);
 355                 delete bitmap;
 356                 return TRUE;
 357             }
 358             else
 359                 return FALSE;
 360             break;
 361         }
 362 */
 363         default:
 364         {
 365             return FALSE;
 366         }
 367     }
 368     return FALSE;
 369 }
 370
 371 #if 0
 372
 373 /*
 374 * Old clipboard implementation by Matthew Flatt
 375 */
 376
 377 wxClipboard *wxTheClipboard = NULL;
 378
 379 void wxInitClipboard()
 380 {
 381     if (!wxTheClipboard)
 382         wxTheClipboard = new wxClipboard;
 383 }
 384
 385 wxClipboard::wxClipboard()
 386 {
 387     clipOwner = NULL;
 388     cbString = NULL;
 389 }
 390
 391 wxClipboard::~wxClipboard()
 392 {
 393     if (clipOwner)
 394         clipOwner->BeingReplaced();
 395     if (cbString)
 396         delete[] cbString;
 397 }
 398
 399 static int FormatStringToID(char *str)
 400 {
 401     if (!strcmp(str, "TEXT"))
 402         return wxDF_TEXT;
 403
 404     return wxRegisterClipboardFormat(str);
 405 }
 406
 407 void wxClipboard::SetClipboardClient(wxClipboardClient *client, long time)
 408 {
 409     bool got_selection;
 410
 411     if (clipOwner)
 412         clipOwner->BeingReplaced();
 413     clipOwner = client;
 414     if (cbString) {
 415         delete[] cbString;
 416         cbString = NULL;
 417     }
 418
 419     if (wxOpenClipboard()) {
 420         char **formats, *data;
 421         int i;
 422         int ftype;
 423         long size;
 424
 425         formats = clipOwner->formats.ListToArray(FALSE);
 426         for (i = clipOwner->formats.Number(); i--; ) {
 427             ftype = FormatStringToID(formats[i]);
 428             data = clipOwner->GetData(formats[i], &size);
 429             if (!wxSetClipboardData(ftype, (wxObject *)data, size, 1)) {
 430                 got_selection = FALSE;
 431                 break;
 432             }
 433         }
 434
 435         if (i < 0)
 436             got_selection = wxCloseClipboard();
 437     } else
 438         got_selection = FALSE;
 439
 440     got_selection = FALSE; // Assume another process takes over
 441
 442     if (!got_selection) {
 443         clipOwner->BeingReplaced();
 444         clipOwner = NULL;
 445     }
 446 }
 447
 448 wxClipboardClient *wxClipboard::GetClipboardClient()
 449 {
 450     return clipOwner;
 451 }
 452
 453 void wxClipboard::SetClipboardString(char *str, long time)
 454 {
 455     bool got_selection;
 456
 457     if (clipOwner) {
 458         clipOwner->BeingReplaced();
 459         clipOwner = NULL;
 460     }
 461     if (cbString)
 462         delete[] cbString;
 463
 464     cbString = str;
 465
 466     if (wxOpenClipboard()) {
 467         if (!wxSetClipboardData(wxDF_TEXT, (wxObject *)str))
 468             got_selection = FALSE;
 469         else
 470             got_selection = wxCloseClipboard();
 471     } else
 472         got_selection = FALSE;
 473
 474     got_selection = FALSE; // Assume another process takes over
 475
 476     if (!got_selection) {
 477         delete[] cbString;
 478         cbString = NULL;
 479     }
 480 }
 481
 482 char *wxClipboard::GetClipboardString(long time)
 483 {
 484     char *str;
 485     long length;
 486
 487     str = GetClipboardData("TEXT", &length, time);
 488     if (!str) {
 489         str = new char[1];
 490         *str = 0;
 491     }
 492
 493     return str;
 494 }
 495
 496 char *wxClipboard::GetClipboardData(char *format, long *length, long time)
 497 {
 498     if (clipOwner)  {
 499         if (clipOwner->formats.Member(format))
 500             return clipOwner->GetData(format, length);
 501         else
 502             return NULL;
 503     } else if (cbString) {
 504         if (!strcmp(format, "TEXT"))
 505             return copystring(cbString);
 506         else
 507             return NULL;
 508     } else {
 509         if (wxOpenClipboard()) {
 510             receivedString = (char *)wxGetClipboardData(FormatStringToID(format),
 511                 length);
 512             wxCloseClipboard();
 513         } else
 514             receivedString = NULL;
 515
 516         return receivedString;
 517     }
 518 }
 519 #endif
 520
 521 #endif // wxUSE_CLIPBOARD