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

*** empty log message ***

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@4126 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
David Webster
1999-10-22 04:37:39 +00:00
parent 2e1a688e3e
commit 6dddc146fb
11 changed files with 707 additions and 296 deletions
Download Patch File Download Diff File Expand all files Collapse all files

33
include/wx/dataobj.h
View File

@@ -157,7 +157,7 @@ public:
#elif defined(__WXMAC__)
#include "wx/mac/dnd.h"
#elif defined(__WXPM__)
#include "wx/os2/dnd.h"
#include "wx/os2/dataobj.h"
#elif defined(__WXSTUBS__)
#include "wx/stubs/dnd.h"
#endif
@@ -312,6 +312,16 @@ public:
private:
wxString m_text;
#if defined(__VISAGECPP__)
// Virtual function hiding supression
size_t GetDataSize(const wxDataFormat& rFormat) const
{ return(wxDataObjectSimple::GetDataSize(rFormat)); }
bool GetDataHere(const wxDataFormat& WXUNUSED(rFormat), void *pBuf) const
{ return(GetDataHere(pBuf)); }
bool SetData(const wxDataFormat& rFormat, size_t nLen, const void* pBuf)
{ return(wxDataObjectSimple::SetData(rFormat, nLen, pBuf)); }
#endif
};
// ----------------------------------------------------------------------------
@@ -359,6 +369,15 @@ public:
protected:
wxArrayString m_filenames;
#if defined(__VISAGECPP__)
private:
// Virtual function hiding supression
size_t GetDataSize(const wxDataFormat& rFormat) const
{ return(wxDataObjectSimple::GetDataSize(rFormat)); }
bool GetDataHere(const wxDataFormat& WXUNUSED(rformat), void* pBuf) const
{ return(GetDataHere(pBuf)); }
#endif
};
// ----------------------------------------------------------------------------
@@ -405,6 +424,16 @@ public:
private:
size_t m_size;
void *m_data;
#if defined(__VISAGECPP__)
// Virtual function hiding supression
size_t GetDataSize(const wxDataFormat& rFormat) const
{ return(wxDataObjectSimple::GetDataSize(rFormat)); }
bool GetDataHere(const wxDataFormat& rFormat, void* pBuf) const
{ return(wxDataObjectSimple::GetDataHere(rFormat, pBuf)); }
bool SetData(const wxDataFormat& rFormat, size_t nLen, const void* pBuf)
{ return(wxDataObjectSimple::SetData(rFormat, nLen, pBuf)); }
#endif
};
// ----------------------------------------------------------------------------
@@ -417,6 +446,8 @@ private:
// #include "wx/motif/dataobj2.h" -- not yet
#elif defined(__WXGTK__)
#include "wx/gtk/dataobj2.h"
#elif defined(__WXPM__)
#include "wx/os2/dataobj2.h"
#endif
#endif // _WX_DATAOBJ_H_BASE_

3
include/wx/os2/clipbrd.h
View File

@@ -65,6 +65,9 @@ public:
// close the clipboard after SetData() and GetData()
virtual void Close();
// query whether the clipboard is opened
virtual bool IsOpened() const;
// set the clipboard data. all other formats will be deleted.
virtual bool SetData( wxDataObject *data );

2
include/wx/os2/dataform.h
View File

@@ -1,5 +1,5 @@
///////////////////////////////////////////////////////////////////////////////
// Name: gtk/dataform.h
// Name: os2/dataform.h
// Purpose: declaration of the wxDataFormat class
// Author: David Webster (lifted from dnd.h)
// Modified by:

32
include/wx/os2/dataobj.h Normal file
View File

