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

New DnD and Clipboard code

Browse Source 
Rearranged wxApp to do the same in the
    same order upon program start-up on
    wxGTK and wxMSW
  ODBC tweaks
  exchanged wxDataFormat for wxIPCFormat


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@1427 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Robert Roebling
1999-01-19 16:33:16 +00:00
parent c75e66953f
commit 0d2a2b601b
30 changed files with 2042 additions and 940 deletions
Download Patch File Download Diff File Expand all files Collapse all files

216
src/gtk1/app.cpp
View File

@@ -19,6 +19,7 @@
#include "wx/memory.h"
#include "wx/font.h"
#include "wx/settings.h"
#include "wx/dialog.h"
#if wxUSE_WX_RESOURCES
#include "wx/resource.h"
#endif
@@ -158,11 +159,14 @@ gint wxapp_idle_callback( gpointer WXUNUSED(data) )
wxApp::wxApp()
{
m_idleTag = 0;
wxTheApp = this;
m_topWindow = (wxWindow *) NULL;
m_exitOnFrameDelete = TRUE;
m_idleTag = gtk_idle_add( wxapp_idle_callback, (gpointer) NULL );
m_colorCube = (unsigned char*) NULL;
wxTheApp = this;
}
wxApp::~wxApp(void)
@@ -172,35 +176,36 @@ wxApp::~wxApp(void)
if (m_colorCube) free(m_colorCube);
}
bool wxApp::InitVisual()
bool wxApp::OnInitGui()
{
/* Nothing to do for 15, 16, 24, 32 bit displays */
GdkVisual *visual = gdk_visual_get_system();
if (visual->depth > 8) return TRUE;
/* this initiates the standard palette as defined by GdkImlib
in the GNOME libraries. it ensures that all GNOME applications
use the same 64 colormap entries on 8-bit displays so you
can use several rather graphics-heavy applications at the
same time */
/*
GdkColormap *cmap = gdk_colormap_new( gdk_visual_get_system(), TRUE );
/* this initiates the standard palette as defined by GdkImlib
in the GNOME libraries. it ensures that all GNOME applications
use the same 64 colormap entries on 8-bit displays so you
can use several rather graphics-heavy applications at the
same time.
NOTE: this doesn't really seem to work this way... */
for (int i = 0; i < 64; i++)
{
GdkColor col;
col.red = g_palette[i*3 + 0] << 8;
col.green = g_palette[i*3 + 1] << 8;
col.blue = g_palette[i*3 + 2] << 8;
col.pixel = 0;
/*
GdkColormap *cmap = gdk_colormap_new( gdk_visual_get_system(), TRUE );
gdk_color_alloc( cmap, &col );
}
for (int i = 0; i < 64; i++)
{
GdkColor col;
col.red = g_palette[i*3 + 0] << 8;
col.green = g_palette[i*3 + 1] << 8;
col.blue = g_palette[i*3 + 2] << 8;
col.pixel = 0;
gdk_color_alloc( cmap, &col );
}
gtk_widget_set_default_colormap( cmap );
*/
gtk_widget_set_default_colormap( cmap );
*/
/* initialize color cube for 8-bit color reduction dithering */
@@ -235,27 +240,11 @@ bool wxApp::InitVisual()
}
}
}
return TRUE;
}
bool wxApp::OnInitGui(void)
{
m_idleTag = gtk_idle_add( wxapp_idle_callback, NULL );
return TRUE;
}
bool wxApp::OnInit(void)
{
return TRUE;
}
int wxApp::OnRun(void)
{
return MainLoop();
}
bool wxApp::ProcessIdle(void)
{
wxIdleEvent event;
@@ -330,11 +319,6 @@ bool wxApp::SendIdleEvents( wxWindow* win )
return needMore ;
}
int wxApp::OnExit(void)
{
return 0;
}
int wxApp::MainLoop(void)
{
gtk_main();
@@ -389,39 +373,43 @@ void wxApp::SetTopWindow( wxWindow *win )
m_topWindow = win;
}
void wxApp::CommonInit(void)
bool wxApp::Initialize(void)
{
wxSystemSettings::Init();
wxBuffer = new char[BUFSIZ + 512];
wxClassInfo::InitializeClasses();
wxSystemSettings::Init();
wxTheFontNameDirectory = new wxFontNameDirectory;
wxTheFontNameDirectory->Initialize();
wxTheFontNameDirectory = new wxFontNameDirectory;
wxTheFontNameDirectory->Initialize();
wxTheColourDatabase = new wxColourDatabase(wxKEY_STRING);
wxTheColourDatabase->Initialize();
wxTheColourDatabase = new wxColourDatabase( wxKEY_STRING );
wxTheColourDatabase->Initialize();
wxInitializeStockLists();
wxInitializeStockObjects();
wxInitializeStockLists();
wxInitializeStockObjects();
#if wxUSE_WX_RESOURCES
wxTheResourceCache = new wxResourceCache(wxKEY_STRING);
wxTheResourceCache = new wxResourceCache( wxKEY_STRING );
wxInitializeResourceSystem();
wxInitializeResourceSystem();
#endif
wxImage::InitStandardHandlers();
wxImage::InitStandardHandlers();
// g_globalCursor = new wxCursor;
/* no global cursor under X
g_globalCursor = new wxCursor; */
wxModule::RegisterModules();
if (!wxModule::InitializeModules()) return FALSE;
return TRUE;
}
void wxApp::CommonCleanUp(void)
void wxApp::CleanUp(void)
{
if (wxTheColourDatabase) delete wxTheColourDatabase;
wxTheColourDatabase = (wxColourDatabase*) NULL;
if (wxTheFontNameDirectory) delete wxTheFontNameDirectory;
wxTheFontNameDirectory = (wxFontNameDirectory*) NULL;
wxDeleteStockObjects();
wxModule::CleanUpModules();
#if wxUSE_WX_RESOURCES
wxFlushResources();
@@ -432,16 +420,47 @@ void wxApp::CommonCleanUp(void)
wxCleanUpResourceSystem();
#endif
if (wxTheColourDatabase) delete wxTheColourDatabase;
wxTheColourDatabase = (wxColourDatabase*) NULL;
if (wxTheFontNameDirectory) delete wxTheFontNameDirectory;
wxTheFontNameDirectory = (wxFontNameDirectory*) NULL;
wxDeleteStockObjects();
wxDeleteStockLists();
wxImage::CleanUpHandlers();
delete wxTheApp;
wxTheApp = (wxApp*) NULL;
/* check for memory leaks */
#if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
if (wxDebugContext::CountObjectsLeft() > 0)
{
wxLogDebug("There were memory leaks.\n");
wxDebugContext::Dump();
wxDebugContext::PrintStatistics();
}
#endif
/* do this as the very last thing because everything else can log messages */
wxLog::DontCreateOnDemand();
wxLog *oldLog = wxLog::SetActiveTarget( (wxLog*) NULL );
if (oldLog) delete oldLog;
wxSystemSettings::Done();
wxClassInfo::CleanUpClasses();
delete[] wxBuffer;
}
wxLog *wxApp::CreateLogTarget()
{
return new wxLogGui;
return new wxLogGui;
}
//-----------------------------------------------------------------------------
@@ -450,10 +469,11 @@ wxLog *wxApp::CreateLogTarget()
int wxEntry( int argc, char *argv[] )
{
wxBuffer = new char[BUFSIZ + 512];
gtk_set_locale();
wxClassInfo::InitializeClasses();
gtk_init( &argc, &argv );
if (!wxApp::Initialize()) return 0;
if (!wxTheApp)
{
@@ -485,22 +505,11 @@ int wxEntry( int argc, char *argv[] )
wxStripExtension( name );
wxTheApp->SetAppName( name );
gtk_set_locale();
gtk_init( &argc, &argv );
if (!wxTheApp->InitVisual()) return 0;
wxApp::CommonInit();
if (!wxTheApp->OnInitGui()) return 0;
wxModule::RegisterModules();
if (!wxModule::InitializeModules()) return FALSE;
// Here frames insert themselves automatically
// into wxTopLevelWindows by getting created
// in OnInit().
/* Here frames insert themselves automatically
* into wxTopLevelWindows by getting created
* in OnInit(). */
if (!wxTheApp->OnInit()) return 0;
@@ -510,34 +519,31 @@ int wxEntry( int argc, char *argv[] )
if (wxTheApp->Initialized()) retValue = wxTheApp->OnRun();
wxTheApp->DeletePendingObjects();
wxWindow *topWindow = wxTheApp->GetTopWindow();
if (topWindow)
{
/* Forcibly delete the window. */
if (topWindow->IsKindOf(CLASSINFO(wxFrame)) ||
topWindow->IsKindOf(CLASSINFO(wxDialog)) )
{
topWindow->Close( TRUE );
wxTheApp->DeletePendingObjects();
}
else
{
delete topWindow;
wxTheApp->SetTopWindow( (wxWindow*) NULL );
}
}
wxTheApp->OnExit();
wxModule::CleanUpModules();
/* flush the logged messages if any */
wxLog *log = wxLog::GetActiveTarget();
if (log != NULL && log->HasPendingMessages())
log->Flush();
wxApp::CommonCleanUp();
delete wxTheApp;
wxTheApp = (wxApp*) NULL;
wxClassInfo::CleanUpClasses();
delete[] wxBuffer;
#if (defined(__WXDEBUG__) && wxUSE_MEMORY_TRACING) || wxUSE_DEBUG_CONTEXT
if (wxDebugContext::CountObjectsLeft() > 0)
{
wxLogDebug("There were memory leaks.\n");
wxDebugContext::Dump();
wxDebugContext::PrintStatistics();
}
#endif
wxLog *oldLog = wxLog::SetActiveTarget( (wxLog*) NULL );
if (oldLog) delete oldLog;
wxApp::CleanUp();
return retValue;
}

203
src/gtk1/clipbrd.cpp
View File

@@ -104,12 +104,12 @@ selection_received( GtkWidget *WXUNUSED(widget),
// make sure we got the data in the correct format
if (data_object->m_formatAtom != selection_data->target) return;
if (data_object->GetFormat().GetAtom() != selection_data->target) return;
// make sure we got the data in the correct form (selection type).
// if so, copy data to target object
switch (data_object->GetFormat())
switch (data_object->GetFormat().GetType())
{
case wxDF_TEXT:
{
@@ -179,10 +179,13 @@ selection_clear_clip( GtkWidget *WXUNUSED(widget), GdkEventSelection *event )
if ((!wxTheClipboard->m_ownsPrimarySelection) &&
(!wxTheClipboard->m_ownsClipboard))
{
// the clipboard is no longer in our hands. we can the
// clipboard data.
wxTheClipboard->m_dataObjects.Clear();
/* the clipboard is no longer in our hands. we can the clipboard data. */
if (wxTheClipboard->m_dataBroker)
{
delete wxTheClipboard->m_dataBroker;
wxTheClipboard->m_dataBroker = (wxDataBroker*) NULL;
}
}
return TRUE;
@@ -197,19 +200,21 @@ selection_handler( GtkWidget *WXUNUSED(widget), GtkSelectionData *selection_data
{
if (!wxTheClipboard) return;
wxNode *node = wxTheClipboard->m_dataObjects.First();
if (!wxTheClipboard->m_dataBroker) return;
wxNode *node = wxTheClipboard->m_dataBroker->m_dataObjects.First();
while (node)
{
wxDataObject *data_object = (wxDataObject *)node->Data();
if (data_object->m_formatAtom != selection_data->target)
if (data_object->GetFormat().GetAtom() != selection_data->target)
{
node = node->Next();
break;
}
switch (data_object->GetFormat())
switch (data_object->GetFormat().GetType())
{
case wxDF_TEXT:
{
@@ -243,14 +248,14 @@ selection_handler( GtkWidget *WXUNUSED(widget), GtkSelectionData *selection_data
{
wxPrivateDataObject *private_object = (wxPrivateDataObject*) data_object;
if (private_object->GetDataSize() == 0) return;
if (private_object->GetSize() == 0) return;
gtk_selection_data_set(
selection_data,
GDK_SELECTION_TYPE_STRING,
8*sizeof(gchar),
(unsigned char*) private_object->GetData(),
(int) private_object->GetDataSize() );
(int) private_object->GetSize() );
}
default:
@@ -274,7 +279,7 @@ wxClipboard::wxClipboard()
m_ownsClipboard = FALSE;
m_ownsPrimarySelection = FALSE;
m_dataObjects.DeleteContents( TRUE );
m_dataBroker = (wxDataBroker*) NULL;
m_receivedData = (wxDataObject*) NULL;
@@ -303,7 +308,7 @@ wxClipboard::~wxClipboard()
void wxClipboard::Clear()
{
if (m_dataObjects.GetCount())
if (m_dataBroker)
{
/* As we have data we also own the clipboard. Once we no longer own
it, clear_selection is called which will set m_data to zero */
@@ -318,7 +323,11 @@ void wxClipboard::Clear()
gtk_selection_owner_set( (GtkWidget*) NULL, GDK_SELECTION_PRIMARY, GDK_CURRENT_TIME );
}
m_dataObjects.Clear();
if (m_dataBroker)
{
delete m_dataBroker;
m_dataBroker = (wxDataBroker*) NULL;
}
}
m_targetRequested = 0;
@@ -335,79 +344,67 @@ bool wxClipboard::Open()
return TRUE;
}
bool wxClipboard::SetData( wxDataObject *data )
bool wxClipboard::SetData( wxDataBroker *data )
{
wxCHECK_MSG( data, FALSE, "data is invalid" );
wxNode *node = m_dataObjects.First();
Clear();
m_dataBroker = data;
while (node)
{
wxDataObject *d = (wxDataObject*)node->Data();
if (d->GetFormat() == data->GetFormat())
{
m_dataObjects.DeleteNode( node );
break;
}
node = node->Next();
}
m_dataObjects.Append( data );
if (!m_dataBroker) return FALSE;
wxCHECK_MSG( m_open, FALSE, "clipboard not open" );
if (data->GetFormat() == wxDF_PRIVATE)
wxNode *node = m_dataBroker->m_dataObjects.First();
while (node)
{
wxPrivateDataObject* pd = (wxPrivateDataObject*) data;
wxDataObject *dobj = (wxDataObject*)node->Data();
wxCHECK_MSG( !pd->GetId().IsEmpty(), FALSE, "private clipboard format requires ID string" );
GdkAtom format = dobj->GetFormat().GetAtom();
data->m_formatAtom = GetTargetAtom( data->GetFormat(), pd->GetId() );
}
else
{
data->m_formatAtom = GetTargetAtom( data->GetFormat() );
}
// This should happen automatically
if (format != (GdkAtom) 0)
{
/* This should happen automatically */
m_ownsClipboard = FALSE;
m_ownsPrimarySelection = FALSE;
m_ownsClipboard = FALSE;
m_ownsPrimarySelection = FALSE;
// Add handlers if someone requests data
/* Add handlers if someone requests data */
gtk_selection_add_handler( m_clipboardWidget,
gtk_selection_add_handler( m_clipboardWidget,
g_clipboardAtom,
data->m_formatAtom,
format,
selection_handler,
NULL );
(gpointer) NULL );
gtk_selection_add_handler( m_clipboardWidget,
gtk_selection_add_handler( m_clipboardWidget,
GDK_SELECTION_PRIMARY,
data->m_formatAtom,
format,
selection_handler,
NULL );
(gpointer) NULL );
// Tell the world we offer clipboard data
/* Tell the world we offer clipboard data */
if (!gtk_selection_owner_set( m_clipboardWidget,
if (!gtk_selection_owner_set( m_clipboardWidget,
g_clipboardAtom,
GDK_CURRENT_TIME ))
{
return FALSE;
}
m_ownsClipboard = TRUE;
{
return FALSE;
}
m_ownsClipboard = TRUE;
if (!gtk_selection_owner_set( m_clipboardWidget,
if (!gtk_selection_owner_set( m_clipboardWidget,
GDK_SELECTION_PRIMARY,
GDK_CURRENT_TIME ))
{
return FALSE;
{
return FALSE;
}
m_ownsPrimarySelection = TRUE;
}
node = node->Next();
}
m_ownsPrimarySelection = TRUE;
return TRUE;
}
@@ -419,13 +416,23 @@ void wxClipboard::Close()
m_open = FALSE;
}
bool wxClipboard::IsSupportedFormat( wxDataFormat format, const wxString &id )
bool wxClipboard::GetData( wxDataObject *data )
{
m_targetRequested = GetTargetAtom( format, id );
wxCHECK_MSG( m_open, FALSE, "clipboard not open" );
m_receivedData = data;
wxCHECK_MSG( m_receivedData, FALSE, "invalid data object" );
/* STEP ONE: check if there is such data in the clipboard */
m_targetRequested = data->GetFormat().GetAtom();
wxCHECK_MSG( m_targetRequested, FALSE, "invalid clipboard format" );
if (m_targetRequested == 0) return FALSE;
// add handler for target (= format) query
/* add handler for target (= format) query */
gtk_signal_connect( GTK_OBJECT(m_clipboardWidget),
"selection_received",
@@ -434,8 +441,8 @@ bool wxClipboard::IsSupportedFormat( wxDataFormat format, const wxString &id )
m_formatSupported = FALSE;
// perform query. this will set m_formatSupported to
// TRUE if m_targetRequested is supported
/* perform query. this will set m_formatSupported to
* TRUE if m_targetRequested is supported */
gtk_selection_convert( m_clipboardWidget,
g_clipboardAtom,
@@ -448,34 +455,8 @@ bool wxClipboard::IsSupportedFormat( wxDataFormat format, const wxString &id )
if (!m_formatSupported) return FALSE;
return TRUE;
}
bool wxClipboard::GetData( wxDataObject *data )
{
wxCHECK_MSG( m_open, FALSE, "clipboard not open" );
/* STEP TWO: get the data from the clipboard */
m_receivedData = data;
wxCHECK_MSG( m_receivedData, FALSE, "invalid data object" );
if (m_receivedData->GetFormat() == wxDF_PRIVATE)
{
wxPrivateDataObject* pd = (wxPrivateDataObject*) m_receivedData;
wxCHECK_MSG( !pd->GetId().IsEmpty(), FALSE, "private clipboard format requires ID string" );
m_targetRequested = GetTargetAtom( m_receivedData->GetFormat(), pd->GetId() );
}
else
{
m_targetRequested = GetTargetAtom( m_receivedData->GetFormat() );
}
data->m_formatAtom = m_targetRequested;
wxCHECK_MSG( m_targetRequested, FALSE, "unsupported clipboard format" );
m_formatSupported = FALSE;
gtk_signal_connect( GTK_OBJECT(m_clipboardWidget),
@@ -492,45 +473,13 @@ bool wxClipboard::GetData( wxDataObject *data )
GTK_SIGNAL_FUNC( selection_received ),
(gpointer) this );
/* this is a true error as we checked for the presence of such data before */
wxCHECK_MSG( m_formatSupported, FALSE, "error retrieving data from clipboard" );
return TRUE;
}
GdkAtom wxClipboard::GetTargetAtom( wxDataFormat format, const wxString &id )
{
// What is X representation of that format?
switch (format)
{
case wxDF_TEXT:
{
return GDK_TARGET_STRING;
// g_textAtom
}
case wxDF_BITMAP:
{
return GDK_TARGET_BITMAP;
break;
}
case wxDF_PRIVATE:
{
// we create our own X representation
return gdk_atom_intern( WXSTRINGCAST( id ), FALSE );
}
default:
{
return (GdkAtom) 0;
}
}
return (GdkAtom) 0;
}
//-----------------------------------------------------------------------------
// wxClipboardModule
//-----------------------------------------------------------------------------

378
src/gtk1/dataobj.cpp
View File

@@ -13,6 +13,230 @@
#include "wx/dataobj.h"
#include "wx/app.h"
#include "wx/debug.h"
#include "gdk/gdk.h"
//-------------------------------------------------------------------------
// wxDataFormat
//-------------------------------------------------------------------------
IMPLEMENT_CLASS(wxDataFormat, wxObject)
wxDataFormat::wxDataFormat( wxDataType type )
{
m_type = type;
if (m_type == wxDF_TEXT)
{
m_id = "STRING";
}
else
if (m_type == wxDF_BITMAP)
{
m_id = "BITMAP";
}
else
if (m_type == wxDF_FILENAME)
{
m_id = "file:ALL";
}
else
{
wxFAIL_MSG( "invalid dataformat" )
}
m_hasAtom = FALSE;
}
wxDataFormat::wxDataFormat( const wxString &id )
{
m_type = wxDF_PRIVATE;
m_id = id;
m_hasAtom = FALSE;
}
wxDataFormat::wxDataFormat( wxDataFormat &format )
{
m_type = format.GetType();
m_id = format.GetId();
m_hasAtom = TRUE;
m_atom = format.GetAtom();
}
wxDataFormat::wxDataFormat( const GdkAtom atom )
{
m_hasAtom = TRUE;
m_atom = atom;
if (m_atom == GDK_TARGET_STRING)
{
m_type = wxDF_TEXT;
} else
if (m_atom == GDK_TARGET_BITMAP)
{
m_type = wxDF_BITMAP;
} else
{
m_type = wxDF_PRIVATE;
m_id = gdk_atom_name( m_atom );
if (m_id == "file:ALL")
{
m_type = wxDF_FILENAME;
}
}
}
int wxDataFormat::GetType() const
{
return m_type;
}
wxString wxDataFormat::GetId() const
{
return m_id;
}
void wxDataFormat::SetId( const wxString &id )
{
m_type = wxDF_PRIVATE;
m_id = id;
m_hasAtom = FALSE;
}
GdkAtom wxDataFormat::GetAtom()
{
if (!m_hasAtom)
{
m_hasAtom = TRUE;
if (m_type == wxDF_TEXT)
{
m_atom = GDK_TARGET_STRING;
}
else
if (m_type == wxDF_BITMAP)
{
m_atom = GDK_TARGET_BITMAP;
}
else
if (m_type == wxDF_PRIVATE)
{
m_atom = gdk_atom_intern( WXSTRINGCAST( m_id ), 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;
}
//-------------------------------------------------------------------------
// wxDataBroker
//-------------------------------------------------------------------------
IMPLEMENT_CLASS(wxDataBroker,wxObject)
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();
}
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())
{
return dobj->WriteData( dest );
}
node = node->Next();
}
}
//-------------------------------------------------------------------------
// wxDataObject
@@ -20,24 +244,141 @@
IMPLEMENT_ABSTRACT_CLASS( wxDataObject, wxObject )
wxDataObject::wxDataObject()
{
m_format = (wxDataFormat*) NULL;
}
wxDataObject::~wxDataObject()
{
if (m_format) delete m_format;
}
wxDataFormat &wxDataObject::GetFormat() const
{
wxASSERT( m_format );
return (*m_format);
}
// ----------------------------------------------------------------------------
// wxTextDataObject
// ----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS( wxTextDataObject, wxDataObject )
wxTextDataObject::wxTextDataObject()
{
m_format = new wxDataFormat( wxDF_TEXT );
}
wxTextDataObject::wxTextDataObject( const wxString& data )
{
m_format = new wxDataFormat( wxDF_TEXT );
m_data = data;
}
void wxTextDataObject::SetText( const wxString& data )
{
m_data = data;
}
wxString wxTextDataObject::GetText() const
{
return m_data;
}
void wxTextDataObject::WriteData( void *dest ) const
{
WriteString( m_data, dest );
}
size_t wxTextDataObject::GetSize() const
{
return m_data.Len() + 1;
}
void wxTextDataObject::WriteString( const wxString &str, void *dest ) const
{
memcpy( dest, m_data.c_str(), GetSize() );
}
// ----------------------------------------------------------------------------
// wxFileDataObject
// ----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS( wxFileDataObject, wxDataObject )
wxFileDataObject::wxFileDataObject(void)
{
m_format = new wxDataFormat( wxDF_FILENAME );
}
void wxFileDataObject::AddFile( const wxString &file )
{
m_files += file;
m_files += (char)0;
}
wxString wxFileDataObject::GetFiles() const
{
return m_files;
}
void wxFileDataObject::WriteData( void *dest ) const
{
memcpy( dest, m_files.c_str(), GetSize() );
}
size_t wxFileDataObject::GetSize() const
{
return m_files.Len() + 1;
}
// ----------------------------------------------------------------------------
// wxBitmapDataObject
// ----------------------------------------------------------------------------
IMPLEMENT_DYNAMIC_CLASS( wxBitmapDataObject, wxDataObject )
wxBitmapDataObject::wxBitmapDataObject()
{
m_format = new wxDataFormat( wxDF_BITMAP );
}
wxBitmapDataObject::wxBitmapDataObject( const wxBitmap& bitmap )
{
m_format = new wxDataFormat( wxDF_BITMAP );
m_bitmap = bitmap;
}
void wxBitmapDataObject::SetBitmap( const wxBitmap &bitmap )
{
m_bitmap = bitmap;
}
wxBitmap wxBitmapDataObject::GetBitmap() const
{
return m_bitmap;
}
void wxBitmapDataObject::WriteData( void *dest ) const
{
WriteBitmap( m_bitmap, dest );
}
size_t wxBitmapDataObject::GetSize() const
{
return 0;
}
void wxBitmapDataObject::WriteBitmap( const wxBitmap &bitmap, void *dest ) const
{
memcpy( dest, m_bitmap.GetPixmap(), GetSize() );
}
// ----------------------------------------------------------------------------
// wxPrivateDataObject
// ----------------------------------------------------------------------------
@@ -46,9 +387,13 @@ IMPLEMENT_DYNAMIC_CLASS( wxPrivateDataObject, wxDataObject )
wxPrivateDataObject::wxPrivateDataObject()
{
m_id = "application/";
m_id += wxTheApp->GetAppName();
m_format = new wxDataFormat( m_id );
m_size = 0;
m_data = (char*) NULL;
m_id = wxTheApp->GetAppName();
}
wxPrivateDataObject::~wxPrivateDataObject()
@@ -56,6 +401,17 @@ 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::SetData( const char *data, size_t size )
{
m_size = size;
@@ -67,3 +423,23 @@ void wxPrivateDataObject::SetData( const char *data, size_t size )
memcpy( m_data, data, size );
}
char* wxPrivateDataObject::GetData() const
{
return m_data;
}
void wxPrivateDataObject::WriteData( void *dest ) const
{
WriteData( m_data, dest );
}
size_t wxPrivateDataObject::GetSize() const
{
return m_size;
}
void wxPrivateDataObject::WriteData( const char *data, void *dest ) const
{
memcpy( dest, data, GetSize() );
}

11
src/gtk1/dialog.cpp
View File

@@ -134,7 +134,16 @@ bool wxDialog::Create( wxWindow *parent,
wxDialog::~wxDialog()
{
wxTopLevelWindows.DeleteObject( this );
if (wxTopLevelWindows.Number() == 0) wxTheApp->ExitMainLoop();
if (wxTheApp->GetTopWindow() == this)
{
wxTheApp->SetTopWindow( (wxWindow*) NULL );
}
if (wxTopLevelWindows.Number() == 0)
{
wxTheApp->ExitMainLoop();
}
}
void wxDialog::SetTitle( const wxString& title )

238
src/gtk1/dnd.cpp
View File

@@ -171,8 +171,7 @@ void wxDropTarget::RegisterWidget( GtkWidget *widget )
break;
case wxDF_PRIVATE:
wxPrivateDropTarget *pdt = (wxPrivateDropTarget *)this;
strcpy( buf, "applications/" );
strcat( buf, WXSTRINGCAST pdt->GetID() );
strcpy( buf, WXSTRINGCAST pdt->GetID() );
format.target = buf;
valid++;
default:
@@ -533,10 +532,17 @@ static void gtk_target_callback( GtkWidget *widget,
wxDropTarget::wxDropTarget()
{
m_format = (wxDataFormat*) NULL;
}
wxDropTarget::~wxDropTarget()
{
if (m_format) delete m_format;
}
wxDataFormat &wxDropTarget::GetFormat(size_t n) const
{
return (*m_format);
}
void wxDropTarget::UnregisterWidget( GtkWidget *widget )
@@ -556,8 +562,7 @@ void wxDropTarget::RegisterWidget( GtkWidget *widget )
for ( size_t i = 0; i < GetFormatCount(); i++ )
{
wxDataFormat df = GetFormat( i );
switch (df)
switch (GetFormat(i).GetType())
{
case wxDF_TEXT:
{
@@ -577,7 +582,6 @@ void wxDropTarget::RegisterWidget( GtkWidget *widget )
{
if (i > 0) formats += ";";
wxPrivateDropTarget *pdt = (wxPrivateDropTarget *)this;
formats += "applications/";
formats += pdt->GetId();
valid++;
break;
@@ -605,6 +609,11 @@ void wxDropTarget::RegisterWidget( GtkWidget *widget )
// wxTextDropTarget
// ----------------------------------------------------------------------------
wxTextDropTarget::wxTextDropTarget()
{
m_format = new wxDataFormat( wxDF_TEXT );
}
bool wxTextDropTarget::OnDrop( long x, long y, const void *data, size_t WXUNUSED(size) )
{
OnDropText( x, y, (const char*)data );
@@ -625,11 +634,6 @@ size_t wxTextDropTarget::GetFormatCount() const
return 1;
}
wxDataFormat wxTextDropTarget::GetFormat(size_t WXUNUSED(n)) const
{
return wxDF_TEXT;
}
// ----------------------------------------------------------------------------
// wxPrivateDropTarget
// ----------------------------------------------------------------------------
@@ -637,6 +641,13 @@ wxDataFormat wxTextDropTarget::GetFormat(size_t WXUNUSED(n)) const
wxPrivateDropTarget::wxPrivateDropTarget()
{
m_id = wxTheApp->GetAppName();
m_format = new wxDataFormat( m_id );
}
void wxPrivateDropTarget::SetId( const wxString& id )
{
m_id = id;
m_format->SetId( id );
}
size_t wxPrivateDropTarget::GetFormatCount() const
@@ -644,15 +655,15 @@ size_t wxPrivateDropTarget::GetFormatCount() const
return 1;
}
wxDataFormat wxPrivateDropTarget::GetFormat(size_t WXUNUSED(n)) const
{
return wxDF_PRIVATE;
}
// ----------------------------------------------------------------------------
// wxFileDropTarget
// ----------------------------------------------------------------------------
wxFileDropTarget::wxFileDropTarget()
{
m_format = new wxDataFormat( wxDF_FILENAME );
}
bool wxFileDropTarget::OnDropFiles( long x, long y, size_t nFiles, const char * const aszFiles[] )
{
printf( "Got %d dropped files.\n", (int)nFiles );
@@ -698,11 +709,6 @@ size_t wxFileDropTarget::GetFormatCount() const
return 1;
}
wxDataFormat wxFileDropTarget::GetFormat(size_t WXUNUSED(n)) const
{
return wxDF_FILENAME;
}
//-------------------------------------------------------------------------
// wxDropSource
//-------------------------------------------------------------------------
@@ -712,64 +718,76 @@ shape_motion (GtkWidget *widget,
GdkEventMotion * /*event*/);
//-----------------------------------------------------------------------------
// drag request
// "drag_request_event"
//-----------------------------------------------------------------------------
void gtk_drag_callback( GtkWidget *widget, GdkEvent *event, wxDropSource *source )
void gtk_drag_callback( GtkWidget *widget, GdkEventDragRequest *event, wxDropSource *source )
{
wxDataObject *data = source->m_data;
switch (data->GetFormat())
wxDataBroker *data = source->m_data;
if (!data) return;
wxNode *node = data->m_dataObjects.First();
{
case wxDF_PRIVATE:
{
wxPrivateDataObject *pdo = (wxPrivateDataObject*) data;
gtk_widget_dnd_data_set( widget,
event,
(unsigned char*) pdo->GetData(),
(int) pdo->GetDataSize() );
break;
}
case wxDF_TEXT:
{
wxTextDataObject *text_object = (wxTextDataObject*) data;
wxString text = text_object->GetText();
char *s = WXSTRINGCAST text;
gtk_widget_dnd_data_set( widget,
event,
(unsigned char*) s,
(int) text.Length()+1 );
wxDataObject *dobj = (wxDataObject*) node->Data();
break;
}
case wxDF_FILENAME:
if ((strcmp(event->data_type,"file:ALL") == 0) &&
(dobj->GetFormat().GetType() == wxDF_FILENAME))
{
wxFileDataObject *file_object = (wxFileDataObject*) data;
wxFileDataObject *file_object = (wxFileDataObject*) dobj;
wxString text = file_object->GetFiles();
char *s = WXSTRINGCAST text;
gtk_widget_dnd_data_set( widget,
event,
(GdkEvent*)event,
(unsigned char*) s,
(int) text.Length()+1 );
break;
}
default:
{
source->m_retValue = wxDragCopy;
return;
}
if ((strcmp(event->data_type,"text/plain") == 0) &&
(dobj->GetFormat().GetType() == wxDF_TEXT))
{
wxTextDataObject *text_object = (wxTextDataObject*) dobj;
wxString text = text_object->GetText();
char *s = WXSTRINGCAST text;
gtk_widget_dnd_data_set( widget,
(GdkEvent*)event,
(unsigned char*) s,
(int) text.Length()+1 );
source->m_retValue = wxDragCopy;
return;
}
if (dobj->GetFormat().GetType() == wxDF_PRIVATE)
{
wxPrivateDataObject *pdo = (wxPrivateDataObject*) dobj;
if (pdo->GetId() == event->data_type)
{
gtk_widget_dnd_data_set( widget,
(GdkEvent*)event,
(unsigned char*) pdo->GetData(),
(int) pdo->GetSize() );
source->m_retValue = wxDragCopy;
return;
}
}
node = node->Next();
}
source->m_retValue = wxDragCopy;
}
wxDropSource::wxDropSource( wxWindow *win )
@@ -780,14 +798,14 @@ wxDropSource::wxDropSource( wxWindow *win )
m_widget = win->m_widget;
if (win->m_wxwindow) m_widget = win->m_wxwindow;
m_data = (wxDataObject *) NULL;
m_data = (wxDataBroker*) NULL;
m_retValue = wxDragCancel;
m_defaultCursor = wxCursor( wxCURSOR_NO_ENTRY );
m_goaheadCursor = wxCursor( wxCURSOR_HAND );
}
wxDropSource::wxDropSource( wxDataObject &data, wxWindow *win )
wxDropSource::wxDropSource( wxDataObject *data, wxWindow *win )
{
g_blockEventsOnDrag = TRUE;
@@ -796,20 +814,60 @@ wxDropSource::wxDropSource( wxDataObject &data, wxWindow *win )
if (win->m_wxwindow) m_widget = win->m_wxwindow;
m_retValue = wxDragCancel;
m_data = &data;
if (data)
{
m_data = new wxDataBroker();
m_data->Add( data );
}
else
{
m_data = (wxDataBroker*) NULL;
}
m_defaultCursor = wxCursor( wxCURSOR_NO_ENTRY );
m_goaheadCursor = wxCursor( wxCURSOR_HAND );
}
void wxDropSource::SetData( wxDataObject &data )
wxDropSource::wxDropSource( wxDataBroker *data, wxWindow *win )
{
m_data = &data;
g_blockEventsOnDrag = TRUE;
m_window = win;
m_widget = win->m_widget;
if (win->m_wxwindow) m_widget = win->m_wxwindow;
m_retValue = wxDragCancel;
m_data = data;
m_defaultCursor = wxCursor( wxCURSOR_NO_ENTRY );
m_goaheadCursor = wxCursor( wxCURSOR_HAND );
}
void wxDropSource::SetData( wxDataObject *data )
{
if (m_data) delete m_data;
if (data)
{
m_data = new wxDataBroker();
m_data->Add( data );
}
else
{
m_data = (wxDataBroker*) NULL;
}
}
void wxDropSource::SetData( wxDataBroker *data )
{
if (m_data) delete m_data;
m_data = data;
}
wxDropSource::~wxDropSource(void)
{
// if (m_data) delete m_data;
if (m_data) delete m_data;
g_blockEventsOnDrag = FALSE;
}
@@ -926,29 +984,33 @@ void wxDropSource::RegisterWindow(void)
wxString formats;
wxDataFormat df = m_data->GetFormat();
switch (df)
wxNode *node = m_data->m_dataObjects.First();
while (node)
{
case wxDF_TEXT:
{
formats += "text/plain";
break;
wxDataObject* dobj = (wxDataObject*) node->Data();
switch (dobj->GetFormat().GetType())
{
case wxDF_TEXT:
{
formats += "text/plain";
break;
}
case wxDF_FILENAME:
{
formats += "file:ALL";
break;
}
case wxDF_PRIVATE:
{
wxPrivateDataObject* pdo = (wxPrivateDataObject*) m_data;
formats += pdo->GetId();
break;
}
default:
break;
}
case wxDF_FILENAME:
{
formats += "file:ALL";
break;
}
case wxDF_PRIVATE:
{
wxPrivateDataObject* pdo = (wxPrivateDataObject*) m_data;
formats += "applications/";
formats += pdo->GetId();
break;
}
default:
break;
node = node->Next();
}
char *str = WXSTRINGCAST formats;

11
src/gtk1/frame.cpp
View File

@@ -193,7 +193,16 @@ wxFrame::~wxFrame()
if (m_frameToolBar) delete m_frameToolBar;
wxTopLevelWindows.DeleteObject( this );
if (wxTopLevelWindows.Number() == 0) wxTheApp->ExitMainLoop();
if (wxTheApp->GetTopWindow() == this)
{
wxTheApp->SetTopWindow( (wxWindow*) NULL );
}
if (wxTopLevelWindows.Number() == 0)
{
wxTheApp->ExitMainLoop();
}
}
bool wxFrame::Show( bool show )