src/msw/clipbrd.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        clipbrd.cpp
// Purpose:     Clipboard functionality
// Author:      Julian Smart
// Modified by:
// Created:     04/01/98
// RCS-ID:      $Id$
// Copyright:   (c) Julian Smart and Markus Holzem
// Licence:   	wxWindows license
/////////////////////////////////////////////////////////////////////////////

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

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
#pragma hdrstop
#endif

#ifndef WX_PRECOMP
#include "wx/setup.h"
#endif

#if USE_CLIPBOARD

#ifndef WX_PRECOMP
#include "wx/app.h"
#include "wx/frame.h"
#include "wx/bitmap.h"
#include "wx/utils.h"
#endif

#include "wx/metafile.h"
#include "wx/clipbrd.h"
#include "wx/msw/private.h"
#include "wx/msw/dib.h"

#include <string.h>

#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxClipboard, wxObject)
IMPLEMENT_ABSTRACT_CLASS(wxClipboardClient, wxObject)
#endif

bool wxClipboardIsOpen = FALSE;

bool wxOpenClipboard(void)
{
  if (wxTheApp->GetTopWindow() && !wxClipboardIsOpen)
  {
    wxClipboardIsOpen = (::OpenClipboard((HWND) wxTheApp->GetTopWindow()->GetHWND()) != 0);
    return wxClipboardIsOpen;
  }
  else return FALSE;
}

bool wxCloseClipboard(void)
{
  if (wxClipboardIsOpen)
  {
    wxClipboardIsOpen = FALSE;
  }
  return (::CloseClipboard() != 0);
}

bool wxEmptyClipboard(void)
{
  return (::EmptyClipboard() != 0);
}

bool wxClipboardOpen(void)
{
  return wxClipboardIsOpen;
}

bool wxIsClipboardFormatAvailable(int dataFormat)
{
  return (::IsClipboardFormatAvailable(dataFormat) != 0);
}

bool wxSetClipboardData(int dataFormat, wxObject *obj, int width, int height)
{
  switch (dataFormat)
  {
    case wxDF_BITMAP:
    {
      wxBitmap *wxBM = (wxBitmap *)obj;

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

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

      // Set the data
      bool success = (bool)(::SetClipboardData(CF_BITMAP, hBitmap) != 0);

      // Clean up
      SelectObject(hdcSrc, old);
      DeleteDC(hdcSrc);
      DeleteDC(hdcMem);
      return success;
      break;
    }
    case wxDF_DIB:
    {
#if USE_IMAGE_LOADING_IN_MSW
      HBITMAP hBitmap=(HBITMAP) ((wxBitmap *)obj)->GetHBITMAP();
      HANDLE hDIB=BitmapToDIB(hBitmap,NULL); // NULL==uses system palette
      bool success = (::SetClipboardData(CF_DIB,hDIB) != 0);
#else
      bool success=FALSE;
#endif
      return success;
      break;
    }
#if USE_METAFILE
    case wxDF_METAFILE:
    {
      wxMetaFile *wxMF = (wxMetaFile *)obj;
      HANDLE data = GlobalAlloc(GHND, sizeof(METAFILEPICT) + 1);
#ifdef __WINDOWS_386__
      METAFILEPICT *mf = (METAFILEPICT *)MK_FP32(GlobalLock(data));
#else
      METAFILEPICT *mf = (METAFILEPICT *)GlobalLock(data);
#endif

      mf->mm = wxMF->GetWindowsMappingMode();
      mf->xExt = width;
      mf->yExt = height;
      mf->hMF = (HMETAFILE) wxMF->GetHMETAFILE();
      GlobalUnlock(data);
      wxMF->SetHMETAFILE((WXHANDLE) NULL);

      return (SetClipboardData(CF_METAFILEPICT, data) != 0);
      break;
    }
#endif
    case CF_SYLK:
    case CF_DIF:
    case CF_TIFF:
    case CF_PALETTE:
    {
      return FALSE;
      break;
    }
    case wxDF_OEMTEXT:
      dataFormat = wxDF_TEXT;
    case wxDF_TEXT:
       width = strlen((char *)obj) + 1;
       height = 1;
    default:
    {
      char *s = (char *)obj;
      DWORD l;

      l = (width * height);
      HANDLE hGlobalMemory = GlobalAlloc(GHND, l);
                if (!hGlobalMemory)
        return FALSE;

#ifdef __WINDOWS_386__
      LPSTR lpGlobalMemory = (LPSTR)MK_FP32(GlobalLock(hGlobalMemory));
#else
      LPSTR lpGlobalMemory = (LPSTR)GlobalLock(hGlobalMemory);
#endif

#ifdef __WIN32__
      memcpy(lpGlobalMemory, s, l);
#elif defined(__WATCOMC__) && defined(__WINDOWS_386__)
      memcpy(lpGlobalMemory, s, l);
#else
      hmemcpy(lpGlobalMemory, s, l);
#endif

      GlobalUnlock(hGlobalMemory);
      HANDLE success = SetClipboardData(dataFormat, hGlobalMemory);
      return (success != 0);
      break;
    }
  }
  return FALSE;
}