@@ -0,0 +1,32 @@
///////////////////////////////////////////////////////////////////////////////
// Name: os2/dataobj.h
// Purpose: declaration of the wxDataObject
// Author: David Webster (adapted from Robert Roebling's gtk port)
// Modified by:
// Created: 10/21/99
// RCS-ID: $Id$
// Copyright: (c) 1998, 1999 Vadim Zeitlin, Robert Roebling
// Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTK_DATAOBJ_H_
#define _WX_GTK_DATAOBJ_H_
#ifdef __GNUG__
#pragma interface "dataobj.h"
#endif
// ----------------------------------------------------------------------------
// wxDataObject is the same as wxDataObjectBase under wxGTK
// ----------------------------------------------------------------------------
class wxDataObject : public wxDataObjectBase
{
public:
wxDataObject();
virtual bool IsSupportedFormat( const wxDataFormat& format, Direction dir = Get ) const;
};
#endif // _WX_GTK_DATAOBJ_H_

90
include/wx/os2/dataobj2.h Normal file
View File

@@ -0,0 +1,90 @@
///////////////////////////////////////////////////////////////////////////////
// Name: os2/dataobj2.h
// Purpose: declaration of standard wxDataObjectSimple-derived classes
// Author: David Webster (adapted from Robert Roebling's gtk port
// Modified by:
// Created: 10/21/99
// RCS-ID: $Id$
// Copyright: (c) 1998, 1999 Vadim Zeitlin, Robert Roebling
// Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_GTK_DATAOBJ2_H_
#define _WX_GTK_DATAOBJ2_H_
#ifdef __GNUG__
#pragma interface "dataobj.h"
#endif
// ----------------------------------------------------------------------------
// wxBitmapDataObject is a specialization of wxDataObject for bitmaps
// ----------------------------------------------------------------------------
class wxBitmapDataObject : public wxBitmapDataObjectBase
{
public:
// ctors
wxBitmapDataObject();
wxBitmapDataObject(const wxBitmap& bitmap);
// destr
~wxBitmapDataObject();
// override base class virtual to update PNG data too
virtual void SetBitmap(const wxBitmap& bitmap);
// implement base class pure virtuals
// ----------------------------------
virtual size_t GetDataSize() const { return m_pngSize; }
virtual bool GetDataHere(void *buf) const;
virtual bool SetData(size_t len, const void *buf);
protected:
void Init() { m_pngData = (void *)NULL; m_pngSize = 0; }
void Clear() { free(m_pngData); }
void ClearAll() { Clear(); Init(); }
size_t m_pngSize;
void *m_pngData;
void DoConvertToPng();
private:
// Virtual function hiding supression
size_t GetDataSize(const wxDataFormat& rFormat) const
{ return(wxDataObjectSimple::GetDataSize(rFormat)); }
bool GetDataHere(const wxDataFormat& rFormat, void* pBuf) const
{ return(wxDataObjectSimple::GetDataHere(rFormat, pBuf)); }
bool SetData(const wxDataFormat& rFormat, size_t nLen, const void* pBuf)
{ return(wxDataObjectSimple::SetData(rFormat, nLen, pBuf)); }
};
// ----------------------------------------------------------------------------
// wxFileDataObject is a specialization of wxDataObject for file names
// ----------------------------------------------------------------------------
class wxFileDataObject : public wxFileDataObjectBase
{
public:
// implement base class pure virtuals
// ----------------------------------
void AddFile( const wxString &filename );
virtual size_t GetDataSize() const;
virtual bool GetDataHere(void *buf) const;
virtual bool SetData(size_t len, const void *buf);
private:
// Virtual function hiding supression
size_t GetDataSize(const wxDataFormat& rFormat) const
{ return(wxDataObjectSimple::GetDataSize(rFormat)); }
bool GetDataHere(const wxDataFormat& rFormat, void* pBuf) const
{ return(wxDataObjectSimple::GetDataHere(rFormat, pBuf)); }
bool SetData(const wxDataFormat& rFormat, size_t nLen, const void* pBuf)
{ return(wxDataObjectSimple::SetData(rFormat, nLen, pBuf)); }
};
#endif // _WX_GTK_DATAOBJ2_H_

287
include/wx/os2/dnd.h
View File

