// Purpose: wxTextEntry implementation for wxGTK
// Author: Vadim Zeitlin
// Created: 2007-09-24
-// RCS-ID: $Id$
// Copyright: (c) 2007 Vadim Zeitlin <vadim@wxwindows.org>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#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 <gtk/gtk.h>
#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"
// ============================================================================
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<wxTextEntry *>(this)->GetEditableWindow()->GetFont());
}
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());
{
// 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;
}
// ----------------------------------------------------------------------------
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
// 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;
bool wxTextEntry::IsEditable() const
{
- return gtk_editable_get_editable(GetEditable());
+ return gtk_editable_get_editable(GetEditable()) != 0;
}
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<wxWindow *>(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
projects / wxWidgets.git / blobdiff