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
/////////////////////////////////////////////////////////////////////////////

// ===========================================================================
// declarations
// ===========================================================================

// ---------------------------------------------------------------------------
// headers
// ---------------------------------------------------------------------------

#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/object.h"
    #include "wx/event.h"
    #include "wx/app.h"
    #include "wx/frame.h"
    #include "wx/bitmap.h"
    #include "wx/utils.h"
    #include "wx/intl.h"
#endif

#if wxUSE_METAFILE
    #include "wx/metafile.h"
#endif

#include "wx/log.h"
#include "wx/clipbrd.h"

#include <string.h>
#include <windows.h>

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

// wxDataObject is tied to OLE/drag and drop implementation, therefore so are
// the functions using wxDataObject in wxClipboard
//#define wxUSE_DATAOBJ wxUSE_DRAG_AND_DROP

#if wxUSE_DATAOBJ
    #include "wx/dataobj.h"

    // use OLE clipboard
    #define wxUSE_OLE_CLIPBOARD 1
#else // !wxUSE_DATAOBJ
    // use Win clipboard API
    #define wxUSE_OLE_CLIPBOARD 0
#endif

#if wxUSE_OLE_CLIPBOARD
    #include <ole2.h>
#endif // wxUSE_OLE_CLIPBOARD

#ifdef __WIN16__
    #define memcpy hmemcpy
#endif

// ===========================================================================
// implementation
// ===========================================================================

// ---------------------------------------------------------------------------
// old-style clipboard functions using Windows API
// ---------------------------------------------------------------------------

static bool gs_wxClipboardIsOpen = FALSE;

bool wxOpenClipboard()
{
    wxCHECK_MSG( !gs_wxClipboardIsOpen, TRUE, wxT("clipboard already opened.") );

    wxWindow *win = wxTheApp->GetTopWindow();
    if ( win )
    {
        gs_wxClipboardIsOpen = ::OpenClipboard((HWND)win->GetHWND()) != 0;

        if ( !gs_wxClipboardIsOpen )
            wxLogSysError(_("Failed to open the clipboard."));

        return gs_wxClipboardIsOpen;
    }
    else
    {
        wxLogDebug(wxT("Can not open clipboard without a main window."));

        return FALSE;
    }
}

bool wxCloseClipboard()
{
    wxCHECK_MSG( gs_wxClipboardIsOpen, FALSE, wxT("clipboard is not opened") );

    gs_wxClipboardIsOpen = FALSE;

    if ( ::CloseClipboard() == 0 )
    {
        wxLogSysError(_("Failed to close the clipboard."));

        return FALSE;
    }

    return TRUE;
}

bool wxEmptyClipboard()
{
    if ( ::EmptyClipboard() == 0 )
    {
        wxLogSysError(_("Failed to empty the clipboard."));

        return FALSE;
    }

    return TRUE;
}

bool wxIsClipboardOpened()
{
  return gs_wxClipboardIsOpen;
}

bool wxIsClipboardFormatAvailable(wxDataFormat dataFormat)
{
    if ( ::IsClipboardFormatAvailable(dataFormat) )
    {
        // ok from the first try
        return TRUE;
    }

    // for several standard formats, we can convert from some other ones too
    switch ( dataFormat.GetFormatId() )
    {
        // for bitmaps, DIBs will also do
        case CF_BITMAP:
            return ::IsClipboardFormatAvailable(CF_DIB) != 0;

#if wxUSE_ENH_METAFILE && !defined(__WIN16__)
        case CF_METAFILEPICT:
            return ::IsClipboardFormatAvailable(CF_ENHMETAFILE) != 0;
#endif // wxUSE_ENH_METAFILE

        default:
            return FALSE;
    }
}

bool wxSetClipboardData(wxDataFormat dataFormat,
                        const void *data,
                        int width, int height)
{
    HANDLE handle = 0; // return value of SetClipboardData

    switch (dataFormat)
    {
        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;
            }

    // VZ: I'm told that this code works, but it doesn't seem to work for me
    //     and, anyhow, I'd be highly surprized if it did. So I leave it here
    //     but IMNSHO it is completely broken.
#if wxUSE_METAFILE && !defined(wxMETAFILE_IS_ENH)
        case wxDF_METAFILE:
            {
                wxMetafile *wxMF = (wxMetafile *)data;
                HANDLE data = GlobalAlloc(GHND, sizeof(METAFILEPICT) + 1);
                METAFILEPICT *mf = (METAFILEPICT *)GlobalLock(data);

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

                handle = SetClipboardData(CF_METAFILEPICT, data);
                break;
            }
#endif // wxUSE_METAFILE

#if wxUSE_ENH_METAFILE && !defined(__WIN16__)
        case wxDF_ENHMETAFILE:
            {
                wxEnhMetaFile *emf = (wxEnhMetaFile *)data;
                wxEnhMetaFile emfCopy = *emf;

                handle = SetClipboardData(CF_ENHMETAFILE,
                                          (void *)emfCopy.GetHENHMETAFILE());
            }
            break;
#endif // wxUSE_ENH_METAFILE

        case CF_SYLK:
        case CF_DIF:
        case CF_TIFF:
        case CF_PALETTE:
        default:
            {
                wxLogError(_("Unsupported clipboard format."));
                return FALSE;
            }

        case wxDF_OEMTEXT:
            dataFormat = wxDF_TEXT;
            // fall through

        case wxDF_TEXT:
            {
                char *s = (char *)data;

                width = strlen(s) + 1;
                height = 1;
                DWORD l = (width * height);
                HANDLE hGlobalMemory = GlobalAlloc(GHND, l);
                if ( hGlobalMemory )
                {
                    LPSTR lpGlobalMemory = (LPSTR)GlobalLock(hGlobalMemory);

                    memcpy(lpGlobalMemory, s, l);

                    GlobalUnlock(hGlobalMemory);
                }

                handle = SetClipboardData(dataFormat, hGlobalMemory);
                break;
            }
    }

    if ( handle == 0 )
    {
        wxLogSysError(_("Failed to set clipboard data."));

        return FALSE;
    }

    return TRUE;
}