@@ -1,257 +1,126 @@
///////////////////////////////////////////////////////////////////////////////
// Name: dnd.h
// Purpose: Declaration of the wxDropTarget, wxDropSource class etc.
// Author: AUTHOR
// Purpose: declaration of the wxDropTarget class
// Author: David Webster
// Modified by:
// Created: 10/21/99
// RCS-ID: $Id$
// Copyright: (c) 1998 AUTHOR
// Licence: wxWindows licence
// Copyright: (c) 1999 David Webster
// Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DND_H_
#define _WX_DND_H_
#ifndef __OS2DNDH__
#define __OS2DNDH__
#ifdef __GNUG__
#pragma interface "dnd.h"
#pragma interface
#endif
#include "wx/defs.h"
#include "wx/object.h"
#include "wx/string.h"
#include "wx/cursor.h"
#if !wxUSE_DRAG_AND_DROP
#error "You should #define wxUSE_DRAG_AND_DROP to 1 to compile this file!"
#endif //WX_DRAG_DROP
//-------------------------------------------------------------------------
// classes
// wxDropSource
//-------------------------------------------------------------------------
class WXDLLEXPORT wxWindow;
class WXDLLEXPORT wxDataObject;
class WXDLLEXPORT wxTextDataObject;
class WXDLLEXPORT wxFileDataObject;
class WXDLLEXPORT wxDropTarget;
class WXDLLEXPORT wxTextDropTarget;
class WXDLLEXPORT wxFileDropTarget;
class WXDLLEXPORT wxDropSource;
//-------------------------------------------------------------------------
// wxDataBroker (internal)
//-------------------------------------------------------------------------
class wxDataBroker : public wxObject
{
DECLARE_CLASS( wxDataBroker )
public:
/* constructor */
wxDataBroker();
/* add data object */
void Add( wxDataObject *dataObject, bool preferred = FALSE );
private:
/* OLE implementation, the methods don't need to be overridden */
/* get number of supported formats */
virtual size_t GetFormatCount() const;
/* return nth supported format */
virtual wxDataFormat &GetNthFormat( size_t nth ) const;
/* return preferrd/best supported format */
virtual wxDataFormatId GetPreferredFormat() const;
/* search through m_dataObjects, return TRUE if found */
virtual bool IsSupportedFormat( wxDataFormat &format ) const;
/* search through m_dataObjects and call child's GetSize() */
virtual size_t GetSize( wxDataFormat& format ) const;
/* search through m_dataObjects and call child's WriteData(dest) */
virtual void WriteData( wxDataFormat& format, void *dest ) const;
/* implementation */
public:
wxList m_dataObjects;
size_t m_preferred;
};
//-------------------------------------------------------------------------
// wxDataObject
//-------------------------------------------------------------------------
class WXDLLEXPORT wxDataObject: public wxDataObjectBase
class WXDLLEXPORT wxDropSource: public wxDropSourceBase
{
public:
// all data formats (values are the same as in windows.h, do not change!)
enum StdFormat
{
Invalid,
Text,
Bitmap,
MetafilePict,
Sylk,
Dif,
Tiff,
OemText,
Dib,
Palette,
Pendata,
Riff,
Wave,
UnicodeText,
EnhMetafile,
Hdrop,
Locale,
Max
};
/* constructor. set data later with SetData() */
wxDropSource( wxWindow* pWin
,const wxIcon& rGo = wxNullIcon
,const wxIcon& rStop = wxNullIcon
);
// function to return symbolic name of clipboard format (debug messages)
static const char *GetFormatName(wxDataFormat format);
/* constructor for setting one data object */
wxDropSource( wxDataObject& rData,
wxWindow* pWin,
const wxIcon& rGo = wxNullIcon,
const wxIcon& rStop = wxNullIcon
);
virtual ~wxDropSource();
// ctor & dtor
wxDataObject() {};
~wxDataObject() {};
/* start drag action */
virtual wxDragResult DoDragDrop(bool bAllowMove = FALSE);
// pure virtuals to override
// get the best suited format for our data
virtual wxDataFormat GetPreferredFormat() const = 0;
// decide if we support this format (should be one of values of
// StdFormat enumerations or a user-defined format)
virtual bool IsSupportedFormat(wxDataFormat format) const = 0;
// get the (total) size of data
virtual size_t GetDataSize() const = 0;
// copy raw data to provided pointer
virtual bool GetDataHere(void *pBuf) const = 0;
protected:
void Init(void);
bool m_bLazyDrag;
DRAGIMAGE* m_pDragImage;
DRAGINFO* m_pDragInfo;
DRAGTRANSFER* m_pDragTransfer;
};
// ----------------------------------------------------------------------------
// wxFileDataObject is a specialization of wxDataObject for file names
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxFileDataObject : public wxDataObject
{
public:
wxFileDataObject(void) { }
void AddFile( const wxString &file )
{ m_files += file; m_files += ";"; }
// implement base class pure virtuals
virtual wxDataFormat GetPreferredFormat() const
{ return wxDF_FILENAME; }
virtual bool IsSupportedFormat(wxDataFormat format) const
{ return format == (unsigned short)wxDF_FILENAME; }
virtual size_t GetDataSize() const
{ return m_files.Len() + 1; } // +1 for trailing '\0'of course
virtual bool GetDataHere(void *pBuf) const
{ memcpy(pBuf, m_files.c_str(), GetDataSize()); }
private:
wxString m_files;
};
//-------------------------------------------------------------------------
// wxDropTarget
//-------------------------------------------------------------------------
class WXDLLEXPORT wxDropTarget: public wxObject
class WXDLLEXPORT wxDropTarget: public wxDropTargetBase
{
public:
public:
wxDropTarget(wxDataObject *dataObject = (wxDataObject*)NULL);
virtual ~wxDropTarget();
wxDropTarget();
~wxDropTarget();
void Register(WXHWND hwnd);
void Revoke(WXHWND hwnd);
virtual void OnEnter() { }
virtual void OnLeave() { }
virtual bool OnDrop( long x, long y, const void *pData ) = 0;
virtual wxDragResult OnDragOver(wxCoord x, wxCoord y, wxDragResult def);
virtual bool OnDrop(wxCoord x, wxCoord y);
virtual bool OnData(wxCoord x, wxCoord y);
virtual bool GetData();
// protected:
// implementation
protected:
virtual bool IsAcceptable(DRAGINFO* pInfo);
friend wxWindow;
// Override these to indicate what kind of data you support:
virtual size_t GetFormatCount() const = 0;
virtual wxDataFormat GetFormat(size_t n) const = 0;
DRAGINFO* m_pDragInfo;
DRAGTRANSFER* m_pDragTransfer;
};
//-------------------------------------------------------------------------
// wxTextDropTarget
//-------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// A simple wxDropTarget derived class for text data: you only need to
// override OnDropText() to get something working
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxTextDropTarget: public wxDropTarget
class WXDLLEXPORT wxTextDropTarget : public wxDropTarget
{
public:
public:
wxTextDropTarget();
virtual ~wxTextDropTarget();
wxTextDropTarget() {};
virtual bool OnDrop( long x, long y, const void *pData );
virtual bool OnDropText( long x, long y, const char *psz );
virtual bool OnDropText( wxCoord x
,wxCoord y
,const wxString& rText
) = 0;
protected:
virtual size_t GetFormatCount() const;
virtual wxDataFormat GetFormat(size_t n) const;
virtual bool OnData( wxCoord x
,wxCoord y
);
};
// ----------------------------------------------------------------------------
// A drop target which accepts files (dragged from File Manager or Explorer)
// ----------------------------------------------------------------------------
class WXDLLEXPORT wxFileDropTarget: public wxDropTarget
class WXDLLEXPORT wxFileDropTarget : public wxDropTarget
{
public:
public:
wxFileDropTarget();
virtual ~wxFileDropTarget();
wxFileDropTarget() {};
// parameters are the number of files and the array of file names
virtual bool OnDropFiles( wxCoord x
,wxCoord y
,const wxArrayString& rFilenames
) = 0;
virtual bool OnDrop(long x, long y, const void *pData);
virtual bool OnDropFiles( long x, long y,
size_t nFiles, const char * const aszFiles[]);
protected:
virtual size_t GetFormatCount() const;
virtual wxDataFormat GetFormat(size_t n) const;
virtual bool OnData( wxCoord x
,wxCoord y
);
};
//-------------------------------------------------------------------------
// wxDropSource
//-------------------------------------------------------------------------
enum wxDragResult
{
wxDragError, // error prevented the d&d operation from completing
wxDragNone, // drag target didn't accept the data
wxDragCopy, // the data was successfully copied
wxDragMove, // the data was successfully moved
wxDragCancel // the operation was cancelled by user (not an error)
};
class WXDLLEXPORT wxDropSource: public wxObject
{
public:
wxDropSource( wxWindow *win );
wxDropSource( wxDataObject &data, wxWindow *win );
~wxDropSource(void);
void SetData( wxDataObject &data );
wxDragResult DoDragDrop( bool bAllowMove = FALSE );
virtual bool GiveFeedback( wxDragResult WXUNUSED(effect), bool WXUNUSED(bScrolling) ) { return TRUE; };
protected:
wxDataObject *m_data;
};
#endif
//_WX_DND_H_
#endif //__OS2DNDH__

