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 ;
	if ( GetScrap( NULL , dataFormat.GetFormatId() , &offset ) > 0 )
	{
		return TRUE ;
	}
     return FALSE;
#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)
{
    return NULL;
}


/*
 * 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 )
    {
        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	if ( GetScrap( NULL , dataFormat.GetFormatId() , &offset ) > 0 )
	97	{
	98	return TRUE ;
	99	}
	100	return FALSE;
	101	#endif
	102	}
	103
	104	bool wxSetClipboardData(wxDataFormat dataFormat,const void *data,int width , int height)
	105	{
	106	#if !TARGET_CARBON
	107	OSErr err = noErr ;
	108	#else
	109	OSStatus err = noErr ;
	110	#endif
	111
	112	switch (dataFormat.GetType())
	113	{
	114	case wxDF_BITMAP:
	115	{
	116	/*
	117	wxBitmap bitmap = (wxBitmap )data;
	118
	119	HDC hdcMem = CreateCompatibleDC((HDC) NULL);
	120	HDC hdcSrc = CreateCompatibleDC((HDC) NULL);
	121	HBITMAP old = (HBITMAP)
	122	::SelectObject(hdcSrc, (HBITMAP)bitmap->GetHBITMAP());
	123	HBITMAP hBitmap = CreateCompatibleBitmap(hdcSrc,
	124	bitmap->GetWidth(),
	125	bitmap->GetHeight());
	126	if (!hBitmap)
	127	{
	128	SelectObject(hdcSrc, old);
	129	DeleteDC(hdcMem);
	130	DeleteDC(hdcSrc);
	131	return FALSE;
	132	}
	133
	134	HBITMAP old1 = (HBITMAP) SelectObject(hdcMem, hBitmap);
	135	BitBlt(hdcMem, 0, 0, bitmap->GetWidth(), bitmap->GetHeight(),
	136	hdcSrc, 0, 0, SRCCOPY);
	137
	138	// Select new bitmap out of memory DC
	139	SelectObject(hdcMem, old1);
	140
	141	// Set the data
	142	handle = ::SetClipboardData(CF_BITMAP, hBitmap);
	143
	144	// Clean up
	145	SelectObject(hdcSrc, old);
	146	DeleteDC(hdcSrc);
	147	DeleteDC(hdcMem);
	148	*/
	149	break;
	150	}
	151
	152	case wxDF_DIB:
	153	{
	154	/*
	155	#if wxUSE_IMAGE_LOADING_IN_MSW
	156	wxBitmap bitmap = (wxBitmap )data;
	157	HBITMAP hBitmap = (HBITMAP)bitmap->GetHBITMAP();
	158	// NULL palette means to use the system one
	159	HANDLE hDIB = wxBitmapToDIB(hBitmap, (HPALETTE)NULL);
	160	handle = SetClipboardData(CF_DIB, hDIB);
	161	#endif // wxUSE_IMAGE_LOADING_IN_MSW
	162	*/
	163	break;
	164	}
	165
	166	#if wxUSE_METAFILE
	167	case wxDF_METAFILE:
	168	{
	169	wxMetafile wxMF = (wxMetafile )data;
	170	PicHandle pict = wxMF->GetHMETAFILE() ;
	171	HLock( (Handle) pict ) ;
	172	#if !TARGET_CARBON
	173	err = PutScrap( GetHandleSize( (Handle) pict ) , 'PICT' , *pict ) ;
	174	#else
	175	ScrapRef scrap;
	176	err = GetCurrentScrap (&scrap);
	177	if ( !err )
	178	{
	179	err = PutScrapFlavor (scrap, 'PICT', 0, GetHandleSize((Handle) pict), *pict);
	180	}
	181	#endif
	182	HUnlock( (Handle) pict ) ;
	183	break;
	184	}
	185	#endif
	186	case wxDF_SYLK:
	187	case wxDF_DIF:
	188	case wxDF_TIFF:
	189	case wxDF_PALETTE:
	190	default:
	191	{
	192	wxLogError(_("Unsupported clipboard format."));
	193	return FALSE;
	194	}
	195
	196	case wxDF_OEMTEXT:
	197	dataFormat = wxDF_TEXT;
	198	// fall through
	199
	200	case wxDF_TEXT:
	201	{
	202	wxString mac ;
	203	if ( wxApp::s_macDefaultEncodingIsPC )
	204	{
	205	mac = wxMacMakeMacStringFromPC((char *)data) ;
	206	}
	207	else
	208	{
	209	mac = (char *)data ;
	210	}
	211	#if !TARGET_CARBON
	212	err = PutScrap( mac.Length() , 'TEXT' , mac.c_str() ) ;
	213	#else
	214	ScrapRef scrap;
	215	err = GetCurrentScrap (&scrap);
	216	if ( !err )
	217	{
	218	err = PutScrapFlavor (scrap, 'TEXT', 0, mac.Length(), mac.c_str());
	219	}
	220	#endif
	221	break;
	222	}
	223	}
	224
	225	if ( err )
	226	{
	227	wxLogSysError(_("Failed to set clipboard data."));
	228
	229	return FALSE;
	230	}
	231
	232	return TRUE;
	233	}
	234
	235	wxDataFormat wxEnumClipboardFormats(wxDataFormat dataFormat)
	236	{
	237	return wxDataFormat();
	238	}
	239
	240	int wxRegisterClipboardFormat(wxChar *formatName)
	241	{
	242	return 0;
	243	}
	244
	245	bool wxGetClipboardFormatName(wxDataFormat dataFormat, wxChar *formatName, int maxCount)
	246	{
	247	return FALSE;
	248	}
	249
	250	void wxGetClipboardData(wxDataFormat dataFormat, long len)
	251	{
	252	return NULL;
	253	}
	254
	255
	256	/*
	257	* Generalized clipboard implementation by Matthew Flatt
	258	*/
	259
	260	IMPLEMENT_DYNAMIC_CLASS(wxClipboard, wxClipboardBase)
	261
	262	wxClipboard::wxClipboard()
	263	{
	264	m_clearOnExit = FALSE;
	265	}
	266
	267	wxClipboard::~wxClipboard()
	268	{
	269	if ( m_clearOnExit )
	270	{
	271	Clear();
	272	}
	273	}
	274
	275	void wxClipboard::Clear()
	276	{
	277	}
	278
	279	bool wxClipboard::Flush()
	280	{
	281	return FALSE;
	282	}
	283
	284	bool wxClipboard::Open()
	285	{
	286	return wxOpenClipboard();
	287	}
	288
	289	bool wxClipboard::IsOpened() const
	290	{
	291	return wxIsClipboardOpened();
	292	}
	293
	294	static int FormatStringToID(char *str)
	295	{
	296	if (!strcmp(str, "TEXT"))
	297	return wxDF_TEXT;
	298
	299	return wxRegisterClipboardFormat(str);
	300	}
	301
	302	bool wxClipboard::SetData( wxDataObject *data )
	303	{
	304	(void)wxEmptyClipboard();
	305
	306	if ( data )
	307	return AddData(data);
	308	else
	309	return TRUE;
	310	}
	311
	312	bool wxClipboard::AddData( wxDataObject *data )
	313	{
	314	wxCHECK_MSG( data, FALSE, wxT("data is invalid") );
	315
	316	#if wxUSE_DATAOBJ
	317	wxCHECK_MSG( wxIsClipboardOpened(), FALSE, wxT("clipboard not open") );
	318
	319	wxDataFormat format = data->GetPreferredFormat();
	320
	321	switch ( format.GetType() )
	322	{
	323	case wxDF_TEXT:
	324	case wxDF_OEMTEXT:
	325	{
	326	wxTextDataObject* textDataObject = (wxTextDataObject*) data;
	327	wxString str(textDataObject->GetText());
	328	return wxSetClipboardData(format, str.c_str());
	329	}
	330
	331	case wxDF_BITMAP:
	332	case wxDF_DIB:
	333	{
	334	wxBitmapDataObject* bitmapDataObject = (wxBitmapDataObject*) data;
	335	wxBitmap bitmap(bitmapDataObject->GetBitmap());
	336	return wxSetClipboardData(format, &bitmap);
	337	}
	338
	339	#if 0 // wxUSE_METAFILE
	340	case wxDF_METAFILE:
	341	{
	342	wxMetafileDataObject* metaFileDataObject =
	343	(wxMetafileDataObject*) data;
	344	wxMetafile metaFile = metaFileDataObject->GetMetafile();
	345	return wxSetClipboardData(wxDF_METAFILE, &metaFile,
	346	metaFileDataObject->GetWidth(),
	347	metaFileDataObject->GetHeight());
	348	}
	349	#endif // wxUSE_METAFILE
	350
	351	default:
	352	// return wxSetClipboardData(data);
	353	break ;
	354	}
	355	#else // !wxUSE_DATAOBJ
	356	#endif
	357	return FALSE;
	358	}
	359
	360	void wxClipboard::Close()
	361	{
	362	wxCloseClipboard();
	363	}
	364
	365	bool wxClipboard::IsSupported( const wxDataFormat &format )
	366	{
	367	return wxIsClipboardFormatAvailable(format);
	368	}
	369
	370	bool wxClipboard::GetData( wxDataObject& data )
	371	{
	372	#if wxUSE_DATAOBJ
	373	wxCHECK_MSG( wxIsClipboardOpened(), FALSE, wxT("clipboard not open") );
	374
	375	wxDataFormat format = data.GetPreferredFormat();
	376	switch ( format )
	377	{
	378	case wxDF_TEXT:
	379	case wxDF_OEMTEXT:
	380	{
	381	wxTextDataObject& textDataObject = (wxTextDataObject &)data;
	382	char* s = (char*)wxGetClipboardData(format);
	383	if ( !s )
	384	return FALSE;
	385
	386	textDataObject.SetText(s);
	387	delete [] s;
	388
	389	return TRUE;
	390	}
	391
	392	case wxDF_BITMAP:
	393	case wxDF_DIB:
	394	{
	395	wxBitmapDataObject& bitmapDataObject = (wxBitmapDataObject &)data;
	396	wxBitmap* bitmap = (wxBitmap *)wxGetClipboardData(format );
	397	if ( !bitmap )
	398	return FALSE;
	399
	400	bitmapDataObject.SetBitmap(*bitmap);
	401	delete bitmap;
	402
	403	return TRUE;
	404	}
	405	#if 0 // wxUSE_METAFILE
	406	case wxDF_METAFILE:
	407	{
	408	wxMetafileDataObject& metaFileDataObject = (wxMetafileDataObject &)data;
	409	wxMetafile* metaFile = (wxMetafile *)wxGetClipboardData(wxDF_METAFILE);
	410	if ( !metaFile )
	411	return FALSE;
	412
	413	metaFileDataObject.SetMetafile(*metaFile);
	414	delete metaFile;
	415
	416	return TRUE;
	417	}
	418	#endif // wxUSE_METAFILE
	419	}
	420	#else // !wxUSE_DATAOBJ
	421	wxFAIL_MSG( wxT("no clipboard implementation") );
	422	#endif
	423	return FALSE;
	424	}
	425	/*
	426	void wxClipboard::SetClipboardClient(wxClipboardClient *client, long time)
	427	{
	428	bool got_selection;
	429
	430	if (clipOwner)
	431	clipOwner->BeingReplaced();
	432	clipOwner = client;
	433	if (cbString) {
	434	delete[] cbString;
	435	cbString = NULL;
	436	}
	437
	438	if (wxOpenClipboard()) {
	439	char *formats, data;
	440	int i;
	441	int ftype;
	442	long size;
	443
	444	formats = clipOwner->formats.ListToArray(FALSE);
	445	for (i = clipOwner->formats.Number(); i--; ) {
	446	ftype = FormatStringToID(formats[i]);
	447	data = clipOwner->GetData(formats[i], &size);
	448	if (!wxSetClipboardData(ftype, (wxObject *)data, size, 1)) {
	449	got_selection = FALSE;
	450	break;
	451	}
	452	}
	453
	454	if (i < 0)
	455	got_selection = wxCloseClipboard();
	456	} else
	457	got_selection = FALSE;
	458
	459	got_selection = FALSE; // Assume another process takes over
	460
	461	if (!got_selection) {
	462	clipOwner->BeingReplaced();
	463	clipOwner = NULL;
	464	}
	465	}
	466
	467	wxClipboardClient *wxClipboard::GetClipboardClient()
	468	{
	469	return clipOwner;
	470	}
	471
	472	void wxClipboard::SetClipboardString(char *str, long time)
	473	{
	474	bool got_selection;
	475
	476	if (clipOwner) {
	477	clipOwner->BeingReplaced();
	478	clipOwner = NULL;
	479	}
	480	if (cbString)
	481	delete[] cbString;
	482
	483	cbString = str;
	484
	485	if (wxOpenClipboard()) {
	486	if (!wxSetClipboardData(wxDF_TEXT, (wxObject *)str))
	487	got_selection = FALSE;
	488	else
	489	got_selection = wxCloseClipboard();
	490	} else
	491	got_selection = FALSE;
	492
	493	got_selection = FALSE; // Assume another process takes over
	494
	495	if (!got_selection) {
	496	delete[] cbString;
	497	cbString = NULL;
	498	}
	499	}
	500	char *wxClipboard::GetClipboardString(long time)
	501	{
	502	char *str;
	503	long length;
	504
	505	str = GetClipboardData("TEXT", &length, time);
	506	if (!str) {
	507	str = new char[1];
	508	*str = 0;
	509	}
	510
	511	return str;
	512	}
	513
	514
	515	char wxClipboard::GetClipboardData(char format, long *length, long time)
	516	{
	517	if (clipOwner) {
	518	if (clipOwner->formats.Member(format))
	519	return clipOwner->GetData(format, length);
	520	else
	521	return NULL;
	522	} else if (cbString) {
	523	if (!strcmp(format, "TEXT"))
	524	return copystring(cbString);
	525	else
	526	return NULL;
	527	} else {
	528	if (wxOpenClipboard()) {
	529	receivedString = (char *)wxGetClipboardData(FormatStringToID(format),
	530	length);
	531	wxCloseClipboard();
	532	} else
	533	receivedString = NULL;
	534
	535	return receivedString;
	536	}
	537	}
	538	*/
	539