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

wxPrivateDataObject works under MSW as well (hopefully it still does under

Browse Source 
GTK too)


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@2578 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
1999-05-26 22:39:42 +00:00
parent 238d735dc2
commit 3f480da37c
14 changed files with 683 additions and 632 deletions
Download Patch File Download Diff File Expand all files Collapse all files

188
src/gtk/dataobj.cpp
View File

@@ -4,11 +4,11 @@
// Author: Robert Roebling
// Id: $Id$
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "dataobj.h"
#pragma implementation "dataobj.h"
#endif
#include "wx/dataobj.h"
@@ -38,7 +38,7 @@ wxDataFormat::wxDataFormat()
m_atom = (GdkAtom) 0;
}
wxDataFormat::wxDataFormat( wxDataType type )
wxDataFormat::wxDataFormat( wxDataFormatId type )
{
if (!g_textAtom) g_textAtom = gdk_atom_intern( "STRING", FALSE );
SetType( type );
@@ -69,9 +69,9 @@ wxDataFormat::wxDataFormat( const GdkAtom atom )
{
if (!g_textAtom) g_textAtom = gdk_atom_intern( "STRING", FALSE );
m_hasAtom = TRUE;
m_atom = atom;
if (m_atom == g_textAtom)
{
m_type = wxDF_TEXT;
@@ -83,7 +83,7 @@ wxDataFormat::wxDataFormat( const GdkAtom atom )
{
m_type = wxDF_PRIVATE;
m_id = gdk_atom_name( m_atom );
if (m_id == _T("file:ALL"))
{
m_type = wxDF_FILENAME;
@@ -91,19 +91,19 @@ wxDataFormat::wxDataFormat( const GdkAtom atom )
}
}
void wxDataFormat::SetType( wxDataType type )
void wxDataFormat::SetType( wxDataFormatId type )
{
m_type = type;
if (m_type == wxDF_TEXT)
{
m_id = _T("STRING");
}
}
else
if (m_type == wxDF_BITMAP)
{
m_id = _T("BITMAP");
}
}
else
if (m_type == wxDF_FILENAME)
{
@@ -113,11 +113,11 @@ void wxDataFormat::SetType( wxDataType type )
{
wxFAIL_MSG( _T("invalid dataformat") );
}
m_hasAtom = FALSE;
}
wxDataType wxDataFormat::GetType() const
wxDataFormatId wxDataFormat::GetType() const
{
return m_type;
}
@@ -139,7 +139,7 @@ GdkAtom wxDataFormat::GetAtom()
if (!m_hasAtom)
{
m_hasAtom = TRUE;
if (m_type == wxDF_TEXT)
{
m_atom = g_textAtom;
@@ -148,24 +148,24 @@ GdkAtom wxDataFormat::GetAtom()
if (m_type == wxDF_BITMAP)
{
m_atom = GDK_TARGET_BITMAP;
}
}
else
if (m_type == wxDF_PRIVATE)
{
m_atom = gdk_atom_intern( MBSTRINGCAST m_id.mbc_str(), FALSE );
}
}
else
if (m_type == wxDF_FILENAME)
{
m_atom = gdk_atom_intern( "file:ALL", FALSE );
}
}
else
{
m_hasAtom = FALSE;
m_atom = (GdkAtom) 0;
}
}
return m_atom;
}
@@ -175,93 +175,93 @@ GdkAtom wxDataFormat::GetAtom()
IMPLEMENT_CLASS(wxDataBroker,wxObject)
wxDataBroker::wxDataBroker()
{
wxDataBroker::wxDataBroker()
{
m_dataObjects.DeleteContents(TRUE);
m_preferred = 0;
}
void wxDataBroker::Add( wxDataObject *dataObject, bool preferred )
{
{
if (preferred) m_preferred = m_dataObjects.GetCount();
m_dataObjects.Append( dataObject );
}
size_t wxDataBroker::GetFormatCount() const
{
return m_dataObjects.GetCount();
}
size_t wxDataBroker::GetFormatCount() const
{
return m_dataObjects.GetCount();
}
wxDataFormat &wxDataBroker::GetPreferredFormat() const
{
{
wxNode *node = m_dataObjects.Nth( m_preferred );
wxASSERT( node );
wxDataObject* data_obj = (wxDataObject*)node->Data();
return data_obj->GetFormat();
}
wxDataFormat &wxDataBroker::GetNthFormat( size_t nth ) const
{
{
wxNode *node = m_dataObjects.Nth( nth );
wxASSERT( node );
wxDataObject* data_obj = (wxDataObject*)node->Data();
return data_obj->GetFormat();
}
bool wxDataBroker::IsSupportedFormat( wxDataFormat &format ) const
{
{
wxNode *node = m_dataObjects.First();
while (node)
{
wxDataObject *dobj = (wxDataObject*)node->Data();
if (dobj->GetFormat().GetAtom() == format.GetAtom())
{
return TRUE;
}
node = node->Next();
}
return FALSE;
}
size_t wxDataBroker::GetSize( wxDataFormat& format ) const
{
wxNode *node = m_dataObjects.First();
while (node)
{
wxDataObject *dobj = (wxDataObject*)node->Data();
if (dobj->GetFormat().GetAtom() == format.GetAtom())
{
return dobj->GetSize();
}
node = node->Next();
}
return 0;
}
void wxDataBroker::WriteData( wxDataFormat& format, void *dest ) const
{
wxNode *node = m_dataObjects.First();
while (node)
{
wxDataObject *dobj = (wxDataObject*)node->Data();
if (dobj->GetFormat().GetAtom() == format.GetAtom())
{
dobj->WriteData( dest );
}
node = node->Next();
}
}
@@ -275,7 +275,7 @@ IMPLEMENT_ABSTRACT_CLASS( wxDataObject, wxObject )
wxDataObject::wxDataObject()
{
}
wxDataObject::~wxDataObject()
{
}
@@ -285,7 +285,7 @@ wxDataFormat &wxDataObject::GetFormat()
return m_format;
}
wxDataType wxDataObject::GetFormatType() const
wxDataFormatId wxDataObject::GetFormatType() const
{
return m_format.GetType();
}
@@ -299,7 +299,7 @@ GdkAtom wxDataObject::GetFormatAtom() const
{
GdkAtom ret = ((wxDataObject*) this)->m_format.GetAtom();
return ret;
}
}
// ----------------------------------------------------------------------------
// wxTextDataObject
@@ -315,11 +315,11 @@ wxTextDataObject::wxTextDataObject()
wxTextDataObject::wxTextDataObject( const wxString& data )
{
m_format.SetType( wxDF_TEXT );
m_data = data;
}
void wxTextDataObject::SetText( const wxString& data )
void wxTextDataObject::SetText( const wxString& data )
{
m_data = data;
}
@@ -343,7 +343,7 @@ void wxTextDataObject::WriteString( const wxString &str, void *dest ) const
{
memcpy( dest, str.mb_str(), str.Len()+1 );
}
// ----------------------------------------------------------------------------
// wxFileDataObject
// ----------------------------------------------------------------------------
@@ -356,26 +356,26 @@ wxFileDataObject::wxFileDataObject()
}
void wxFileDataObject::AddFile( const wxString &file )
{
m_files += file;
m_files += (wxChar)0;
{
m_files += file;
m_files += (wxChar)0;
}
wxString wxFileDataObject::GetFiles() const
{
return m_files;
{
return m_files;
}
void wxFileDataObject::WriteData( void *dest ) const
{
memcpy( dest, m_files.mbc_str(), GetSize() );
}
size_t wxFileDataObject::GetSize() const
{
return m_files.Len() + 1;
}
// ----------------------------------------------------------------------------
// wxBitmapDataObject
// ----------------------------------------------------------------------------
@@ -390,7 +390,7 @@ wxBitmapDataObject::wxBitmapDataObject()
wxBitmapDataObject::wxBitmapDataObject( const wxBitmap& bitmap )
{
m_format.SetType( wxDF_BITMAP );
m_bitmap = bitmap;
}
@@ -418,54 +418,38 @@ void wxBitmapDataObject::WriteBitmap( const wxBitmap &bitmap, void *dest ) const
{
memcpy( dest, m_bitmap.GetPixmap(), GetSize() );
}
// ----------------------------------------------------------------------------
// wxPrivateDataObject
// ----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS( wxPrivateDataObject, wxDataObject )
wxPrivateDataObject::wxPrivateDataObject()
{
m_id = _T("application/");
m_id += wxTheApp->GetAppName();
m_format.SetId( m_id );
m_size = 0;
m_data = (char*) NULL;
}
wxPrivateDataObject::~wxPrivateDataObject()
{
if (m_data) delete[] m_data;
}
void wxPrivateDataObject::SetId( const wxString& id )
{
m_id = id;
m_format.SetId( m_id );
}
wxString wxPrivateDataObject::GetId() const
{
return m_id;
void wxPrivateDataObject::Free()
{
if ( m_data )
free(m_data);
}
void wxPrivateDataObject::SetData( const char *data, size_t size )
wxPrivateDataObject::wxPrivateDataObject()
{
wxString id = _T("application/");
id += wxTheApp->GetAppName();
m_format.SetId( id );
m_size = 0;
m_data = (void *)NULL;
}
void wxPrivateDataObject::SetData( const void *data, size_t size )
{
Free();
m_size = size;
if (m_data) delete[] m_data;
m_data = new char[size];
m_data = malloc(size);
memcpy( m_data, data, size );
}
char* wxPrivateDataObject::GetData() const
{
return m_data;
memcpy( m_data, data, size );
}
void wxPrivateDataObject::WriteData( void *dest ) const
@@ -475,10 +459,10 @@ void wxPrivateDataObject::WriteData( void *dest ) const
size_t wxPrivateDataObject::GetSize() const
{
return m_size;
return m_size;
}
void wxPrivateDataObject::WriteData( const char *data, void *dest ) const
void wxPrivateDataObject::WriteData( const void *data, void *dest ) const
{
memcpy( dest, data, GetSize() );
}

188
src/gtk1/dataobj.cpp
View File

@@ -4,11 +4,11 @@
// Author: Robert Roebling
// Id: $Id$
// Copyright: (c) 1998 Robert Roebling
// Licence: wxWindows licence
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "dataobj.h"
#pragma implementation "dataobj.h"
#endif
#include "wx/dataobj.h"
@@ -38,7 +38,7 @@ wxDataFormat::wxDataFormat()
m_atom = (GdkAtom) 0;
}
wxDataFormat::wxDataFormat( wxDataType type )
wxDataFormat::wxDataFormat( wxDataFormatId type )
{
if (!g_textAtom) g_textAtom = gdk_atom_intern( "STRING", FALSE );
SetType( type );
@@ -69,9 +69,9 @@ wxDataFormat::wxDataFormat( const GdkAtom atom )
{
if (!g_textAtom) g_textAtom = gdk_atom_intern( "STRING", FALSE );
m_hasAtom = TRUE;
m_atom = atom;
if (m_atom == g_textAtom)
{
m_type = wxDF_TEXT;
@@ -83,7 +83,7 @@ wxDataFormat::wxDataFormat( const GdkAtom atom )
{
m_type = wxDF_PRIVATE;
m_id = gdk_atom_name( m_atom );
if (m_id == _T("file:ALL"))
{
m_type = wxDF_FILENAME;
@@ -91,19 +91,19 @@ wxDataFormat::wxDataFormat( const GdkAtom atom )
}
}
void wxDataFormat::SetType( wxDataType type )
void wxDataFormat::SetType( wxDataFormatId type )
{
m_type = type;
if (m_type == wxDF_TEXT)
{
m_id = _T("STRING");
}
}
else
if (m_type == wxDF_BITMAP)
{
m_id = _T("BITMAP");
}
}
else
if (m_type == wxDF_FILENAME)
{
@@ -113,11 +113,11 @@ void wxDataFormat::SetType( wxDataType type )
{
wxFAIL_MSG( _T("invalid dataformat") );
}
m_hasAtom = FALSE;
}
wxDataType wxDataFormat::GetType() const
wxDataFormatId wxDataFormat::GetType() const
{
return m_type;
}
@@ -139,7 +139,7 @@ GdkAtom wxDataFormat::GetAtom()
if (!m_hasAtom)
{
m_hasAtom = TRUE;
if (m_type == wxDF_TEXT)
{
m_atom = g_textAtom;
@@ -148,24 +148,24 @@ GdkAtom wxDataFormat::GetAtom()
if (m_type == wxDF_BITMAP)
{
m_atom = GDK_TARGET_BITMAP;
}
}
else
if (m_type == wxDF_PRIVATE)
{
m_atom = gdk_atom_intern( MBSTRINGCAST m_id.mbc_str(), FALSE );
}
}
else
if (m_type == wxDF_FILENAME)
{
m_atom = gdk_atom_intern( "file:ALL", FALSE );
}
}
else
{
m_hasAtom = FALSE;
m_atom = (GdkAtom) 0;
}
}
return m_atom;
}
@@ -175,93 +175,93 @@ GdkAtom wxDataFormat::GetAtom()
IMPLEMENT_CLASS(wxDataBroker,wxObject)
wxDataBroker::wxDataBroker()
{
wxDataBroker::wxDataBroker()
{
m_dataObjects.DeleteContents(TRUE);
m_preferred = 0;
}
void wxDataBroker::Add( wxDataObject *dataObject, bool preferred )
{
{
if (preferred) m_preferred = m_dataObjects.GetCount();
m_dataObjects.Append( dataObject );
}
size_t wxDataBroker::GetFormatCount() const
{
return m_dataObjects.GetCount();
}
size_t wxDataBroker::GetFormatCount() const
{
return m_dataObjects.GetCount();
}
wxDataFormat &wxDataBroker::GetPreferredFormat() const
{
{
wxNode *node = m_dataObjects.Nth( m_preferred );
wxASSERT( node );
wxDataObject* data_obj = (wxDataObject*)node->Data();
return data_obj->GetFormat();
}
wxDataFormat &wxDataBroker::GetNthFormat( size_t nth ) const
{
{
wxNode *node = m_dataObjects.Nth( nth );
wxASSERT( node );
wxDataObject* data_obj = (wxDataObject*)node->Data();
return data_obj->GetFormat();
}
bool wxDataBroker::IsSupportedFormat( wxDataFormat &format ) const
{
{
wxNode *node = m_dataObjects.First();
while (node)
{
wxDataObject *dobj = (wxDataObject*)node->Data();
if (dobj->GetFormat().GetAtom() == format.GetAtom())
{
return TRUE;
}
node = node->Next();
}
return FALSE;
}
size_t wxDataBroker::GetSize( wxDataFormat& format ) const
{
wxNode *node = m_dataObjects.First();
while (node)
{
wxDataObject *dobj = (wxDataObject*)node->Data();
if (dobj->GetFormat().GetAtom() == format.GetAtom())
{
return dobj->GetSize();
}
node = node->Next();
}
return 0;
}
void wxDataBroker::WriteData( wxDataFormat& format, void *dest ) const
{
wxNode *node = m_dataObjects.First();
while (node)
{
wxDataObject *dobj = (wxDataObject*)node->Data();
if (dobj->GetFormat().GetAtom() == format.GetAtom())
{
dobj->WriteData( dest );
}
node = node->Next();
}
}
@@ -275,7 +275,7 @@ IMPLEMENT_ABSTRACT_CLASS( wxDataObject, wxObject )
wxDataObject::wxDataObject()
{
}
wxDataObject::~wxDataObject()
{
}
@@ -285,7 +285,7 @@ wxDataFormat &wxDataObject::GetFormat()
return m_format;
}
wxDataType wxDataObject::GetFormatType() const
wxDataFormatId wxDataObject::GetFormatType() const
{
return m_format.GetType();
}
@@ -299,7 +299,7 @@ GdkAtom wxDataObject::GetFormatAtom() const
{
GdkAtom ret = ((wxDataObject*) this)->m_format.GetAtom();
return ret;
}
}
// ----------------------------------------------------------------------------
// wxTextDataObject
@@ -315,11 +315,11 @@ wxTextDataObject::wxTextDataObject()
wxTextDataObject::wxTextDataObject( const wxString& data )
{
m_format.SetType( wxDF_TEXT );
m_data = data;
}
void wxTextDataObject::SetText( const wxString& data )
void wxTextDataObject::SetText( const wxString& data )
{
m_data = data;
}
@@ -343,7 +343,7 @@ void wxTextDataObject::WriteString( const wxString &str, void *dest ) const
{
memcpy( dest, str.mb_str(), str.Len()+1 );
}
// ----------------------------------------------------------------------------
// wxFileDataObject
// ----------------------------------------------------------------------------
@@ -356,26 +356,26 @@ wxFileDataObject::wxFileDataObject()
}
void wxFileDataObject::AddFile( const wxString &file )
{
m_files += file;
m_files += (wxChar)0;
{
m_files += file;
m_files += (wxChar)0;
}
wxString wxFileDataObject::GetFiles() const
{
return m_files;
{
return m_files;
}
void wxFileDataObject::WriteData( void *dest ) const
{
memcpy( dest, m_files.mbc_str(), GetSize() );
}
size_t wxFileDataObject::GetSize() const
{
return m_files.Len() + 1;
}
// ----------------------------------------------------------------------------
// wxBitmapDataObject
// ----------------------------------------------------------------------------
@@ -390,7 +390,7 @@ wxBitmapDataObject::wxBitmapDataObject()
wxBitmapDataObject::wxBitmapDataObject( const wxBitmap& bitmap )
{
m_format.SetType( wxDF_BITMAP );
m_bitmap = bitmap;
}
@@ -418,54 +418,38 @@ void wxBitmapDataObject::WriteBitmap( const wxBitmap &bitmap, void *dest ) const
{
memcpy( dest, m_bitmap.GetPixmap(), GetSize() );
}
// ----------------------------------------------------------------------------
// wxPrivateDataObject
// ----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS( wxPrivateDataObject, wxDataObject )
wxPrivateDataObject::wxPrivateDataObject()
{
m_id = _T("application/");
m_id += wxTheApp->GetAppName();
m_format.SetId( m_id );
m_size = 0;
m_data = (char*) NULL;
}
wxPrivateDataObject::~wxPrivateDataObject()
{
if (m_data) delete[] m_data;
}
void wxPrivateDataObject::SetId( const wxString& id )
{
m_id = id;
m_format.SetId( m_id );
}
wxString wxPrivateDataObject::GetId() const
{
return m_id;
void wxPrivateDataObject::Free()
{
if ( m_data )
free(m_data);
}
void wxPrivateDataObject::SetData( const char *data, size_t size )
wxPrivateDataObject::wxPrivateDataObject()
{
wxString id = _T("application/");
id += wxTheApp->GetAppName();
m_format.SetId( id );
m_size = 0;
m_data = (void *)NULL;
}
void wxPrivateDataObject::SetData( const void *data, size_t size )
{
Free();
m_size = size;
if (m_data) delete[] m_data;
m_data = new char[size];
m_data = malloc(size);
memcpy( m_data, data, size );
}
char* wxPrivateDataObject::GetData() const
{
return m_data;
memcpy( m_data, data, size );
}
void wxPrivateDataObject::WriteData( void *dest ) const
@@ -475,10 +459,10 @@ void wxPrivateDataObject::WriteData( void *dest ) const
size_t wxPrivateDataObject::GetSize() const
{
return m_size;
return m_size;
}
void wxPrivateDataObject::WriteData( const char *data, void *dest ) const
void wxPrivateDataObject::WriteData( const void *data, void *dest ) const
{
memcpy( dest, data, GetSize() );
}

117
src/msw/clipbrd.cpp
View File

@@ -50,6 +50,7 @@
#include "wx/log.h"
#include "wx/clipbrd.h"
#include <string.h>
#include <windows.h>
#include "wx/msw/private.h"
@@ -59,9 +60,13 @@
// therefore so is wxClipboard :-(
#if wxUSE_DRAG_AND_DROP
#include "wx/dataobj.h"
static bool wxSetClipboardData(wxDataObject *data);
#endif
#include <string.h>
#ifdef __WIN16__
#define memcpy hmemcpy
#endif
// ===========================================================================
// implementation
@@ -133,6 +138,38 @@ bool wxIsClipboardFormatAvailable(wxDataFormat dataFormat)
return ::IsClipboardFormatAvailable(dataFormat) != 0;
}
#if wxUSE_DRAG_AND_DROP
static bool wxSetClipboardData(wxDataObject *data)
{
size_t size = data->GetDataSize();
HANDLE hGlobal = ::GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, size);
if ( !hGlobal )
{
wxLogSysError(_("Failed to allocate %dKb of memory for clipboard "
"transfer."), size / 1024);
return FALSE;
}
LPVOID lpGlobalMemory = ::GlobalLock(hGlobal);
data->GetDataHere(lpGlobalMemory);
GlobalUnlock(hGlobal);
wxDataFormat format = data->GetPreferredFormat();
if ( !::SetClipboardData(format, hGlobal) )
{
wxLogSysError(_("Failed to set clipboard data in format %s"),
wxDataObject::GetFormatName(format));
return FALSE;
}
return TRUE;
}
#endif // wxUSE_DRAG_AND_DROP
bool wxSetClipboardData(wxDataFormat dataFormat,
const void *data,
int width, int height)
@@ -194,11 +231,7 @@ bool wxSetClipboardData(wxDataFormat dataFormat,
{
wxMetafile *wxMF = (wxMetafile *)data;
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;
@@ -235,19 +268,9 @@ bool wxSetClipboardData(wxDataFormat dataFormat,
HANDLE hGlobalMemory = GlobalAlloc(GHND, l);
if ( hGlobalMemory )
{
#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);
}
@@ -325,7 +348,6 @@ void *wxGetClipboardData(wxDataFormat dataFormat, long *len)
case CF_TIFF:
case CF_PALETTE:
case wxDF_DIB:
default:
{
wxLogError(_("Unsupported clipboard format."));
return FALSE;
@@ -349,25 +371,39 @@ void *wxGetClipboardData(wxDataFormat dataFormat, long *len)
if (!s)
break;
#ifdef __WINDOWS_386__
LPSTR lpGlobalMemory = (LPSTR)MK_FP32(GlobalLock(hGlobalMemory));
#else
LPSTR lpGlobalMemory = (LPSTR)::GlobalLock(hGlobalMemory);
#endif
#ifdef __WIN32__
memcpy(s, lpGlobalMemory, hsize);
#elif __WATCOMC__ && defined(__WINDOWS_386__)
memcpy(s, lpGlobalMemory, hsize);
#else
hmemcpy(s, lpGlobalMemory, hsize);
#endif
::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 )
@@ -378,9 +414,9 @@ void *wxGetClipboardData(wxDataFormat dataFormat, long *len)
return retval;
}
wxDataFormat wxEnumClipboardFormats(wxDataFormat dataFormat)
wxDataFormat wxEnumClipboardFormats(wxDataFormat dataFormat)
{
return (wxDataFormat)::EnumClipboardFormats(dataFormat);
return ::EnumClipboardFormats(dataFormat);
}
int wxRegisterClipboardFormat(char *formatName)
@@ -471,16 +507,11 @@ bool wxClipboard::AddData( wxDataObject *data )
#endif // wxUSE_METAFILE
default:
wxLogError(_("Can not put data in format '%s' on clipboard."),
wxDataObject::GetFormatName(format));
return FALSE;
return wxSetClipboardData(data);
}
#else // !wxUSE_DRAG_AND_DROP
return FALSE;
#else
return FALSE;
#endif
#endif // wxUSE_DRAG_AND_DROP/!wxUSE_DRAG_AND_DROP
}
void wxClipboard::Close()
@@ -546,8 +577,18 @@ bool wxClipboard::GetData( wxDataObject *data )
}
#endif
default:
wxLogError(_("Can not get data in format '%s' from clipboard."),
wxDataObject::GetFormatName(format));
{
long len;
void *buf = wxGetClipboardData(format, &len);
if ( buf )
{
// FIXME this is for testing only!!
((wxPrivateDataObject *)data)->SetData(buf, len);
free(buf);
return TRUE;
}
}
return FALSE;
}

88
src/msw/ole/dataobj.cpp
View File

@@ -28,12 +28,12 @@
#pragma hdrstop
#endif
#include <wx/defs.h>
#include "wx/defs.h"
#if defined(__WIN32__) && !defined(__GNUWIN32__)
#include <wx/log.h>
#include <wx/msw/ole/dataobj.h>
#include "wx/log.h"
#include "wx/dataobj.h"
#include <windows.h>
#include <oleauto.h>
@@ -43,7 +43,7 @@
#include <olestd.h>
#endif
#include <wx/msw/ole/oleutils.h>
#include "wx/msw/ole/oleutils.h"
// ----------------------------------------------------------------------------
// functions
@@ -101,6 +101,39 @@ private:
// implementation
// ============================================================================
// ----------------------------------------------------------------------------
// wxDataFormat
// ----------------------------------------------------------------------------
void wxDataFormat::SetId(const wxChar *format)
{
m_format = ::RegisterClipboardFormat(format);
if ( !m_format )
{
wxLogError(_("Couldn't register clipboard format '%s'."), format);
}
}
wxString wxDataFormat::GetId() const
{
static const int max = 256;
wxString s;
wxCHECK_MSG( !IsStandard(), s,
_T("name of predefined format cannot be retrieved") );
int len = ::GetClipboardFormatName(m_format, s.GetWriteBuf(max), max);
s.UngetWriteBuf();
if ( !len )
{
wxLogError(_("The clipboard format '%d' doesn't exist."), m_format);
}
return s;
}
// ----------------------------------------------------------------------------
// wxIEnumFORMATETC
// ----------------------------------------------------------------------------
@@ -284,14 +317,14 @@ STDMETHODIMP wxIDataObject::QueryGetData(FORMATETC *pformatetc)
}
// and now check the type of data requested
if ( m_pDataObject->IsSupportedFormat((wxDataFormat) pformatetc->cfFormat) ) {
if ( m_pDataObject->IsSupportedFormat((wxDataFormatId)pformatetc->cfFormat) ) {
wxLogTrace("wxIDataObject::QueryGetData: %s ok",
wxDataObject::GetFormatName((wxDataFormat) pformatetc->cfFormat));
wxDataObject::GetFormatName((wxDataFormatId)pformatetc->cfFormat));
return S_OK;
}
else {
wxLogTrace("wxIDataObject::QueryGetData: %s unsupported",
wxDataObject::GetFormatName((wxDataFormat) pformatetc->cfFormat));
wxDataObject::GetFormatName((wxDataFormatId)pformatetc->cfFormat));
return DV_E_FORMATETC;
}
}
@@ -399,6 +432,47 @@ const char *wxDataObject::GetFormatName(wxDataFormat format)
#endif // Debug
}
// ----------------------------------------------------------------------------
// wxPrivateDataObject
// ----------------------------------------------------------------------------
wxPrivateDataObject::wxPrivateDataObject()
{
m_size = 0;
m_data = NULL;
}
void wxPrivateDataObject::Free()
{
if ( m_data )
free(m_data);
}
void wxPrivateDataObject::SetData( const void *data, size_t size )
{
Free();
m_size = size;
m_data = malloc(size);
memcpy( m_data, data, size );
}
void wxPrivateDataObject::WriteData( void *dest ) const
{
WriteData( m_data, dest );
}
size_t wxPrivateDataObject::GetSize() const
{
return m_size;
}
void wxPrivateDataObject::WriteData( const void *data, void *dest ) const
{
memcpy( dest, data, GetSize() );
}
// ----------------------------------------------------------------------------
// private functions
// ----------------------------------------------------------------------------

