src/mac/carbon/clipbrd.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        clipbrd.cpp
// Purpose:     Clipboard functionality
// Author:      AUTHOR
// Modified by:
// Created:     ??/??/98
// RCS-ID:      $Id$
// Copyright:   (c) AUTHOR
// Licence:   	wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#ifdef __GNUG__
#pragma implementation
#pragma implementation "clipbrd.h"
#endif

#include "wx/app.h"
#include "wx/frame.h"
#include "wx/bitmap.h"
#include "wx/utils.h"
#include "wx/metafile.h"
#include "wx/clipbrd.h"
#include "wx/intl.h"

#define wxUSE_DATAOBJ 1

#include <string.h>

// open/close

bool clipboard_opened = false ;

bool wxOpenClipboard()
{
	clipboard_opened = true ;
    return TRUE;
}

bool wxCloseClipboard()
{
	clipboard_opened = false ;
    return TRUE;
}

bool wxIsClipboardOpened()
{
     return clipboard_opened;
}

bool wxEmptyClipboard()
{

#if TARGET_CARBON
	OSStatus err ;
	err = ClearCurrentScrap( );
#else
	OSErr err ;
	err = ZeroScrap( );
#endif
	if ( err )
	{
        wxLogSysError(_("Failed to empty the clipboard."));
		return FALSE ;
	}
    return TRUE;
}

// get/set data

// clipboard formats

bool wxIsClipboardFormatAvailable(wxDataFormat dataFormat)
{
#if TARGET_CARBON
	OSStatus err = noErr;
	ScrapRef scrapRef;

	err = GetCurrentScrap( &scrapRef );
	if ( err != noTypeErr && err != memFullErr )
	{
		ScrapFlavorFlags	flavorFlags;
		Size				byteCount;

		if (( err = GetScrapFlavorFlags( scrapRef, dataFormat.GetFormatId(), &flavorFlags )) == noErr)
		{
			if (( err = GetScrapFlavorSize( scrapRef, dataFormat.GetFormatId(), &byteCount )) == noErr)
			{
				return TRUE ;
			}
		}
	}
	return FALSE;

#else
	long offset ;
	Handle datahandle = NewHandle(0) ;
	HLock( datahandle ) ;
	GetScrap( datahandle , dataFormat.GetFormatId() , &offset ) ;
	HUnlock( datahandle ) ;
	bool hasData = GetHandleSize( datahandle ) > 0 ;
	DisposeHandle( datahandle ) ;
	return hasData ;
#endif
}

bool wxSetClipboardData(wxDataFormat dataFormat,const void *data,int width , int height)
{
#if !TARGET_CARBON
	OSErr err = noErr ;
#else
	OSStatus err = noErr ;
#endif

    switch (dataFormat.GetType())
    {
        case wxDF_BITMAP:
            {
            	/*
                wxBitmap *bitmap = (wxBitmap *)data;

                HDC hdcMem = CreateCompatibleDC((HDC) NULL);
                HDC hdcSrc = CreateCompatibleDC((HDC) NULL);
                HBITMAP old = (HBITMAP)
                    ::SelectObject(hdcSrc, (HBITMAP)bitmap->GetHBITMAP());
                HBITMAP hBitmap = CreateCompatibleBitmap(hdcSrc,
                                                         bitmap->GetWidth(),
                                                         bitmap->GetHeight());
                if (!hBitmap)
                {
                    SelectObject(hdcSrc, old);
                    DeleteDC(hdcMem);
                    DeleteDC(hdcSrc);
                    return FALSE;
                }

                HBITMAP old1 = (HBITMAP) SelectObject(hdcMem, hBitmap);
                BitBlt(hdcMem, 0, 0, bitmap->GetWidth(), bitmap->GetHeight(),
                       hdcSrc, 0, 0, SRCCOPY);

                // Select new bitmap out of memory DC
                SelectObject(hdcMem, old1);

                // Set the data
                handle = ::SetClipboardData(CF_BITMAP, hBitmap);

                // Clean up
                SelectObject(hdcSrc, old);
                DeleteDC(hdcSrc);
                DeleteDC(hdcMem);
                */
                break;
            }

        case wxDF_DIB:
            {
            	/*
#if wxUSE_IMAGE_LOADING_IN_MSW
                wxBitmap *bitmap = (wxBitmap *)data;
                HBITMAP hBitmap = (HBITMAP)bitmap->GetHBITMAP();
                // NULL palette means to use the system one
                HANDLE hDIB = wxBitmapToDIB(hBitmap, (HPALETTE)NULL);
                handle = SetClipboardData(CF_DIB, hDIB);
#endif // wxUSE_IMAGE_LOADING_IN_MSW
*/
                break;
            }

#if wxUSE_METAFILE
        case wxDF_METAFILE:
            {
                wxMetafile *wxMF = (wxMetafile *)data;
				PicHandle pict = wxMF->GetHMETAFILE() ;
				HLock( (Handle) pict ) ;
#if !TARGET_CARBON
				err = PutScrap( GetHandleSize(  (Handle) pict ) , 'PICT' , *pict ) ;
#else
				ScrapRef	scrap;
				err = GetCurrentScrap (&scrap);
				if ( !err )
				{
					err = PutScrapFlavor (scrap, 'PICT', 0, GetHandleSize((Handle) pict), *pict);
				}
#endif
				HUnlock(  (Handle) pict ) ;
                break;
            }
#endif
        case wxDF_SYLK:
        case wxDF_DIF:
        case wxDF_TIFF:
        case wxDF_PALETTE:
        default:
            {
                wxLogError(_("Unsupported clipboard format."));
                return FALSE;
            }

        case wxDF_OEMTEXT:
            dataFormat = wxDF_TEXT;
            // fall through

        case wxDF_TEXT:
            {
            	wxString mac ;
            	if ( wxApp::s_macDefaultEncodingIsPC )
            	{
            		mac = wxMacMakeMacStringFromPC((char *)data) ;
            	}
            	else
            	{
            		mac = (char *)data ;
            	}
#if !TARGET_CARBON
				err = PutScrap( mac.Length() , 'TEXT' , mac.c_str() ) ;
#else
				ScrapRef	scrap;
				err = GetCurrentScrap (&scrap);
				if ( !err )
				{
					err = PutScrapFlavor (scrap, 'TEXT', 0, mac.Length(), mac.c_str());
				}
#endif
                break;
            }
    }

    if ( err )
    {
        wxLogSysError(_("Failed to set clipboard data."));

        return FALSE;
    }

    return TRUE;
}

