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 width, int 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 *formatName)
 217 {
 218     // Not supported
 219     return (wxDataFormat) wxDF_INVALID;
 220 }
 221
 222 bool wxGetClipboardFormatName(wxDataFormat dataFormat, char *formatName, int 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* wxTheClipboard = (wxClipboard*) NULL;
 241
 242 wxClipboard::wxClipboard()
 243 {
 244     m_open = FALSE;
 245 }
 246
 247 wxClipboard::~wxClipboard()
 248 {
 249     Clear();
 250 }
 251
 252 void wxClipboard::Clear()
 253 {
 254     wxNode* node = m_data.First();
 255     while (node)
 256     {
 257         wxDataObject* data = (wxDataObject*) node->Data();
 258         delete data;
 259         node = node->Next();
 260     }
 261     m_data.Clear();
 262 }
 263
 264 bool wxClipboard::Open()
 265 {
 266     wxCHECK_MSG( !m_open, FALSE, "clipboard already open" );
 267
 268     m_open = TRUE;
 269
 270     return wxOpenClipboard();
 271 }
 272
 273 bool wxClipboard::SetData( wxDataObject *data )
 274 {
 275     wxCHECK_MSG( data, FALSE, "data is invalid" );
 276     wxCHECK_MSG( m_open, FALSE, "clipboard not open" );
 277
 278     switch (data->GetFormat())
 279     {
 280         case wxDF_TEXT:
 281         case wxDF_OEMTEXT:
 282         {
 283             wxTextDataObject* textDataObject = (wxTextDataObject*) data;
 284             wxString str(textDataObject->GetText());
 285             return wxSetClipboardData(data->GetFormat(), (wxObject*) (const char*) str);
 286             break;
 287         }
 288 /*
 289         case wxDF_BITMAP:
 290         case wxDF_DIB:
 291         {
 292             wxBitmapDataObject* bitmapDataObject = (wxBitmapDataObject*) data;
 293             wxBitmap bitmap(bitmapDataObject->GetBitmap());
 294             return wxSetClipboardData(data->GetFormat(), & bitmap);
 295             break;
 296         }
 297 */
 298         default:
 299         {
 300             return FALSE;
 301         }
 302     }
 303
 304     return FALSE;
 305 }
 306
 307 void wxClipboard::Close()
 308 {
 309     wxCHECK_RET( m_open, "clipboard not open" );
 310
 311     m_open = FALSE;
 312     wxCloseClipboard();
 313 }
 314
 315 bool wxClipboard::IsSupported( wxDataFormat format)
 316 {
 317     return wxIsClipboardFormatAvailable(format);
 318 }
 319
 320 bool wxClipboard::GetData( wxDataObject *data )
 321 {
 322     wxCHECK_MSG( m_open, FALSE, "clipboard not open" );
 323
 324     switch (data->GetFormat())
 325     {
 326         case wxDF_TEXT:
 327         case wxDF_OEMTEXT:
 328         {
 329             wxTextDataObject* textDataObject = (wxTextDataObject*) data;
 330             char* s = (char*) wxGetClipboardData(data->GetFormat());
 331             if (s)
 332             {
 333                 textDataObject->SetText(s);
 334                 delete[] s;
 335                 return TRUE;
 336             }
 337             else
 338                 return FALSE;
 339             break;
 340         }
 341 /*
 342         case wxDF_BITMAP:
 343         case wxDF_DIB:
 344         {
 345             wxBitmapDataObject* bitmapDataObject = (wxBitmapDataObject*) data;
 346             wxBitmap* bitmap = (wxBitmap*) wxGetClipboardData(data->GetFormat());
 347             if (bitmap)
 348             {
 349                 bitmapDataObject->SetBitmap(* bitmap);
 350                 delete bitmap;
 351                 return TRUE;
 352             }
 353             else
 354                 return FALSE;
 355             break;
 356         }
 357 */
 358         default:
 359         {
 360             return FALSE;
 361         }
 362     }
 363     return FALSE;
 364 }
 365
 366 //-----------------------------------------------------------------------------
 367 // wxClipboardModule
 368 //-----------------------------------------------------------------------------
 369
 370 IMPLEMENT_DYNAMIC_CLASS(wxClipboardModule,wxModule)
 371
 372 bool wxClipboardModule::OnInit()
 373 {
 374     wxTheClipboard = new wxClipboard();
 375
 376     return TRUE;
 377 }
 378
 379 void wxClipboardModule::OnExit()
 380 {
 381     if (wxTheClipboard) delete wxTheClipboard;
 382     wxTheClipboard = (wxClipboard*) NULL;
 383 }
 384
 385
 386 #if 0
 387
 388 /*
 389 * Old clipboard implementation by Matthew Flatt
 390 */
 391
 392 wxClipboard *wxTheClipboard = NULL;
 393
 394 void wxInitClipboard()
 395 {
 396     if (!wxTheClipboard)
 397         wxTheClipboard = new wxClipboard;
 398 }
 399
 400 wxClipboard::wxClipboard()
 401 {
 402     clipOwner = NULL;
 403     cbString = NULL;
 404 }
 405
 406 wxClipboard::~wxClipboard()
 407 {
 408     if (clipOwner)
 409         clipOwner->BeingReplaced();
 410     if (cbString)
 411         delete[] cbString;
 412 }
 413
 414 static int FormatStringToID(char *str)
 415 {
 416     if (!strcmp(str, "TEXT"))
 417         return wxDF_TEXT;
 418
 419     return wxRegisterClipboardFormat(str);
 420 }
 421
 422 void wxClipboard::SetClipboardClient(wxClipboardClient *client, long time)
 423 {
 424     bool got_selection;
 425
 426     if (clipOwner)
 427         clipOwner->BeingReplaced();
 428     clipOwner = client;
 429     if (cbString) {
 430         delete[] cbString;
 431         cbString = NULL;
 432     }
 433
 434     if (wxOpenClipboard()) {
 435         char **formats, *data;
 436         int i;
 437         int ftype;
 438         long size;
 439
 440         formats = clipOwner->formats.ListToArray(FALSE);
 441         for (i = clipOwner->formats.Number(); i--; ) {
 442             ftype = FormatStringToID(formats[i]);
 443             data = clipOwner->GetData(formats[i], &size);
 444             if (!wxSetClipboardData(ftype, (wxObject *)data, size, 1)) {
 445                 got_selection = FALSE;
 446                 break;
 447             }
 448         }
 449
 450         if (i < 0)
 451             got_selection = wxCloseClipboard();
 452     } else
 453         got_selection = FALSE;
 454
 455     got_selection = FALSE; // Assume another process takes over
 456
 457     if (!got_selection) {
 458         clipOwner->BeingReplaced();
 459         clipOwner = NULL;
 460     }
 461 }
 462
 463 wxClipboardClient *wxClipboard::GetClipboardClient()
 464 {
 465     return clipOwner;
 466 }
 467
 468 void wxClipboard::SetClipboardString(char *str, long time)
 469 {
 470     bool got_selection;
 471
 472     if (clipOwner) {
 473         clipOwner->BeingReplaced();
 474         clipOwner = NULL;
 475     }
 476     if (cbString)
 477         delete[] cbString;
 478
 479     cbString = str;
 480
 481     if (wxOpenClipboard()) {
 482         if (!wxSetClipboardData(wxDF_TEXT, (wxObject *)str))
 483             got_selection = FALSE;
 484         else
 485             got_selection = wxCloseClipboard();
 486     } else
 487         got_selection = FALSE;
 488
 489     got_selection = FALSE; // Assume another process takes over
 490
 491     if (!got_selection) {
 492         delete[] cbString;
 493         cbString = NULL;
 494     }
 495 }
 496
 497 char *wxClipboard::GetClipboardString(long time)
 498 {
 499     char *str;
 500     long length;
 501
 502     str = GetClipboardData("TEXT", &length, time);
 503     if (!str) {
 504         str = new char[1];
 505         *str = 0;
 506     }
 507
 508     return str;
 509 }
 510
 511 char *wxClipboard::GetClipboardData(char *format, long *length, long time)
 512 {
 513     if (clipOwner)  {
 514         if (clipOwner->formats.Member(format))
 515             return clipOwner->GetData(format, length);
 516         else
 517             return NULL;
 518     } else if (cbString) {
 519         if (!strcmp(format, "TEXT"))
 520             return copystring(cbString);
 521         else
 522             return NULL;
 523     } else {
 524         if (wxOpenClipboard()) {
 525             receivedString = (char *)wxGetClipboardData(FormatStringToID(format),
 526                 length);
 527             wxCloseClipboard();
 528         } else
 529             receivedString = NULL;
 530
 531         return receivedString;
 532     }
 533 }
 534 #endif
 535
 536 #endif // wxUSE_CLIPBOARD