void *wxGetClipboardData(wxDataFormat dataFormat, long *len)
{
    void *retval = NULL;

    switch ( dataFormat )
    {
        case wxDF_BITMAP:
            {
                BITMAP bm;
                HBITMAP hBitmap = (HBITMAP) GetClipboardData(CF_BITMAP);
                if (!hBitmap)
                    break;

                HDC hdcMem = CreateCompatibleDC((HDC) NULL);
                HDC hdcSrc = CreateCompatibleDC((HDC) 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);
                    break;
                }

                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);
#if WXWIN_COMPATIBILITY_2
                wxBM->SetOk(TRUE);
#endif // WXWIN_COMPATIBILITY_2
                retval = wxBM;
                break;
            }

        case wxDF_METAFILE:
        case CF_SYLK:
        case CF_DIF:
        case CF_TIFF:
        case CF_PALETTE:
        case wxDF_DIB:
            {
                wxLogError(_("Unsupported clipboard format."));
                return FALSE;
            }

        case wxDF_OEMTEXT:
            dataFormat = wxDF_TEXT;
            // 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;

                LPSTR lpGlobalMemory = (LPSTR)::GlobalLock(hGlobalMemory);

                memcpy(s, lpGlobalMemory, hsize);

                ::GlobalUnlock(hGlobalMemory);

                retval = s;
                break;
            }

        default:
            {
                HANDLE hGlobalMemory = ::GetClipboardData(dataFormat);
                if ( !hGlobalMemory )
                    break;

                DWORD size = ::GlobalSize(hGlobalMemory);
                if ( len )
                    *len = size;

                void *buf = malloc(size);
                if ( !buf )
                    break;

                LPSTR lpGlobalMemory = (LPSTR)::GlobalLock(hGlobalMemory);

                memcpy(buf, lpGlobalMemory, size);

                ::GlobalUnlock(hGlobalMemory);

                retval = buf;
                break;
            }
    }

    if ( !retval )
    {
        wxLogSysError(_("Failed to retrieve data from the clipboard."));
    }

    return retval;
}

wxDataFormat wxEnumClipboardFormats(wxDataFormat dataFormat)
{
  return (wxDataFormat::NativeFormat)::EnumClipboardFormats(dataFormat);
}

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

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

// ---------------------------------------------------------------------------
// wxClipboard
// ---------------------------------------------------------------------------

IMPLEMENT_DYNAMIC_CLASS(wxClipboard, wxObject)

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

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

void wxClipboard::Clear()
{
#if wxUSE_OLE_CLIPBOARD
    if ( FAILED(OleSetClipboard(NULL)) )
    {
        wxLogLastError(wxT("OleSetClipboard(NULL)"));
    }
#endif
}

bool wxClipboard::Flush()
{
#if wxUSE_OLE_CLIPBOARD
    if ( FAILED(OleFlushClipboard()) )
    {
        wxLogLastError(wxT("OleFlushClipboard"));

        return FALSE;
    }
    else
    {
        m_clearOnExit = FALSE;

        return TRUE;
    }
#else // !wxUSE_OLE_CLIPBOARD
    return FALSE;
#endif // wxUSE_OLE_CLIPBOARD/!wxUSE_OLE_CLIPBOARD
}

bool wxClipboard::Open()
{
    // OLE opens clipboard for us
#if wxUSE_OLE_CLIPBOARD
    return TRUE;
#else
    return wxOpenClipboard();
#endif
}

bool wxClipboard::IsOpened() const
{
#if wxUSE_OLE_CLIPBOARD
    return TRUE;
#else
    return wxIsClipboardOpened();
#endif
}

bool wxClipboard::SetData( wxDataObject *data )
{
#if !wxUSE_OLE_CLIPBOARD
    (void)wxEmptyClipboard();
#endif // wxUSE_OLE_CLIPBOARD

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

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

#if wxUSE_OLE_CLIPBOARD
    HRESULT hr = OleSetClipboard(data->GetInterface());
    if ( FAILED(hr) )
    {
        wxLogSysError(hr, _("Failed to put data on the clipboard"));

        // don't free anything in this case

        return FALSE;
    }

    // we have a problem here because we should delete wxDataObject, but we
    // can't do it because IDataObject which we just gave to the clipboard
    // would try to use it when it will need the data. IDataObject is ref
    // counted and so doesn't suffer from such problem, so we release it now
    // and tell it to delete wxDataObject when it is deleted itself.
    data->SetAutoDelete();

    // we have to call either OleSetClipboard(NULL) or OleFlushClipboard() when
    // using OLE clipboard when the app terminates - by default, we call
    // OleSetClipboard(NULL) which won't waste RAM, but the app can call
    // wxClipboard::Flush() to chaneg this
    m_clearOnExit = TRUE;

    return TRUE;
#elif wxUSE_DATAOBJ
    wxCHECK_MSG( wxIsClipboardOpened(), FALSE, wxT("clipboard not open") );

    wxDataFormat format = data->GetFormat();

    switch ( format )
    {
        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(data->GetFormat(), &bitmap);
        }

#if 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);
    }
#else // !wxUSE_DATAOBJ
    return FALSE;