wxDataFormat wxEnumClipboardFormats(wxDataFormat dataFormat)
{
    return wxDataFormat();
}

int  wxRegisterClipboardFormat(wxChar *formatName)
{
    return 0;
}

bool wxGetClipboardFormatName(wxDataFormat dataFormat, wxChar *formatName, int maxCount)
{
    return FALSE;
}

void *wxGetClipboardData(wxDataFormat dataFormat, long *len)
{
#if !TARGET_CARBON
	OSErr err = noErr ;
#else
	OSStatus err = noErr ;
#endif
  void * data = NULL ;

    switch (dataFormat.GetType())
    {
        case wxDF_BITMAP:
        case wxDF_DIB:
#if wxUSE_METAFILE
        case wxDF_METAFILE:
#endif
        case wxDF_SYLK:
        case wxDF_DIF:
        case wxDF_TIFF:
        case wxDF_PALETTE:
        default:
            {
                wxLogError(_("Unsupported clipboard format."));
                return NULL;
            }

        case wxDF_OEMTEXT:
            dataFormat = wxDF_TEXT;
            // fall through

        case wxDF_TEXT:
                break;
    }

#if TARGET_CARBON
  	ScrapRef scrapRef;

  	err = GetCurrentScrap( &scrapRef );
  	if ( err != noTypeErr && err != memFullErr )
  	{
  		ScrapFlavorFlags	flavorFlags;
  		Size				byteCount;

  		if (( err = GetScrapFlavorFlags( scrapRef, dataFormat.GetFormatId(), &flavorFlags )) == noErr)
  		{
  			if (( err = GetScrapFlavorSize( scrapRef, dataFormat.GetFormatId(), &byteCount )) == noErr)
  			{
  			  if ( dataFormat.GetType() == wxDF_TEXT )
  			    byteCount++ ;

          data = new char[ byteCount ] ;
          if (( err = GetScrapFlavorData( scrapRef, dataFormat.GetFormatId(), &byteCount , data )) == noErr )
          {
            *len = byteCount ;
  			    if ( dataFormat.GetType() == wxDF_TEXT )
  		        ((char*)data)[byteCount] = 0 ;
          }
          else
          {
            delete[] data ;
            data = NULL ;
          }
	   		}
  		}
  	}

#else
  	long offset ;
  	Handle datahandle = NewHandle(0) ;
  	HLock( datahandle ) ;
  	GetScrap( datahandle , dataFormat.GetFormatId() , &offset ) ;
  	HUnlock( datahandle ) ;
  	if ( GetHandleSize( datahandle ) > 0 )
  	{
  	  long byteCount = GetHandleSize( datahandle ) ;
  	  if ( dataFormat.GetType() == wxDF_TEXT )
  	    data = new char[ byteCount + 1] ;
      else
        data = new char[ byteCount ] ;

  	  memcpy( (char*) data , (char*) *datahandle , byteCount ) ;
  	  if ( dataFormat.GetType() == wxDF_TEXT )
  		  ((char*)data)[byteCount] = 0 ;
  	  * len = byteCount ;
  	}
  	DisposeHandle( datahandle ) ;
#endif
    if ( err )
    {
        wxLogSysError(_("Failed to get clipboard data."));

        return NULL ;
    }
    if ( dataFormat.GetType() == wxDF_TEXT && wxApp::s_macDefaultEncodingIsPC )
    {
      wxMacConvertToPC((char*)data) ;
    }
    return data;
}


