#include "wx/clipbrd.h"
#ifndef WX_PRECOMP
+ #include "wx/app.h"
#include "wx/log.h"
#include "wx/utils.h"
#include "wx/dataobj.h"
#endif
-#include "wx/ptr_scpd.h"
+#include "wx/scopedarray.h"
#include "wx/scopeguard.h"
+#include "wx/evtloop.h"
#include "wx/gtk/private.h"
-wxDECLARE_SCOPED_ARRAY(wxDataFormat, wxDataFormatArray)
-wxDEFINE_SCOPED_ARRAY(wxDataFormat, wxDataFormatArray)
+typedef wxScopedArray<wxDataFormat> wxDataFormatArray;
// ----------------------------------------------------------------------------
// data
// the trace mask we use with wxLogTrace() - call
// wxLog::AddTraceMask(TRACE_CLIPBOARD) to enable the trace messages from here
// (there will be a *lot* of them!)
-#define TRACE_CLIPBOARD _T("clipboard")
+#define TRACE_CLIPBOARD wxT("clipboard")
// ----------------------------------------------------------------------------
// wxClipboardSync: used to perform clipboard operations synchronously
public:
wxClipboardSync(wxClipboard& clipboard)
{
- wxASSERT_MSG( !ms_clipboard, _T("reentrancy in clipboard code") );
+ wxASSERT_MSG( !ms_clipboard, wxT("reentrancy in clipboard code") );
ms_clipboard = &clipboard;
}
~wxClipboardSync()
{
- while ( ms_clipboard )
- gtk_main_iteration();
+ // ensure that there is a running event loop: this might not be the
+ // case if we're called before the main event loop startup
+ wxEventLoopGuarantor ensureEventLoop;
+
+ while (ms_clipboard)
+ wxEventLoopBase::GetActive()->YieldFor(wxEVT_CATEGORY_CLIPBOARD);
}
// this method must be called by GTK+ callbacks to indicate that we got the
// result for our clipboard operation
- static void OnDone(wxClipboard *clipboard)
+ static void OnDone(wxClipboard * WXUNUSED_UNLESS_DEBUG(clipboard))
{
wxASSERT_MSG( clipboard == ms_clipboard,
- _T("got notification for alien clipboard") );
+ wxT("got notification for alien clipboard") );
ms_clipboard = NULL;
}
+ // this method should be called if it's possible that no async clipboard
+ // operation is currently in progress (like it can be the case when the
+ // clipboard is cleared but not because we asked about it), it should only
+ // be called if such situation is expected -- otherwise call OnDone() which
+ // would assert in this case
+ static void OnDoneIfInProgress(wxClipboard *clipboard)
+ {
+ if ( ms_clipboard )
+ OnDone(clipboard);
+ }
+
private:
static wxClipboard *ms_clipboard;
- DECLARE_NO_COPY_CLASS(wxClipboardSync)
+ wxDECLARE_NO_COPY_CLASS(wxClipboardSync);
};
wxClipboard *wxClipboardSync::ms_clipboard = NULL;
// ============================================================================
-// clipboard ca;backs implementation
+// clipboard callbacks implementation
// ============================================================================
//-----------------------------------------------------------------------------
if ( strcmp(wxGtkString(gdk_atom_name(type)), "TARGETS") != 0 )
{
wxLogTrace( TRACE_CLIPBOARD,
- _T("got unsupported clipboard target") );
+ wxT("got unsupported clipboard target") );
return;
}
}
-#ifdef __WXDEBUG__
// it's not really a format, of course, but we can reuse its GetId() method
// to format this atom as string
wxDataFormat clip(selection_data->selection);
wxLogTrace( TRACE_CLIPBOARD,
wxT("Received available formats for clipboard %s"),
clip.GetId().c_str() );
-#endif // __WXDEBUG__
// the atoms we received, holding a list of targets (= formats)
const GdkAtom * const atoms = (GdkAtom *)selection_data->data;
if ( !clipboard )
return TRUE;
- wxON_BLOCK_EXIT1(wxClipboardSync::OnDone, clipboard);
+ // notice the use of OnDoneIfInProgress() here instead of just OnDone():
+ // it's perfectly possible that we're receiving this notification from GTK+
+ // even though we hadn't cleared the clipboard ourselves but because
+ // another application (or even another window in the same program)
+ // acquired it
+ wxON_BLOCK_EXIT1(wxClipboardSync::OnDoneIfInProgress, clipboard);
wxClipboard::Kind kind;
if (event->selection == GDK_SELECTION_PRIMARY)
(guchar*)&(timestamp),
sizeof(timestamp));
wxLogTrace(TRACE_CLIPBOARD,
- _T("Clipboard TIMESTAMP requested, returning timestamp=%u"),
+ wxT("Clipboard TIMESTAMP requested, returning timestamp=%u"),
timestamp);
return;
}
wxDataFormat format( selection_data->target );
-#ifdef __WXDEBUG__
wxLogTrace(TRACE_CLIPBOARD,
- _T("clipboard data in format %s, GtkSelectionData is target=%s type=%s selection=%s timestamp=%u"),
+ wxT("clipboard data in format %s, GtkSelectionData is target=%s type=%s selection=%s timestamp=%u"),
format.GetId().c_str(),
wxString::FromAscii(wxGtkString(gdk_atom_name(selection_data->target))).c_str(),
wxString::FromAscii(wxGtkString(gdk_atom_name(selection_data->type))).c_str(),
wxString::FromAscii(wxGtkString(gdk_atom_name(selection_data->selection))).c_str(),
GPOINTER_TO_UINT( signal_data )
);
-#endif
- if (!data->IsSupportedFormat( format )) return;
+ if ( !data->IsSupportedFormat( format ) )
+ return;
int size = data->GetDataSize( format );
+ if ( !size )
+ return;
- if (size == 0) return;
-
- void *d = malloc(size);
- wxON_BLOCK_EXIT1(free, d);
+ wxCharBuffer buf(size - 1); // it adds 1 internally (for NUL)
- // Text data will be in UTF8 in Unicode mode.
- data->GetDataHere( selection_data->target, d );
+ // text data must be returned in UTF8 if format is wxDF_UNICODETEXT
+ if ( !data->GetDataHere(format, buf.data()) )
+ return;
- // NB: GTK+ requires special treatment of UTF8_STRING data, the text
- // would show as UTF-8 data interpreted as latin1 (?) in other
- // GTK+ apps if we used gtk_selection_data_set()
+ // use UTF8_STRING format if requested in Unicode build but just plain
+ // STRING one in ANSI or if explicitly asked in Unicode
+#if wxUSE_UNICODE
if (format == wxDataFormat(wxDF_UNICODETEXT))
{
gtk_selection_data_set_text(
selection_data,
- (const gchar*)d,
+ (const gchar*)buf.data(),
size );
}
else
+#endif // wxUSE_UNICODE
{
gtk_selection_data_set(
selection_data,
GDK_SELECTION_TYPE_STRING,
8*sizeof(gchar),
- (unsigned char*) d,
+ (const guchar*)buf.data(),
size );
}
}
void wxClipboard::GTKOnSelectionReceived(const GtkSelectionData& sel)
{
- wxCHECK_RET( m_receivedData, _T("should be inside GetData()") );
+ wxCHECK_RET( m_receivedData, wxT("should be inside GetData()") );
const wxDataFormat format(sel.target);
- wxLogTrace(TRACE_CLIPBOARD, _T("Received selection %s"),
+ wxLogTrace(TRACE_CLIPBOARD, wxT("Received selection %s"),
format.GetId().c_str());
if ( !m_receivedData->IsSupportedFormat(format) )
m_formatSupported = true;
}
+//-----------------------------------------------------------------------------
+// asynchronous "selection_received" for targets
+//-----------------------------------------------------------------------------
+
+extern "C" {
+static void
+async_targets_selection_received( GtkWidget *WXUNUSED(widget),
+ GtkSelectionData *selection_data,
+ guint32 WXUNUSED(time),
+ wxClipboard *clipboard )
+{
+ if ( !clipboard ) // Assert?
+ return;
+
+ if (!clipboard->m_sink)
+ return;
+
+ wxClipboardEvent *event = new wxClipboardEvent(wxEVT_CLIPBOARD_CHANGED);
+ event->SetEventObject( clipboard );
+
+ if ( !selection_data || selection_data->length <= 0 )
+ {
+ clipboard->m_sink->QueueEvent( event );
+ clipboard->m_sink.Release();
+ return;
+ }
+
+ // make sure we got the data in the correct form
+ GdkAtom type = selection_data->type;
+ if ( type != GDK_SELECTION_TYPE_ATOM )
+ {
+ if ( strcmp(wxGtkString(gdk_atom_name(type)), "TARGETS") != 0 )
+ {
+ wxLogTrace( TRACE_CLIPBOARD,
+ wxT("got unsupported clipboard target") );
+
+ clipboard->m_sink->QueueEvent( event );
+ clipboard->m_sink.Release();
+ return;
+ }
+ }
+
+ // it's not really a format, of course, but we can reuse its GetId() method
+ // to format this atom as string
+ wxDataFormat clip(selection_data->selection);
+ wxLogTrace( TRACE_CLIPBOARD,
+ wxT("Received available formats for clipboard %s"),
+ clip.GetId().c_str() );
+
+ // the atoms we received, holding a list of targets (= formats)
+ const GdkAtom * const atoms = (GdkAtom *)selection_data->data;
+ for ( size_t i = 0; i < selection_data->length/sizeof(GdkAtom); i++ )
+ {
+ const wxDataFormat format(atoms[i]);
+
+ wxLogTrace(TRACE_CLIPBOARD, wxT("\t%s"), format.GetId().c_str());
+
+ event->AddFormat( format );
+ }
+
+ clipboard->m_sink->QueueEvent( event );
+ clipboard->m_sink.Release();
+}
+}
+
// ============================================================================
// wxClipboard implementation
// ============================================================================
g_signal_connect (m_targetsWidget, "selection_received",
G_CALLBACK (targets_selection_received), this);
+ // we use m_targetsWidgetAsync to query what formats are available asynchronously
+ m_targetsWidgetAsync = gtk_window_new( GTK_WINDOW_POPUP );
+ gtk_widget_realize( m_targetsWidgetAsync );
+
+ g_signal_connect (m_targetsWidgetAsync, "selection_received",
+ G_CALLBACK (async_targets_selection_received), this);
+
// we use m_clipboardWidget to get and to offer data
m_clipboardWidget = gtk_window_new( GTK_WINDOW_POPUP );
gtk_widget_realize( m_clipboardWidget );
{
Clear();
- if ( m_clipboardWidget )
- gtk_widget_destroy( m_clipboardWidget );
- if ( m_targetsWidget )
- gtk_widget_destroy( m_targetsWidget );
+ gtk_widget_destroy( m_clipboardWidget );
+ gtk_widget_destroy( m_targetsWidget );
}
// ----------------------------------------------------------------------------
void wxClipboard::GTKClearData(Kind kind)
{
- wxDataObject *&data = Data();
- if ( data )
- {
- delete data;
- data = NULL;
- }
+ wxDataObject *&data = Data(kind);
+ wxDELETE(data);
}
bool wxClipboard::SetSelectionOwner(bool set)
if ( !rc )
{
- wxLogTrace(TRACE_CLIPBOARD, _T("Failed to %sset selection owner"),
- set ? _T("") : _T("un"));
+ wxLogTrace(TRACE_CLIPBOARD, wxT("Failed to %sset selection owner"),
+ set ? wxT("") : wxT("un"));
}
return rc;
{
gtk_selection_add_target
(
- GTK_WIDGET(m_clipboardWidget),
+ m_clipboardWidget,
GTKGetClipboardAtom(),
atom,
0 // info (same as client data) unused
);
}
+bool wxClipboard::IsSupportedAsync(wxEvtHandler *sink)
+{
+ if (m_sink.get())
+ return false; // currently busy, come back later
+
+ wxCHECK_MSG( sink, false, wxT("no sink given") );
+
+ m_sink = sink;
+ gtk_selection_convert( m_targetsWidgetAsync,
+ GTKGetClipboardAtom(),
+ g_targetsAtom,
+ (guint32) GDK_CURRENT_TIME );
+
+ return true;
+}
+
bool wxClipboard::DoIsSupported(const wxDataFormat& format)
{
wxCHECK_MSG( format, false, wxT("invalid clipboard format") );
void wxClipboard::Clear()
{
+ gtk_selection_clear_targets( m_clipboardWidget, GTKGetClipboardAtom() );
+
if ( gdk_selection_owner_get(GTKGetClipboardAtom()) ==
m_clipboardWidget->window )
{
{
wxCHECK_MSG( m_open, false, wxT("clipboard not open") );
- // get all supported formats from wxDataObjects
- const size_t count = data.GetFormatCount();
+ // get all supported formats from wxDataObjects: notice that we are setting
+ // the object data, so we need them in "Set" direction
+ const size_t count = data.GetFormatCount(wxDataObject::Set);
wxDataFormatArray formats(new wxDataFormat[count]);
- data.GetAllFormats(formats.get());
+ data.GetAllFormats(formats.get(), wxDataObject::Set);
for ( size_t i = 0; i < count; i++ )
{
projects / wxWidgets.git / blobdiff