#endif // wxUSE_DATAOBJ/!wxUSE_DATAOBJ
}

void wxClipboard::Close()
{
    // OLE closes clipboard for us
#if !wxUSE_OLE_CLIPBOARD
    wxCloseClipboard();
#endif
}

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

bool wxClipboard::GetData( wxDataObject& data )
{
#if wxUSE_OLE_CLIPBOARD
    IDataObject *pDataObject = NULL;
    HRESULT hr = OleGetClipboard(&pDataObject);
    if ( FAILED(hr) || !pDataObject )
    {
        wxLogSysError(hr, _("Failed to get data from the clipboard"));

        return FALSE;
    }

    // build the list of supported formats
    size_t nFormats = data.GetFormatCount(wxDataObject::Set);
    wxDataFormat format;
	wxDataFormat *formats;
    if ( nFormats == 1 )
    {
        // the most common case
        formats = &format;
    }
    else
    {
        // bad luck, need to alloc mem
        formats = new wxDataFormat[nFormats];
    }

    data.GetAllFormats(formats, wxDataObject::Set);

    // get the format enumerator
    bool result = FALSE;
    wxArrayInt supportedFormats;
    IEnumFORMATETC *pEnumFormatEtc = NULL;
    hr = pDataObject->EnumFormatEtc(DATADIR_GET, &pEnumFormatEtc);
    if ( FAILED(hr) || !pEnumFormatEtc )
    {
        wxLogSysError(hr,
                      _("Failed to retrieve the supported clipboard formats"));
    }
    else
    {
        // ask for the supported formats and see if there are any we support
        FORMATETC formatEtc;
        for ( ;; )
        {
            ULONG nCount;
            hr = pEnumFormatEtc->Next(1, &formatEtc, &nCount);

            // don't use FAILED() because S_FALSE would pass it
            if ( hr != S_OK )
            {
                // no more formats
                break;
            }

            CLIPFORMAT cf = formatEtc.cfFormat;

#ifdef __WXDEBUG__
            wxLogTrace(wxTRACE_OleCalls,
                       wxT("Object on the clipboard supports format %s."),
                       wxDataObject::GetFormatName(cf));
#endif // Debug

            // is supported?
            for ( size_t n = 0; n < nFormats; n++ )
            {
                if ( formats[n].GetFormatId() == cf )
                {
                    if ( supportedFormats.Index(cf) == wxNOT_FOUND )
                    {
                        supportedFormats.Add(cf);
                    }
                }
            }
        }

        pEnumFormatEtc->Release();
    }

    if ( formats != &format )
    {
        delete [] formats;
    }
    //else: we didn't allocate any memory

    if ( !supportedFormats.IsEmpty() )
    {
        FORMATETC formatEtc;
        formatEtc.ptd      = NULL;
        formatEtc.dwAspect = DVASPECT_CONTENT;
        formatEtc.lindex   = -1;

        size_t nSupportedFormats = supportedFormats.GetCount();
        for ( size_t n = 0; !result && (n < nSupportedFormats); n++ )
        {
            STGMEDIUM medium;
            formatEtc.cfFormat = supportedFormats[n];

            // use the appropriate tymed
            switch ( formatEtc.cfFormat )
            {
                case CF_BITMAP:
                    formatEtc.tymed = TYMED_GDI;
                    break;

                case CF_METAFILEPICT:
                    formatEtc.tymed = TYMED_MFPICT;
                    break;

                case CF_ENHMETAFILE:
                    formatEtc.tymed = TYMED_ENHMF;
                    break;

                default:
                    formatEtc.tymed = TYMED_HGLOBAL;
            }

            // try to get data
            hr = pDataObject->GetData(&formatEtc, &medium);
            if ( FAILED(hr) )
            {
                // try other tymed for GDI objects
                if ( formatEtc.cfFormat == CF_BITMAP )
                {
                    formatEtc.tymed = TYMED_HGLOBAL;
                    hr = pDataObject->GetData(&formatEtc, &medium);
                }
            }

            if ( SUCCEEDED(hr) )
            {
                // pass the data to the data object
                hr = data.GetInterface()->SetData(&formatEtc, &medium, TRUE);
                if ( FAILED(hr) )
                {
                    wxLogDebug(wxT("Failed to set data in wxIDataObject"));

                    // IDataObject only takes the ownership of data if it
                    // successfully got it - which is not the case here
                    ReleaseStgMedium(&medium);
                }
                else
                {
                    result = TRUE;
                }
            }
            //else: unsupported tymed?
        }
    }
    //else: unsupported format

    // clean up and return
    pDataObject->Release();

    return result;
#elif wxUSE_DATAOBJ
    wxCHECK_MSG( wxIsClipboardOpened(), FALSE, wxT("clipboard not open") );

    wxDataFormat format = data.GetFormat();
    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(data->GetFormat());
            if ( !bitmap )
                return FALSE;

            bitmapDataObject.SetBitmap(*bitmap);
            delete bitmap;

            return TRUE;
        }
#if 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
    }
    return FALSE;
#else // !wxUSE_DATAOBJ
    wxFAIL_MSG( wxT("no clipboard implementation") );
    return FALSE;
#endif // wxUSE_OLE_CLIPBOARD/wxUSE_DATAOBJ
}