/*
 * Generalized clipboard implementation by Matthew Flatt
 */

IMPLEMENT_DYNAMIC_CLASS(wxClipboard, wxClipboardBase)

wxClipboard::wxClipboard()
{
    m_clearOnExit = FALSE;
}

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

void wxClipboard::Clear()
{
}

bool wxClipboard::Flush()
{
    return FALSE;
}

bool wxClipboard::Open()
{
    return wxOpenClipboard();
}

bool wxClipboard::IsOpened() const
{
    return wxIsClipboardOpened();
}

static int FormatStringToID(char *str)
{
  if (!strcmp(str, "TEXT"))
    return wxDF_TEXT;

  return wxRegisterClipboardFormat(str);
}

bool wxClipboard::SetData( wxDataObject *data )
{
    (void)wxEmptyClipboard();

    if ( data )
        return AddData(data);
    else
        return TRUE;
}

bool wxClipboard::AddData( wxDataObject *data )
{
    wxCHECK_MSG( data, FALSE, wxT("data is invalid") );

#if wxUSE_DATAOBJ
    wxCHECK_MSG( wxIsClipboardOpened(), FALSE, wxT("clipboard not open") );

    wxDataFormat format = data->GetPreferredFormat();

    switch ( format.GetType() )
    {
        case wxDF_TEXT:
        case wxDF_OEMTEXT:
        {
            wxTextDataObject* textDataObject = (wxTextDataObject*) data;
            wxString str(textDataObject->GetText());
            return wxSetClipboardData(format, str.c_str());
        }

        case wxDF_BITMAP:
        case wxDF_DIB:
        {
            wxBitmapDataObject* bitmapDataObject = (wxBitmapDataObject*) data;
            wxBitmap bitmap(bitmapDataObject->GetBitmap());
            return wxSetClipboardData(format, &bitmap);
        }

#if 0 // wxUSE_METAFILE
        case wxDF_METAFILE:
        {
            wxMetafileDataObject* metaFileDataObject =
                (wxMetafileDataObject*) data;
            wxMetafile metaFile = metaFileDataObject->GetMetafile();
            return wxSetClipboardData(wxDF_METAFILE, &metaFile,
                                      metaFileDataObject->GetWidth(),
                                      metaFileDataObject->GetHeight());
        }
#endif // wxUSE_METAFILE

        default:
 //           return wxSetClipboardData(data);
 				break ;
    }
#else // !wxUSE_DATAOBJ
#endif
    return FALSE;
}

void wxClipboard::Close()
{
    wxCloseClipboard();
}

bool wxClipboard::IsSupported( const wxDataFormat &format )
{
    return wxIsClipboardFormatAvailable(format);
}

