X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/0c3d1aa7fdec7b69a94ef02f7d9c5056526057b6..60d66be369d360e1528e4dd4bb65a909a8c6ac9a:/src/gtk/textentry.cpp diff --git a/src/gtk/textentry.cpp b/src/gtk/textentry.cpp index 2d1f868666..f8f9730d6d 100644 --- a/src/gtk/textentry.cpp +++ b/src/gtk/textentry.cpp @@ -26,47 +26,114 @@ #if wxUSE_TEXTCTRL || wxUSE_COMBOBOX #ifndef WX_PRECOMP + #include "wx/textentry.h" #include "wx/window.h" #include "wx/textctrl.h" #endif //WX_PRECOMP -#include "wx/textentry.h" - +#include #include "wx/gtk/private.h" +#include "wx/gtk/private/gtk2-compat.h" // ============================================================================ // signal handlers implementation // ============================================================================ -extern "C" -{ - // "insert_text" handler for GtkEntry -static void +extern "C" +void wx_gtk_insert_text_callback(GtkEditable *editable, - const gchar * WXUNUSED(new_text), + const gchar * new_text, gint WXUNUSED(new_text_length), gint * WXUNUSED(position), wxTextEntry *text) { - // we should only be called if we have a max len limit at all GtkEntry *entry = GTK_ENTRY (editable); - wxCHECK_RET( entry->text_max_length, _T("shouldn't be called") ); +#if GTK_CHECK_VERSION(3,0,0) || defined(GSEAL_ENABLE) + const int text_max_length = gtk_entry_buffer_get_max_length(gtk_entry_get_buffer(entry)); +#else + const int text_max_length = entry->text_max_length; +#endif + + bool handled = false; + + // check that we don't overflow the max length limit if we have it + if ( text_max_length ) + { + const int text_length = gtk_entry_get_text_length(entry); + + // We can't use new_text_length as it is in bytes while we want to count + // characters (in first approximation, anyhow...). + if ( text_length + g_utf8_strlen(new_text, -1) > text_max_length ) + { + // Prevent the new text from being inserted. + handled = true; + + // Currently we don't insert anything at all, but it would be better to + // insert as many characters as would fit into the text control and + // only discard the rest. - // check that we don't overflow the max length limit - // - // FIXME: this doesn't work when we paste a string which is going to be - // truncated - if ( entry->text_length == entry->text_max_length ) + // Notify the user code about overflow. + text->SendMaxLenEvent(); + } + } + + if ( !handled && text->GTKEntryOnInsertText(new_text) ) { - // we don't need to run the base class version at all + // If we already handled the new text insertion, don't do it again. + handled = true; + } + + if ( handled ) g_signal_stop_emission_by_name (editable, "insert_text"); +} + +//----------------------------------------------------------------------------- +// clipboard events: "copy-clipboard", "cut-clipboard", "paste-clipboard" +//----------------------------------------------------------------------------- - text->SendMaxLenEvent(); +// common part of the event handlers below +static void +DoHandleClipboardCallback( GtkWidget *widget, + wxWindow *win, + wxEventType eventType, + const gchar* signal_name) +{ + wxClipboardTextEvent event( eventType, win->GetId() ); + event.SetEventObject( win ); + if ( win->HandleWindowEvent( event ) ) + { + // don't let the default processing to take place if we did something + // ourselves in the event handler + g_signal_stop_emission_by_name (widget, signal_name); } } +extern "C" +{ + +static void +wx_gtk_copy_clipboard_callback( GtkWidget *widget, wxWindow *win ) +{ + DoHandleClipboardCallback( + widget, win, wxEVT_TEXT_COPY, "copy-clipboard" ); +} + +static void +wx_gtk_cut_clipboard_callback( GtkWidget *widget, wxWindow *win ) +{ + DoHandleClipboardCallback( + widget, win, wxEVT_TEXT_CUT, "cut-clipboard" ); +} + +static void +wx_gtk_paste_clipboard_callback( GtkWidget *widget, wxWindow *win ) +{ + DoHandleClipboardCallback( + widget, win, wxEVT_TEXT_PASTE, "paste-clipboard" ); +} + } // extern "C" // ============================================================================ @@ -103,11 +170,32 @@ void wxTextEntry::WriteText(const wxString& value) gtk_editable_set_position(edit, len); } -wxString wxTextEntry::GetValue() const +void wxTextEntry::DoSetValue(const wxString& value, int flags) +{ + if (value != DoGetValue()) + { + // use Remove() rather than SelectAll() to avoid unnecessary clipboard + // operations, and prevent triggering an apparent bug in GTK which + // causes the the subsequent WriteText() to append rather than overwrite + { + EventsSuppressor noevents(this); + Remove(0, -1); + } + EventsSuppressor noeventsIf(this, !(flags & SetValue_SendEvent)); + WriteText(value); + } + else if (flags & SetValue_SendEvent) + SendTextUpdatedEvent(GetEditableWindow()); + + SetInsertionPoint(0); +} + +wxString wxTextEntry::DoGetValue() const { const wxGtkString value(gtk_editable_get_chars(GetEditable(), 0, -1)); - return wxGTK_CONV_BACK_FONT(value, GetEditableWindow()->GetFont()); + return wxGTK_CONV_BACK_FONT(value, + const_cast(this)->GetEditableWindow()->GetFont()); } void wxTextEntry::Remove(long from, long to) @@ -119,6 +207,19 @@ void wxTextEntry::Remove(long from, long to) // clipboard operations // ---------------------------------------------------------------------------- +void wxTextEntry::GTKConnectClipboardSignals(GtkWidget* entry) +{ + g_signal_connect(entry, "copy-clipboard", + G_CALLBACK (wx_gtk_copy_clipboard_callback), + GetEditableWindow()); + g_signal_connect(entry, "cut-clipboard", + G_CALLBACK (wx_gtk_cut_clipboard_callback), + GetEditableWindow()); + g_signal_connect(entry, "paste-clipboard", + G_CALLBACK (wx_gtk_paste_clipboard_callback), + GetEditableWindow()); +} + void wxTextEntry::Copy() { gtk_editable_copy_clipboard(GetEditable()); @@ -176,9 +277,12 @@ long wxTextEntry::GetLastPosition() const { // this can't be implemented for arbitrary GtkEditable so only do it for // GtkEntries - GtkEntry * const entry = GTK_ENTRY(GetEditable()); + long pos = -1; + GtkEntry* entry = (GtkEntry*)GetEditable(); + if (GTK_IS_ENTRY(entry)) + pos = gtk_entry_get_text_length(entry); - return entry ? entry->text_length : - 1; + return pos; } // ---------------------------------------------------------------------------- @@ -187,7 +291,28 @@ long wxTextEntry::GetLastPosition() const void wxTextEntry::SetSelection(long from, long to) { - gtk_editable_select_region(GetEditable(), from, to); + // in wx convention, (-1, -1) means the entire range but GTK+ translates -1 + // (or any negative number for that matter) into last position so we need + // to translate manually + if ( from == -1 && to == -1 ) + from = 0; + + // for compatibility with MSW, exchange from and to parameters so that the + // insertion point is set to the start of the selection and not its end as + // GTK+ does by default + gtk_editable_select_region(GetEditable(), to, from); + +#ifndef __WXGTK3__ + // avoid reported problem with RHEL 5 GTK+ 2.10 where selection is reset by + // a clipboard callback, see #13277 + if (gtk_check_version(2,12,0)) + { + GtkEntry* entry = GTK_ENTRY(GetEditable()); + if (to < 0) + to = entry->text_length; + entry->selection_bound = to; + } +#endif } void wxTextEntry::GetSelection(long *from, long *to) const @@ -221,10 +346,10 @@ void wxTextEntry::GetSelection(long *from, long *to) const // auto completion // ---------------------------------------------------------------------------- -bool wxTextEntry::AutoComplete(const wxArrayString& choices) +bool wxTextEntry::DoAutoCompleteStrings(const wxArrayString& choices) { - GtkEntry * const entry = GTK_ENTRY(GetEditable()); - wxCHECK_MSG(entry, false, "auto completion doesn't work with this control"); + GtkEntry* const entry = (GtkEntry*)GetEditable(); + wxCHECK_MSG(GTK_IS_ENTRY(entry), false, "auto completion doesn't work with this control"); GtkListStore * const store = gtk_list_store_new(1, G_TYPE_STRING); GtkTreeIter iter; @@ -253,7 +378,7 @@ bool wxTextEntry::AutoComplete(const wxArrayString& choices) bool wxTextEntry::IsEditable() const { - return gtk_editable_get_editable(GetEditable()); + return gtk_editable_get_editable(GetEditable()) != 0; } void wxTextEntry::SetEditable(bool editable) @@ -267,53 +392,127 @@ void wxTextEntry::SetEditable(bool editable) void wxTextEntry::SetMaxLength(unsigned long len) { - GtkEntry * const entry = GTK_ENTRY(GetEditable()); - if ( !entry ) + GtkEntry* const entry = (GtkEntry*)GetEditable(); + if (!GTK_IS_ENTRY(entry)) return; gtk_entry_set_max_length(entry, len); - - // there is a bug in GTK+ 1.2.x: "changed" signal is emitted even if we had - // tried to enter more text than allowed by max text length and the text - // wasn't really changed - // - // to detect this and generate TEXT_MAXLEN event instead of TEXT_CHANGED - // one in this case we also catch "insert_text" signal - // - // when max len is set to 0 we disconnect our handler as it means that we - // shouldn't check anything any more - if ( len ) - { - g_signal_connect - ( - entry, - "insert_text", - G_CALLBACK(wx_gtk_insert_text_callback), - this - ); - } - else // no max length - { - g_signal_handlers_disconnect_by_func - ( - entry, - (gpointer)wx_gtk_insert_text_callback, - this - ); - } } void wxTextEntry::SendMaxLenEvent() { // remember that the next changed signal is to be ignored to avoid - // generating a dummy wxEVT_COMMAND_TEXT_UPDATED event + // generating a dummy wxEVT_TEXT event //IgnoreNextTextUpdate(); - wxWindow * const win = const_cast(GetEditableWindow()); - wxCommandEvent event(wxEVT_COMMAND_TEXT_MAXLEN, win->GetId()); + wxWindow * const win = GetEditableWindow(); + wxCommandEvent event(wxEVT_TEXT_MAXLEN, win->GetId()); event.SetEventObject(win); event.SetString(GetValue()); - win->GetEventHandler()->ProcessEvent(event); + win->HandleWindowEvent(event); +} + +// ---------------------------------------------------------------------------- +// IM handling +// ---------------------------------------------------------------------------- + +int wxTextEntry::GTKIMFilterKeypress(GdkEventKey* event) const +{ +#if GTK_CHECK_VERSION(2, 22, 0) + if ( gtk_check_version(2, 12, 0) == 0 ) + return gtk_entry_im_context_filter_keypress(GetEntry(), event); +#else // GTK+ < 2.22 + wxUnusedVar(event); +#endif // GTK+ 2.22+ + + return FALSE; +} + +void wxTextEntry::GTKConnectInsertTextSignal(GtkEntry* entry) +{ + g_signal_connect(entry, "insert_text", + G_CALLBACK(wx_gtk_insert_text_callback), this); +} + +bool wxTextEntry::GTKEntryOnInsertText(const char* text) +{ + return GetEditableWindow()->GTKOnInsertText(text); +} + +// ---------------------------------------------------------------------------- +// margins support +// ---------------------------------------------------------------------------- + +bool wxTextEntry::DoSetMargins(const wxPoint& margins) +{ +#if GTK_CHECK_VERSION(2,10,0) + GtkEntry* entry = GetEntry(); + + if ( !entry ) + return false; + + const GtkBorder* oldBorder = gtk_entry_get_inner_border(entry); + GtkBorder* newBorder; + + if ( oldBorder ) + { + newBorder = gtk_border_copy(oldBorder); + } + else + { + #if GTK_CHECK_VERSION(2,14,0) + newBorder = gtk_border_new(); + #else + newBorder = g_slice_new0(GtkBorder); + #endif + // Use some reasonable defaults for initial margins + newBorder->left = 2; + newBorder->right = 2; + + // These numbers seem to let the text remain vertically centered + // in common use scenarios when margins.y == -1. + newBorder->top = 3; + newBorder->bottom = 3; + } + + if ( margins.x != -1 ) + newBorder->left = (gint) margins.x; + + if ( margins.y != -1 ) + newBorder->top = (gint) margins.y; + + gtk_entry_set_inner_border(entry, newBorder); + +#if GTK_CHECK_VERSION(2,14,0) + gtk_border_free(newBorder); +#else + g_slice_free(GtkBorder, newBorder); +#endif + + return true; +#else + wxUnusedVar(margins); + return false; +#endif +} + +wxPoint wxTextEntry::DoGetMargins() const +{ +#if GTK_CHECK_VERSION(2,10,0) + GtkEntry* entry = GetEntry(); + + if ( !entry ) + return wxPoint(-1, -1); + + const GtkBorder* border = gtk_entry_get_inner_border(entry); + + if ( !border ) + return wxPoint(-1, -1); + + return wxPoint((wxCoord) border->left, (wxCoord) border->top); +#else + return wxPoint(-1, -1); +#endif } #endif // wxUSE_TEXTCTRL || wxUSE_COMBOBOX