#else
//    #error "Please turn wxUSE_CLIPBOARD on to compile this file."
#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	// ===========================================================================
	13	// declarations
	14	// ===========================================================================
	15
	16	// ---------------------------------------------------------------------------
	17	// headers
	18	// ---------------------------------------------------------------------------
	19
	20	#ifdef __GNUG__
	21	#pragma implementation "clipbrd.h"
	22	#endif
	23
	24	// For compilers that support precompilation, includes "wx.h".
	25	#include "wx/wxprec.h"
	26
	27	#ifdef __BORLANDC__
	28	#pragma hdrstop
	29	#endif
	30
	31	#ifndef WX_PRECOMP
	32	#include "wx/setup.h"
	33	#endif
	34
	35	#if wxUSE_CLIPBOARD
	36
	37	#ifndef WX_PRECOMP
	38	#include "wx/object.h"
	39	#include "wx/event.h"
	40	#include "wx/app.h"
	41	#include "wx/frame.h"
	42	#include "wx/bitmap.h"
	43	#include "wx/utils.h"
	44	#include "wx/intl.h"
	45	#endif
	46
	47	#if wxUSE_METAFILE
	48	#include "wx/metafile.h"
	49	#endif
	50
	51	#include "wx/log.h"
	52	#include "wx/clipbrd.h"
	53
	54	#include <string.h>
	55	#include <windows.h>
	56
	57	#include "wx/msw/private.h"
	58	#include "wx/msw/dib.h"
	59
	60	// wxDataObject is tied to OLE/drag and drop implementation, therefore so are
	61	// the functions using wxDataObject in wxClipboard
	62	//#define wxUSE_DATAOBJ wxUSE_DRAG_AND_DROP
	63
	64	#if wxUSE_DATAOBJ
	65	#include "wx/dataobj.h"
	66
	67	// use OLE clipboard
	68	#define wxUSE_OLE_CLIPBOARD 1
	69	#else // !wxUSE_DATAOBJ
	70	// use Win clipboard API
	71	#define wxUSE_OLE_CLIPBOARD 0
	72	#endif
	73
	74	#if wxUSE_OLE_CLIPBOARD
	75	#include <ole2.h>
	76	#endif // wxUSE_OLE_CLIPBOARD
	77
	78	#ifdef __WIN16__
	79	#define memcpy hmemcpy
	80	#endif
	81
	82	// ===========================================================================
	83	// implementation
	84	// ===========================================================================
	85
	86	// ---------------------------------------------------------------------------
	87	// old-style clipboard functions using Windows API
	88	// ---------------------------------------------------------------------------
	89
	90	static bool gs_wxClipboardIsOpen = FALSE;
	91
	92	bool wxOpenClipboard()
	93	{
	94	wxCHECK_MSG( !gs_wxClipboardIsOpen, TRUE, wxT("clipboard already opened.") );
	95
	96	wxWindow *win = wxTheApp->GetTopWindow();
	97	if ( win )
	98	{
	99	gs_wxClipboardIsOpen = ::OpenClipboard((HWND)win->GetHWND()) != 0;
	100
	101	if ( !gs_wxClipboardIsOpen )
	102	wxLogSysError(_("Failed to open the clipboard."));
	103
	104	return gs_wxClipboardIsOpen;
	105	}
	106	else
	107	{
	108	wxLogDebug(wxT("Can not open clipboard without a main window."));
	109
	110	return FALSE;
	111	}
	112	}
	113
	114	bool wxCloseClipboard()
	115	{
	116	wxCHECK_MSG( gs_wxClipboardIsOpen, FALSE, wxT("clipboard is not opened") );
	117
	118	gs_wxClipboardIsOpen = FALSE;
	119
	120	if ( ::CloseClipboard() == 0 )
	121	{
	122	wxLogSysError(_("Failed to close the clipboard."));
	123
	124	return FALSE;
	125	}
	126
	127	return TRUE;
	128	}
	129
	130	bool wxEmptyClipboard()
	131	{
	132	if ( ::EmptyClipboard() == 0 )
	133	{
	134	wxLogSysError(_("Failed to empty the clipboard."));
	135
	136	return FALSE;
	137	}
	138
	139	return TRUE;
	140	}
	141
	142	bool wxIsClipboardOpened()
	143	{
	144	return gs_wxClipboardIsOpen;
	145	}
	146
	147	bool wxIsClipboardFormatAvailable(wxDataFormat dataFormat)
	148	{
	149	if ( ::IsClipboardFormatAvailable(dataFormat) )
	150	{
	151	// ok from the first try
	152	return TRUE;
	153	}
	154
	155	// for several standard formats, we can convert from some other ones too
	156	switch ( dataFormat.GetFormatId() )
	157	{
	158	// for bitmaps, DIBs will also do
	159	case CF_BITMAP:
	160	return ::IsClipboardFormatAvailable(CF_DIB) != 0;
	161
	162	#if wxUSE_ENH_METAFILE && !defined(__WIN16__)
	163	case CF_METAFILEPICT:
	164	return ::IsClipboardFormatAvailable(CF_ENHMETAFILE) != 0;
	165	#endif // wxUSE_ENH_METAFILE
	166
	167	default:
	168	return FALSE;
	169	}
	170	}
	171
	172	bool wxSetClipboardData(wxDataFormat dataFormat,
	173	const void *data,
	174	int width, int height)
	175	{
	176	HANDLE handle = 0; // return value of SetClipboardData
	177
	178	switch (dataFormat)
	179	{
	180	case wxDF_BITMAP:
	181	{
	182	wxBitmap bitmap = (wxBitmap )data;
	183
	184	HDC hdcMem = CreateCompatibleDC((HDC) NULL);
	185	HDC hdcSrc = CreateCompatibleDC((HDC) NULL);
	186	HBITMAP old = (HBITMAP)
	187	::SelectObject(hdcSrc, (HBITMAP)bitmap->GetHBITMAP());
	188	HBITMAP hBitmap = CreateCompatibleBitmap(hdcSrc,
	189	bitmap->GetWidth(),
	190	bitmap->GetHeight());
	191	if (!hBitmap)
	192	{
	193	SelectObject(hdcSrc, old);
	194	DeleteDC(hdcMem);
	195	DeleteDC(hdcSrc);
	196	return FALSE;
	197	}
	198
	199	HBITMAP old1 = (HBITMAP) SelectObject(hdcMem, hBitmap);
	200	BitBlt(hdcMem, 0, 0, bitmap->GetWidth(), bitmap->GetHeight(),
	201	hdcSrc, 0, 0, SRCCOPY);
	202
	203	// Select new bitmap out of memory DC
	204	SelectObject(hdcMem, old1);
	205
	206	// Set the data
	207	handle = ::SetClipboardData(CF_BITMAP, hBitmap);
	208
	209	// Clean up
	210	SelectObject(hdcSrc, old);
	211	DeleteDC(hdcSrc);
	212	DeleteDC(hdcMem);
	213	break;
	214	}
	215
	216	case wxDF_DIB:
	217	{
	218	#if wxUSE_IMAGE_LOADING_IN_MSW
	219	wxBitmap bitmap = (wxBitmap )data;
	220	HBITMAP hBitmap = (HBITMAP)bitmap->GetHBITMAP();
	221	// NULL palette means to use the system one
	222	HANDLE hDIB = wxBitmapToDIB(hBitmap, (HPALETTE)NULL);
	223	handle = SetClipboardData(CF_DIB, hDIB);
	224	#endif // wxUSE_IMAGE_LOADING_IN_MSW
	225	break;
	226	}
	227
	228	// VZ: I'm told that this code works, but it doesn't seem to work for me
	229	// and, anyhow, I'd be highly surprized if it did. So I leave it here
	230	// but IMNSHO it is completely broken.
	231	#if wxUSE_METAFILE && !defined(wxMETAFILE_IS_ENH)
	232	case wxDF_METAFILE:
	233	{
	234	wxMetafile wxMF = (wxMetafile )data;
	235	HANDLE data = GlobalAlloc(GHND, sizeof(METAFILEPICT) + 1);
	236	METAFILEPICT mf = (METAFILEPICT )GlobalLock(data);
	237
	238	mf->mm = wxMF->GetWindowsMappingMode();
	239	mf->xExt = width;
	240	mf->yExt = height;
	241	mf->hMF = (HMETAFILE) wxMF->GetHMETAFILE();
	242	GlobalUnlock(data);
	243	wxMF->SetHMETAFILE((WXHANDLE) NULL);
	244
	245	handle = SetClipboardData(CF_METAFILEPICT, data);
	246	break;
	247	}
	248	#endif // wxUSE_METAFILE
	249
	250	#if wxUSE_ENH_METAFILE && !defined(__WIN16__)
	251	case wxDF_ENHMETAFILE:
	252	{
	253	wxEnhMetaFile emf = (wxEnhMetaFile )data;
	254	wxEnhMetaFile emfCopy = *emf;
	255
	256	handle = SetClipboardData(CF_ENHMETAFILE,
	257	(void *)emfCopy.GetHENHMETAFILE());
	258	}
	259	break;
	260	#endif // wxUSE_ENH_METAFILE
	261
	262	case CF_SYLK:
	263	case CF_DIF:
	264	case CF_TIFF:
	265	case CF_PALETTE:
	266	default:
	267	{
	268	wxLogError(_("Unsupported clipboard format."));
	269	return FALSE;
	270	}
	271
	272	case wxDF_OEMTEXT:
	273	dataFormat = wxDF_TEXT;
	274	// fall through
	275
	276	case wxDF_TEXT:
	277	{
	278	char s = (char )data;
	279
	280	width = strlen(s) + 1;
	281	height = 1;
	282	DWORD l = (width * height);
	283	HANDLE hGlobalMemory = GlobalAlloc(GHND, l);
	284	if ( hGlobalMemory )
	285	{
	286	LPSTR lpGlobalMemory = (LPSTR)GlobalLock(hGlobalMemory);
	287
	288	memcpy(lpGlobalMemory, s, l);
	289
	290	GlobalUnlock(hGlobalMemory);
	291	}
	292
	293	handle = SetClipboardData(dataFormat, hGlobalMemory);
	294	break;
	295	}
	296	}
	297
	298	if ( handle == 0 )
	299	{
	300	wxLogSysError(_("Failed to set clipboard data."));
	301
	302	return FALSE;
	303	}
	304
	305	return TRUE;
	306	}
	307
	308	void wxGetClipboardData(wxDataFormat dataFormat, long len)
	309	{
	310	void *retval = NULL;
	311
	312	switch ( dataFormat )
	313	{
	314	case wxDF_BITMAP:
	315	{
	316	BITMAP bm;
	317	HBITMAP hBitmap = (HBITMAP) GetClipboardData(CF_BITMAP);
	318	if (!hBitmap)
	319	break;
	320
	321	HDC hdcMem = CreateCompatibleDC((HDC) NULL);
	322	HDC hdcSrc = CreateCompatibleDC((HDC) NULL);
	323
	324	HBITMAP old = (HBITMAP) ::SelectObject(hdcSrc, hBitmap);
	325	GetObject(hBitmap, sizeof(BITMAP), (LPSTR)&bm);
	326
	327	HBITMAP hNewBitmap = CreateBitmapIndirect(&bm);
	328
	329	if (!hNewBitmap)
	330	{
	331	SelectObject(hdcSrc, old);
	332	DeleteDC(hdcMem);
	333	DeleteDC(hdcSrc);
	334	break;
	335	}
	336
	337	HBITMAP old1 = (HBITMAP) SelectObject(hdcMem, hNewBitmap);
	338	BitBlt(hdcMem, 0, 0, bm.bmWidth, bm.bmHeight,
	339	hdcSrc, 0, 0, SRCCOPY);
	340
	341	// Select new bitmap out of memory DC
	342	SelectObject(hdcMem, old1);
	343
	344	// Clean up
	345	SelectObject(hdcSrc, old);
	346	DeleteDC(hdcSrc);
	347	DeleteDC(hdcMem);
	348
	349	// Create and return a new wxBitmap
	350	wxBitmap *wxBM = new wxBitmap;
	351	wxBM->SetHBITMAP((WXHBITMAP) hNewBitmap);
	352	wxBM->SetWidth(bm.bmWidth);
	353	wxBM->SetHeight(bm.bmHeight);
	354	wxBM->SetDepth(bm.bmPlanes);
	355	#if WXWIN_COMPATIBILITY_2
	356	wxBM->SetOk(TRUE);
	357	#endif // WXWIN_COMPATIBILITY_2
	358	retval = wxBM;
	359	break;
	360	}
	361
	362	case wxDF_METAFILE:
	363	case CF_SYLK:
	364	case CF_DIF:
	365	case CF_TIFF:
	366	case CF_PALETTE:
	367	case wxDF_DIB:
	368	{
	369	wxLogError(_("Unsupported clipboard format."));
	370	return FALSE;
	371	}
	372
	373	case wxDF_OEMTEXT:
	374	dataFormat = wxDF_TEXT;
	375	// fall through
	376
	377	case wxDF_TEXT:
	378	{
	379	HANDLE hGlobalMemory = ::GetClipboardData(dataFormat);
	380	if (!hGlobalMemory)
	381	break;
	382
	383	DWORD hsize = ::GlobalSize(hGlobalMemory);
	384	if (len)
	385	*len = hsize;
	386
	387	char *s = new char[hsize];
	388	if (!s)
	389	break;
	390
	391	LPSTR lpGlobalMemory = (LPSTR)::GlobalLock(hGlobalMemory);
	392
	393	memcpy(s, lpGlobalMemory, hsize);
	394
	395	::GlobalUnlock(hGlobalMemory);
	396
	397	retval = s;
	398	break;
	399	}
	400
	401	default:
	402	{
	403	HANDLE hGlobalMemory = ::GetClipboardData(dataFormat);
	404	if ( !hGlobalMemory )
	405	break;
	406
	407	DWORD size = ::GlobalSize(hGlobalMemory);
	408	if ( len )
	409	*len = size;
	410
	411	void *buf = malloc(size);
	412	if ( !buf )
	413	break;
	414
	415	LPSTR lpGlobalMemory = (LPSTR)::GlobalLock(hGlobalMemory);
	416
	417	memcpy(buf, lpGlobalMemory, size);
	418
	419	::GlobalUnlock(hGlobalMemory);
	420
	421	retval = buf;
	422	break;
	423	}
	424	}
	425
	426	if ( !retval )
	427	{
	428	wxLogSysError(_("Failed to retrieve data from the clipboard."));
	429	}
	430
	431	return retval;
	432	}
	433
	434	wxDataFormat wxEnumClipboardFormats(wxDataFormat dataFormat)
	435	{
	436	return (wxDataFormat::NativeFormat)::EnumClipboardFormats(dataFormat);
	437	}
	438
	439	int wxRegisterClipboardFormat(wxChar *formatName)
	440	{
	441	return ::RegisterClipboardFormat(formatName);
	442	}
	443
	444	bool wxGetClipboardFormatName(wxDataFormat dataFormat,
	445	wxChar *formatName,
	446	int maxCount)
	447	{
	448	return ::GetClipboardFormatName((int)dataFormat, formatName, maxCount) > 0;
	449	}
	450
	451	// ---------------------------------------------------------------------------
	452	// wxClipboard
	453	// ---------------------------------------------------------------------------
	454
	455	IMPLEMENT_DYNAMIC_CLASS(wxClipboard, wxObject)
	456
	457	wxClipboard::wxClipboard()
	458	{
	459	m_clearOnExit = FALSE;
	460	}
	461
	462	wxClipboard::~wxClipboard()
	463	{
	464	if ( m_clearOnExit )
	465	{
	466	Clear();
	467	}
	468	}
	469
	470	void wxClipboard::Clear()
	471	{
	472	#if wxUSE_OLE_CLIPBOARD
	473	if ( FAILED(OleSetClipboard(NULL)) )
	474	{
	475	wxLogLastError(wxT("OleSetClipboard(NULL)"));
	476	}
	477	#endif
	478	}
	479
	480	bool wxClipboard::Flush()
	481	{
	482	#if wxUSE_OLE_CLIPBOARD
	483	if ( FAILED(OleFlushClipboard()) )
	484	{
	485	wxLogLastError(wxT("OleFlushClipboard"));
	486
	487	return FALSE;
	488	}
	489	else
	490	{
	491	m_clearOnExit = FALSE;
	492
	493	return TRUE;
	494	}
	495	#else // !wxUSE_OLE_CLIPBOARD
	496	return FALSE;
	497	#endif // wxUSE_OLE_CLIPBOARD/!wxUSE_OLE_CLIPBOARD
	498	}
	499
	500	bool wxClipboard::Open()
	501	{
	502	// OLE opens clipboard for us
	503	#if wxUSE_OLE_CLIPBOARD
	504	return TRUE;
	505	#else
	506	return wxOpenClipboard();
	507	#endif
	508	}
	509
	510	bool wxClipboard::IsOpened() const
	511	{
	512	#if wxUSE_OLE_CLIPBOARD
	513	return TRUE;
	514	#else
	515	return wxIsClipboardOpened();
	516	#endif
	517	}
	518
	519	bool wxClipboard::SetData( wxDataObject *data )
	520	{
	521	#if !wxUSE_OLE_CLIPBOARD
	522	(void)wxEmptyClipboard();
	523	#endif // wxUSE_OLE_CLIPBOARD
	524
	525	if ( data )
	526	return AddData(data);
	527	else
	528	return TRUE;
	529	}
	530
	531	bool wxClipboard::AddData( wxDataObject *data )
	532	{
	533	wxCHECK_MSG( data, FALSE, wxT("data is invalid") );
	534
	535	#if wxUSE_OLE_CLIPBOARD
	536	HRESULT hr = OleSetClipboard(data->GetInterface());
	537	if ( FAILED(hr) )
	538	{
	539	wxLogSysError(hr, _("Failed to put data on the clipboard"));
	540
	541	// don't free anything in this case
	542
	543	return FALSE;
	544	}
	545
	546	// we have a problem here because we should delete wxDataObject, but we
	547	// can't do it because IDataObject which we just gave to the clipboard
	548	// would try to use it when it will need the data. IDataObject is ref
	549	// counted and so doesn't suffer from such problem, so we release it now
	550	// and tell it to delete wxDataObject when it is deleted itself.
	551	data->SetAutoDelete();
	552
	553	// we have to call either OleSetClipboard(NULL) or OleFlushClipboard() when
	554	// using OLE clipboard when the app terminates - by default, we call
	555	// OleSetClipboard(NULL) which won't waste RAM, but the app can call
	556	// wxClipboard::Flush() to chaneg this
	557	m_clearOnExit = TRUE;
	558
	559	return TRUE;
	560	#elif wxUSE_DATAOBJ
	561	wxCHECK_MSG( wxIsClipboardOpened(), FALSE, wxT("clipboard not open") );
	562
	563	wxDataFormat format = data->GetFormat();
	564
	565	switch ( format )
	566	{
	567	case wxDF_TEXT:
	568	case wxDF_OEMTEXT:
	569	{
	570	wxTextDataObject* textDataObject = (wxTextDataObject*) data;
	571	wxString str(textDataObject->GetText());
	572	return wxSetClipboardData(format, str.c_str());
	573	}
	574
	575	case wxDF_BITMAP:
	576	case wxDF_DIB:
	577	{
	578	wxBitmapDataObject* bitmapDataObject = (wxBitmapDataObject*) data;
	579	wxBitmap bitmap(bitmapDataObject->GetBitmap());
	580	return wxSetClipboardData(data->GetFormat(), &bitmap);
	581	}
	582
	583	#if wxUSE_METAFILE
	584	case wxDF_METAFILE:
	585	{
	586	wxMetafileDataObject* metaFileDataObject =
	587	(wxMetafileDataObject*) data;
	588	wxMetafile metaFile = metaFileDataObject->GetMetafile();
	589	return wxSetClipboardData(wxDF_METAFILE, &metaFile,
	590	metaFileDataObject->GetWidth(),
	591	metaFileDataObject->GetHeight());
	592	}
	593	#endif // wxUSE_METAFILE
	594
	595	default:
	596	return wxSetClipboardData(data);
	597	}
	598	#else // !wxUSE_DATAOBJ
	599	return FALSE;
	600	#endif // wxUSE_DATAOBJ/!wxUSE_DATAOBJ
	601	}
	602
	603	void wxClipboard::Close()
	604	{
	605	// OLE closes clipboard for us
	606	#if !wxUSE_OLE_CLIPBOARD
	607	wxCloseClipboard();
	608	#endif
	609	}
	610
	611	bool wxClipboard::IsSupported( wxDataFormat format )
	612	{
	613	return wxIsClipboardFormatAvailable(format);
	614	}
	615
	616	bool wxClipboard::GetData( wxDataObject& data )
	617	{
	618	#if wxUSE_OLE_CLIPBOARD
	619	IDataObject *pDataObject = NULL;
	620	HRESULT hr = OleGetClipboard(&pDataObject);
	621	if ( FAILED(hr) \|\| !pDataObject )
	622	{
	623	wxLogSysError(hr, _("Failed to get data from the clipboard"));
	624
	625	return FALSE;
	626	}
	627
	628	// build the list of supported formats
	629	size_t nFormats = data.GetFormatCount(wxDataObject::Set);
	630	wxDataFormat format;
	631	wxDataFormat *formats;
	632	if ( nFormats == 1 )
	633	{
	634	// the most common case
	635	formats = &format;
	636	}
	637	else
	638	{
	639	// bad luck, need to alloc mem
	640	formats = new wxDataFormat[nFormats];
	641	}
	642
	643	data.GetAllFormats(formats, wxDataObject::Set);
	644
	645	// get the format enumerator
	646	bool result = FALSE;
	647	wxArrayInt supportedFormats;
	648	IEnumFORMATETC *pEnumFormatEtc = NULL;
	649	hr = pDataObject->EnumFormatEtc(DATADIR_GET, &pEnumFormatEtc);
	650	if ( FAILED(hr) \|\| !pEnumFormatEtc )
	651	{
	652	wxLogSysError(hr,
	653	_("Failed to retrieve the supported clipboard formats"));
	654	}
	655	else
	656	{
	657	// ask for the supported formats and see if there are any we support
	658	FORMATETC formatEtc;
	659	for ( ;; )
	660	{
	661	ULONG nCount;
	662	hr = pEnumFormatEtc->Next(1, &formatEtc, &nCount);
	663
	664	// don't use FAILED() because S_FALSE would pass it
	665	if ( hr != S_OK )
	666	{
	667	// no more formats
	668	break;
	669	}
	670
	671	CLIPFORMAT cf = formatEtc.cfFormat;
	672
	673	#ifdef __WXDEBUG__
	674	wxLogTrace(wxTRACE_OleCalls,
	675	wxT("Object on the clipboard supports format %s."),
	676	wxDataObject::GetFormatName(cf));
	677	#endif // Debug
	678
	679	// is supported?
	680	for ( size_t n = 0; n < nFormats; n++ )
	681	{
	682	if ( formats[n].GetFormatId() == cf )
	683	{
	684	if ( supportedFormats.Index(cf) == wxNOT_FOUND )
	685	{
	686	supportedFormats.Add(cf);
	687	}
	688	}
	689	}
	690	}
	691
	692	pEnumFormatEtc->Release();
	693	}
	694
	695	if ( formats != &format )
	696	{
	697	delete [] formats;
	698	}
	699	//else: we didn't allocate any memory
	700
	701	if ( !supportedFormats.IsEmpty() )
	702	{
	703	FORMATETC formatEtc;
	704	formatEtc.ptd = NULL;
	705	formatEtc.dwAspect = DVASPECT_CONTENT;
	706	formatEtc.lindex = -1;
	707
	708	size_t nSupportedFormats = supportedFormats.GetCount();
	709	for ( size_t n = 0; !result && (n < nSupportedFormats); n++ )
	710	{
	711	STGMEDIUM medium;
	712	formatEtc.cfFormat = supportedFormats[n];
	713
	714	// use the appropriate tymed
	715	switch ( formatEtc.cfFormat )
	716	{
	717	case CF_BITMAP:
	718	formatEtc.tymed = TYMED_GDI;
	719	break;
	720
	721	case CF_METAFILEPICT:
	722	formatEtc.tymed = TYMED_MFPICT;
	723	break;
	724
	725	case CF_ENHMETAFILE:
	726	formatEtc.tymed = TYMED_ENHMF;
	727	break;
	728
	729	default:
	730	formatEtc.tymed = TYMED_HGLOBAL;
	731	}
	732
	733	// try to get data
	734	hr = pDataObject->GetData(&formatEtc, &medium);
	735	if ( FAILED(hr) )
	736	{
	737	// try other tymed for GDI objects
	738	if ( formatEtc.cfFormat == CF_BITMAP )
	739	{
	740	formatEtc.tymed = TYMED_HGLOBAL;
	741	hr = pDataObject->GetData(&formatEtc, &medium);
	742	}
	743	}
	744
	745	if ( SUCCEEDED(hr) )
	746	{
	747	// pass the data to the data object
	748	hr = data.GetInterface()->SetData(&formatEtc, &medium, TRUE);
	749	if ( FAILED(hr) )
	750	{
	751	wxLogDebug(wxT("Failed to set data in wxIDataObject"));
	752
	753	// IDataObject only takes the ownership of data if it
	754	// successfully got it - which is not the case here
	755	ReleaseStgMedium(&medium);
	756	}
	757	else
	758	{
	759	result = TRUE;
	760	}
	761	}
	762	//else: unsupported tymed?
	763	}
	764	}
	765	//else: unsupported format
	766
	767	// clean up and return
	768	pDataObject->Release();
	769
	770	return result;
	771	#elif wxUSE_DATAOBJ
	772	wxCHECK_MSG( wxIsClipboardOpened(), FALSE, wxT("clipboard not open") );
	773
	774	wxDataFormat format = data.GetFormat();
	775	switch ( format )
	776	{
	777	case wxDF_TEXT:
	778	case wxDF_OEMTEXT:
	779	{
	780	wxTextDataObject& textDataObject = (wxTextDataObject &)data;
	781	char* s = (char*)wxGetClipboardData(format);
	782	if ( !s )
	783	return FALSE;
	784
	785	textDataObject.SetText(s);
	786	delete [] s;
	787
	788	return TRUE;
	789	}
	790
	791	case wxDF_BITMAP:
	792	case wxDF_DIB:
	793	{
	794	wxBitmapDataObject& bitmapDataObject = (wxBitmapDataObject &)data;
	795	wxBitmap* bitmap = (wxBitmap *)wxGetClipboardData(data->GetFormat());
	796	if ( !bitmap )
	797	return FALSE;
	798
	799	bitmapDataObject.SetBitmap(*bitmap);
	800	delete bitmap;
	801
	802	return TRUE;
	803	}
	804	#if wxUSE_METAFILE
	805	case wxDF_METAFILE:
	806	{
	807	wxMetafileDataObject& metaFileDataObject = (wxMetafileDataObject &)data;
	808	wxMetafile* metaFile = (wxMetafile *)wxGetClipboardData(wxDF_METAFILE);
	809	if ( !metaFile )
	810	return FALSE;
	811
	812	metaFileDataObject.SetMetafile(*metaFile);
	813	delete metaFile;
	814
	815	return TRUE;
	816	}
	817	#endif // wxUSE_METAFILE
	818	}
	819	return FALSE;
	820	#else // !wxUSE_DATAOBJ
	821	wxFAIL_MSG( wxT("no clipboard implementation") );
	822	return FALSE;
	823	#endif // wxUSE_OLE_CLIPBOARD/wxUSE_DATAOBJ
	824	}
	825
	826	#else
	827	// #error "Please turn wxUSE_CLIPBOARD on to compile this file."
	828	#endif // wxUSE_CLIPBOARD
	829