30
src/os2/clipbrd.cpp
View File

@@ -451,11 +451,22 @@ void wxClipboard::Clear()
{
}
bool wxClipboard::Flush()
{
// TODO:
return FALSE;
}
bool wxClipboard::Open()
{
return wxOpenClipboard();
}
bool wxClipboard::IsOpened() const
{
return wxIsClipboardOpened();
}
bool wxClipboard::SetData( wxDataObject *data )
{
(void)wxEmptyClipboard();
@@ -604,25 +615,6 @@ bool wxClipboard::GetData( wxDataObject *data )
#endif
}
//-----------------------------------------------------------------------------
// wxClipboardModule
//-----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS(wxClipboardModule,wxModule)
bool wxClipboardModule::OnInit()
{
wxTheClipboard = new wxClipboard();
return TRUE;
}
void wxClipboardModule::OnExit()
{
if (wxTheClipboard) delete wxTheClipboard;
wxTheClipboard = (wxClipboard*) NULL;
}
#else
#error "Please turn wxUSE_CLIPBOARD on to compile this file."
#endif // wxUSE_CLIPBOARD

347
src/os2/dataobj.cpp Normal file
View File

@@ -0,0 +1,347 @@
///////////////////////////////////////////////////////////////////////////////
// Name: os2/dataobj.cpp
// Purpose: implementation of wx[I]DataObject class
// Author: David Webster
// Modified by:
// Created: 10/21/99
// RCS-ID: $Id$
// Copyright: (c) 1999 David Webster
// Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////////
// ============================================================================
// declarations
// ============================================================================
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
#ifdef __GNUG__
#pragma implementation "dataobj.h"
#endif
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#ifndef WX_PRECOMP
#include "wx/intl.h"
#endif
#include "wx/defs.h"
#include "wx/log.h"
#include "wx/dataobj.h"
#define INCL_DOS
#include <os2.h>
// ----------------------------------------------------------------------------
// functions
// ----------------------------------------------------------------------------
#ifdef __WXDEBUG__
static const wxChar *GetTymedName(DWORD tymed);
#endif // Debug
// ----------------------------------------------------------------------------
// wxDataFormat
// ----------------------------------------------------------------------------
wxDataFormat::wxDataFormat(
wxDataFormatId vType
)
{
PrepareFormats();
m_vType = wxDF_INVALID;
m_vFormat = 0;
}
wxDataFormat::wxDataFormat(
wxDataFormatId vType
)
{
PrepareFormats();
SetType(vType);
}
wxDataFormat::wxDataFormat(
const wxChar* zId
)
{
PrepareFormats();
SetId(zId);
}
wxDataFormat::wxDataFormat(
const wxString& rId
)
{
PrepareFormats();
SetId(rId);
}
wxDataFormat::wxDataFormat(
NativeFormat vFormat
)
{
PrepareFormats();
SetId(vFormat);
}
void wxDataFormat::SetType(
wxDataFormatId vType
)
{
m_vType = vType;
if (m_vType == wxDF_TEXT)
m_vFormat = 0;
else
if (m_vType == wxDF_BITMAP)
m_vFormat = 0;
else
if (m_vType == wxDF_FILENAME)
m_vFormat = 0;
else
{
wxFAIL_MSG( wxT("invalid dataformat") );
}
}
wxDataFormatId wxDataFormat::GetType() const
{
return m_vType;
}
wxString wxDataFormat::GetId() const
{
wxString sRet(""); // TODO: gdk_atom_name( m_format ) );
return sRet;
}
void wxDataFormat::SetId(
NativeFormat vFormat
)
{
m_vFormat = vFormat;
// TODO:
/*
if (m_format == g_textAtom)
m_type = wxDF_TEXT;
else
if (m_format == g_pngAtom)
m_type = wxDF_BITMAP;
else
if (m_format == g_fileAtom)
m_type = wxDF_FILENAME;
else
m_type = wxDF_PRIVATE;
*/
}
void wxDataFormat::SetId(
const wxChar* zId
)
{
wxString tmp(zId);
m_vType = wxDF_PRIVATE;
m_vFormat = 0;// TODO: get the format gdk_atom_intern( wxMBSTRINGCAST tmp.mbc_str(), FALSE );
}
void wxDataFormat::PrepareFormats()
{
// TODO:
/*
if (!g_textAtom)
g_textAtom = gdk_atom_intern( "STRING", FALSE );
if (!g_pngAtom)
g_pngAtom = gdk_atom_intern( "image/png", FALSE );
if (!g_fileAtom)
g_fileAtom = gdk_atom_intern( "file:ALL", FALSE );
*/
}
//-------------------------------------------------------------------------
// wxDataObject
//-------------------------------------------------------------------------
wxDataObject::wxDataObject()
{
}
bool wxDataObject::IsSupportedFormat(
const wxDataFormat& rFormat
, Direction vDir
) const
{
size_t nFormatCount = GetFormatCount(vDir);
if (nFormatCount == 1)
{
return rFormat == GetPreferredFormat();
}
else
{
wxDataFormat* pFormats = new wxDataFormat[nFormatCount];
GetAllFormats( rFormats
,vDir
);
size_t n;
for (n = 0; n < nFormatCount; n++)
{
if (rFormats[n] == rFormat)
break;
}
delete [] rFormats;
// found?
return n < nFormatCount;
}
}
// ----------------------------------------------------------------------------
// wxFileDataObject
// ----------------------------------------------------------------------------
bool wxFileDataObject::GetDataHere(
void* pBuf
) const
{
wxString sFilenames;
for (size_t i = 0; i < m_filenames.GetCount(); i++)
{
filenames += m_filenames[i];
filenames += (wxChar)0;
}
memcpy(pBuf, filenames.mbc_str(), filenames.Len() + 1);
return TRUE;
}
size_t wxFileDataObject::GetDataSize() const
{
size_t nRes = 0;
for (size_t i = 0; i < m_filenames.GetCount(); i++)
{
nRes += m_filenames[i].Len();
nRes += 1;
}
return nRes + 1;
}
bool wxFileDataObject::SetData(
size_t WXUNUSED(nSize)
, const void* pBuf
)
{
/* TODO */
wxString sFile( (const char *)pBuf); /* char, not wxChar */
AddFile(sFile);
return TRUE;
}
void wxFileDataObject::AddFile(
const wxString& rFilename
)
{
m_filenames.Add(rFilename);
}
// ----------------------------------------------------------------------------
// wxBitmapDataObject
// ----------------------------------------------------------------------------
wxBitmapDataObject::wxBitmapDataObject()
{
Init();
}
wxBitmapDataObject::wxBitmapDataObject(
const wxBitmap& rBitmap
)
: wxBitmapDataObjectBase(rBitmap)
{
Init();
DoConvertToPng();
}
wxBitmapDataObject::~wxBitmapDataObject()
{
Clear();
}
void wxBitmapDataObject::SetBitmap(
const wxBitmap& rBitmap
)
{
ClearAll();
wxBitmapDataObjectBase::SetBitmap(rBitmap);
DoConvertToPng();
}
bool wxBitmapDataObject::GetDataHere(
void* pBuf
) const
{
if (!m_pngSize)
{
wxFAIL_MSG(wxT("attempt to copy empty bitmap failed"));
return FALSE;
}
memcpy(pBuf, m_pngData, m_pngSize);
return TRUE;
}
bool wxBitmapDataObject::SetData(
size_t nSize
, const void* pBuf
)
{
Clear();
m_pngSize = nSize;
m_pngData = malloc(m_pngSize);
memcpy(m_pngData, pBuf, m_pngSize);
wxMemoryInputStream vMstream((char*)m_pngData, m_pngSize);
wxImage vImage;
wxPNGHandler vHandler;
if (!vHandler.LoadFile(&vImage, vMstream))
{
return FALSE;
}
m_bitmap = vImage.ConvertToBitmap();
return m_bitmap.Ok();
}
void wxBitmapDataObject::DoConvertToPng()
{
if (!m_bitmap.Ok())
return;
wxImage vImage(m_bitmap);
wxPNGHandler vHandler;
wxCountingOutputStream vCount;
vHandler.SaveFile(&rImage, vCount);
m_pngSize = vCount.GetSize() + 100; // sometimes the size seems to vary ???
m_pngData = malloc(m_pngSize);
wxMemoryOutputStream mstream((char*) m_pngData, m_pngSize);
vHandler.SaveFile(&vImage, vMstream );
}