20
src/msw/ole/dropsrc.cpp
View File

@@ -2,7 +2,7 @@
// Name: msw/ole/dropsrc.cpp
// Purpose: implementation of wxIDropSource and wxDropSource
// Author: Vadim Zeitlin
// Modified by:
// Modified by:
// Created: 10.05.98
// RCS-ID: $Id$
// Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
@@ -28,13 +28,13 @@
#pragma hdrstop
#endif
#include <wx/setup.h>
#include "wx/setup.h"
#if wxUSE_DRAG_AND_DROP
#include <wx/log.h>
#include <wx/msw/ole/dataobj.h>
#include <wx/msw/ole/dropsrc.h>
#include "wx/log.h"
#include "wx/dataobj.h"
#include "wx/msw/ole/dropsrc.h"
#include <windows.h>
@@ -45,7 +45,7 @@
#include <oleauto.h>
#include <wx/msw/ole/oleutils.h>
#include "wx/msw/ole/oleutils.h"
// ----------------------------------------------------------------------------
// wxIDropSource implementation of IDropSource interface
@@ -121,7 +121,7 @@ STDMETHODIMP wxIDropSource::QueryContinueDrag(BOOL fEscapePressed,
// Name : wxIDropSource::GiveFeedback
// Purpose : give UI feedback according to current state of operation
// Returns : STDMETHODIMP
// Returns : STDMETHODIMP
// Params : [in] DWORD dwEffect - what would happen if we dropped now
// Notes : default implementation is ok in more than 99% of cases
STDMETHODIMP wxIDropSource::GiveFeedback(DWORD dwEffect)
@@ -186,8 +186,8 @@ wxDragResult wxDropSource::DoDragDrop(bool bAllowMove)
wxCHECK_MSG( m_pData != NULL, wxDragNone, "No data in wxDropSource!" );
DWORD dwEffect;
HRESULT hr = ::DoDragDrop(m_pData->GetInterface(),
m_pIDropSource,
HRESULT hr = ::DoDragDrop(m_pData->GetInterface(),
m_pIDropSource,
bAllowMove ? DROPEFFECT_COPY | DROPEFFECT_MOVE
: DROPEFFECT_COPY,
&dwEffect);
@@ -229,7 +229,7 @@ wxDragResult wxDropSource::DoDragDrop(bool bAllowMove)
// Purpose : visually inform the user about d&d operation state
// Returns : bool: true if we do all ourselves or false for default feedback
// Params : [in] DragResult effect - what would happen if we dropped now
// [in] bool bScrolling - true if target is scrolling
// [in] bool bScrolling - true if target is scrolling
// Notes : here we just leave this stuff for default implementation
bool wxDropSource::GiveFeedback(wxDragResult effect, bool bScrolling)
{

107
src/msw/ole/droptgt.cpp
View File

@@ -2,8 +2,8 @@
// Name: ole/droptgt.cpp
// Purpose: wxDropTarget implementation
// Author: Vadim Zeitlin
// Modified by:
// Created:
// Modified by:
// Created:
// RCS-ID: $Id$
// Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
// Licence: wxWindows license
@@ -28,28 +28,29 @@
#pragma hdrstop
#endif
#include <wx/setup.h>
#include "wx/setup.h"
#if wxUSE_DRAG_AND_DROP
#include <wx/log.h>
#include "wx/log.h"
#ifdef __WIN32__
#ifndef __GNUWIN32__
#include <shlobj.h> // for DROPFILES structure
#endif
#ifndef __GNUWIN32__
#include <shlobj.h> // for DROPFILES structure
#endif
#else
#include <shellapi.h>
#include <shellapi.h>
#endif
#include <wx/msw/ole/droptgt.h>
#include "wx/dataobj.h"
#include "wx/msw/ole/droptgt.h"
#ifndef __WIN32__
#include <ole2.h>
#include <olestd.h>
#include <ole2.h>
#include <olestd.h>
#endif
#include <wx/msw/ole/oleutils.h>
#include "wx/msw/ole/oleutils.h"
// ----------------------------------------------------------------------------
// IDropTarget interface: forward all interesting things to wxDropTarget
@@ -69,9 +70,9 @@ public:
STDMETHODIMP DragLeave(void);
STDMETHODIMP Drop(LPDATAOBJECT, DWORD, POINTL, LPDWORD);
// @@ we assume that if QueryGetData() returns S_OK, than we can really
// get data in this format, so we remember here the format for which
// QueryGetData() succeeded
// we assume that if QueryGetData() returns S_OK, than we can really get data
// in this format, so we remember here the format for which QueryGetData()
// succeeded
void SetSupportedFormat(wxDataFormat cfFormat) { m_cfFormat = cfFormat; }
DECLARE_IUNKNOWN_METHODS;
@@ -92,11 +93,11 @@ private:
// Name : static wxDropTarget::GetDropEffect
// Purpose : determine the drop operation from keyboard/mouse state.
// Returns : DWORD combined from DROPEFFECT_xxx constants
// Returns : DWORD combined from DROPEFFECT_xxx constants
// Params : [in] DWORD flags kbd & mouse flags as passed to
// IDropTarget methods
// Notes : We do "move" normally and "copy" if <Ctrl> is pressed,
// which is the standard behaviour (currently there is no
// which is the standard behaviour (currently there is no
// way to redefine it)
DWORD wxIDropTarget::GetDropEffect(DWORD flags)
{
@@ -104,15 +105,15 @@ DWORD wxIDropTarget::GetDropEffect(DWORD flags)
}
wxIDropTarget::wxIDropTarget(wxDropTarget *pTarget)
{
m_cRef = 0;
{
m_cRef = 0;
m_pTarget = pTarget;
m_cfFormat = (wxDataFormat) 0;
m_pIDataObject = NULL;
m_cfFormat = wxDF_INVALID;
m_pIDataObject = NULL;
}
wxIDropTarget::~wxIDropTarget()
{
wxIDropTarget::~wxIDropTarget()
{
}
BEGIN_IID_TABLE(wxIDropTarget)
@@ -129,7 +130,7 @@ IMPLEMENT_IUNKNOWN_METHODS(wxIDropTarget)
// [in] DWORD grfKeyState : kbd & mouse state
// [in] POINTL pt : mouse coordinates
// [out]DWORD *pdwEffect : effect flag
// Notes :
// Notes :
STDMETHODIMP wxIDropTarget::DragEnter(IDataObject *pIDataSource,
DWORD grfKeyState,
POINTL pt,
@@ -146,8 +147,8 @@ STDMETHODIMP wxIDropTarget::DragEnter(IDataObject *pIDataSource,
return S_OK;
}
// @@ should check the point also?
// TODO should check the point also?
*pdwEffect = GetDropEffect(grfKeyState);
// get hold of the data object
@@ -167,7 +168,7 @@ STDMETHODIMP wxIDropTarget::DragEnter(IDataObject *pIDataSource,
// Params : [in] DWORD grfKeyState kbd & mouse state
// [in] POINTL pt mouse coordinates
// [out]LPDWORD pdwEffect effect flag
// Notes : We're called on every WM_MOUSEMOVE, so this function should be
// Notes : We're called on every WM_MOUSEMOVE, so this function should be
// very efficient.
STDMETHODIMP wxIDropTarget::DragOver(DWORD grfKeyState,
POINTL pt,
@@ -175,7 +176,7 @@ STDMETHODIMP wxIDropTarget::DragOver(DWORD grfKeyState,
{
// there are too many of them... wxLogDebug("IDropTarget::DragOver");
*pdwEffect = m_pIDataObject == NULL ? DROPEFFECT_NONE
*pdwEffect = m_pIDataObject == NULL ? DROPEFFECT_NONE
: GetDropEffect(grfKeyState);
return S_OK;
}
@@ -193,42 +194,42 @@ STDMETHODIMP wxIDropTarget::DragLeave()
// release the held object
RELEASE_AND_NULL(m_pIDataObject);
return S_OK;
}
// Name : wxIDropTarget::Drop
// Purpose : Instructs the drop target to paste data that was just now
// Purpose : Instructs the drop target to paste data that was just now
// dropped on it.
// Returns : S_OK
// Params : [in] IDataObject *pIDataSource the data to paste
// [in] DWORD grfKeyState kbd & mouse state
// [in] POINTL pt where the drop occured?
// [ouy]DWORD *pdwEffect operation effect
// Notes :
STDMETHODIMP wxIDropTarget::Drop(IDataObject *pIDataSource,
DWORD grfKeyState,
POINTL pt,
// Notes :
STDMETHODIMP wxIDropTarget::Drop(IDataObject *pIDataSource,
DWORD grfKeyState,
POINTL pt,
DWORD *pdwEffect)
{
wxLogDebug("IDropTarget::Drop");
// @@ I don't know why there is this parameter, but so far I assume
// that it's the same we've already got in DragEnter
// TODO I don't know why there is this parameter, but so far I assume
// that it's the same we've already got in DragEnter
wxASSERT( m_pIDataObject == pIDataSource );
STGMEDIUM stm;
*pdwEffect = DROPEFFECT_NONE;
*pdwEffect = DROPEFFECT_NONE;
// should be set by SetSupportedFormat() call
wxASSERT( m_cfFormat != 0 );
wxASSERT( m_cfFormat != wxDF_INVALID );
FORMATETC fmtMemory;
fmtMemory.cfFormat = m_cfFormat;
fmtMemory.ptd = NULL;
fmtMemory.ptd = NULL;
fmtMemory.dwAspect = DVASPECT_CONTENT;
fmtMemory.lindex = -1;
fmtMemory.tymed = TYMED_HGLOBAL; // @@@@ to add other media
fmtMemory.tymed = TYMED_HGLOBAL; // TODO to add other media
HRESULT hr = pIDataSource->GetData(&fmtMemory, &stm);
if ( SUCCEEDED(hr) ) {
@@ -262,7 +263,7 @@ STDMETHODIMP wxIDropTarget::Drop(IDataObject *pIDataSource,
wxDropTarget::wxDropTarget()
{
// create an IDropTarget implementation which will notify us about
// create an IDropTarget implementation which will notify us about
// d&d operations.
m_pIDropTarget = new wxIDropTarget(this);
m_pIDropTarget->AddRef();
@@ -314,22 +315,22 @@ bool wxDropTarget::IsAcceptedData(IDataObject *pIDataSource) const
{
// this strucutre describes a data of any type (first field will be
// changing) being passed through global memory block.
static FORMATETC s_fmtMemory = {
static FORMATETC s_fmtMemory = {
0,
NULL,
DVASPECT_CONTENT,
-1,
TYMED_HGLOBAL
NULL,
DVASPECT_CONTENT,
-1,
TYMED_HGLOBAL
};
// cycle thorugh all supported formats
for ( size_t n = 0; n < GetFormatCount(); n++ ) {
s_fmtMemory.cfFormat = GetFormat(n);
// @ don't use SUCCEEDED macro here: QueryGetData returns 1 (whatever it
// means) for file drag and drop
// NB: don't use SUCCEEDED macro here: QueryGetData returns 1 (whatever it
// means) for file drag and drop
if ( pIDataSource->QueryGetData(&s_fmtMemory) == S_OK ) {
// remember this format: we'll later ask for data in it
m_pIDropTarget->SetSupportedFormat((wxDataFormat) s_fmtMemory.cfFormat);
m_pIDropTarget->SetSupportedFormat((unsigned int)s_fmtMemory.cfFormat);
return TRUE;
}
}
@@ -363,16 +364,16 @@ wxDataFormat wxTextDropTarget::GetFormat(size_t WXUNUSED(n)) const
bool wxFileDropTarget::OnDrop(long x, long y, const void *pData)
{
// the documentation states that the first member of DROPFILES structure
// is a "DWORD offset of double NUL terminated file list". What they mean by
// is a "DWORD offset of double NUL terminated file list". What they mean by
// this (I wonder if you see it immediately) is that the list starts at
// ((char *)&(pDropFiles.pFiles)) + pDropFiles.pFiles. We're also advised to
// use DragQueryFile to work with this structure, but not told where and how
// to get HDROP.
HDROP hdrop = (HDROP)pData; // @@ it works, but I'm not sure about it
HDROP hdrop = (HDROP)pData; // NB: it works, but I'm not sure about it
// get number of files (magic value -1)
UINT nFiles = ::DragQueryFile(hdrop, (unsigned)-1, NULL, 0u);
// for each file get the length, allocate memory and then get the name
char **aszFiles = new char *[nFiles];
UINT len, n;

1
src/msw/window.cpp
View File

@@ -51,6 +51,7 @@
#endif
#if wxUSE_DRAG_AND_DROP
#include "wx/dataobj.h"
#include "wx/msw/ole/droptgt.h"
#endif