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