bool wxClipboard::GetData( wxDataObject& data )
{
#if wxUSE_DATAOBJ
    wxCHECK_MSG( wxIsClipboardOpened(), FALSE, wxT("clipboard not open") );

    wxDataFormat format = data.GetPreferredFormat();
    switch ( format.GetType() )
    {
        case wxDF_TEXT:
        case wxDF_OEMTEXT:
        {
            wxTextDataObject& textDataObject = (wxTextDataObject &)data;
            char* s = (char*)wxGetClipboardData(format);
            if ( !s )
                return FALSE;

            textDataObject.SetText(s);
            delete [] s;

            return TRUE;
        }

        case wxDF_BITMAP:
        case wxDF_DIB:
        {
            wxBitmapDataObject& bitmapDataObject = (wxBitmapDataObject &)data;
            wxBitmap* bitmap = (wxBitmap *)wxGetClipboardData(format );
            if ( !bitmap )
                return FALSE;

            bitmapDataObject.SetBitmap(*bitmap);
            delete bitmap;

            return TRUE;
        }
#if 0 // wxUSE_METAFILE
        case wxDF_METAFILE:
        {
            wxMetafileDataObject& metaFileDataObject = (wxMetafileDataObject &)data;
            wxMetafile* metaFile = (wxMetafile *)wxGetClipboardData(wxDF_METAFILE);
            if ( !metaFile )
                return FALSE;

            metaFileDataObject.SetMetafile(*metaFile);
            delete metaFile;

            return TRUE;
        }
#endif // wxUSE_METAFILE
    }
#else // !wxUSE_DATAOBJ
    wxFAIL_MSG( wxT("no clipboard implementation") );
#endif
    return FALSE;
}
/*
void wxClipboard::SetClipboardClient(wxClipboardClient *client, long time)
{
  bool got_selection;

  if (clipOwner)
    clipOwner->BeingReplaced();
  clipOwner = client;
  if (cbString) {
    delete[] cbString;
    cbString = NULL;
  }

  if (wxOpenClipboard()) {
    char **formats, *data;
         int i;
    int ftype;
    long size;

    formats = clipOwner->formats.ListToArray(FALSE);
    for (i = clipOwner->formats.Number(); i--; ) {
      ftype = FormatStringToID(formats[i]);
      data = clipOwner->GetData(formats[i], &size);
      if (!wxSetClipboardData(ftype, (wxObject *)data, size, 1)) {
        got_selection = FALSE;
        break;
      }
    }

    if (i < 0)
      got_selection = wxCloseClipboard();
  } else
    got_selection = FALSE;

  got_selection = FALSE; // Assume another process takes over

  if (!got_selection) {
    clipOwner->BeingReplaced();
         clipOwner = NULL;
  }
}

wxClipboardClient *wxClipboard::GetClipboardClient()
{
  return clipOwner;
}

void wxClipboard::SetClipboardString(char *str, long time)
{
  bool got_selection;

  if (clipOwner) {
    clipOwner->BeingReplaced();
    clipOwner = NULL;
  }
  if (cbString)
    delete[] cbString;

  cbString = str;

  if (wxOpenClipboard()) {
    if (!wxSetClipboardData(wxDF_TEXT, (wxObject *)str))
      got_selection = FALSE;
    else
                got_selection = wxCloseClipboard();
  } else
    got_selection = FALSE;

  got_selection = FALSE; // Assume another process takes over

  if (!got_selection) {
    delete[] cbString;
    cbString = NULL;
  }
}
char *wxClipboard::GetClipboardString(long time)
{
  char *str;
  long length;

  str = GetClipboardData("TEXT", &length, time);
  if (!str) {
    str = new char[1];
    *str = 0;
  }

  return str;
}


char *wxClipboard::GetClipboardData(char *format, long *length, long time)
{
  if (clipOwner)  {
         if (clipOwner->formats.Member(format))
      return clipOwner->GetData(format, length);
    else
      return NULL;
  } else if (cbString) {
    if (!strcmp(format, "TEXT"))
      return copystring(cbString);
    else
      return NULL;
  } else {
    if (wxOpenClipboard()) {
      receivedString = (char *)wxGetClipboardData(FormatStringToID(format),
                                                  length);
      wxCloseClipboard();
    } else
      receivedString = NULL;

    return receivedString;
  }
}
*/
Commit	Line	Data
	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	#define wxUSE_DATAOBJ 1
	26
	27	#include <string.h>
	28
	29	// open/close
	30
	31	bool clipboard_opened = false ;
	32
	33	bool wxOpenClipboard()
	34	{
	35	clipboard_opened = true ;
	36	return TRUE;
	37	}
	38
	39	bool wxCloseClipboard()
	40	{
	41	clipboard_opened = false ;
	42	return TRUE;
	43	}
	44
	45	bool wxIsClipboardOpened()
	46	{
	47	return clipboard_opened;
	48	}
	49
	50	bool wxEmptyClipboard()
	51	{
	52
	53	#if TARGET_CARBON
	54	OSStatus err ;
	55	err = ClearCurrentScrap( );
	56	#else
	57	OSErr err ;
	58	err = ZeroScrap( );
	59	#endif
	60	if ( err )
	61	{
	62	wxLogSysError(_("Failed to empty the clipboard."));
	63	return FALSE ;
	64	}
	65	return TRUE;
	66	}
	67
	68	// get/set data
	69
	70	// clipboard formats
	71
	72	bool wxIsClipboardFormatAvailable(wxDataFormat dataFormat)
	73	{
	74	#if TARGET_CARBON
	75	OSStatus err = noErr;
	76	ScrapRef scrapRef;
	77
	78	err = GetCurrentScrap( &scrapRef );
	79	if ( err != noTypeErr && err != memFullErr )
	80	{
	81	ScrapFlavorFlags flavorFlags;
	82	Size byteCount;
	83
	84	if (( err = GetScrapFlavorFlags( scrapRef, dataFormat.GetFormatId(), &flavorFlags )) == noErr)
	85	{
	86	if (( err = GetScrapFlavorSize( scrapRef, dataFormat.GetFormatId(), &byteCount )) == noErr)
	87	{
	88	return TRUE ;
	89	}
	90	}
	91	}
	92	return FALSE;
	93
	94	#else
	95	long offset ;
	96	Handle datahandle = NewHandle(0) ;
	97	HLock( datahandle ) ;
	98	GetScrap( datahandle , dataFormat.GetFormatId() , &offset ) ;
	99	HUnlock( datahandle ) ;
	100	bool hasData = GetHandleSize( datahandle ) > 0 ;
	101	DisposeHandle( datahandle ) ;
	102	return hasData ;
	103	#endif
	104	}
	105
	106	bool wxSetClipboardData(wxDataFormat dataFormat,const void *data,int width , int height)
	107	{
	108	#if !TARGET_CARBON
	109	OSErr err = noErr ;
	110	#else
	111	OSStatus err = noErr ;
	112	#endif
	113
	114	switch (dataFormat.GetType())
	115	{
	116	case wxDF_BITMAP:
	117	{
	118	/*
	119	wxBitmap bitmap = (wxBitmap )data;
	120
	121	HDC hdcMem = CreateCompatibleDC((HDC) NULL);
	122	HDC hdcSrc = CreateCompatibleDC((HDC) NULL);
	123	HBITMAP old = (HBITMAP)
	124	::SelectObject(hdcSrc, (HBITMAP)bitmap->GetHBITMAP());
	125	HBITMAP hBitmap = CreateCompatibleBitmap(hdcSrc,
	126	bitmap->GetWidth(),
	127	bitmap->GetHeight());
	128	if (!hBitmap)
	129	{
	130	SelectObject(hdcSrc, old);
	131	DeleteDC(hdcMem);
	132	DeleteDC(hdcSrc);
	133	return FALSE;
	134	}
	135
	136	HBITMAP old1 = (HBITMAP) SelectObject(hdcMem, hBitmap);
	137	BitBlt(hdcMem, 0, 0, bitmap->GetWidth(), bitmap->GetHeight(),
	138	hdcSrc, 0, 0, SRCCOPY);
	139
	140	// Select new bitmap out of memory DC
	141	SelectObject(hdcMem, old1);
	142
	143	// Set the data
	144	handle = ::SetClipboardData(CF_BITMAP, hBitmap);
	145
	146	// Clean up
	147	SelectObject(hdcSrc, old);
	148	DeleteDC(hdcSrc);
	149	DeleteDC(hdcMem);
	150	*/
	151	break;
	152	}
	153
	154	case wxDF_DIB:
	155	{
	156	/*
	157	#if wxUSE_IMAGE_LOADING_IN_MSW
	158	wxBitmap bitmap = (wxBitmap )data;
	159	HBITMAP hBitmap = (HBITMAP)bitmap->GetHBITMAP();
	160	// NULL palette means to use the system one
	161	HANDLE hDIB = wxBitmapToDIB(hBitmap, (HPALETTE)NULL);
	162	handle = SetClipboardData(CF_DIB, hDIB);
	163	#endif // wxUSE_IMAGE_LOADING_IN_MSW
	164	*/
	165	break;
	166	}
	167
	168	#if wxUSE_METAFILE
	169	case wxDF_METAFILE:
	170	{
	171	wxMetafile wxMF = (wxMetafile )data;
	172	PicHandle pict = wxMF->GetHMETAFILE() ;
	173	HLock( (Handle) pict ) ;
	174	#if !TARGET_CARBON
	175	err = PutScrap( GetHandleSize( (Handle) pict ) , 'PICT' , *pict ) ;
	176	#else
	177	ScrapRef scrap;
	178	err = GetCurrentScrap (&scrap);
	179	if ( !err )
	180	{
	181	err = PutScrapFlavor (scrap, 'PICT', 0, GetHandleSize((Handle) pict), *pict);
	182	}
	183	#endif
	184	HUnlock( (Handle) pict ) ;
	185	break;
	186	}
	187	#endif
	188	case wxDF_SYLK:
	189	case wxDF_DIF:
	190	case wxDF_TIFF:
	191	case wxDF_PALETTE:
	192	default:
	193	{
	194	wxLogError(_("Unsupported clipboard format."));
	195	return FALSE;
	196	}
	197
	198	case wxDF_OEMTEXT:
	199	dataFormat = wxDF_TEXT;
	200	// fall through
	201
	202	case wxDF_TEXT:
	203	{
	204	wxString mac ;
	205	if ( wxApp::s_macDefaultEncodingIsPC )
	206	{
	207	mac = wxMacMakeMacStringFromPC((char *)data) ;
	208	}
	209	else
	210	{
	211	mac = (char *)data ;
	212	}
	213	#if !TARGET_CARBON
	214	err = PutScrap( mac.Length() , 'TEXT' , mac.c_str() ) ;
	215	#else
	216	ScrapRef scrap;
	217	err = GetCurrentScrap (&scrap);
	218	if ( !err )
	219	{
	220	err = PutScrapFlavor (scrap, 'TEXT', 0, mac.Length(), mac.c_str());
	221	}
	222	#endif
	223	break;
	224	}
	225	}
	226
	227	if ( err )
	228	{
	229	wxLogSysError(_("Failed to set clipboard data."));
	230
	231	return FALSE;
	232	}
	233
	234	return TRUE;
	235	}
	236
	237	wxDataFormat wxEnumClipboardFormats(wxDataFormat dataFormat)
	238	{
	239	return wxDataFormat();
	240	}
	241
	242	int wxRegisterClipboardFormat(wxChar *formatName)
	243	{
	244	return 0;
	245	}
	246
	247	bool wxGetClipboardFormatName(wxDataFormat dataFormat, wxChar *formatName, int maxCount)
	248	{
	249	return FALSE;
	250	}
	251
	252	void wxGetClipboardData(wxDataFormat dataFormat, long len)
	253	{
	254	#if !TARGET_CARBON
	255	OSErr err = noErr ;
	256	#else
	257	OSStatus err = noErr ;
	258	#endif
	259	void * data = NULL ;
	260
	261	switch (dataFormat.GetType())
	262	{
	263	case wxDF_BITMAP:
	264	case wxDF_DIB:
	265	#if wxUSE_METAFILE
	266	case wxDF_METAFILE:
	267	#endif
	268	case wxDF_SYLK:
	269	case wxDF_DIF:
	270	case wxDF_TIFF:
	271	case wxDF_PALETTE:
	272	default:
	273	{
	274	wxLogError(_("Unsupported clipboard format."));
	275	return NULL;
	276	}
	277
	278	case wxDF_OEMTEXT:
	279	dataFormat = wxDF_TEXT;
	280	// fall through
	281
	282	case wxDF_TEXT:
	283	break;
	284	}
	285
	286	#if TARGET_CARBON
	287	ScrapRef scrapRef;
	288
	289	err = GetCurrentScrap( &scrapRef );
	290	if ( err != noTypeErr && err != memFullErr )
	291	{
	292	ScrapFlavorFlags flavorFlags;
	293	Size byteCount;
	294
	295	if (( err = GetScrapFlavorFlags( scrapRef, dataFormat.GetFormatId(), &flavorFlags )) == noErr)
	296	{
	297	if (( err = GetScrapFlavorSize( scrapRef, dataFormat.GetFormatId(), &byteCount )) == noErr)
	298	{
	299	if ( dataFormat.GetType() == wxDF_TEXT )
	300	byteCount++ ;
	301
	302	data = new char[ byteCount ] ;
	303	if (( err = GetScrapFlavorData( scrapRef, dataFormat.GetFormatId(), &byteCount , data )) == noErr )
	304	{
	305	*len = byteCount ;
	306	if ( dataFormat.GetType() == wxDF_TEXT )
	307	((char*)data)[byteCount] = 0 ;
	308	}
	309	else
	310	{
	311	delete[] data ;
	312	data = NULL ;
	313	}
	314	}
	315	}
	316	}
	317
	318	#else
	319	long offset ;
	320	Handle datahandle = NewHandle(0) ;
	321	HLock( datahandle ) ;
	322	GetScrap( datahandle , dataFormat.GetFormatId() , &offset ) ;
	323	HUnlock( datahandle ) ;
	324	if ( GetHandleSize( datahandle ) > 0 )
	325	{
	326	long byteCount = GetHandleSize( datahandle ) ;
	327	if ( dataFormat.GetType() == wxDF_TEXT )
	328	data = new char[ byteCount + 1] ;
	329	else
	330	data = new char[ byteCount ] ;
	331
	332	memcpy( (char) data , (char) *datahandle , byteCount ) ;
	333	if ( dataFormat.GetType() == wxDF_TEXT )
	334	((char*)data)[byteCount] = 0 ;
	335	* len = byteCount ;
	336	}
	337	DisposeHandle( datahandle ) ;
	338	#endif
	339	if ( err )
	340	{
	341	wxLogSysError(_("Failed to get clipboard data."));
	342
	343	return NULL ;
	344	}
	345	if ( dataFormat.GetType() == wxDF_TEXT && wxApp::s_macDefaultEncodingIsPC )
	346	{
	347	wxMacConvertToPC((char*)data) ;
	348	}
	349	return data;
	350	}
	351
	352
	353	/*
	354	* Generalized clipboard implementation by Matthew Flatt
	355	*/
	356
	357	IMPLEMENT_DYNAMIC_CLASS(wxClipboard, wxClipboardBase)
	358
	359	wxClipboard::wxClipboard()
	360	{
	361	m_clearOnExit = FALSE;
	362	}
	363
	364	wxClipboard::~wxClipboard()
	365	{
	366	if ( m_clearOnExit )
	367	{
	368	Clear();
	369	}
	370	}
	371
	372	void wxClipboard::Clear()
	373	{
	374	}
	375
	376	bool wxClipboard::Flush()
	377	{
	378	return FALSE;
	379	}
	380
	381	bool wxClipboard::Open()
	382	{
	383	return wxOpenClipboard();
	384	}
	385
	386	bool wxClipboard::IsOpened() const
	387	{
	388	return wxIsClipboardOpened();
	389	}
	390
	391	static int FormatStringToID(char *str)
	392	{
	393	if (!strcmp(str, "TEXT"))
	394	return wxDF_TEXT;
	395
	396	return wxRegisterClipboardFormat(str);
	397	}
	398
	399	bool wxClipboard::SetData( wxDataObject *data )
	400	{
	401	(void)wxEmptyClipboard();
	402
	403	if ( data )
	404	return AddData(data);
	405	else
	406	return TRUE;
	407	}
	408
	409	bool wxClipboard::AddData( wxDataObject *data )
	410	{
	411	wxCHECK_MSG( data, FALSE, wxT("data is invalid") );
	412
	413	#if wxUSE_DATAOBJ
	414	wxCHECK_MSG( wxIsClipboardOpened(), FALSE, wxT("clipboard not open") );
	415
	416	wxDataFormat format = data->GetPreferredFormat();
	417
	418	switch ( format.GetType() )
	419	{
	420	case wxDF_TEXT:
	421	case wxDF_OEMTEXT:
	422	{
	423	wxTextDataObject* textDataObject = (wxTextDataObject*) data;
	424	wxString str(textDataObject->GetText());
	425	return wxSetClipboardData(format, str.c_str());
	426	}
	427
	428	case wxDF_BITMAP:
	429	case wxDF_DIB:
	430	{
	431	wxBitmapDataObject* bitmapDataObject = (wxBitmapDataObject*) data;
	432	wxBitmap bitmap(bitmapDataObject->GetBitmap());
	433	return wxSetClipboardData(format, &bitmap);
	434	}
	435
	436	#if 0 // wxUSE_METAFILE
	437	case wxDF_METAFILE:
	438	{
	439	wxMetafileDataObject* metaFileDataObject =
	440	(wxMetafileDataObject*) data;
	441	wxMetafile metaFile = metaFileDataObject->GetMetafile();
	442	return wxSetClipboardData(wxDF_METAFILE, &metaFile,
	443	metaFileDataObject->GetWidth(),
	444	metaFileDataObject->GetHeight());
	445	}
	446	#endif // wxUSE_METAFILE
	447
	448	default:
	449	// return wxSetClipboardData(data);
	450	break ;
	451	}
	452	#else // !wxUSE_DATAOBJ
	453	#endif
	454	return FALSE;
	455	}
	456
	457	void wxClipboard::Close()
	458	{
	459	wxCloseClipboard();
	460	}
	461
	462	bool wxClipboard::IsSupported( const wxDataFormat &format )
	463	{
	464	return wxIsClipboardFormatAvailable(format);
	465	}
	466
	467	bool wxClipboard::GetData( wxDataObject& data )
	468	{
	469	#if wxUSE_DATAOBJ
	470	wxCHECK_MSG( wxIsClipboardOpened(), FALSE, wxT("clipboard not open") );
	471
	472	wxDataFormat format = data.GetPreferredFormat();
	473	switch ( format.GetType() )
	474	{
	475	case wxDF_TEXT:
	476	case wxDF_OEMTEXT:
	477	{
	478	wxTextDataObject& textDataObject = (wxTextDataObject &)data;
	479	char* s = (char*)wxGetClipboardData(format);
	480	if ( !s )
	481	return FALSE;
	482
	483	textDataObject.SetText(s);
	484	delete [] s;
	485
	486	return TRUE;
	487	}
	488
	489	case wxDF_BITMAP:
	490	case wxDF_DIB:
	491	{
	492	wxBitmapDataObject& bitmapDataObject = (wxBitmapDataObject &)data;
	493	wxBitmap* bitmap = (wxBitmap *)wxGetClipboardData(format );
	494	if ( !bitmap )
	495	return FALSE;
	496
	497	bitmapDataObject.SetBitmap(*bitmap);
	498	delete bitmap;
	499
	500	return TRUE;
	501	}
	502	#if 0 // wxUSE_METAFILE
	503	case wxDF_METAFILE:
	504	{
	505	wxMetafileDataObject& metaFileDataObject = (wxMetafileDataObject &)data;
	506	wxMetafile* metaFile = (wxMetafile *)wxGetClipboardData(wxDF_METAFILE);
	507	if ( !metaFile )
	508	return FALSE;
	509
	510	metaFileDataObject.SetMetafile(*metaFile);
	511	delete metaFile;
	512
	513	return TRUE;
	514	}
	515	#endif // wxUSE_METAFILE
	516	}
	517	#else // !wxUSE_DATAOBJ
	518	wxFAIL_MSG( wxT("no clipboard implementation") );
	519	#endif
	520	return FALSE;
	521	}
	522	/*
	523	void wxClipboard::SetClipboardClient(wxClipboardClient *client, long time)
	524	{
	525	bool got_selection;
	526
	527	if (clipOwner)
	528	clipOwner->BeingReplaced();
	529	clipOwner = client;
	530	if (cbString) {
	531	delete[] cbString;
	532	cbString = NULL;
	533	}
	534
	535	if (wxOpenClipboard()) {
	536	char *formats, data;
	537	int i;
	538	int ftype;
	539	long size;
	540
	541	formats = clipOwner->formats.ListToArray(FALSE);
	542	for (i = clipOwner->formats.Number(); i--; ) {
	543	ftype = FormatStringToID(formats[i]);
	544	data = clipOwner->GetData(formats[i], &size);
	545	if (!wxSetClipboardData(ftype, (wxObject *)data, size, 1)) {
	546	got_selection = FALSE;
	547	break;
	548	}
	549	}
	550
	551	if (i < 0)
	552	got_selection = wxCloseClipboard();
	553	} else
	554	got_selection = FALSE;
	555
	556	got_selection = FALSE; // Assume another process takes over
	557
	558	if (!got_selection) {
	559	clipOwner->BeingReplaced();
	560	clipOwner = NULL;
	561	}
	562	}
	563
	564	wxClipboardClient *wxClipboard::GetClipboardClient()
	565	{
	566	return clipOwner;
	567	}
	568
	569	void wxClipboard::SetClipboardString(char *str, long time)
	570	{
	571	bool got_selection;
	572
	573	if (clipOwner) {
	574	clipOwner->BeingReplaced();
	575	clipOwner = NULL;
	576	}
	577	if (cbString)
	578	delete[] cbString;
	579
	580	cbString = str;
	581
	582	if (wxOpenClipboard()) {
	583	if (!wxSetClipboardData(wxDF_TEXT, (wxObject *)str))
	584	got_selection = FALSE;
	585	else
	586	got_selection = wxCloseClipboard();
	587	} else
	588	got_selection = FALSE;
	589
	590	got_selection = FALSE; // Assume another process takes over
	591
	592	if (!got_selection) {
	593	delete[] cbString;
	594	cbString = NULL;
	595	}
	596	}
	597	char *wxClipboard::GetClipboardString(long time)
	598	{
	599	char *str;
	600	long length;
	601
	602	str = GetClipboardData("TEXT", &length, time);
	603	if (!str) {
	604	str = new char[1];
	605	*str = 0;
	606	}
	607
	608	return str;
	609	}
	610
	611
	612	char wxClipboard::GetClipboardData(char format, long *length, long time)
	613	{
	614	if (clipOwner) {
	615	if (clipOwner->formats.Member(format))
	616	return clipOwner->GetData(format, length);
	617	else
	618	return NULL;
	619	} else if (cbString) {
	620	if (!strcmp(format, "TEXT"))
	621	return copystring(cbString);
	622	else
	623	return NULL;
	624	} else {
	625	if (wxOpenClipboard()) {
	626	receivedString = (char *)wxGetClipboardData(FormatStringToID(format),
	627	length);
	628	wxCloseClipboard();
	629	} else
	630	receivedString = NULL;
	631
	632	return receivedString;
	633	}
	634	}
	635	*/
	636