wxObject *wxGetClipboardData(int dataFormat, long *len)
{
  switch (dataFormat)
  {
    case wxDF_BITMAP:
    {
      BITMAP bm;
      HBITMAP hBitmap = (HBITMAP) GetClipboardData(CF_BITMAP);
      if (!hBitmap)
        return NULL;

      HDC hdcMem = CreateCompatibleDC(NULL);
      HDC hdcSrc = CreateCompatibleDC(NULL);

      HBITMAP old = (HBITMAP) ::SelectObject(hdcSrc, hBitmap);
      GetObject(hBitmap, sizeof(BITMAP), (LPSTR)&bm);

      HBITMAP hNewBitmap = CreateBitmapIndirect(&bm);

      if (!hNewBitmap)
      {
        SelectObject(hdcSrc, old);
        DeleteDC(hdcMem);
        DeleteDC(hdcSrc);
        return NULL;
      }

      HBITMAP old1 = (HBITMAP) SelectObject(hdcMem, hNewBitmap);
      BitBlt(hdcMem, 0, 0, bm.bmWidth, bm.bmHeight,
             hdcSrc, 0, 0, SRCCOPY);

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

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

      // Create and return a new wxBitmap
      wxBitmap *wxBM = new wxBitmap;
      wxBM->SetHBITMAP((WXHBITMAP) hNewBitmap);
      wxBM->SetWidth(bm.bmWidth);
      wxBM->SetHeight(bm.bmHeight);
      wxBM->SetDepth(bm.bmPlanes);
      wxBM->SetOk(TRUE);
      return (wxObject *)wxBM;
      break;
    }
    case wxDF_METAFILE:
    case CF_SYLK:
    case CF_DIF:
    case CF_TIFF:
    case CF_PALETTE:
    case wxDF_DIB:
    {
      return FALSE;
      break;
    }
    case wxDF_OEMTEXT:
      dataFormat = wxDF_TEXT;
         case wxDF_TEXT:
    default:
    {
      HANDLE hGlobalMemory = GetClipboardData(dataFormat);
      if (!hGlobalMemory)
        return NULL;

      int hsize = (int)GlobalSize(hGlobalMemory);
      if (len)
        *len = hsize;

      char *s = new char[hsize];
      if (!s)
        return NULL;

#ifdef __WINDOWS_386__
      LPSTR lpGlobalMemory = (LPSTR)MK_FP32(GlobalLock(hGlobalMemory));
#else
      LPSTR lpGlobalMemory = (LPSTR)GlobalLock(hGlobalMemory);
#endif

#ifdef __WIN32__
      memcpy(s, lpGlobalMemory, GlobalSize(hGlobalMemory));
#elif __WATCOMC__ && defined(__WINDOWS_386__)
      memcpy(s, lpGlobalMemory, GlobalSize(hGlobalMemory));
#else
      hmemcpy(s, lpGlobalMemory, GlobalSize(hGlobalMemory));
#endif

      GlobalUnlock(hGlobalMemory);

      return (wxObject *)s;
      break;
    }
  }
  return NULL;
}

int  wxEnumClipboardFormats(int dataFormat)
{
  return ::EnumClipboardFormats(dataFormat);
}

int  wxRegisterClipboardFormat(char *formatName)
{
  return ::RegisterClipboardFormat(formatName);
}