161
src/os2/dnd.cpp
View File

@@ -1,9 +1,9 @@
///////////////////////////////////////////////////////////////////////////////
// Name: dnd.cpp
// Purpose: wxDropTarget, wxDropSource, wxDataObject implementation
// Author: AUTHOR
// Author: David Webster
// Modified by:
// Created: ??/??/98
// Created: 10/21/99
// RCS-ID: $Id$
// Copyright: (c) 1998 AUTHOR
// Licence: wxWindows licence
@@ -26,108 +26,153 @@
// wxDropTarget
// ----------------------------------------------------------------------------
wxDropTarget::wxDropTarget()
wxDropTarget::wxDropTarget(
wxDataObject* pDataObject
)
{
// TODO:
};
wxDropTarget::~wxDropTarget()
{
};
void wxDropTarget::Register(
WXHWND hwnd
)
{
//TODO:
};
void wxDropTarget::Revoke(
WXHWND hwnd
)
{
//TODO:
};
wxDragResult wxDropTarget::OnDragOver(
wxCoord x
, wxCoord y
, wxDragResult vDef
)
{
//TODO:
return vDef;
};
bool wxDropTarget::OnDrop(
wxCoord x
, wxCoord y
)
{
//TODO:
return FALSE;
};
bool wxDropTarget::OnData(
wxCoord x
, wxCoord y
)
{
//TODO:
return FALSE;
};
bool wxDropTarget::GetData()
{
//TODO:
return FALSE;
};
bool wxDropTarget::IsAcceptable(
DRAGINFO* pInfo
)
{
//TODO:
return FALSE;
};
// ----------------------------------------------------------------------------
// wxTextDropTarget
// ----------------------------------------------------------------------------
bool wxTextDropTarget::OnDrop( long x, long y, const void *pData )
wxTextDropTarget::wxTextDropTarget()
{
OnDropText( x, y, (const char*)pData );
return TRUE;
};
bool wxTextDropTarget::OnDropText( long x, long y, const char *psz )
{
printf( "Got dropped text: %s.\n", psz );
printf( "At x: %d, y: %d.\n", (int)x, (int)y );
return TRUE;
};
size_t wxTextDropTarget::GetFormatCount() const
{
return 1;
// TODO:
}
wxDataFormat wxTextDropTarget::GetFormat(size_t WXUNUSED(n)) const
wxTextDropTarget::~wxTextDropTarget()
{
return wxDF_TEXT;
// TODO:
}
bool wxTextDropTarget::OnData(
wxCoord x
, wxCoord y
)
{
// TODO:
return FALSE;
};
// ----------------------------------------------------------------------------
// wxFileDropTarget
// ----------------------------------------------------------------------------
bool wxFileDropTarget::OnDropFiles( long x, long y, size_t nFiles, const char * const WXUNUSED(aszFiles)[] )
wxFileDropTarget::wxFileDropTarget()
{
printf( "Got %d dropped files.\n", (int)nFiles );
printf( "At x: %d, y: %d.\n", (int)x, (int)y );
return TRUE;
// TODO:
}
bool wxFileDropTarget::OnDrop(long x, long y, const void *WXUNUSED(pData) )
wxFileDropTarget::~wxFileDropTarget()
{
char *str = "/this/is/a/path.txt";
return OnDropFiles(x, y, 1, &str );
// TODO:
}
size_t wxFileDropTarget::GetFormatCount() const
bool wxFileDropTarget::OnData(
wxCoord x
, wxCoord y
)
{
return 1;
}
wxDataFormat wxFileDropTarget::GetFormat(size_t WXUNUSED(n)) const
{
return wxDF_FILENAME;
}
// TODO:
return FALSE;
};
//-------------------------------------------------------------------------
// wxDropSource
//-------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// drag request
wxDropSource::wxDropSource( wxWindow *win )
wxDropSource::wxDropSource(
wxWindow* pWin
)
{
// TODO
// m_window = win;
m_data = NULL;
// m_defaultCursor = wxCursor( wxCURSOR_NO_ENTRY );
// m_goaheadCursor = wxCursor( wxCURSOR_HAND );
};
wxDropSource::wxDropSource( wxDataObject &data, wxWindow *win )
wxDropSource::wxDropSource(
wxDataObject& rData
, wxWindow* pWin
)
{
// TODO
// m_window = win;
m_data = &data;
// m_defaultCursor = wxCursor( wxCURSOR_NO_ENTRY );
// m_goaheadCursor = wxCursor( wxCURSOR_HAND );
};
void wxDropSource::SetData( wxDataObject &data )
wxDropSource::~wxDropSource()
{
m_data = &data;
// TODO
};
wxDropSource::~wxDropSource(void)
{
};
wxDragResult wxDropSource::DoDragDrop( bool WXUNUSED(bAllowMove) )
wxDragResult wxDropSource::DoDragDrop(
bool WXUNUSED(bAllowMove)
)
{
// TODO
return wxDragError;
};
void wxDropSource::Init()
{
// TODO
};

6
src/os2/makefile.va
View File

@@ -339,6 +339,7 @@ OS2OBJS = \
..\os2\$D\control.obj \
..\os2\$D\cursor.obj \
..\os2\$D\data.obj \
..\os2\$D\dataobj.obj \
..\os2\$D\dc.obj \
..\os2\$D\dcclient.obj \
..\os2\$D\dcmemory.obj \
@@ -416,6 +417,7 @@ OS2LIBOBJS1 = \
control.obj \
cursor.obj \
data.obj \
dataobj.obj \
dc.obj \
dcclient.obj \
dcmemory.obj \
@@ -444,10 +446,10 @@ OS2LIBOBJS1 = \
menuitem.obj \
metafile.obj \
minifram.obj \
msgdlg.obj \
nativdlg.obj
msgdlg.obj
OS2LIBOBJS2 = \
nativdlg.obj \
notebook.obj \
ownerdrw.obj \
palette.obj \