src/mac/carbon/clipbrd.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        clipbrd.cpp
   3 // Purpose:     Clipboard functionality
   4 // Author:      AUTHOR
   5 // Modified by:
   6 // Created:     ??/??/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) AUTHOR
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13 #pragma implementation
  14 #pragma implementation "clipbrd.h"
  15 #endif
  16
  17 #include "wx/app.h"
  18 #include "wx/frame.h"
  19 #include "wx/bitmap.h"
  20 #include "wx/utils.h"
  21 #include "wx/metafile.h"
  22 #include "wx/clipbrd.h"
  23 #include "wx/intl.h"
  24
  25 #include "wx/mac/private.h"
  26 #ifndef __DARWIN__
  27 #include <Scrap.h>
  28 #endif
  29
  30 #define wxUSE_DATAOBJ 1
  31
  32 #include <string.h>
  33
  34 // the trace mask we use with wxLogTrace() - call
  35 // wxLog::AddTraceMask(TRACE_CLIPBOARD) to enable the trace messages from here
  36 // (there will be a *lot* of them!)
  37 static const wxChar *TRACE_CLIPBOARD = _T("clipboard");
  38
  39 void *wxGetClipboardData(wxDataFormat dataFormat, long *len)
  40 {
  41 #if !TARGET_CARBON
  42         OSErr err = noErr ;
  43 #else
  44         OSStatus err = noErr ;
  45 #endif
  46   void * data = NULL ;
  47
  48     switch (dataFormat.GetType())
  49     {
  50         case wxDF_OEMTEXT:
  51             dataFormat = wxDF_TEXT;
  52             // fall through
  53
  54         case wxDF_TEXT:
  55                 break;
  56         default:
  57             {
  58                 wxLogError(_("Unsupported clipboard format."));
  59                 return NULL;
  60             }
  61     }
  62
  63 #if TARGET_CARBON
  64         ScrapRef scrapRef;
  65
  66         err = GetCurrentScrap( &scrapRef );
  67         if ( err != noTypeErr && err != memFullErr )
  68         {
  69                 ScrapFlavorFlags        flavorFlags;
  70                 Size                            byteCount;
  71
  72                 if (( err = GetScrapFlavorFlags( scrapRef, dataFormat.GetFormatId(), &flavorFlags )) == noErr)
  73                 {
  74                         if (( err = GetScrapFlavorSize( scrapRef, dataFormat.GetFormatId(), &byteCount )) == noErr)
  75                         {
  76                           if ( dataFormat.GetType() == wxDF_TEXT )
  77                             byteCount++ ;
  78
  79           data = new char[ byteCount ] ;
  80           if (( err = GetScrapFlavorData( scrapRef, dataFormat.GetFormatId(), &byteCount , data )) == noErr )
  81           {
  82             *len = byteCount ;
  83                             if ( dataFormat.GetType() == wxDF_TEXT )
  84                         ((char*)data)[byteCount] = 0 ;
  85           }
  86           else
  87           {
  88             delete[] ((char *)data) ;
  89             data = NULL ;
  90           }
  91                         }
  92                 }
  93         }
  94
  95 #else
  96         long offset ;
  97         Handle datahandle = NewHandle(0) ;
  98         HLock( datahandle ) ;
  99         GetScrap( datahandle , dataFormat.GetFormatId() , &offset ) ;
 100         HUnlock( datahandle ) ;
 101         if ( GetHandleSize( datahandle ) > 0 )
 102         {
 103           long byteCount = GetHandleSize( datahandle ) ;
 104           if ( dataFormat.GetType() == wxDF_TEXT )
 105             data = new char[ byteCount + 1] ;
 106       else
 107         data = new char[ byteCount ] ;
 108
 109           memcpy( (char*) data , (char*) *datahandle , byteCount ) ;
 110           if ( dataFormat.GetType() == wxDF_TEXT )
 111                   ((char*)data)[byteCount] = 0 ;
 112           * len = byteCount ;
 113         }
 114         DisposeHandle( datahandle ) ;
 115 #endif
 116     if ( err )
 117     {
 118         wxLogSysError(_("Failed to get clipboard data."));
 119
 120         return NULL ;
 121     }
 122     if ( dataFormat.GetType() == wxDF_TEXT && wxApp::s_macDefaultEncodingIsPC )
 123     {
 124       wxMacConvertToPC((char*)data) ;
 125     }
 126     return data;
 127 }
 128
 129
 130 /*
 131  * Generalized clipboard implementation by Matthew Flatt
 132  */
 133
 134 IMPLEMENT_DYNAMIC_CLASS(wxClipboard, wxClipboardBase)
 135
 136 wxClipboard::wxClipboard()
 137 {
 138   m_open = false ;
 139   m_data = NULL ;
 140 }
 141
 142 wxClipboard::~wxClipboard()
 143 {
 144     if (m_data)
 145     {
 146         delete m_data;
 147         m_data = (wxDataObject*) NULL;
 148     }
 149 }
 150
 151 void wxClipboard::Clear()
 152 {
 153     if (m_data)
 154     {
 155         delete m_data;
 156         m_data = (wxDataObject*) NULL;
 157     }
 158 #if TARGET_CARBON
 159         OSStatus err ;
 160         err = ClearCurrentScrap( );
 161 #else
 162         OSErr err ;
 163         err = ZeroScrap( );
 164 #endif
 165         if ( err )
 166         {
 167         wxLogSysError(_("Failed to empty the clipboard."));
 168         }
 169 }
 170
 171 bool wxClipboard::Flush()
 172 {
 173     return FALSE;
 174 }
 175
 176 bool wxClipboard::Open()
 177 {
 178     wxCHECK_MSG( !m_open, FALSE, wxT("clipboard already open") );
 179     m_open = true ;
 180     return true ;
 181 }
 182
 183 bool wxClipboard::IsOpened() const
 184 {
 185     return m_open;
 186 }
 187
 188 bool wxClipboard::SetData( wxDataObject *data )
 189 {
 190     wxCHECK_MSG( m_open, FALSE, wxT("clipboard not open") );
 191
 192     wxCHECK_MSG( data, FALSE, wxT("data is invalid") );
 193
 194     Clear();
 195
 196     return AddData( data );
 197 }
 198
 199 bool wxClipboard::AddData( wxDataObject *data )
 200 {
 201     wxCHECK_MSG( m_open, FALSE, wxT("clipboard not open") );
 202
 203     wxCHECK_MSG( data, FALSE, wxT("data is invalid") );
 204
 205     wxDataFormat format = data->GetPreferredFormat();
 206
 207     /* we can only store one wxDataObject */
 208     Clear();
 209
 210     m_data = data;
 211
 212     /* get formats from wxDataObjects */
 213     wxDataFormat *array = new wxDataFormat[ m_data->GetFormatCount() ];
 214     m_data->GetAllFormats( array );
 215
 216     for (size_t i = 0; i < m_data->GetFormatCount(); i++)
 217     {
 218         wxLogTrace( TRACE_CLIPBOARD,
 219                     wxT("wxClipboard now supports atom %s"),
 220                     array[i].GetId().c_str() );
 221
 222 #if !TARGET_CARBON
 223               OSErr err = noErr ;
 224 #else
 225               OSStatus err = noErr ;
 226 #endif
 227
 228        switch ( array[i].GetType() )
 229        {
 230            case wxDF_TEXT:
 231            case wxDF_OEMTEXT:
 232            {
 233                wxTextDataObject* textDataObject = (wxTextDataObject*) data;
 234                wxString str(textDataObject->GetText());
 235                 wxString mac ;
 236                 if ( wxApp::s_macDefaultEncodingIsPC )
 237                 {
 238                         mac = wxMacMakeMacStringFromPC(textDataObject->GetText()) ;
 239                 }
 240                 else
 241                 {
 242                         mac = textDataObject->GetText() ;
 243                 }
 244         #if !TARGET_CARBON
 245                                         err = PutScrap( mac.Length() , 'TEXT' , mac.c_str() ) ;
 246         #else
 247                                         ScrapRef        scrap;
 248                                         err = GetCurrentScrap (&scrap);
 249                                         if ( !err )
 250                                         {
 251                                                 err = PutScrapFlavor (scrap, 'TEXT', 0, mac.Length(), mac.c_str());
 252                                         }
 253         #endif
 254            }
 255
 256 #if wxUSE_DRAG_AND_DROP
 257         case wxDF_METAFILE:
 258            {
 259               wxMetafileDataObject* metaFileDataObject =
 260                 (wxMetafileDataObject*) data;
 261               wxMetafile metaFile = metaFileDataObject->GetMetafile();
 262                                 PicHandle pict = (PicHandle) metaFile.GetHMETAFILE() ;
 263                                 HLock( (Handle) pict ) ;
 264       #if !TARGET_CARBON
 265                                 err = PutScrap( GetHandleSize(  (Handle) pict ) , 'PICT' , *pict ) ;
 266       #else
 267                                 ScrapRef        scrap;
 268                                 err = GetCurrentScrap (&scrap);
 269                                 if ( !err )
 270                                 {
 271                                         err = PutScrapFlavor (scrap, 'PICT', 0, GetHandleSize((Handle) pict), *pict);
 272                                 }
 273       #endif
 274                                 HUnlock(  (Handle) pict ) ;
 275            }
 276 #endif
 277            case wxDF_BITMAP:
 278            case wxDF_DIB:
 279            default:
 280                         break ;
 281        }
 282
 283     }
 284
 285     delete[] array;
 286
 287     return true ;
 288 }
 289
 290 void wxClipboard::Close()
 291 {
 292     m_open = false ;
 293 }
 294
 295 bool wxClipboard::IsSupported( const wxDataFormat &dataFormat )
 296 {
 297   if ( m_data )
 298   {
 299     return m_data->IsSupported( dataFormat ) ;
 300   }
 301 #if TARGET_CARBON
 302         OSStatus err = noErr;
 303         ScrapRef scrapRef;
 304
 305         err = GetCurrentScrap( &scrapRef );
 306         if ( err != noTypeErr && err != memFullErr )
 307         {
 308                 ScrapFlavorFlags        flavorFlags;
 309                 Size                            byteCount;
 310
 311                 if (( err = GetScrapFlavorFlags( scrapRef, dataFormat.GetFormatId(), &flavorFlags )) == noErr)
 312                 {
 313                         if (( err = GetScrapFlavorSize( scrapRef, dataFormat.GetFormatId(), &byteCount )) == noErr)
 314                         {
 315                                 return TRUE ;
 316                         }
 317                 }
 318         }
 319         return FALSE;
 320
 321 #else
 322         long offset ;
 323         Handle datahandle = NewHandle(0) ;
 324         HLock( datahandle ) ;
 325         GetScrap( datahandle , dataFormat.GetFormatId() , &offset ) ;
 326         HUnlock( datahandle ) ;
 327         bool hasData = GetHandleSize( datahandle ) > 0 ;
 328         DisposeHandle( datahandle ) ;
 329         return hasData ;
 330 #endif
 331 }
 332
 333 bool wxClipboard::GetData( wxDataObject& data )
 334 {
 335     wxCHECK_MSG( m_open, FALSE, wxT("clipboard not open") );
 336
 337     int formatcount = data.GetFormatCount() + 1 ;
 338     wxDataFormat *array = new wxDataFormat[ formatcount  ];
 339     array[0] = data.GetPreferredFormat();
 340     data.GetAllFormats( &array[1] );
 341
 342     bool transferred = false ;
 343
 344     if ( m_data )
 345     {
 346       for (size_t i = 0; !transferred && i < formatcount ; i++)
 347       {
 348           wxDataFormat format = array[i] ;
 349           if ( m_data->IsSupported( format ) )
 350           {
 351             int size = m_data->GetDataSize( format );
 352             transferred = true ;
 353
 354             if (size == 0)
 355             {
 356               data.SetData(format , 0 , 0 ) ;
 357             }
 358             else
 359             {
 360               char *d = new char[size];
 361               m_data->GetDataHere( format , (void*) d );
 362               data.SetData( format , size , d ) ;
 363               delete[] d ;
 364             }
 365           }
 366        }
 367     }
 368     /* get formats from wxDataObjects */
 369     if ( !transferred )
 370     {
 371       for (size_t i = 0; !transferred && i < formatcount ; i++)
 372       {
 373           wxDataFormat format = array[i] ;
 374
 375           switch ( format.GetType() )
 376           {
 377               case wxDF_TEXT:
 378               case wxDF_OEMTEXT:
 379               {
 380                   long len ;
 381                   char* s = (char*)wxGetClipboardData(format, &len );
 382                   if ( s )
 383                   {
 384                     data.SetData( format , len , s ) ;
 385                     delete [] s;
 386
 387                     transferred = true ;
 388                   }
 389               }
 390               default :
 391                 break ;
 392           }
 393        }
 394     }
 395
 396     delete[] array ;
 397     return transferred ;
 398 }