bool wxGetClipboardFormatName(int dataFormat, char *formatName, int maxCount)
{
  return (::GetClipboardFormatName(dataFormat, formatName, maxCount) > 0);
}

/*
 * Generalized clipboard implementation by Matthew Flatt
 */

wxClipboard *wxTheClipboard = NULL;

void wxInitClipboard(void)
{
  if (!wxTheClipboard)
    wxTheClipboard = new wxClipboard;
}

wxClipboard::wxClipboard()
{
  clipOwner = NULL;
  cbString = NULL;
}

wxClipboard::~wxClipboard()
{
  if (clipOwner)
    clipOwner->BeingReplaced();
  if (cbString)
    delete[] cbString;
}

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

  return wxRegisterClipboardFormat(str);
}

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;
  }
}


#endif // USE_CLIPBOARD
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: clipbrd.cpp
	3	// Purpose: Clipboard functionality
	4	// Author: Julian Smart
	5	// Modified by:
	6	// Created: 04/01/98
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Julian Smart and Markus Holzem
	9	// Licence: wxWindows license
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	#ifdef __GNUG__
	13	#pragma implementation
	14	#pragma implementation "clipbrd.h"
	15	#endif
	16
	17	// For compilers that support precompilation, includes "wx.h".
	18	#include "wx/wxprec.h"
	19
	20	#ifdef __BORLANDC__
	21	#pragma hdrstop
	22	#endif
	23
	24	#ifndef WX_PRECOMP
	25	#include "wx/setup.h"
	26	#endif
	27
	28	#if USE_CLIPBOARD
	29
	30	#ifndef WX_PRECOMP
	31	#include "wx/app.h"
	32	#include "wx/frame.h"
	33	#include "wx/bitmap.h"
	34	#include "wx/utils.h"
	35	#endif
	36
	37	#include "wx/metafile.h"
	38	#include "wx/clipbrd.h"
	39	#include "wx/msw/private.h"
	40	#include "wx/msw/dib.h"
	41
	42	#include <string.h>
	43
	44	#if !USE_SHARED_LIBRARY
	45	IMPLEMENT_DYNAMIC_CLASS(wxClipboard, wxObject)
	46	IMPLEMENT_ABSTRACT_CLASS(wxClipboardClient, wxObject)
	47	#endif
	48
	49	bool wxClipboardIsOpen = FALSE;
	50
	51	bool wxOpenClipboard(void)
	52	{
	53	if (wxTheApp->GetTopWindow() && !wxClipboardIsOpen)
	54	{
	55	wxClipboardIsOpen = (::OpenClipboard((HWND) wxTheApp->GetTopWindow()->GetHWND()) != 0);
	56	return wxClipboardIsOpen;
	57	}
	58	else return FALSE;
	59	}
	60
	61	bool wxCloseClipboard(void)
	62	{
	63	if (wxClipboardIsOpen)
	64	{
	65	wxClipboardIsOpen = FALSE;
	66	}
	67	return (::CloseClipboard() != 0);
	68	}
	69
	70	bool wxEmptyClipboard(void)
	71	{
	72	return (::EmptyClipboard() != 0);
	73	}
	74
	75	bool wxClipboardOpen(void)
	76	{
	77	return wxClipboardIsOpen;
	78	}
	79
	80	bool wxIsClipboardFormatAvailable(int dataFormat)
	81	{
	82	return (::IsClipboardFormatAvailable(dataFormat) != 0);
	83	}
	84
	85	bool wxSetClipboardData(int dataFormat, wxObject *obj, int width, int height)
	86	{
	87	switch (dataFormat)
	88	{
	89	case wxDF_BITMAP:
	90	{
	91	wxBitmap wxBM = (wxBitmap )obj;
	92
	93	HDC hdcMem = CreateCompatibleDC(NULL);
	94	HDC hdcSrc = CreateCompatibleDC(NULL);
	95	HBITMAP old = (HBITMAP) ::SelectObject(hdcSrc, (HBITMAP) wxBM->GetHBITMAP());
	96	HBITMAP hBitmap = CreateCompatibleBitmap(hdcSrc,
	97	wxBM->GetWidth(), wxBM->GetHeight());
	98	if (!hBitmap)
	99	{
	100	SelectObject(hdcSrc, old);
	101	DeleteDC(hdcMem);
	102	DeleteDC(hdcSrc);
	103	return FALSE;
	104	}
	105	HBITMAP old1 = (HBITMAP) SelectObject(hdcMem, hBitmap);
	106	BitBlt(hdcMem, 0, 0, wxBM->GetWidth(), wxBM->GetHeight(),
	107	hdcSrc, 0, 0, SRCCOPY);
	108
	109	// Select new bitmap out of memory DC
	110	SelectObject(hdcMem, old1);
	111
	112	// Set the data
	113	bool success = (bool)(::SetClipboardData(CF_BITMAP, hBitmap) != 0);
	114
	115	// Clean up
	116	SelectObject(hdcSrc, old);
	117	DeleteDC(hdcSrc);
	118	DeleteDC(hdcMem);
	119	return success;
	120	break;
	121	}
	122	case wxDF_DIB:
	123	{
	124	#if USE_IMAGE_LOADING_IN_MSW
	125	HBITMAP hBitmap=(HBITMAP) ((wxBitmap *)obj)->GetHBITMAP();
	126	HANDLE hDIB=BitmapToDIB(hBitmap,NULL); // NULL==uses system palette
	127	bool success = (::SetClipboardData(CF_DIB,hDIB) != 0);
	128	#else
	129	bool success=FALSE;
	130	#endif
	131	return success;
	132	break;
	133	}
	134	#if USE_METAFILE
	135	case wxDF_METAFILE:
	136	{
	137	wxMetaFile wxMF = (wxMetaFile )obj;
	138	HANDLE data = GlobalAlloc(GHND, sizeof(METAFILEPICT) + 1);
	139	#ifdef __WINDOWS_386__
	140	METAFILEPICT mf = (METAFILEPICT )MK_FP32(GlobalLock(data));
	141	#else
	142	METAFILEPICT mf = (METAFILEPICT )GlobalLock(data);
	143	#endif
	144
	145	mf->mm = wxMF->GetWindowsMappingMode();
	146	mf->xExt = width;
	147	mf->yExt = height;
	148	mf->hMF = (HMETAFILE) wxMF->GetHMETAFILE();
	149	GlobalUnlock(data);
	150	wxMF->SetHMETAFILE((WXHANDLE) NULL);
	151
	152	return (SetClipboardData(CF_METAFILEPICT, data) != 0);
	153	break;
	154	}
	155	#endif
	156	case CF_SYLK:
	157	case CF_DIF:
	158	case CF_TIFF:
	159	case CF_PALETTE:
	160	{
	161	return FALSE;
	162	break;
	163	}
	164	case wxDF_OEMTEXT:
	165	dataFormat = wxDF_TEXT;
	166	case wxDF_TEXT:
	167	width = strlen((char *)obj) + 1;
	168	height = 1;
	169	default:
	170	{
	171	char s = (char )obj;
	172	DWORD l;
	173
	174	l = (width * height);
	175	HANDLE hGlobalMemory = GlobalAlloc(GHND, l);
	176	if (!hGlobalMemory)
	177	return FALSE;
	178
	179	#ifdef __WINDOWS_386__
	180	LPSTR lpGlobalMemory = (LPSTR)MK_FP32(GlobalLock(hGlobalMemory));
	181	#else
	182	LPSTR lpGlobalMemory = (LPSTR)GlobalLock(hGlobalMemory);
	183	#endif
	184
	185	#ifdef __WIN32__
	186	memcpy(lpGlobalMemory, s, l);
	187	#elif defined(__WATCOMC__) && defined(__WINDOWS_386__)
	188	memcpy(lpGlobalMemory, s, l);
	189	#else
	190	hmemcpy(lpGlobalMemory, s, l);
	191	#endif
	192
	193	GlobalUnlock(hGlobalMemory);
	194	HANDLE success = SetClipboardData(dataFormat, hGlobalMemory);
	195	return (success != 0);
	196	break;
	197	}
	198	}
	199	return FALSE;
	200	}
	201
	202	wxObject wxGetClipboardData(int dataFormat, long len)
	203	{
	204	switch (dataFormat)
	205	{
	206	case wxDF_BITMAP:
	207	{
	208	BITMAP bm;
	209	HBITMAP hBitmap = (HBITMAP) GetClipboardData(CF_BITMAP);
	210	if (!hBitmap)
	211	return NULL;
	212
	213	HDC hdcMem = CreateCompatibleDC(NULL);
	214	HDC hdcSrc = CreateCompatibleDC(NULL);
	215
	216	HBITMAP old = (HBITMAP) ::SelectObject(hdcSrc, hBitmap);
	217	GetObject(hBitmap, sizeof(BITMAP), (LPSTR)&bm);
	218
	219	HBITMAP hNewBitmap = CreateBitmapIndirect(&bm);
	220
	221	if (!hNewBitmap)
	222	{
	223	SelectObject(hdcSrc, old);
	224	DeleteDC(hdcMem);
	225	DeleteDC(hdcSrc);
	226	return NULL;
	227	}
	228
	229	HBITMAP old1 = (HBITMAP) SelectObject(hdcMem, hNewBitmap);
	230	BitBlt(hdcMem, 0, 0, bm.bmWidth, bm.bmHeight,
	231	hdcSrc, 0, 0, SRCCOPY);
	232
	233	// Select new bitmap out of memory DC
	234	SelectObject(hdcMem, old1);
	235
	236	// Clean up
	237	SelectObject(hdcSrc, old);
	238	DeleteDC(hdcSrc);
	239	DeleteDC(hdcMem);
	240
	241	// Create and return a new wxBitmap
	242	wxBitmap *wxBM = new wxBitmap;
	243	wxBM->SetHBITMAP((WXHBITMAP) hNewBitmap);
	244	wxBM->SetWidth(bm.bmWidth);
	245	wxBM->SetHeight(bm.bmHeight);
	246	wxBM->SetDepth(bm.bmPlanes);
	247	wxBM->SetOk(TRUE);
	248	return (wxObject *)wxBM;
	249	break;
	250	}
	251	case wxDF_METAFILE:
	252	case CF_SYLK:
	253	case CF_DIF:
	254	case CF_TIFF:
	255	case CF_PALETTE:
	256	case wxDF_DIB:
	257	{
	258	return FALSE;
	259	break;
	260	}
	261	case wxDF_OEMTEXT:
	262	dataFormat = wxDF_TEXT;
	263	case wxDF_TEXT:
	264	default:
	265	{
	266	HANDLE hGlobalMemory = GetClipboardData(dataFormat);
	267	if (!hGlobalMemory)
	268	return NULL;
	269
	270	int hsize = (int)GlobalSize(hGlobalMemory);
	271	if (len)
	272	*len = hsize;
	273
	274	char *s = new char[hsize];
	275	if (!s)
	276	return NULL;
	277
	278	#ifdef __WINDOWS_386__
	279	LPSTR lpGlobalMemory = (LPSTR)MK_FP32(GlobalLock(hGlobalMemory));
	280	#else
	281	LPSTR lpGlobalMemory = (LPSTR)GlobalLock(hGlobalMemory);
	282	#endif
	283
	284	#ifdef __WIN32__
	285	memcpy(s, lpGlobalMemory, GlobalSize(hGlobalMemory));
	286	#elif __WATCOMC__ && defined(__WINDOWS_386__)
	287	memcpy(s, lpGlobalMemory, GlobalSize(hGlobalMemory));
	288	#else
	289	hmemcpy(s, lpGlobalMemory, GlobalSize(hGlobalMemory));
	290	#endif
	291
	292	GlobalUnlock(hGlobalMemory);
	293
	294	return (wxObject *)s;
	295	break;
	296	}
	297	}
	298	return NULL;
	299	}
	300
	301	int wxEnumClipboardFormats(int dataFormat)
	302	{
	303	return ::EnumClipboardFormats(dataFormat);
	304	}
	305
	306	int wxRegisterClipboardFormat(char *formatName)
	307	{
	308	return ::RegisterClipboardFormat(formatName);
	309	}
	310
	311	bool wxGetClipboardFormatName(int dataFormat, char *formatName, int maxCount)
	312	{
	313	return (::GetClipboardFormatName(dataFormat, formatName, maxCount) > 0);
	314	}
	315
	316	/*
	317	* Generalized clipboard implementation by Matthew Flatt
	318	*/
	319
	320	wxClipboard *wxTheClipboard = NULL;
	321
	322	void wxInitClipboard(void)
	323	{
	324	if (!wxTheClipboard)
	325	wxTheClipboard = new wxClipboard;
	326	}
	327
	328	wxClipboard::wxClipboard()
	329	{
	330	clipOwner = NULL;
	331	cbString = NULL;
	332	}
	333
	334	wxClipboard::~wxClipboard()
	335	{
	336	if (clipOwner)
	337	clipOwner->BeingReplaced();
	338	if (cbString)
	339	delete[] cbString;
	340	}
	341
	342	static int FormatStringToID(char *str)
	343	{
	344	if (!strcmp(str, "TEXT"))
	345	return wxDF_TEXT;
	346
	347	return wxRegisterClipboardFormat(str);
	348	}
	349
	350	void wxClipboard::SetClipboardClient(wxClipboardClient *client, long time)
	351	{
	352	bool got_selection;
	353
	354	if (clipOwner)
	355	clipOwner->BeingReplaced();
	356	clipOwner = client;
	357	if (cbString) {
	358	delete[] cbString;
	359	cbString = NULL;
	360	}
	361
	362	if (wxOpenClipboard()) {
	363	char *formats, data;
	364	int i;
	365	int ftype;
	366	long size;
	367
	368	formats = clipOwner->formats.ListToArray(FALSE);
	369	for (i = clipOwner->formats.Number(); i--; ) {
	370	ftype = FormatStringToID(formats[i]);
	371	data = clipOwner->GetData(formats[i], &size);
	372	if (!wxSetClipboardData(ftype, (wxObject *)data, size, 1)) {
	373	got_selection = FALSE;
	374	break;
	375	}
	376	}
	377
	378	if (i < 0)
	379	got_selection = wxCloseClipboard();
	380	} else
	381	got_selection = FALSE;
	382
	383	got_selection = FALSE; // Assume another process takes over
	384
	385	if (!got_selection) {
	386	clipOwner->BeingReplaced();
	387	clipOwner = NULL;
	388	}
	389	}
	390
	391	wxClipboardClient *wxClipboard::GetClipboardClient()
	392	{
	393	return clipOwner;
	394	}
	395
	396	void wxClipboard::SetClipboardString(char *str, long time)
	397	{
	398	bool got_selection;
	399
	400	if (clipOwner) {
	401	clipOwner->BeingReplaced();
	402	clipOwner = NULL;
	403	}
	404	if (cbString)
	405	delete[] cbString;
	406
	407	cbString = str;
	408
	409	if (wxOpenClipboard()) {
	410	if (!wxSetClipboardData(wxDF_TEXT, (wxObject *)str))
	411	got_selection = FALSE;
	412	else
	413	got_selection = wxCloseClipboard();
	414	} else
	415	got_selection = FALSE;
	416
	417	got_selection = FALSE; // Assume another process takes over
	418
	419	if (!got_selection) {
	420	delete[] cbString;
	421	cbString = NULL;
	422	}
	423	}
	424
	425	char *wxClipboard::GetClipboardString(long time)
	426	{
	427	char *str;
	428	long length;
	429
	430	str = GetClipboardData("TEXT", &length, time);
	431	if (!str) {
	432	str = new char[1];
	433	*str = 0;
	434	}
	435
	436	return str;
	437	}
	438
	439	char wxClipboard::GetClipboardData(char format, long *length, long time)
	440	{
	441	if (clipOwner) {
	442	if (clipOwner->formats.Member(format))
	443	return clipOwner->GetData(format, length);
	444	else
	445	return NULL;
	446	} else if (cbString) {
	447	if (!strcmp(format, "TEXT"))
	448	return copystring(cbString);
	449	else
	450	return NULL;
	451	} else {
	452	if (wxOpenClipboard()) {
	453	receivedString = (char *)wxGetClipboardData(FormatStringToID(format),
	454	length);
	455	wxCloseClipboard();
	456	} else
	457	receivedString = NULL;
	458
	459	return receivedString;
	460	}
	461	}
	462
	463
	464	#endif // USE_CLIPBOARD
	465