Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

wxGTK compatible clipboard implementation (not OLE clipboard - it will come

Browse Source 
later)


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@1621 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
1999-02-06 23:25:47 +00:00
parent d79b79b5e8
commit 26f86486b0
5 changed files with 454 additions and 376 deletions
Download Patch File Download Diff File Expand all files Collapse all files

77
include/wx/gtk/clipbrd.h
View File

@@ -4,7 +4,7 @@
// Author: Robert Roebling // Author: Robert Roebling
// Id: $Id$ // Id: $Id$
// Copyright: (c) 1998 Robert Roebling // Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
@@ -42,50 +42,49 @@ extern wxClipboard* wxTheClipboard;
// wxClipboard // wxClipboard
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
class wxClipboard: public wxObject class wxClipboard : public wxObject
{ {
DECLARE_DYNAMIC_CLASS(wxClipboard) DECLARE_DYNAMIC_CLASS(wxClipboard)
public: public:
wxClipboard();
wxClipboard(); ~wxClipboard();
~wxClipboard();
/* open the clipboard before SetData() and GetData() */ // open the clipboard before SetData() and GetData()
virtual bool Open(); virtual bool Open();
/* close the clipboard after SetData() and GetData() */
virtual void Close();
/* set the clipboard data. all other formats will be deleted. */
virtual bool SetData( wxDataObject *data );
/* add to the clipboard data. */ // close the clipboard after SetData() and GetData()
virtual bool AddData( wxDataObject *data ); virtual void Close();
/* ask if data in correct format is available */
virtual bool IsSupported( wxDataObject &data );
/* fill data with data on the clipboard (if available) */
virtual bool GetData( wxDataObject &data );
/* clears wxTheClipboard and the system's clipboard if possible */
virtual void Clear();
/* implementation */ // set the clipboard data. all other formats will be deleted.
virtual bool SetData( wxDataObject *data );
bool m_open;
bool m_ownsClipboard;
bool m_ownsPrimarySelection;
wxDataBroker *m_dataBroker;
GtkWidget *m_clipboardWidget;
bool m_formatSupported;
GdkAtom m_targetRequested;
wxDataObject *m_receivedData; // add to the clipboard data.
virtual bool AddData( wxDataObject *data );
// ask if data in correct format is available
virtual bool IsSupported( wxDataObject &data );
// fill data with data on the clipboard (if available)
virtual bool GetData( wxDataObject &data );
// clears wxTheClipboard and the system's clipboard if possible
virtual void Clear();
// implementation
bool m_open;
bool m_ownsClipboard;
bool m_ownsPrimarySelection;
wxDataBroker *m_dataBroker;
GtkWidget *m_clipboardWidget;
bool m_formatSupported;
GdkAtom m_targetRequested;
wxDataObject *m_receivedData;
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@@ -95,7 +94,7 @@ public:
class wxClipboardModule: public wxModule class wxClipboardModule: public wxModule
{ {
DECLARE_DYNAMIC_CLASS(wxClipboardModule) DECLARE_DYNAMIC_CLASS(wxClipboardModule)
public: public:
wxClipboardModule() {} wxClipboardModule() {}
bool OnInit(); bool OnInit();

77
include/wx/gtk1/clipbrd.h
View File

@@ -4,7 +4,7 @@
// Author: Robert Roebling // Author: Robert Roebling
// Id: $Id$ // Id: $Id$
// Copyright: (c) 1998 Robert Roebling // Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
@@ -42,50 +42,49 @@ extern wxClipboard* wxTheClipboard;
// wxClipboard // wxClipboard
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
class wxClipboard: public wxObject class wxClipboard : public wxObject
{ {
DECLARE_DYNAMIC_CLASS(wxClipboard) DECLARE_DYNAMIC_CLASS(wxClipboard)
public: public:
wxClipboard();
wxClipboard(); ~wxClipboard();
~wxClipboard();
/* open the clipboard before SetData() and GetData() */ // open the clipboard before SetData() and GetData()
virtual bool Open(); virtual bool Open();
/* close the clipboard after SetData() and GetData() */
virtual void Close();
/* set the clipboard data. all other formats will be deleted. */
virtual bool SetData( wxDataObject *data );
/* add to the clipboard data. */ // close the clipboard after SetData() and GetData()
virtual bool AddData( wxDataObject *data ); virtual void Close();
/* ask if data in correct format is available */
virtual bool IsSupported( wxDataObject &data );
/* fill data with data on the clipboard (if available) */
virtual bool GetData( wxDataObject &data );
/* clears wxTheClipboard and the system's clipboard if possible */
virtual void Clear();
/* implementation */ // set the clipboard data. all other formats will be deleted.
virtual bool SetData( wxDataObject *data );
bool m_open;
bool m_ownsClipboard;
bool m_ownsPrimarySelection;
wxDataBroker *m_dataBroker;
GtkWidget *m_clipboardWidget;
bool m_formatSupported;
GdkAtom m_targetRequested;
wxDataObject *m_receivedData; // add to the clipboard data.
virtual bool AddData( wxDataObject *data );
// ask if data in correct format is available
virtual bool IsSupported( wxDataObject &data );
// fill data with data on the clipboard (if available)
virtual bool GetData( wxDataObject &data );
// clears wxTheClipboard and the system's clipboard if possible
virtual void Clear();
// implementation
bool m_open;
bool m_ownsClipboard;
bool m_ownsPrimarySelection;
wxDataBroker *m_dataBroker;
GtkWidget *m_clipboardWidget;
bool m_formatSupported;
GdkAtom m_targetRequested;
wxDataObject *m_receivedData;
}; };
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
@@ -95,7 +94,7 @@ public:
class wxClipboardModule: public wxModule class wxClipboardModule: public wxModule
{ {
DECLARE_DYNAMIC_CLASS(wxClipboardModule) DECLARE_DYNAMIC_CLASS(wxClipboardModule)
public: public:
wxClipboardModule() {} wxClipboardModule() {}
bool OnInit(); bool OnInit();

94
include/wx/msw/clipbrd.h
View File

@@ -6,7 +6,7 @@
// Created: 01/02/97 // Created: 01/02/97
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) Julian Smart // Copyright: (c) Julian Smart
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#ifndef _WX_CLIPBRD_H_ #ifndef _WX_CLIPBRD_H_
@@ -24,71 +24,81 @@
#include "wx/list.h" #include "wx/list.h"
#include "wx/module.h" #include "wx/module.h"
// These functions superceded by wxClipboard, but retained in order to implement // These functions superceded by wxClipboard, but retained in order to
// wxClipboard, and for compatibility. // implement wxClipboard, and for compatibility.
WXDLLEXPORT bool wxOpenClipboard(void);
WXDLLEXPORT bool wxClipboardOpen(void); // open/close the clipboard
WXDLLEXPORT bool wxCloseClipboard(void); WXDLLEXPORT bool wxOpenClipboard();
WXDLLEXPORT bool wxEmptyClipboard(void); WXDLLEXPORT bool wxIsClipboardOpened();
#define wxClipboardOpen wxIsClipboardOpened
WXDLLEXPORT bool wxCloseClipboard();
// get/set data
WXDLLEXPORT bool wxEmptyClipboard();
WXDLLEXPORT bool wxSetClipboardData(wxDataFormat dataFormat,
const void *data,
int width = 0, int height = 0);
WXDLLEXPORT void* wxGetClipboardData(wxDataFormat dataFormat,
long *len = NULL);
// clipboard formats
WXDLLEXPORT bool wxIsClipboardFormatAvailable(wxDataFormat dataFormat); WXDLLEXPORT bool wxIsClipboardFormatAvailable(wxDataFormat dataFormat);
WXDLLEXPORT bool wxSetClipboardData(wxDataFormat dataFormat, wxObject *obj, int width = 0, int height = 0);
WXDLLEXPORT wxObject* wxGetClipboardData(wxDataFormat dataFormat, long *len = NULL);
WXDLLEXPORT wxDataFormat wxEnumClipboardFormats(wxDataFormat dataFormat); WXDLLEXPORT wxDataFormat wxEnumClipboardFormats(wxDataFormat dataFormat);
WXDLLEXPORT int wxRegisterClipboardFormat(char *formatName); WXDLLEXPORT int wxRegisterClipboardFormat(char *formatName);
WXDLLEXPORT bool wxGetClipboardFormatName(wxDataFormat dataFormat, char *formatName, int maxCount); WXDLLEXPORT bool wxGetClipboardFormatName(wxDataFormat dataFormat,
char *formatName,
int maxCount);
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// wxClipboard // wxClipboard
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
class WXDLLEXPORT wxDataObject; class WXDLLEXPORT wxDataObject;
class WXDLLEXPORT wxClipboard: public wxObject class WXDLLEXPORT wxClipboard : public wxObject
{ {
DECLARE_DYNAMIC_CLASS(wxClipboard) DECLARE_DYNAMIC_CLASS(wxClipboard)
public: public:
wxClipboard();
wxClipboard(); ~wxClipboard();
~wxClipboard();
// open the clipboard before SetData() and GetData() // open the clipboard before SetData() and GetData()
virtual bool Open(); virtual bool Open();
// close the clipboard after SetData() and GetData()
virtual void Close();
// can be called several times
virtual bool SetData( wxDataObject *data );
// format available on the clipboard ? // close the clipboard after SetData() and GetData()
// supply ID if private format, the same as wxPrivateDataObject::SetId() virtual void Close();
virtual bool IsSupportedFormat( wxDataFormat format, const wxString &id = wxEmptyString );
// fill data with data on the clipboard (if available)
virtual bool GetData( wxDataObject *data );
// clears wxTheClipboard and the system's clipboard if possible
virtual void Clear();
// implementation // set the clipboard data. all other formats will be deleted.
virtual bool SetData( wxDataObject *data );
bool m_open;
wxList m_data; // add to the clipboard data.
virtual bool AddData( wxDataObject *data );
// ask if data in correct format is available
virtual bool IsSupported( wxDataFormat format );
// fill data with data on the clipboard (if available)
virtual bool GetData( wxDataObject *data );
// clears wxTheClipboard and the system's clipboard if possible
virtual void Clear();
}; };
/* The clipboard */ // The global clipboard object
WXDLLEXPORT_DATA(extern wxClipboard*) wxTheClipboard; WXDLLEXPORT_DATA(extern wxClipboard*) wxTheClipboard;
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
// wxClipboardModule // wxClipboardModule: module responsible for initializing the global clipboard
// object
//----------------------------------------------------------------------------- //-----------------------------------------------------------------------------
class wxClipboardModule: public wxModule class wxClipboardModule : public wxModule
{ {
DECLARE_DYNAMIC_CLASS(wxClipboardModule) DECLARE_DYNAMIC_CLASS(wxClipboardModule)
public: public:
wxClipboardModule() {} wxClipboardModule() { }
bool OnInit(); bool OnInit();
void OnExit(); void OnExit();
}; };

2
include/wx/msw/ole/dataobj.h
View File

@@ -87,7 +87,7 @@ class WXDLLEXPORT wxTextDataObject : public wxDataObject
{ {
public: public:
// ctors // ctors
wxTextDataObject(); wxTextDataObject() { }
wxTextDataObject(const wxString& strText) : m_strText(strText) { } wxTextDataObject(const wxString& strText) : m_strText(strText) { }
void Init(const wxString& strText) { m_strText = strText; } void Init(const wxString& strText) { m_strText = strText; }

580
src/msw/clipbrd.cpp
View File

@@ -6,403 +6,476 @@
// Created: 04/01/98 // Created: 04/01/98
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) Julian Smart and Markus Holzem // Copyright: (c) Julian Smart and Markus Holzem
// Licence: wxWindows license // Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// ===========================================================================
// declarations
// ===========================================================================
// ---------------------------------------------------------------------------
// headers
// ---------------------------------------------------------------------------
#ifdef __GNUG__ #ifdef __GNUG__
#pragma implementation "clipbrd.h" #pragma implementation "clipbrd.h"
#endif #endif
// For compilers that support precompilation, includes "wx.h". // For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h" #include "wx/wxprec.h"
#ifdef __BORLANDC__ #ifdef __BORLANDC__
#pragma hdrstop #pragma hdrstop
#endif #endif
#ifndef WX_PRECOMP #ifndef WX_PRECOMP
#include "wx/setup.h" #include "wx/setup.h"
#endif #endif
#if wxUSE_CLIPBOARD #if wxUSE_CLIPBOARD
#ifndef WX_PRECOMP #ifndef WX_PRECOMP
#include "wx/object.h" #include "wx/object.h"
#include "wx/event.h" #include "wx/event.h"
#include "wx/app.h" #include "wx/app.h"
#include "wx/frame.h" #include "wx/frame.h"
#include "wx/bitmap.h" #include "wx/bitmap.h"
#include "wx/utils.h" #include "wx/utils.h"
#endif #endif
#if wxUSE_METAFILE #if wxUSE_METAFILE
#include "wx/metafile.h" #include "wx/metafile.h"
#endif #endif
#include "wx/clipbrd.h" #include "wx/clipbrd.h"
#include <windows.h> #include <windows.h>
HICON myIcon;
#include "wx/msw/private.h" #include "wx/msw/private.h"
#include "wx/msw/dib.h" #include "wx/msw/dib.h"
// wxDataObject is tied to OLE/drag and drop implementation, // wxDataObject is tied to OLE/drag and drop implementation,
// therefore so is wxClipboard :-( // therefore so is wxClipboard :-(
#if wxUSE_DRAG_AND_DROP #if wxUSE_DRAG_AND_DROP
#include "wx/dataobj.h" #include "wx/dataobj.h"
#endif #endif
#include <string.h> #include <string.h>
bool wxClipboardIsOpen = FALSE; // ===========================================================================
// implementation
// ===========================================================================
bool wxOpenClipboard(void) // ---------------------------------------------------------------------------
// old-style clipboard functions using Windows API
// ---------------------------------------------------------------------------
static bool gs_wxClipboardIsOpen = FALSE;
bool wxOpenClipboard()
{ {
if (wxTheApp->GetTopWindow() && !wxClipboardIsOpen) wxCHECK_MSG( !gs_wxClipboardIsOpen, TRUE, "clipboard already opened." );
{
wxClipboardIsOpen = (::OpenClipboard((HWND) wxTheApp->GetTopWindow()->GetHWND()) != 0); wxWindow *win = wxTheApp->GetTopWindow();
return wxClipboardIsOpen; if ( win )
} {
else return FALSE; gs_wxClipboardIsOpen = ::OpenClipboard((HWND)win->GetHWND()) != 0;
if ( !gs_wxClipboardIsOpen )
wxLogSysError(_("Failed to open the clipboard."));
return gs_wxClipboardIsOpen;
}
else
{
wxLogDebug("Can not open clipboard without a main window,");
return FALSE;
}
} }
bool wxCloseClipboard(void) bool wxCloseClipboard()
{ {
if (wxClipboardIsOpen) wxCHECK_MSG( gs_wxClipboardIsOpen, FALSE, "clipboard is not opened" );
{
wxClipboardIsOpen = FALSE; gs_wxClipboardIsOpen = FALSE;
}
return (::CloseClipboard() != 0); if ( ::CloseClipboard() == 0 )
{
wxLogSysError(_("Failed to close the clipboard."));
return FALSE;
}
return TRUE;
} }
bool wxEmptyClipboard(void) bool wxEmptyClipboard()
{ {
return (::EmptyClipboard() != 0); if ( ::EmptyClipboard() == 0 )
{
wxLogSysError(_("Failed to empty the clipboard."));
return FALSE;
}
return TRUE;
} }
bool wxClipboardOpen(void) bool wxIsClipboardOpened()
{ {
return wxClipboardIsOpen; return gs_wxClipboardIsOpen;
} }
bool wxIsClipboardFormatAvailable(wxDataFormat dataFormat) bool wxIsClipboardFormatAvailable(wxDataFormat dataFormat)
{ {
return (::IsClipboardFormatAvailable(dataFormat) != 0); return ::IsClipboardFormatAvailable(dataFormat) != 0;
} }
bool wxSetClipboardData(wxDataFormat dataFormat, wxObject *obj, int width, int height) bool wxSetClipboardData(wxDataFormat dataFormat,
const void *data,
int width, int height)
{ {
switch (dataFormat) HANDLE handle = 0; // return value of SetClipboardData
{
case wxDF_BITMAP: switch (dataFormat)
{ {
wxBitmap *wxBM = (wxBitmap *)obj; case wxDF_BITMAP:
{
wxBitmap *bitmap = (wxBitmap *)data;
HDC hdcMem = CreateCompatibleDC((HDC) NULL); HDC hdcMem = CreateCompatibleDC((HDC) NULL);
HDC hdcSrc = CreateCompatibleDC((HDC) NULL); HDC hdcSrc = CreateCompatibleDC((HDC) NULL);
HBITMAP old = (HBITMAP) ::SelectObject(hdcSrc, (HBITMAP) wxBM->GetHBITMAP()); HBITMAP old = (HBITMAP)
HBITMAP hBitmap = CreateCompatibleBitmap(hdcSrc, ::SelectObject(hdcSrc, (HBITMAP)bitmap->GetHBITMAP());
wxBM->GetWidth(), wxBM->GetHeight()); HBITMAP hBitmap = CreateCompatibleBitmap(hdcSrc,
if (!hBitmap) bitmap->GetWidth(),
{ bitmap->GetHeight());
SelectObject(hdcSrc, old); if (!hBitmap)
DeleteDC(hdcMem); {
DeleteDC(hdcSrc); SelectObject(hdcSrc, old);
return FALSE; DeleteDC(hdcMem);
} DeleteDC(hdcSrc);
HBITMAP old1 = (HBITMAP) SelectObject(hdcMem, hBitmap); return FALSE;
BitBlt(hdcMem, 0, 0, wxBM->GetWidth(), wxBM->GetHeight(), }
hdcSrc, 0, 0, SRCCOPY);
// Select new bitmap out of memory DC HBITMAP old1 = (HBITMAP) SelectObject(hdcMem, hBitmap);
SelectObject(hdcMem, old1); BitBlt(hdcMem, 0, 0, bitmap->GetWidth(), bitmap->GetHeight(),
hdcSrc, 0, 0, SRCCOPY);
// Set the data // Select new bitmap out of memory DC
bool success = (bool)(::SetClipboardData(CF_BITMAP, hBitmap) != 0); SelectObject(hdcMem, old1);
// Clean up // Set the data
SelectObject(hdcSrc, old); handle = ::SetClipboardData(CF_BITMAP, hBitmap);
DeleteDC(hdcSrc);
DeleteDC(hdcMem); // Clean up
return success; SelectObject(hdcSrc, old);
break; DeleteDC(hdcSrc);
} DeleteDC(hdcMem);
case wxDF_DIB: break;
{ }
case wxDF_DIB:
{
#if wxUSE_IMAGE_LOADING_IN_MSW #if wxUSE_IMAGE_LOADING_IN_MSW
HBITMAP hBitmap=(HBITMAP) ((wxBitmap *)obj)->GetHBITMAP(); wxBitmap *bitmap = (wxBitmap *)data;
HANDLE hDIB=BitmapToDIB(hBitmap,(HPALETTE) NULL); // NULL==uses system palette HBITMAP hBitmap = (HBITMAP)bitmap->GetHBITMAP();
bool success = (::SetClipboardData(CF_DIB,hDIB) != 0); // NULL palette means to use the system one
#else HANDLE hDIB = BitmapToDIB(hBitmap, (HPALETTE)NULL);
bool success=FALSE; handle = SetClipboardData(CF_DIB, hDIB);
#endif #endif
return success; break;
break; }
}
#if wxUSE_METAFILE #if wxUSE_METAFILE
case wxDF_METAFILE: case wxDF_METAFILE:
{ {
wxMetafile *wxMF = (wxMetafile *)obj; wxMetafile *wxMF = (wxMetafile *)data;
HANDLE data = GlobalAlloc(GHND, sizeof(METAFILEPICT) + 1); HANDLE data = GlobalAlloc(GHND, sizeof(METAFILEPICT) + 1);
#ifdef __WINDOWS_386__ #ifdef __WINDOWS_386__
METAFILEPICT *mf = (METAFILEPICT *)MK_FP32(GlobalLock(data)); METAFILEPICT *mf = (METAFILEPICT *)MK_FP32(GlobalLock(data));
#else #else
METAFILEPICT *mf = (METAFILEPICT *)GlobalLock(data); METAFILEPICT *mf = (METAFILEPICT *)GlobalLock(data);
#endif #endif
mf->mm = wxMF->GetWindowsMappingMode(); mf->mm = wxMF->GetWindowsMappingMode();
mf->xExt = width; mf->xExt = width;
mf->yExt = height; mf->yExt = height;
mf->hMF = (HMETAFILE) wxMF->GetHMETAFILE(); mf->hMF = (HMETAFILE) wxMF->GetHMETAFILE();
GlobalUnlock(data); GlobalUnlock(data);
wxMF->SetHMETAFILE((WXHANDLE) NULL); wxMF->SetHMETAFILE((WXHANDLE) NULL);
return (SetClipboardData(CF_METAFILEPICT, data) != 0); handle = SetClipboardData(CF_METAFILEPICT, data);
break; break;
} }
#endif #endif
case CF_SYLK: case CF_SYLK:
case CF_DIF: case CF_DIF:
case CF_TIFF: case CF_TIFF:
case CF_PALETTE: case CF_PALETTE:
{ default:
return FALSE; {
break; wxLogError(_("Unsupported clipboard format."));
} return FALSE;
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); case wxDF_OEMTEXT:
HANDLE hGlobalMemory = GlobalAlloc(GHND, l); dataFormat = wxDF_TEXT;
if (!hGlobalMemory) // fall through
return FALSE;
case wxDF_TEXT:
{
char *s = (char *)data;
width = strlen(s) + 1;
height = 1;
DWORD l = (width * height);
HANDLE hGlobalMemory = GlobalAlloc(GHND, l);
if ( hGlobalMemory )
{
#ifdef __WINDOWS_386__ #ifdef __WINDOWS_386__
LPSTR lpGlobalMemory = (LPSTR)MK_FP32(GlobalLock(hGlobalMemory)); LPSTR lpGlobalMemory = (LPSTR)MK_FP32(GlobalLock(hGlobalMemory));
#else #else
LPSTR lpGlobalMemory = (LPSTR)GlobalLock(hGlobalMemory); LPSTR lpGlobalMemory = (LPSTR)GlobalLock(hGlobalMemory);
#endif #endif
#ifdef __WIN32__ #ifdef __WIN32__
memcpy(lpGlobalMemory, s, l); memcpy(lpGlobalMemory, s, l);
#elif defined(__WATCOMC__) && defined(__WINDOWS_386__) #elif defined(__WATCOMC__) && defined(__WINDOWS_386__)
memcpy(lpGlobalMemory, s, l); memcpy(lpGlobalMemory, s, l);
#else #else
hmemcpy(lpGlobalMemory, s, l); hmemcpy(lpGlobalMemory, s, l);
#endif #endif
GlobalUnlock(hGlobalMemory); GlobalUnlock(hGlobalMemory);
HANDLE success = SetClipboardData(dataFormat, hGlobalMemory); }
return (success != 0);
break; handle = SetClipboardData(dataFormat, hGlobalMemory);
break;
}
} }
}
return FALSE; if ( handle == 0 )
{
wxLogSysError(_("Failed to set clipboard data."));
return FALSE;
}
return TRUE;
} }
wxObject *wxGetClipboardData(wxDataFormat dataFormat, long *len) void *wxGetClipboardData(wxDataFormat dataFormat, long *len)
{ {
switch (dataFormat) void *retval = NULL;
{
case wxDF_BITMAP: switch ( dataFormat )
{ {
BITMAP bm; case wxDF_BITMAP:
HBITMAP hBitmap = (HBITMAP) GetClipboardData(CF_BITMAP); {
if (!hBitmap) BITMAP bm;
return NULL; HBITMAP hBitmap = (HBITMAP) GetClipboardData(CF_BITMAP);
if (!hBitmap)
break;
HDC hdcMem = CreateCompatibleDC((HDC) NULL); HDC hdcMem = CreateCompatibleDC((HDC) NULL);
HDC hdcSrc = CreateCompatibleDC((HDC) NULL); HDC hdcSrc = CreateCompatibleDC((HDC) NULL);
HBITMAP old = (HBITMAP) ::SelectObject(hdcSrc, hBitmap); HBITMAP old = (HBITMAP) ::SelectObject(hdcSrc, hBitmap);
GetObject(hBitmap, sizeof(BITMAP), (LPSTR)&bm); GetObject(hBitmap, sizeof(BITMAP), (LPSTR)&bm);
HBITMAP hNewBitmap = CreateBitmapIndirect(&bm); HBITMAP hNewBitmap = CreateBitmapIndirect(&bm);
if (!hNewBitmap) if (!hNewBitmap)
{ {
SelectObject(hdcSrc, old); SelectObject(hdcSrc, old);
DeleteDC(hdcMem); DeleteDC(hdcMem);
DeleteDC(hdcSrc); DeleteDC(hdcSrc);
return NULL; break;
} }
HBITMAP old1 = (HBITMAP) SelectObject(hdcMem, hNewBitmap); HBITMAP old1 = (HBITMAP) SelectObject(hdcMem, hNewBitmap);
BitBlt(hdcMem, 0, 0, bm.bmWidth, bm.bmHeight, BitBlt(hdcMem, 0, 0, bm.bmWidth, bm.bmHeight,
hdcSrc, 0, 0, SRCCOPY); hdcSrc, 0, 0, SRCCOPY);
// Select new bitmap out of memory DC // Select new bitmap out of memory DC
SelectObject(hdcMem, old1); SelectObject(hdcMem, old1);
// Clean up // Clean up
SelectObject(hdcSrc, old); SelectObject(hdcSrc, old);
DeleteDC(hdcSrc); DeleteDC(hdcSrc);
DeleteDC(hdcMem); DeleteDC(hdcMem);
// Create and return a new wxBitmap // Create and return a new wxBitmap
wxBitmap *wxBM = new wxBitmap; wxBitmap *wxBM = new wxBitmap;
wxBM->SetHBITMAP((WXHBITMAP) hNewBitmap); wxBM->SetHBITMAP((WXHBITMAP) hNewBitmap);
wxBM->SetWidth(bm.bmWidth); wxBM->SetWidth(bm.bmWidth);
wxBM->SetHeight(bm.bmHeight); wxBM->SetHeight(bm.bmHeight);
wxBM->SetDepth(bm.bmPlanes); wxBM->SetDepth(bm.bmPlanes);
wxBM->SetOk(TRUE); wxBM->SetOk(TRUE);
return (wxObject *)wxBM; retval = wxBM;
break; 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); case wxDF_METAFILE:
if (len) case CF_SYLK:
*len = hsize; case CF_DIF:
case CF_TIFF:
case CF_PALETTE:
case wxDF_DIB:
default:
{
wxLogError(_("Unsupported clipboard format."));
return FALSE;
}
char *s = new char[hsize]; case wxDF_OEMTEXT:
if (!s) dataFormat = wxDF_TEXT;
return NULL; // fall through
case wxDF_TEXT:
{
HANDLE hGlobalMemory = ::GetClipboardData(dataFormat);
if (!hGlobalMemory)
break;
DWORD hsize = ::GlobalSize(hGlobalMemory);
if (len)
*len = hsize;
char *s = new char[hsize];
if (!s)
break;
#ifdef __WINDOWS_386__ #ifdef __WINDOWS_386__
LPSTR lpGlobalMemory = (LPSTR)MK_FP32(GlobalLock(hGlobalMemory)); LPSTR lpGlobalMemory = (LPSTR)MK_FP32(GlobalLock(hGlobalMemory));
#else #else
LPSTR lpGlobalMemory = (LPSTR)GlobalLock(hGlobalMemory); LPSTR lpGlobalMemory = (LPSTR)::GlobalLock(hGlobalMemory);
#endif #endif
#ifdef __WIN32__ #ifdef __WIN32__
memcpy(s, lpGlobalMemory, GlobalSize(hGlobalMemory)); memcpy(s, lpGlobalMemory, hsize);
#elif __WATCOMC__ && defined(__WINDOWS_386__) #elif __WATCOMC__ && defined(__WINDOWS_386__)
memcpy(s, lpGlobalMemory, GlobalSize(hGlobalMemory)); memcpy(s, lpGlobalMemory, hsize);
#else #else
hmemcpy(s, lpGlobalMemory, GlobalSize(hGlobalMemory)); hmemcpy(s, lpGlobalMemory, hsize);
#endif #endif
GlobalUnlock(hGlobalMemory); ::GlobalUnlock(hGlobalMemory);
return (wxObject *)s; retval = s;
break; break;
}
} }
}
return NULL; if ( !retval )
{
wxLogSysError(_("Failed to retrieve data from the clipboard."));
}
return retval;
} }
wxDataFormat wxEnumClipboardFormats(wxDataFormat dataFormat) wxDataFormat wxEnumClipboardFormats(wxDataFormat dataFormat)
{ {
return (wxDataFormat) ::EnumClipboardFormats(dataFormat); return (wxDataFormat)::EnumClipboardFormats(dataFormat);
} }
int wxRegisterClipboardFormat(char *formatName) int wxRegisterClipboardFormat(char *formatName)
{ {
return ::RegisterClipboardFormat(formatName); return ::RegisterClipboardFormat(formatName);
} }
bool wxGetClipboardFormatName(wxDataFormat dataFormat, char *formatName, int maxCount) bool wxGetClipboardFormatName(wxDataFormat dataFormat,
char *formatName,
int maxCount)
{ {
return (::GetClipboardFormatName((int) dataFormat, formatName, maxCount) > 0); return ::GetClipboardFormatName((int)dataFormat, formatName, maxCount) > 0;
} }
//----------------------------------------------------------------------------- // ---------------------------------------------------------------------------
// wxClipboard // wxClipboard
//----------------------------------------------------------------------------- // ---------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxClipboard,wxObject) IMPLEMENT_DYNAMIC_CLASS(wxClipboard, wxObject)
wxClipboard* wxTheClipboard = (wxClipboard*) NULL; wxClipboard* wxTheClipboard = (wxClipboard *)NULL;
wxClipboard::wxClipboard() wxClipboard::wxClipboard()
{ {
m_open = FALSE;
} }
wxClipboard::~wxClipboard() wxClipboard::~wxClipboard()
{ {
Clear(); Clear();
} }
void wxClipboard::Clear() void wxClipboard::Clear()
{ {
#if wxUSE_DRAG_AND_DROP
wxNode* node = m_data.First();
while (node)
{
wxDataObject* data = (wxDataObject*) node->Data();
delete data;
node = node->Next();
}
m_data.Clear();
#endif
} }
bool wxClipboard::Open() bool wxClipboard::Open()
{ {
wxCHECK_MSG( !m_open, FALSE, "clipboard already open" );
m_open = TRUE;
return wxOpenClipboard(); return wxOpenClipboard();
} }
bool wxClipboard::SetData( wxDataObject *data ) bool wxClipboard::SetData( wxDataObject *data )
{ {
#if wxUSE_DRAG_AND_DROP (void)wxEmptyClipboard();
wxCHECK_MSG( data, FALSE, "data is invalid" );
wxCHECK_MSG( m_open, FALSE, "clipboard not open" );
switch (data->GetFormat()) if ( data )
return AddData(data);
else
return TRUE;
}
bool wxClipboard::AddData( wxDataObject *data )
{
wxCHECK_MSG( data, FALSE, "data is invalid" );
#if wxUSE_DRAG_AND_DROP
wxCHECK_MSG( wxIsClipboardOpened(), FALSE, "clipboard not open" );
wxDataFormat format = data->GetFormat();
switch ( format )
{ {
case wxDF_TEXT: case wxDF_TEXT:
case wxDF_OEMTEXT: case wxDF_OEMTEXT:
{ {
wxTextDataObject* textDataObject = (wxTextDataObject*) data; wxTextDataObject* textDataObject = (wxTextDataObject*) data;
wxString str(textDataObject->GetText()); wxString str(textDataObject->GetText());
return wxSetClipboardData(data->GetFormat(), (wxObject*) (const char*) str); return wxSetClipboardData(format, str.c_str());
break;
} }
case wxDF_BITMAP: case wxDF_BITMAP:
case wxDF_DIB: case wxDF_DIB:
{ {
wxBitmapDataObject* bitmapDataObject = (wxBitmapDataObject*) data; wxBitmapDataObject* bitmapDataObject = (wxBitmapDataObject*) data;
wxBitmap bitmap(bitmapDataObject->GetBitmap()); wxBitmap bitmap(bitmapDataObject->GetBitmap());
return wxSetClipboardData(data->GetFormat(), & bitmap); return wxSetClipboardData(data->GetFormat(), &bitmap);
break;
} }
#if wxUSE_METAFILE #if wxUSE_METAFILE
case wxDF_METAFILE: case wxDF_METAFILE:
{ {
wxMetafileDataObject* metaFileDataObject = (wxMetafileDataObject*) data; wxMetafileDataObject* metaFileDataObject =
(wxMetafileDataObject*) data;
wxMetafile metaFile = metaFileDataObject->GetMetafile(); wxMetafile metaFile = metaFileDataObject->GetMetafile();
return wxSetClipboardData(wxDF_METAFILE, & metaFile, metaFileDataObject->GetWidth(), metaFileDataObject->GetHeight()); return wxSetClipboardData(wxDF_METAFILE, &metaFile,
break; metaFileDataObject->GetWidth(),
metaFileDataObject->GetHeight());
} }
#endif #endif // wxUSE_METAFILE
default: default:
{ wxLogError(_("Can not put data in format '%s' on clipboard."),
wxDataObject::GetFormatName(format));
return FALSE; return FALSE;
}
} }
return FALSE; return FALSE;
#else #else
return FALSE; return FALSE;
@@ -411,30 +484,28 @@ bool wxClipboard::SetData( wxDataObject *data )
void wxClipboard::Close() void wxClipboard::Close()
{ {
wxCHECK_RET( m_open, "clipboard not open" );
m_open = FALSE;
wxCloseClipboard(); wxCloseClipboard();
} }
bool wxClipboard::IsSupportedFormat( wxDataFormat format, const wxString& WXUNUSED(id) ) bool wxClipboard::IsSupported( wxDataFormat format )
{ {
return wxIsClipboardFormatAvailable(format); return wxIsClipboardFormatAvailable(format);
} }
bool wxClipboard::GetData( wxDataObject *data ) bool wxClipboard::GetData( wxDataObject *data )
{ {
wxCHECK_MSG( m_open, FALSE, "clipboard not open" ); wxCHECK_MSG( wxIsClipboardOpened(), FALSE, "clipboard not open" );
#if wxUSE_DRAG_AND_DROP #if wxUSE_DRAG_AND_DROP
switch (data->GetFormat()) wxDataFormat format = data->GetFormat();
switch ( format )
{ {
case wxDF_TEXT: case wxDF_TEXT:
case wxDF_OEMTEXT: case wxDF_OEMTEXT:
{ {
wxTextDataObject* textDataObject = (wxTextDataObject*) data; wxTextDataObject* textDataObject = (wxTextDataObject*) data;
char* s = (char*) wxGetClipboardData(data->GetFormat()); char* s = (char*) wxGetClipboardData(format);
if (s) if ( s )
{ {
textDataObject->SetText(s); textDataObject->SetText(s);
delete[] s; delete[] s;
@@ -442,13 +513,13 @@ bool wxClipboard::GetData( wxDataObject *data )
} }
else else
return FALSE; return FALSE;
break;
} }
case wxDF_BITMAP: case wxDF_BITMAP:
case wxDF_DIB: case wxDF_DIB:
{ {
wxBitmapDataObject* bitmapDataObject = (wxBitmapDataObject*) data; wxBitmapDataObject* bitmapDataObject = (wxBitmapDataObject *)data;
wxBitmap* bitmap = (wxBitmap*) wxGetClipboardData(data->GetFormat()); wxBitmap* bitmap = (wxBitmap *)wxGetClipboardData(data->GetFormat());
if (bitmap) if (bitmap)
{ {
bitmapDataObject->SetBitmap(* bitmap); bitmapDataObject->SetBitmap(* bitmap);
@@ -457,31 +528,28 @@ bool wxClipboard::GetData( wxDataObject *data )
} }
else else
return FALSE; return FALSE;
break;
} }
#if wxUSE_METAFILE #if wxUSE_METAFILE
case wxDF_METAFILE: case wxDF_METAFILE:
{ {
wxMetafileDataObject* metaFileDataObject = (wxMetafileDataObject*) data; wxMetafileDataObject* metaFileDataObject = (wxMetafileDataObject *)data;
wxMetafile* metaFile = (wxMetafile*) wxGetClipboardData(wxDF_METAFILE); wxMetafile* metaFile = (wxMetafile *)wxGetClipboardData(wxDF_METAFILE);
if (metaFile) if (metaFile)
{ {
metaFileDataObject->SetMetafile(* metaFile); metaFileDataObject->SetMetafile(*metaFile);
delete metaFile; delete metaFile;
return TRUE; return TRUE;
} }
else else
return FALSE; return FALSE;
break;
} }
#endif #endif
default: default:
{ wxLogError(_("Can not get data in format '%s' from clipboard."),
wxDataObject::GetFormatName(format));
return FALSE; return FALSE;
}
} }
return FALSE;
#else #else
return FALSE; return FALSE;
#endif #endif
@@ -496,7 +564,7 @@ IMPLEMENT_DYNAMIC_CLASS(wxClipboardModule,wxModule)
bool wxClipboardModule::OnInit() bool wxClipboardModule::OnInit()
{ {
wxTheClipboard = new wxClipboard(); wxTheClipboard = new wxClipboard();
return TRUE; return TRUE;
} }
@@ -506,5 +574,7 @@ void wxClipboardModule::OnExit()
wxTheClipboard = (wxClipboard*) NULL; wxTheClipboard = (wxClipboard*) NULL;
} }
#else
#error "Please turn wxUSE_CLIPBOARD on to compile this file."
#endif // wxUSE_CLIPBOARD #endif // wxUSE_CLIPBOARD