diff options
Diffstat (limited to 'gtksecentry/gtksecentry.c')
| -rw-r--r-- | gtksecentry/gtksecentry.c | 3364 |
1 files changed, 0 insertions, 3364 deletions
diff --git a/gtksecentry/gtksecentry.c b/gtksecentry/gtksecentry.c deleted file mode 100644 index f68f094..0000000 --- a/gtksecentry/gtksecentry.c +++ /dev/null @@ -1,3364 +0,0 @@ -/* GTK - The GIMP Toolkit - * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald - * Copyright (C) 2004 Albrecht Dreß - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2 of the License, or (at your option) any later version. - * - * This library is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library; if not, write to the - * Free Software Foundation, Inc., 59 Temple Place - Suite 330, - * Boston, MA 02111-1307, USA. - */ - -/* - * Modified by the GTK+ Team and others 1997-2000. See the AUTHORS - * file for a list of people on the GTK+ Team. See the ChangeLog - * files for a list of changes. These files are distributed with - * GTK+ at ftp://ftp.gtk.org/pub/gtk/. - */ - -/* - * Heavily stripped down for use in pinentry-gtk-2 by Albrecht Dreß - * <albrecht.dress@arcor.de> Feb. 2004: - * - * The entry is now always invisible, uses secure memory methods to - * allocate the text memory, and all potentially dangerous methods - * (copy & paste, popup, etc.) have been removed. - */ - -#include <stdlib.h> -#include <string.h> -#include <gdk/gdkkeysyms.h> -#include <gtk/gtk.h> - -#include "gtksecentry.h" -#include "memory.h" - -#define MIN_SECURE_ENTRY_WIDTH 150 -#define DRAW_TIMEOUT 20 -#define INNER_BORDER 2 - -/* Initial size of buffer, in bytes */ -#define MIN_SIZE 16 - -/* Maximum size of text buffer, in bytes */ -#define MAX_SIZE G_MAXUSHORT - -enum { - ACTIVATE, - MOVE_CURSOR, - INSERT_AT_CURSOR, - DELETE_FROM_CURSOR, - LAST_SIGNAL -}; - -enum { - PROP_0, - PROP_CURSOR_POSITION, - PROP_SELECTION_BOUND, - PROP_MAX_LENGTH, - PROP_HAS_FRAME, - PROP_INVISIBLE_CHAR, - PROP_ACTIVATES_DEFAULT, - PROP_WIDTH_CHARS, - PROP_SCROLL_OFFSET, - PROP_TEXT -}; - -static guint signals[LAST_SIGNAL] = { 0 }; - -/* GObject, GtkObject methods - */ -static void gtk_secure_entry_class_init(GtkSecureEntryClass * klass); -static void gtk_secure_entry_editable_init(GtkEditableClass * iface); -static void gtk_secure_entry_cell_editable_init(GtkCellEditableIface * - iface); -static void gtk_secure_entry_init(GtkSecureEntry * entry); -static void gtk_secure_entry_set_property(GObject * object, - guint prop_id, - const GValue * value, - GParamSpec * pspec); -static void gtk_secure_entry_get_property(GObject * object, - guint prop_id, - GValue * value, - GParamSpec * pspec); -static void gtk_secure_entry_finalize(GObject * object); - -/* GtkWidget methods - */ -static void gtk_secure_entry_realize(GtkWidget * widget); -static void gtk_secure_entry_unrealize(GtkWidget * widget); -static void gtk_secure_entry_size_request(GtkWidget * widget, - GtkRequisition * requisition); -static void gtk_secure_entry_size_allocate(GtkWidget * widget, - GtkAllocation * allocation); -static void gtk_secure_entry_draw_frame(GtkWidget * widget); -static gint gtk_secure_entry_expose(GtkWidget * widget, - GdkEventExpose * event); -static gint gtk_secure_entry_button_press(GtkWidget * widget, - GdkEventButton * event); -static gint gtk_secure_entry_button_release(GtkWidget * widget, - GdkEventButton * event); -static gint gtk_secure_entry_motion_notify(GtkWidget * widget, - GdkEventMotion * event); -static gint gtk_secure_entry_key_press(GtkWidget * widget, - GdkEventKey * event); -static gint gtk_secure_entry_key_release(GtkWidget * widget, - GdkEventKey * event); -static gint gtk_secure_entry_focus_in(GtkWidget * widget, - GdkEventFocus * event); -static gint gtk_secure_entry_focus_out(GtkWidget * widget, - GdkEventFocus * event); -static void gtk_secure_entry_grab_focus(GtkWidget * widget); -static void gtk_secure_entry_style_set(GtkWidget * widget, - GtkStyle * previous_style); -static void gtk_secure_entry_direction_changed(GtkWidget * widget, - GtkTextDirection - previous_dir); -static void gtk_secure_entry_state_changed(GtkWidget * widget, - GtkStateType previous_state); -static void gtk_secure_entry_screen_changed(GtkWidget * widget, - GdkScreen * old_screen); - -/* GtkEditable method implementations - */ -static void gtk_secure_entry_insert_text(GtkEditable * editable, - const gchar * new_text, - gint new_text_length, - gint * position); -static void gtk_secure_entry_delete_text(GtkEditable * editable, - gint start_pos, gint end_pos); -static void gtk_secure_entry_real_set_position(GtkEditable * editable, - gint position); -static gint gtk_secure_entry_get_position(GtkEditable * editable); -static void gtk_secure_entry_set_selection_bounds(GtkEditable * editable, - gint start, gint end); -static gboolean gtk_secure_entry_get_selection_bounds(GtkEditable * - editable, - gint * start, - gint * end); - -/* GtkCellEditable method implementations - */ -static void gtk_secure_entry_start_editing(GtkCellEditable * cell_editable, - GdkEvent * event); - -/* Default signal handlers - */ -static void gtk_secure_entry_real_insert_text(GtkEditable * editable, - const gchar * new_text, - gint new_text_length, - gint * position); -static void gtk_secure_entry_real_delete_text(GtkEditable * editable, - gint start_pos, - gint end_pos); -static void gtk_secure_entry_move_cursor(GtkSecureEntry * entry, - GtkMovementStep step, - gint count, - gboolean extend_selection); -static void gtk_secure_entry_insert_at_cursor(GtkSecureEntry * entry, - const gchar * str); -static void gtk_secure_entry_delete_from_cursor(GtkSecureEntry * entry, - GtkDeleteType type, - gint count); -static void gtk_secure_entry_real_activate(GtkSecureEntry * entry); - -static void gtk_secure_entry_keymap_direction_changed(GdkKeymap * keymap, - GtkSecureEntry * - entry); -/* IM Context Callbacks - */ -static void gtk_secure_entry_commit_cb(GtkIMContext * context, - const gchar * str, - GtkSecureEntry * entry); -static void gtk_secure_entry_preedit_changed_cb(GtkIMContext * context, - GtkSecureEntry * entry); -static gboolean gtk_secure_entry_retrieve_surrounding_cb(GtkIMContext * - context, - GtkSecureEntry * - entry); -static gboolean gtk_secure_entry_delete_surrounding_cb(GtkIMContext * - context, - gint offset, - gint n_chars, - GtkSecureEntry * - entry); - -/* Internal routines - */ -static void gtk_secure_entry_enter_text(GtkSecureEntry * entry, - const gchar * str); -static void gtk_secure_entry_set_positions(GtkSecureEntry * entry, - gint current_pos, - gint selection_bound); -static void gtk_secure_entry_draw_text(GtkSecureEntry * entry); -static void gtk_secure_entry_draw_cursor(GtkSecureEntry * entry); -static PangoLayout *gtk_secure_entry_ensure_layout(GtkSecureEntry * entry, - gboolean - include_preedit); -static void gtk_secure_entry_reset_layout(GtkSecureEntry * entry); -static void gtk_secure_entry_queue_draw(GtkSecureEntry * entry); -static void gtk_secure_entry_reset_im_context(GtkSecureEntry * entry); -static void gtk_secure_entry_recompute(GtkSecureEntry * entry); -static gint gtk_secure_entry_find_position(GtkSecureEntry * entry, gint x); -static void gtk_secure_entry_get_cursor_locations(GtkSecureEntry * entry, - gint * strong_x, - gint * weak_x); -static void gtk_secure_entry_adjust_scroll(GtkSecureEntry * entry); -static gint gtk_secure_entry_move_visually(GtkSecureEntry * editable, - gint start, gint count); -static gint gtk_secure_entry_move_logically(GtkSecureEntry * entry, - gint start, gint count); -static gboolean gtk_secure_entry_mnemonic_activate(GtkWidget * widget, - gboolean group_cycling); -static void gtk_secure_entry_check_cursor_blink(GtkSecureEntry * entry); -static void gtk_secure_entry_pend_cursor_blink(GtkSecureEntry * entry); -static void get_text_area_size(GtkSecureEntry * entry, - gint * x, - gint * y, gint * width, gint * height); -static void get_widget_window_size(GtkSecureEntry * entry, - gint * x, - gint * y, gint * width, gint * height); - - - -#define _gtk_marshal_VOID__VOID g_cclosure_marshal_VOID__VOID -#define _gtk_marshal_VOID__STRING g_cclosure_marshal_VOID__STRING -static void _gtk_marshal_VOID__ENUM_INT_BOOLEAN(GClosure * closure, - GValue * return_value, - guint n_param_values, - const GValue * - param_values, - gpointer invocation_hint, - gpointer marshal_data); -static void _gtk_marshal_VOID__ENUM_INT(GClosure * closure, - GValue * return_value, - guint n_param_values, - const GValue * param_values, - gpointer invocation_hint, - gpointer marshal_data); - - -static GtkWidgetClass *parent_class = NULL; - -gboolean g_use_secure_mem = FALSE; - -# define g_sec_new(type, count) \ - ((type *) g_sec_malloc ((unsigned) sizeof (type) * (count))) - -#define WITH_SECURE_MEM(EXP) do { \ - gboolean tmp = g_use_secure_mem; \ - g_use_secure_mem = TRUE; \ - EXP; \ - g_use_secure_mem = tmp; \ - } while(0) - - -gpointer -g_malloc(gsize size) -{ - gpointer p; - - if (size == 0) - return NULL; - - if (g_use_secure_mem) - p = (gpointer) secmem_malloc(size); - else - p = (gpointer) malloc(size); - if (!p) - g_error("could not allocate %"G_GSIZE_FORMAT" bytes", size); - - return p; -} - -gpointer -g_malloc0(gsize size) -{ - gpointer p; - - if (size == 0) - return NULL; - - if (g_use_secure_mem) { - p = (gpointer) secmem_malloc(size); - if (p) - memset(p, 0, size); - } else - p = (gpointer) calloc(size, 1); - if (!p) - g_error("could not allocate %"G_GSIZE_FORMAT" bytes", size); - - return p; -} - -gpointer -g_realloc(gpointer mem, gsize size) -{ - gpointer p; - - if (size == 0) { - g_free(mem); - - return NULL; - } - - if (!mem) { - if (g_use_secure_mem) - p = (gpointer) secmem_malloc(size); - else - p = (gpointer) malloc(size); - } else { - if (g_use_secure_mem) { - g_assert(m_is_secure(mem)); - p = (gpointer) secmem_realloc(mem, size); - } else - p = (gpointer) realloc(mem, size); - } - - if (!p) - g_error("could not reallocate %lu bytes", (gulong) size); - - return p; -} - -void -g_free(gpointer mem) -{ - if (mem) { - if (m_is_secure(mem)) - secmem_free(mem); - else - free(mem); - } -} - -GType -gtk_secure_entry_get_type(void) -{ - static GType entry_type = 0; - - if (!entry_type) { - static const GTypeInfo entry_info = { - sizeof(GtkSecureEntryClass), - NULL, /* base_init */ - NULL, /* base_finalize */ - (GClassInitFunc) gtk_secure_entry_class_init, - NULL, /* class_finalize */ - NULL, /* class_data */ - sizeof(GtkSecureEntry), - 0, /* n_preallocs */ - (GInstanceInitFunc) gtk_secure_entry_init, - NULL, - }; - - static const GInterfaceInfo editable_info = { - (GInterfaceInitFunc) gtk_secure_entry_editable_init, /* interface_init */ - NULL, /* interface_finalize */ - NULL /* interface_data */ - }; - - static const GInterfaceInfo cell_editable_info = { - (GInterfaceInitFunc) gtk_secure_entry_cell_editable_init, /* interface_init */ - NULL, /* interface_finalize */ - NULL /* interface_data */ - }; - - entry_type = - g_type_register_static(GTK_TYPE_WIDGET, "GtkSecureEntry", - &entry_info, 0); - - g_type_add_interface_static(entry_type, - GTK_TYPE_EDITABLE, &editable_info); - g_type_add_interface_static(entry_type, - GTK_TYPE_CELL_EDITABLE, - &cell_editable_info); - } - - return entry_type; -} - -static void -add_move_binding(GtkBindingSet * binding_set, - guint keyval, - guint modmask, GtkMovementStep step, gint count) -{ - g_return_if_fail((modmask & GDK_SHIFT_MASK) == 0); - - gtk_binding_entry_add_signal(binding_set, keyval, modmask, - "move_cursor", 3, - G_TYPE_ENUM, step, - G_TYPE_INT, count, G_TYPE_BOOLEAN, FALSE); - - /* Selection-extending version */ - gtk_binding_entry_add_signal(binding_set, keyval, - modmask | GDK_SHIFT_MASK, "move_cursor", - 3, G_TYPE_ENUM, step, G_TYPE_INT, count, - G_TYPE_BOOLEAN, TRUE); -} - -static void -gtk_secure_entry_class_init(GtkSecureEntryClass * class) -{ - GObjectClass *gobject_class = G_OBJECT_CLASS(class); - GtkWidgetClass *widget_class; - GtkBindingSet *binding_set; - - widget_class = (GtkWidgetClass *) class; - parent_class = g_type_class_peek_parent(class); - - gobject_class->finalize = gtk_secure_entry_finalize; - gobject_class->set_property = gtk_secure_entry_set_property; - gobject_class->get_property = gtk_secure_entry_get_property; - - widget_class->realize = gtk_secure_entry_realize; - widget_class->unrealize = gtk_secure_entry_unrealize; - widget_class->size_request = gtk_secure_entry_size_request; - widget_class->size_allocate = gtk_secure_entry_size_allocate; - widget_class->expose_event = gtk_secure_entry_expose; - widget_class->button_press_event = gtk_secure_entry_button_press; - widget_class->button_release_event = gtk_secure_entry_button_release; - widget_class->motion_notify_event = gtk_secure_entry_motion_notify; - widget_class->key_press_event = gtk_secure_entry_key_press; - widget_class->key_release_event = gtk_secure_entry_key_release; - widget_class->focus_in_event = gtk_secure_entry_focus_in; - widget_class->focus_out_event = gtk_secure_entry_focus_out; - widget_class->grab_focus = gtk_secure_entry_grab_focus; - widget_class->style_set = gtk_secure_entry_style_set; - widget_class->direction_changed = gtk_secure_entry_direction_changed; - widget_class->state_changed = gtk_secure_entry_state_changed; - widget_class->screen_changed = gtk_secure_entry_screen_changed; - widget_class->mnemonic_activate = gtk_secure_entry_mnemonic_activate; - - class->move_cursor = gtk_secure_entry_move_cursor; - class->insert_at_cursor = gtk_secure_entry_insert_at_cursor; - class->delete_from_cursor = gtk_secure_entry_delete_from_cursor; - class->activate = gtk_secure_entry_real_activate; - - g_object_class_install_property(gobject_class, - PROP_CURSOR_POSITION, - g_param_spec_int("cursor_position", - "Cursor Position", - "The current position of the insertion cursor in chars", - 0, MAX_SIZE, 0, - G_PARAM_READABLE)); - - g_object_class_install_property(gobject_class, - PROP_SELECTION_BOUND, - g_param_spec_int("selection_bound", - "Selection Bound", - "The position of the opposite end of the selection from the cursor in chars", - 0, MAX_SIZE, 0, - G_PARAM_READABLE)); - - g_object_class_install_property(gobject_class, - PROP_MAX_LENGTH, - g_param_spec_int("max_length", - "Maximum length", - "Maximum number of characters for this entry. Zero if no maximum", - 0, MAX_SIZE, 0, - G_PARAM_READABLE | - G_PARAM_WRITABLE)); - - g_object_class_install_property(gobject_class, - PROP_HAS_FRAME, - g_param_spec_boolean("has_frame", - "Has Frame", - "FALSE removes outside bevel from entry", - TRUE, - G_PARAM_READABLE | - G_PARAM_WRITABLE)); - - g_object_class_install_property(gobject_class, - PROP_INVISIBLE_CHAR, - g_param_spec_unichar("invisible_char", - "Invisible character", - "The character to use when masking entry contents (in \"password mode\")", - '*', - G_PARAM_READABLE | - G_PARAM_WRITABLE)); - - g_object_class_install_property(gobject_class, - PROP_ACTIVATES_DEFAULT, - g_param_spec_boolean - ("activates_default", - "Activates default", - "Whether to activate the default widget (such as the default button in a dialog) when Enter is pressed", - FALSE, - G_PARAM_READABLE | G_PARAM_WRITABLE)); - g_object_class_install_property(gobject_class, PROP_WIDTH_CHARS, - g_param_spec_int("width_chars", - "Width in chars", - "Number of characters to leave space for in the entry", - -1, G_MAXINT, -1, - G_PARAM_READABLE | - G_PARAM_WRITABLE)); - - g_object_class_install_property(gobject_class, - PROP_SCROLL_OFFSET, - g_param_spec_int("scroll_offset", - "Scroll offset", - "Number of pixels of the entry scrolled off the screen to the left", - 0, G_MAXINT, 0, - G_PARAM_READABLE)); - - g_object_class_install_property(gobject_class, - PROP_TEXT, - g_param_spec_string("text", - "Text", - "The contents of the entry", - "", - G_PARAM_READABLE | - G_PARAM_WRITABLE)); - - /* Action signals */ - - signals[ACTIVATE] = - g_signal_new("activate", - G_OBJECT_CLASS_TYPE(gobject_class), - G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, - G_STRUCT_OFFSET(GtkSecureEntryClass, activate), - NULL, NULL, _gtk_marshal_VOID__VOID, G_TYPE_NONE, 0); - widget_class->activate_signal = signals[ACTIVATE]; - - signals[MOVE_CURSOR] = - g_signal_new("move_cursor", - G_OBJECT_CLASS_TYPE(gobject_class), - G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, - G_STRUCT_OFFSET(GtkSecureEntryClass, move_cursor), - NULL, NULL, - _gtk_marshal_VOID__ENUM_INT_BOOLEAN, - G_TYPE_NONE, 3, - GTK_TYPE_MOVEMENT_STEP, G_TYPE_INT, G_TYPE_BOOLEAN); - - signals[INSERT_AT_CURSOR] = - g_signal_new("insert_at_cursor", - G_OBJECT_CLASS_TYPE(gobject_class), - G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, - G_STRUCT_OFFSET(GtkSecureEntryClass, - insert_at_cursor), NULL, NULL, - _gtk_marshal_VOID__STRING, G_TYPE_NONE, 1, - G_TYPE_STRING); - - signals[DELETE_FROM_CURSOR] = - g_signal_new("delete_from_cursor", - G_OBJECT_CLASS_TYPE(gobject_class), - G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, - G_STRUCT_OFFSET(GtkSecureEntryClass, - delete_from_cursor), NULL, NULL, - _gtk_marshal_VOID__ENUM_INT, G_TYPE_NONE, 2, - GTK_TYPE_DELETE_TYPE, G_TYPE_INT); - - /* - * Key bindings - */ - - binding_set = gtk_binding_set_by_class(class); - - /* Moving the insertion point */ - add_move_binding(binding_set, GDK_Right, 0, - GTK_MOVEMENT_VISUAL_POSITIONS, 1); - - add_move_binding(binding_set, GDK_Left, 0, - GTK_MOVEMENT_VISUAL_POSITIONS, -1); - - add_move_binding(binding_set, GDK_KP_Right, 0, - GTK_MOVEMENT_VISUAL_POSITIONS, 1); - - add_move_binding(binding_set, GDK_KP_Left, 0, - GTK_MOVEMENT_VISUAL_POSITIONS, -1); - - add_move_binding(binding_set, GDK_Right, GDK_CONTROL_MASK, - GTK_MOVEMENT_WORDS, 1); - - add_move_binding(binding_set, GDK_Left, GDK_CONTROL_MASK, - GTK_MOVEMENT_WORDS, -1); - - add_move_binding(binding_set, GDK_KP_Right, GDK_CONTROL_MASK, - GTK_MOVEMENT_WORDS, 1); - - add_move_binding(binding_set, GDK_KP_Left, GDK_CONTROL_MASK, - GTK_MOVEMENT_WORDS, -1); - - add_move_binding(binding_set, GDK_Home, 0, - GTK_MOVEMENT_DISPLAY_LINE_ENDS, -1); - - add_move_binding(binding_set, GDK_End, 0, - GTK_MOVEMENT_DISPLAY_LINE_ENDS, 1); - - add_move_binding(binding_set, GDK_KP_Home, 0, - GTK_MOVEMENT_DISPLAY_LINE_ENDS, -1); - - add_move_binding(binding_set, GDK_KP_End, 0, - GTK_MOVEMENT_DISPLAY_LINE_ENDS, 1); - - add_move_binding(binding_set, GDK_Home, GDK_CONTROL_MASK, - GTK_MOVEMENT_BUFFER_ENDS, -1); - - add_move_binding(binding_set, GDK_End, GDK_CONTROL_MASK, - GTK_MOVEMENT_BUFFER_ENDS, 1); - - add_move_binding(binding_set, GDK_KP_Home, GDK_CONTROL_MASK, - GTK_MOVEMENT_BUFFER_ENDS, -1); - - add_move_binding(binding_set, GDK_KP_End, GDK_CONTROL_MASK, - GTK_MOVEMENT_BUFFER_ENDS, 1); - - /* Select all - */ - gtk_binding_entry_add_signal(binding_set, GDK_a, GDK_CONTROL_MASK, - "move_cursor", 3, - GTK_TYPE_MOVEMENT_STEP, - GTK_MOVEMENT_BUFFER_ENDS, G_TYPE_INT, -1, - G_TYPE_BOOLEAN, FALSE); - gtk_binding_entry_add_signal(binding_set, GDK_a, GDK_CONTROL_MASK, - "move_cursor", 3, GTK_TYPE_MOVEMENT_STEP, - GTK_MOVEMENT_BUFFER_ENDS, G_TYPE_INT, 1, - G_TYPE_BOOLEAN, TRUE); - - - /* Activate - */ - gtk_binding_entry_add_signal(binding_set, GDK_Return, 0, - "activate", 0); - gtk_binding_entry_add_signal(binding_set, GDK_KP_Enter, 0, - "activate", 0); - - /* Deleting text */ - gtk_binding_entry_add_signal(binding_set, GDK_Delete, 0, - "delete_from_cursor", 2, - G_TYPE_ENUM, GTK_DELETE_CHARS, - G_TYPE_INT, 1); - - gtk_binding_entry_add_signal(binding_set, GDK_KP_Delete, 0, - "delete_from_cursor", 2, - G_TYPE_ENUM, GTK_DELETE_CHARS, - G_TYPE_INT, 1); - - gtk_binding_entry_add_signal(binding_set, GDK_BackSpace, 0, - "delete_from_cursor", 2, - G_TYPE_ENUM, GTK_DELETE_CHARS, - G_TYPE_INT, -1); - - /* Make this do the same as Backspace, to help with mis-typing */ - gtk_binding_entry_add_signal(binding_set, GDK_BackSpace, - GDK_SHIFT_MASK, "delete_from_cursor", 2, - G_TYPE_ENUM, GTK_DELETE_CHARS, G_TYPE_INT, - -1); - - gtk_binding_entry_add_signal(binding_set, GDK_Delete, GDK_CONTROL_MASK, - "delete_from_cursor", 2, - G_TYPE_ENUM, GTK_DELETE_WORD_ENDS, - G_TYPE_INT, 1); - - gtk_binding_entry_add_signal(binding_set, GDK_KP_Delete, - GDK_CONTROL_MASK, "delete_from_cursor", 2, - G_TYPE_ENUM, GTK_DELETE_WORD_ENDS, - G_TYPE_INT, 1); - - gtk_binding_entry_add_signal(binding_set, GDK_BackSpace, - GDK_CONTROL_MASK, "delete_from_cursor", 2, - G_TYPE_ENUM, GTK_DELETE_WORD_ENDS, - G_TYPE_INT, -1); -} - -static void -gtk_secure_entry_editable_init(GtkEditableClass * iface) -{ - iface->do_insert_text = gtk_secure_entry_insert_text; - iface->do_delete_text = gtk_secure_entry_delete_text; - iface->insert_text = gtk_secure_entry_real_insert_text; - iface->delete_text = gtk_secure_entry_real_delete_text; - iface->set_selection_bounds = gtk_secure_entry_set_selection_bounds; - iface->get_selection_bounds = gtk_secure_entry_get_selection_bounds; - iface->set_position = gtk_secure_entry_real_set_position; - iface->get_position = gtk_secure_entry_get_position; -} - -static void -gtk_secure_entry_cell_editable_init(GtkCellEditableIface * iface) -{ - iface->start_editing = gtk_secure_entry_start_editing; -} - -static void -gtk_secure_entry_set_property(GObject * object, - guint prop_id, - const GValue * value, GParamSpec * pspec) -{ - GtkSecureEntry *entry = GTK_SECURE_ENTRY(object); - - switch (prop_id) { - case PROP_MAX_LENGTH: - gtk_secure_entry_set_max_length(entry, g_value_get_int(value)); - break; - - case PROP_HAS_FRAME: - gtk_secure_entry_set_has_frame(entry, g_value_get_boolean(value)); - break; - - case PROP_INVISIBLE_CHAR: - gtk_secure_entry_set_invisible_char(entry, - g_value_get_uint(value)); - break; - - case PROP_ACTIVATES_DEFAULT: - gtk_secure_entry_set_activates_default(entry, - g_value_get_boolean(value)); - break; - - case PROP_WIDTH_CHARS: - gtk_secure_entry_set_width_chars(entry, g_value_get_int(value)); - break; - - case PROP_TEXT: - gtk_secure_entry_set_text(entry, g_value_get_string(value)); - break; - - case PROP_SCROLL_OFFSET: - case PROP_CURSOR_POSITION: - default: - G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); - break; - } -} - -static void -gtk_secure_entry_get_property(GObject * object, - guint prop_id, - GValue * value, GParamSpec * pspec) -{ - GtkSecureEntry *entry = GTK_SECURE_ENTRY(object); - - switch (prop_id) { - case PROP_CURSOR_POSITION: - g_value_set_int(value, entry->current_pos); - break; - case PROP_SELECTION_BOUND: - g_value_set_int(value, entry->selection_bound); - break; - case PROP_MAX_LENGTH: - g_value_set_int(value, entry->text_max_length); - break; - case PROP_HAS_FRAME: - g_value_set_boolean(value, entry->has_frame); - break; - case PROP_INVISIBLE_CHAR: - g_value_set_uint(value, entry->invisible_char); - break; - case PROP_ACTIVATES_DEFAULT: - g_value_set_boolean(value, entry->activates_default); - break; - case PROP_WIDTH_CHARS: - g_value_set_int(value, entry->width_chars); - break; - case PROP_SCROLL_OFFSET: - g_value_set_int(value, entry->scroll_offset); - break; - case PROP_TEXT: - g_value_set_string(value, gtk_secure_entry_get_text(entry)); - break; - - default: - G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec); - break; - } -} - -static void -gtk_secure_entry_init(GtkSecureEntry * entry) -{ - gtk_widget_set_can_focus (GTK_WIDGET(entry), TRUE); - - entry->text_size = MIN_SIZE; - WITH_SECURE_MEM(entry->text = g_malloc(entry->text_size)); - entry->text[0] = '\0'; - - entry->invisible_char = '*'; - entry->width_chars = -1; - entry->is_cell_renderer = FALSE; - entry->editing_canceled = FALSE; - entry->has_frame = TRUE; - - /* This object is completely private. No external entity can gain a reference - * to it; so we create it here and destroy it in finalize(). - */ - entry->im_context = gtk_im_multicontext_new(); - - g_signal_connect(entry->im_context, "commit", - G_CALLBACK(gtk_secure_entry_commit_cb), entry); - g_signal_connect(entry->im_context, "preedit_changed", - G_CALLBACK(gtk_secure_entry_preedit_changed_cb), - entry); - g_signal_connect(entry->im_context, "retrieve_surrounding", - G_CALLBACK(gtk_secure_entry_retrieve_surrounding_cb), - entry); - g_signal_connect(entry->im_context, "delete_surrounding", - G_CALLBACK(gtk_secure_entry_delete_surrounding_cb), - entry); -} - -static void -gtk_secure_entry_finalize(GObject * object) -{ - GtkSecureEntry *entry = GTK_SECURE_ENTRY(object); - - if (entry->cached_layout) - g_object_unref(entry->cached_layout); - - g_object_unref(entry->im_context); - - if (entry->blink_timeout) - g_source_remove(entry->blink_timeout); - - if (entry->recompute_idle) - g_source_remove(entry->recompute_idle); - - entry->text_size = 0; - - if (entry->text) - WITH_SECURE_MEM(g_free(entry->text)); - entry->text = NULL; - - G_OBJECT_CLASS(parent_class)->finalize(object); -} - -static void -gtk_secure_entry_realize(GtkWidget * widget) -{ - GtkSecureEntry *entry; - GtkEditable *editable; - GdkWindow *window; - GtkStyle *style; - GdkWindowAttr attributes; - gint attributes_mask; - - gtk_widget_set_realized (widget, TRUE); - - entry = GTK_SECURE_ENTRY(widget); - editable = GTK_EDITABLE(widget); - - attributes.window_type = GDK_WINDOW_CHILD; - - get_widget_window_size(entry, &attributes.x, &attributes.y, - &attributes.width, &attributes.height); - - attributes.wclass = GDK_INPUT_OUTPUT; - attributes.visual = gtk_widget_get_visual(widget); - attributes.colormap = gtk_widget_get_colormap(widget); - attributes.event_mask = gtk_widget_get_events(widget); - attributes.event_mask |= (GDK_EXPOSURE_MASK | - GDK_BUTTON_PRESS_MASK | - GDK_BUTTON_RELEASE_MASK | - GDK_BUTTON1_MOTION_MASK | - GDK_BUTTON3_MOTION_MASK | - GDK_POINTER_MOTION_HINT_MASK | - GDK_POINTER_MOTION_MASK | - GDK_ENTER_NOTIFY_MASK | - GDK_LEAVE_NOTIFY_MASK); - attributes_mask = - GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP; - - window = gdk_window_new(gtk_widget_get_parent_window(widget), - &attributes, attributes_mask); - gtk_widget_set_window (widget, window); - gdk_window_set_user_data(window, entry); - - get_text_area_size(entry, &attributes.x, &attributes.y, - &attributes.width, &attributes.height); - - attributes.cursor = - gdk_cursor_new_for_display(gtk_widget_get_display(widget), - GDK_XTERM); - attributes_mask |= GDK_WA_CURSOR; - - entry->text_area = - gdk_window_new(window, &attributes, attributes_mask); - gdk_window_set_user_data(entry->text_area, entry); - - gdk_cursor_unref(attributes.cursor); - - style = gtk_widget_get_style (widget); - style = gtk_style_attach(style, window); - gtk_widget_set_style (widget, style); - - gdk_window_set_background(window, - &style->base[gtk_widget_get_state (widget)]); - gdk_window_set_background(entry->text_area, - &style->base[gtk_widget_get_state (widget)]); - - gdk_window_show(entry->text_area); - - gtk_im_context_set_client_window(entry->im_context, entry->text_area); - - gtk_secure_entry_adjust_scroll(entry); -} - -static void -gtk_secure_entry_unrealize(GtkWidget * widget) -{ - GtkSecureEntry *entry = GTK_SECURE_ENTRY(widget); - - gtk_secure_entry_reset_layout(entry); - - gtk_im_context_set_client_window(entry->im_context, NULL); - - if (entry->text_area) { - gdk_window_set_user_data(entry->text_area, NULL); - gdk_window_destroy(entry->text_area); - entry->text_area = NULL; - } - - if (GTK_WIDGET_CLASS(parent_class)->unrealize) - (*GTK_WIDGET_CLASS(parent_class)->unrealize) (widget); -} - -static void -get_borders(GtkSecureEntry * entry, gint * xborder, gint * yborder) -{ - GtkWidget *widget = GTK_WIDGET(entry); - GtkStyle *style; - gint focus_width; - gboolean interior_focus; - - gtk_widget_style_get(widget, - "interior-focus", &interior_focus, - "focus-line-width", &focus_width, NULL); - - style = gtk_widget_get_style (widget); - if (entry->has_frame) { - *xborder = style->xthickness; - *yborder = style->ythickness; - } else { - *xborder = 0; - *yborder = 0; - } - - if (!interior_focus) { - *xborder += focus_width; - *yborder += focus_width; - } -} - -static void -gtk_secure_entry_size_request(GtkWidget * widget, - GtkRequisition * requisition) -{ - GtkSecureEntry *entry = GTK_SECURE_ENTRY(widget); - GtkStyle *style; - PangoFontMetrics *metrics; - gint xborder, yborder; - PangoContext *context; - - style = gtk_widget_get_style (widget); - context = gtk_widget_get_pango_context(widget); - metrics = pango_context_get_metrics(context, - style->font_desc, - pango_context_get_language - (context)); - - entry->ascent = pango_font_metrics_get_ascent(metrics); - entry->descent = pango_font_metrics_get_descent(metrics); - - get_borders(entry, &xborder, &yborder); - - xborder += INNER_BORDER; - yborder += INNER_BORDER; - - if (entry->width_chars < 0) - requisition->width = MIN_SECURE_ENTRY_WIDTH + xborder * 2; - else { - gint char_width = - pango_font_metrics_get_approximate_char_width(metrics); - gint digit_width = - pango_font_metrics_get_approximate_digit_width(metrics); - gint char_pixels = - (MAX(char_width, digit_width) + PANGO_SCALE - 1) / PANGO_SCALE; - - requisition->width = - char_pixels * entry->width_chars + xborder * 2; - } - - requisition->height = - PANGO_PIXELS(entry->ascent + entry->descent) + yborder * 2; - - pango_font_metrics_unref(metrics); -} - -static void -get_text_area_size(GtkSecureEntry * entry, - gint * x, gint * y, gint * width, gint * height) -{ - gint xborder, yborder; - GtkRequisition requisition; - GtkWidget *widget = GTK_WIDGET(entry); - GtkAllocation allocation; - - gtk_widget_get_child_requisition(widget, &requisition); - gtk_widget_get_allocation (GTK_WIDGET(entry), &allocation); - - get_borders(entry, &xborder, &yborder); - - if (x) - *x = xborder; - - if (y) - *y = yborder; - - if (width) - *width = allocation.width - xborder * 2; - - if (height) - *height = requisition.height - yborder * 2; -} - -static void -get_widget_window_size(GtkSecureEntry * entry, - gint * x, gint * y, gint * width, gint * height) -{ - GtkRequisition requisition; - GtkWidget *widget = GTK_WIDGET(entry); - GtkAllocation allocation; - - gtk_widget_get_child_requisition(widget, &requisition); - gtk_widget_get_allocation (GTK_WIDGET(entry), &allocation); - - if (x) - *x = allocation.x; - - if (y) { - if (entry->is_cell_renderer) - *y = allocation.y; - else - *y = allocation.y + (allocation.height - - requisition.height) / 2; - } - - if (width) - *width = allocation.width; - - if (height) { - if (entry->is_cell_renderer) - *height = allocation.height; - else - *height = requisition.height; - } -} - -static void -gtk_secure_entry_size_allocate(GtkWidget * widget, - GtkAllocation * allocation) -{ - GtkSecureEntry *entry = GTK_SECURE_ENTRY(widget); - - gtk_widget_set_allocation (widget, allocation); - - if (gtk_widget_get_realized (widget)) { - /* We call gtk_widget_get_child_requisition, since we want (for - * backwards compatibility reasons) the realization here to - * be affected by the usize of the entry, if set - */ - gint x, y, width, height; - - get_widget_window_size(entry, &x, &y, &width, &height); - - gdk_window_move_resize(gtk_widget_get_window (widget), - x, y, width, height); - - get_text_area_size(entry, &x, &y, &width, &height); - - gdk_window_move_resize(entry->text_area, x, y, width, height); - - gtk_secure_entry_recompute(entry); - } -} - -static void -gtk_secure_entry_draw_frame(GtkWidget * widget) -{ - GtkStyle *style; - GdkWindow *window; - gint x = 0, y = 0; - gint width, height; - gboolean interior_focus; - gint focus_width; - - gtk_widget_style_get(widget, - "interior-focus", &interior_focus, - "focus-line-width", &focus_width, NULL); - - window = gtk_widget_get_window (widget); - gdk_drawable_get_size(window, &width, &height); - - if (gtk_widget_has_focus (widget) && !interior_focus) { - x += focus_width; - y += focus_width; - width -= 2 * focus_width; - height -= 2 * focus_width; - } - - style = gtk_widget_get_style (widget); - gtk_paint_shadow(style, window, - GTK_STATE_NORMAL, GTK_SHADOW_IN, - NULL, widget, "entry", x, y, width, height); - - if (gtk_widget_has_focus (widget) && !interior_focus) { - x -= focus_width; - y -= focus_width; - width += 2 * focus_width; - height += 2 * focus_width; - - gtk_paint_focus(style, window, - gtk_widget_get_state (widget), NULL, widget, "entry", 0, - 0, width, height); - } -} - -static gint -gtk_secure_entry_expose(GtkWidget * widget, GdkEventExpose * event) -{ - GtkSecureEntry *entry = GTK_SECURE_ENTRY(widget); - GtkStyle *style; - - if (gtk_widget_get_window (widget) == event->window) - gtk_secure_entry_draw_frame(widget); - else if (entry->text_area == event->window) { - gint area_width, area_height; - - get_text_area_size(entry, NULL, NULL, &area_width, &area_height); - - - style = gtk_widget_get_style (widget); - gtk_paint_flat_box(style, entry->text_area, - gtk_widget_get_state (widget), GTK_SHADOW_NONE, - NULL, widget, "entry_bg", - 0, 0, area_width, area_height); - - if ((entry->invisible_char != 0) && - gtk_widget_has_focus (widget) && - entry->selection_bound == entry->current_pos - && entry->cursor_visible) - gtk_secure_entry_draw_cursor(GTK_SECURE_ENTRY(widget)); - - gtk_secure_entry_draw_text(GTK_SECURE_ENTRY(widget)); - } - - return FALSE; -} - -static gint -gtk_secure_entry_button_press(GtkWidget * widget, GdkEventButton * event) -{ - GtkSecureEntry *entry = GTK_SECURE_ENTRY(widget); - gint tmp_pos; - - if (event->window != entry->text_area || - (entry->button && event->button != entry->button)) - return FALSE; - - entry->button = event->button; - - if (!gtk_widget_has_focus (widget)) { - entry->in_click = TRUE; - gtk_widget_grab_focus(widget); - entry->in_click = FALSE; - } - - tmp_pos = - gtk_secure_entry_find_position(entry, - event->x + entry->scroll_offset); - - if (event->button == 1) { - switch (event->type) { - case GDK_BUTTON_PRESS: - gtk_secure_entry_set_positions(entry, tmp_pos, tmp_pos); - break; - - default: - break; - } - - return TRUE; - } - - return FALSE; -} - -static gint -gtk_secure_entry_button_release(GtkWidget * widget, GdkEventButton * event) -{ - GtkSecureEntry *entry = GTK_SECURE_ENTRY(widget); - - if (event->window != entry->text_area - || entry->button != event->button) - return FALSE; - - entry->button = 0; - - return TRUE; -} - -static gint -gtk_secure_entry_motion_notify(GtkWidget * widget, GdkEventMotion * event) -{ - GtkSecureEntry *entry = GTK_SECURE_ENTRY(widget); - gint tmp_pos; - - if (entry->mouse_cursor_obscured) { - GdkCursor *cursor; - - cursor = - gdk_cursor_new_for_display(gtk_widget_get_display(widget), - GDK_XTERM); - gdk_window_set_cursor(entry->text_area, cursor); - gdk_cursor_unref(cursor); - entry->mouse_cursor_obscured = FALSE; - } - - if (event->window != entry->text_area || entry->button != 1) - return FALSE; - - if (event->is_hint || (entry->text_area != event->window)) - gdk_window_get_pointer(entry->text_area, NULL, NULL, NULL); - - { - gint height; - gdk_drawable_get_size(entry->text_area, NULL, &height); - - if (event->y < 0) - tmp_pos = 0; - else if (event->y >= height) - tmp_pos = entry->text_length; - else - tmp_pos = - gtk_secure_entry_find_position(entry, - event->x + - entry->scroll_offset); - - gtk_secure_entry_set_positions(entry, tmp_pos, -1); - } - - return TRUE; -} - -static void -set_invisible_cursor(GdkWindow * window) -{ - GdkBitmap *empty_bitmap; - GdkCursor *cursor; - GdkColor useless; - char invisible_cursor_bits[] = { 0x0 }; - - useless.red = useless.green = useless.blue = 0; - useless.pixel = 0; - - empty_bitmap = gdk_bitmap_create_from_data(window, - invisible_cursor_bits, 1, - 1); - - cursor = gdk_cursor_new_from_pixmap(empty_bitmap, - empty_bitmap, - &useless, &useless, 0, 0); - - gdk_window_set_cursor(window, cursor); - - gdk_cursor_unref(cursor); - - g_object_unref(empty_bitmap); -} - -static void -gtk_secure_entry_obscure_mouse_cursor(GtkSecureEntry * entry) -{ - if (entry->mouse_cursor_obscured) - return; - - set_invisible_cursor(entry->text_area); - - entry->mouse_cursor_obscured = TRUE; -} - -static gint -gtk_secure_entry_key_press(GtkWidget * widget, GdkEventKey * event) -{ - GtkSecureEntry *entry = GTK_SECURE_ENTRY(widget); - - gtk_secure_entry_pend_cursor_blink(entry); - - if (gtk_im_context_filter_keypress(entry->im_context, event)) { - gtk_secure_entry_obscure_mouse_cursor(entry); - entry->need_im_reset = TRUE; - return TRUE; - } - - if (GTK_WIDGET_CLASS(parent_class)->key_press_event(widget, event)) - /* Activate key bindings - */ - return TRUE; - - return FALSE; -} - -static gint -gtk_secure_entry_key_release(GtkWidget * widget, GdkEventKey * event) -{ - GtkSecureEntry *entry = GTK_SECURE_ENTRY(widget); - - if (gtk_im_context_filter_keypress(entry->im_context, event)) { - entry->need_im_reset = TRUE; - return TRUE; - } - - return GTK_WIDGET_CLASS(parent_class)->key_release_event(widget, - event); -} - -static gint -gtk_secure_entry_focus_in(GtkWidget * widget, - GdkEventFocus * event G_GNUC_UNUSED) -{ - GtkSecureEntry *entry = GTK_SECURE_ENTRY(widget); - - gtk_widget_queue_draw(widget); - - entry->need_im_reset = TRUE; - gtk_im_context_focus_in(entry->im_context); - - g_signal_connect(gdk_keymap_get_for_display - (gtk_widget_get_display(widget)), "direction_changed", - G_CALLBACK(gtk_secure_entry_keymap_direction_changed), - entry); - - gtk_secure_entry_check_cursor_blink(entry); - - return FALSE; -} - -static gint -gtk_secure_entry_focus_out(GtkWidget * widget, - GdkEventFocus * event G_GNUC_UNUSED) -{ - GtkSecureEntry *entry = GTK_SECURE_ENTRY(widget); - - gtk_widget_queue_draw(widget); - - entry->need_im_reset = TRUE; - gtk_im_context_focus_out(entry->im_context); - - gtk_secure_entry_check_cursor_blink(entry); - - g_signal_handlers_disconnect_by_func(gdk_keymap_get_for_display - (gtk_widget_get_display(widget)), - gtk_secure_entry_keymap_direction_changed, - entry); - - return FALSE; -} - -static void -gtk_secure_entry_grab_focus(GtkWidget * widget) -{ - GtkWidget *tmp; - GtkSecureEntry *entry = GTK_SECURE_ENTRY(widget); - gboolean select_on_focus; - - gtk_widget_set_can_default (widget, TRUE); - GTK_WIDGET_CLASS(parent_class)->grab_focus(widget); - - /* read current select on focus setting from GtkEntry */ - tmp = gtk_entry_new (); - g_object_get(gtk_widget_get_settings(tmp), - "gtk-entry-select-on-focus", &select_on_focus, NULL); - gtk_widget_destroy (tmp); - - if (select_on_focus && !entry->in_click) - gtk_editable_select_region(GTK_EDITABLE(widget), 0, -1); -} - -static void -gtk_secure_entry_direction_changed(GtkWidget * widget, - GtkTextDirection previous_dir) -{ - GtkSecureEntry *entry = GTK_SECURE_ENTRY(widget); - - gtk_secure_entry_recompute(entry); - - GTK_WIDGET_CLASS(parent_class)->direction_changed(widget, - previous_dir); -} - -static void -gtk_secure_entry_state_changed(GtkWidget * widget, - GtkStateType previous_state G_GNUC_UNUSED) -{ - GtkSecureEntry *entry = GTK_SECURE_ENTRY(widget); - GtkStyle *style; - - style = gtk_widget_get_style (widget); - if (gtk_widget_get_realized (widget)) { - gdk_window_set_background(gtk_widget_get_window(widget), - &style->base[gtk_widget_get_state (widget)]); - gdk_window_set_background(entry->text_area, - &style->base[gtk_widget_get_state (widget)]); - } - - if (!gtk_widget_is_sensitive (widget)) { - /* Clear any selection */ - gtk_editable_select_region(GTK_EDITABLE(entry), entry->current_pos, - entry->current_pos); - } - - gtk_widget_queue_draw(widget); -} - -static void -gtk_secure_entry_screen_changed(GtkWidget * widget, - GdkScreen * old_screen G_GNUC_UNUSED) -{ - gtk_secure_entry_recompute(GTK_SECURE_ENTRY(widget)); -} - -/* GtkEditable method implementations - */ -static void -gtk_secure_entry_insert_text(GtkEditable * editable, - const gchar * new_text, - gint new_text_length, gint * position) -{ - GtkSecureEntry *entry = GTK_SECURE_ENTRY(editable); - gchar *text; - - if (*position < 0 || *position > entry->text_length) - *position = entry->text_length; - - g_object_ref(editable); - - WITH_SECURE_MEM(text = g_new(gchar, new_text_length + 1)); - - text[new_text_length] = '\0'; - strncpy(text, new_text, new_text_length); - - g_signal_emit_by_name(editable, "insert_text", text, new_text_length, - position); - - WITH_SECURE_MEM(g_free(text)); - - g_object_unref(editable); -} - -static void -gtk_secure_entry_delete_text(GtkEditable * editable, - gint start_pos, gint end_pos) -{ - GtkSecureEntry *entry = GTK_SECURE_ENTRY(editable); - - if (end_pos < 0 || end_pos > entry->text_length) - end_pos = entry->text_length; - if (start_pos < 0) - start_pos = 0; - if (start_pos > end_pos) - start_pos = end_pos; - - g_object_ref(editable); - - g_signal_emit_by_name(editable, "delete_text", start_pos, end_pos); - - g_object_unref(editable); -} - -static void -gtk_secure_entry_set_position_internal(GtkSecureEntry * entry, - gint position, gboolean reset_im) -{ - if (position < 0 || position > entry->text_length) - position = entry->text_length; - - if (position != entry->current_pos || - position != entry->selection_bound) { - if (reset_im) - gtk_secure_entry_reset_im_context(entry); - gtk_secure_entry_set_positions(entry, position, position); - } -} - -static void -gtk_secure_entry_real_set_position(GtkEditable * editable, gint position) -{ - gtk_secure_entry_set_position_internal(GTK_SECURE_ENTRY(editable), - position, TRUE); -} - -static gint -gtk_secure_entry_get_position(GtkEditable * editable) -{ - return GTK_SECURE_ENTRY(editable)->current_pos; -} - -static void -gtk_secure_entry_set_selection_bounds(GtkEditable * editable, - gint start, gint end) -{ - GtkSecureEntry *entry = GTK_SECURE_ENTRY(editable); - - if (start < 0) - start = entry->text_length; - if (end < 0) - end = entry->text_length; - - gtk_secure_entry_reset_im_context(entry); - - gtk_secure_entry_set_positions(entry, - MIN(end, entry->text_length), - MIN(start, entry->text_length)); -} - -static gboolean -gtk_secure_entry_get_selection_bounds(GtkEditable * editable, - gint * start, gint * end) -{ - GtkSecureEntry *entry = GTK_SECURE_ENTRY(editable); - - *start = entry->selection_bound; - *end = entry->current_pos; - - return (entry->selection_bound != entry->current_pos); -} - -static void -gtk_secure_entry_style_set(GtkWidget * widget, GtkStyle * previous_style) -{ - GtkSecureEntry *entry = GTK_SECURE_ENTRY(widget); - GtkStyle *style; - - gtk_secure_entry_recompute(entry); - - style = gtk_widget_get_style (widget); - if (previous_style && gtk_widget_get_realized (widget)) { - gdk_window_set_background(gtk_widget_get_window (widget), - &style->base[gtk_widget_get_state (widget)]); - gdk_window_set_background(entry->text_area, - &style->base[gtk_widget_get_state (widget)]); - } -} - -/* GtkCellEditable method implementations - */ -static void -gtk_cell_editable_secure_entry_activated(GtkSecureEntry * entry, - gpointer data G_GNUC_UNUSED) -{ - gtk_cell_editable_editing_done(GTK_CELL_EDITABLE(entry)); - gtk_cell_editable_remove_widget(GTK_CELL_EDITABLE(entry)); -} - -static gboolean -gtk_cell_editable_key_press_event(GtkSecureEntry * entry, - GdkEventKey * key_event, - gpointer data G_GNUC_UNUSED) -{ - if (key_event->keyval == GDK_Escape) { - entry->editing_canceled = TRUE; - gtk_cell_editable_editing_done(GTK_CELL_EDITABLE(entry)); - gtk_cell_editable_remove_widget(GTK_CELL_EDITABLE(entry)); - - return TRUE; - } - - /* override focus */ - if (key_event->keyval == GDK_Up || key_event->keyval == GDK_Down) { - gtk_cell_editable_editing_done(GTK_CELL_EDITABLE(entry)); - gtk_cell_editable_remove_widget(GTK_CELL_EDITABLE(entry)); - - return TRUE; - } - - return FALSE; -} - -static void -gtk_secure_entry_start_editing(GtkCellEditable * cell_editable, - GdkEvent * event G_GNUC_UNUSED) -{ - GTK_SECURE_ENTRY(cell_editable)->is_cell_renderer = TRUE; - - g_signal_connect(cell_editable, "activate", - G_CALLBACK(gtk_cell_editable_secure_entry_activated), NULL); - g_signal_connect(cell_editable, "key_press_event", - G_CALLBACK(gtk_cell_editable_key_press_event), NULL); -} - -/* Default signal handlers - */ -static void -gtk_secure_entry_real_insert_text(GtkEditable * editable, - const gchar * new_text, - gint new_text_length, gint * position) -{ - gint _index; - gint n_chars; - - GtkSecureEntry *entry = GTK_SECURE_ENTRY(editable); - - if (new_text_length < 0) - new_text_length = strlen(new_text); - - n_chars = g_utf8_strlen(new_text, new_text_length); - if (entry->text_max_length > 0 - && n_chars + entry->text_length > entry->text_max_length) { - gdk_display_beep(gtk_widget_get_display(GTK_WIDGET(entry))); - n_chars = entry->text_max_length - entry->text_length; - new_text_length = - g_utf8_offset_to_pointer(new_text, n_chars) - new_text; - } - - if (new_text_length + entry->n_bytes + 1 > entry->text_size) { - while (new_text_length + entry->n_bytes + 1 > entry->text_size) { - if (entry->text_size == 0) - entry->text_size = MIN_SIZE; - else { - if (2 * (guint) entry->text_size < MAX_SIZE && - 2 * (guint) entry->text_size > entry->text_size) - entry->text_size *= 2; - else { - entry->text_size = MAX_SIZE; - if (new_text_length > - (gint) entry->text_size - (gint) entry->n_bytes - - 1) { - new_text_length = - (gint) entry->text_size - - (gint) entry->n_bytes - 1; - new_text_length = - g_utf8_find_prev_char(new_text, - new_text + - new_text_length + 1) - - new_text; - n_chars = g_utf8_strlen(new_text, new_text_length); - } - break; - } - } - } - - WITH_SECURE_MEM(entry->text = - g_realloc(entry->text, entry->text_size)); - } - - _index = g_utf8_offset_to_pointer(entry->text, *position) - entry->text; - - g_memmove(entry->text + _index + new_text_length, entry->text + _index, - entry->n_bytes - _index); - memcpy(entry->text + _index, new_text, new_text_length); - - entry->n_bytes += new_text_length; - entry->text_length += n_chars; - - /* NUL terminate for safety and convenience */ - entry->text[entry->n_bytes] = '\0'; - - if (entry->current_pos > *position) - entry->current_pos += n_chars; - - if (entry->selection_bound > *position) - entry->selection_bound += n_chars; - - *position += n_chars; - - gtk_secure_entry_recompute(entry); - - g_signal_emit_by_name(editable, "changed"); - g_object_notify(G_OBJECT(editable), "text"); -} - -static void -gtk_secure_entry_real_delete_text(GtkEditable * editable, - gint start_pos, gint end_pos) -{ - GtkSecureEntry *entry = GTK_SECURE_ENTRY(editable); - - if (start_pos < 0) - start_pos = 0; - if (end_pos < 0 || end_pos > entry->text_length) - end_pos = entry->text_length; - - if (start_pos < end_pos) { - gint start_index = - g_utf8_offset_to_pointer(entry->text, start_pos) - entry->text; - gint end_index = - g_utf8_offset_to_pointer(entry->text, end_pos) - entry->text; - gint current_pos; - gint selection_bound; - - g_memmove(entry->text + start_index, entry->text + end_index, - entry->n_bytes + 1 - end_index); - entry->text_length -= (end_pos - start_pos); - entry->n_bytes -= (end_index - start_index); - - current_pos = entry->current_pos; - if (current_pos > start_pos) - current_pos -= MIN(current_pos, end_pos) - start_pos; - - selection_bound = entry->selection_bound; - if (selection_bound > start_pos) - selection_bound -= MIN(selection_bound, end_pos) - start_pos; - - gtk_secure_entry_set_positions(entry, current_pos, - selection_bound); - - gtk_secure_entry_recompute(entry); - - g_signal_emit_by_name(editable, "changed"); - g_object_notify(G_OBJECT(editable), "text"); - } -} - -/* Compute the X position for an offset that corresponds to the "more important - * cursor position for that offset. We use this when trying to guess to which - * end of the selection we should go to when the user hits the left or - * right arrow key. - */ -static gint -get_better_cursor_x(GtkSecureEntry * entry, gint offset) -{ - GdkKeymap *keymap = - gdk_keymap_get_for_display(gtk_widget_get_display - (GTK_WIDGET(entry))); - PangoDirection keymap_direction = gdk_keymap_get_direction(keymap); - gboolean split_cursor; - - PangoLayout *layout = gtk_secure_entry_ensure_layout(entry, TRUE); - const gchar *text = pango_layout_get_text(layout); - gint _index = g_utf8_offset_to_pointer(text, offset) - text; - - PangoRectangle strong_pos, weak_pos; - - g_object_get(gtk_widget_get_settings(GTK_WIDGET(entry)), - "gtk-split-cursor", &split_cursor, NULL); - - pango_layout_get_cursor_pos(layout, _index, &strong_pos, &weak_pos); - - if (split_cursor) - return strong_pos.x / PANGO_SCALE; - else - return (keymap_direction == - entry->resolved_dir) ? strong_pos.x / - PANGO_SCALE : weak_pos.x / PANGO_SCALE; -} - -static void -gtk_secure_entry_move_cursor(GtkSecureEntry * entry, - GtkMovementStep step, - gint count, gboolean extend_selection) -{ - gint new_pos = entry->current_pos; - - gtk_secure_entry_reset_im_context(entry); - - if (entry->current_pos != entry->selection_bound && !extend_selection) { - /* If we have a current selection and aren't extending it, move to the - * start/or end of the selection as appropriate - */ - switch (step) { - case GTK_MOVEMENT_VISUAL_POSITIONS: - { - gint current_x = - get_better_cursor_x(entry, entry->current_pos); - gint bound_x = - get_better_cursor_x(entry, entry->selection_bound); - - if (count < 0) - new_pos = - current_x < - bound_x ? entry->current_pos : entry-> - selection_bound; - else - new_pos = - current_x > - bound_x ? entry->current_pos : entry-> - selection_bound; - - break; - } - case GTK_MOVEMENT_LOGICAL_POSITIONS: - case GTK_MOVEMENT_DISPLAY_LINE_ENDS: - case GTK_MOVEMENT_PARAGRAPH_ENDS: - case GTK_MOVEMENT_BUFFER_ENDS: - new_pos = count < 0 ? 0 : entry->text_length; - break; - case GTK_MOVEMENT_WORDS: - case GTK_MOVEMENT_DISPLAY_LINES: - case GTK_MOVEMENT_PARAGRAPHS: - case GTK_MOVEMENT_PAGES: - case GTK_MOVEMENT_HORIZONTAL_PAGES: - break; - } - } else { - switch (step) { - case GTK_MOVEMENT_LOGICAL_POSITIONS: - new_pos = - gtk_secure_entry_move_logically(entry, new_pos, count); - break; - case GTK_MOVEMENT_VISUAL_POSITIONS: - new_pos = - gtk_secure_entry_move_visually(entry, new_pos, count); - break; - case GTK_MOVEMENT_DISPLAY_LINE_ENDS: - case GTK_MOVEMENT_PARAGRAPH_ENDS: - case GTK_MOVEMENT_BUFFER_ENDS: - new_pos = count < 0 ? 0 : entry->text_length; - break; - case GTK_MOVEMENT_WORDS: - case GTK_MOVEMENT_DISPLAY_LINES: - case GTK_MOVEMENT_PARAGRAPHS: - case GTK_MOVEMENT_PAGES: - case GTK_MOVEMENT_HORIZONTAL_PAGES: - break; - } - } - - if (extend_selection) - gtk_editable_select_region(GTK_EDITABLE(entry), - entry->selection_bound, new_pos); - else - gtk_editable_set_position(GTK_EDITABLE(entry), new_pos); - - gtk_secure_entry_pend_cursor_blink(entry); -} - -static void -gtk_secure_entry_insert_at_cursor(GtkSecureEntry * entry, - const gchar * str) -{ - GtkEditable *editable = GTK_EDITABLE(entry); - gint pos = entry->current_pos; - - gtk_secure_entry_reset_im_context(entry); - - gtk_editable_insert_text(editable, str, -1, &pos); - gtk_editable_set_position(editable, pos); -} - -static void -gtk_secure_entry_delete_from_cursor(GtkSecureEntry * entry, - GtkDeleteType type, gint count) -{ - GtkEditable *editable = GTK_EDITABLE(entry); - gint start_pos = entry->current_pos; - gint end_pos = entry->current_pos; - - gtk_secure_entry_reset_im_context(entry); - - if (entry->selection_bound != entry->current_pos) { - gtk_editable_delete_selection(editable); - return; - } - - switch (type) { - case GTK_DELETE_CHARS: - end_pos = - gtk_secure_entry_move_logically(entry, entry->current_pos, - count); - gtk_editable_delete_text(editable, MIN(start_pos, end_pos), - MAX(start_pos, end_pos)); - break; - case GTK_DELETE_DISPLAY_LINE_ENDS: - case GTK_DELETE_PARAGRAPH_ENDS: - if (count < 0) - gtk_editable_delete_text(editable, 0, entry->current_pos); - else - gtk_editable_delete_text(editable, entry->current_pos, -1); - break; - case GTK_DELETE_DISPLAY_LINES: - case GTK_DELETE_PARAGRAPHS: - gtk_editable_delete_text(editable, 0, -1); - break; - default: - break; - } - - gtk_secure_entry_pend_cursor_blink(entry); -} - -static void -gtk_secure_entry_real_activate(GtkSecureEntry * entry) -{ - GtkWindow *window; - GtkWidget *toplevel; - GtkWidget *widget; - - widget = GTK_WIDGET(entry); - - if (entry->activates_default) { - toplevel = gtk_widget_get_toplevel(widget); - if (GTK_IS_WINDOW(toplevel)) { - GtkWidget *default_widget; - - window = GTK_WINDOW(toplevel); - if (window) - default_widget = gtk_window_get_default_widget (window); - else - return; - - if (widget != default_widget && - !(widget == gtk_window_get_focus (window) && - (!default_widget - || !gtk_widget_get_sensitive (default_widget)))) - gtk_window_activate_default(window); - } - } -} - -static void -gtk_secure_entry_keymap_direction_changed(GdkKeymap * keymap G_GNUC_UNUSED, - GtkSecureEntry * entry) -{ - gtk_secure_entry_recompute(entry); -} - -/* IM Context Callbacks - */ - -static void -gtk_secure_entry_commit_cb(GtkIMContext * context G_GNUC_UNUSED, - const gchar * str, GtkSecureEntry * entry) -{ - gtk_secure_entry_enter_text(entry, str); -} - -static void -gtk_secure_entry_preedit_changed_cb(GtkIMContext * context G_GNUC_UNUSED, - GtkSecureEntry * entry) -{ - gchar *preedit_string; - gint cursor_pos; - - gtk_im_context_get_preedit_string(entry->im_context, - &preedit_string, NULL, &cursor_pos); - entry->preedit_length = strlen(preedit_string); - cursor_pos = CLAMP(cursor_pos, 0, g_utf8_strlen(preedit_string, -1)); - entry->preedit_cursor = cursor_pos; - g_free(preedit_string); - - gtk_secure_entry_recompute(entry); -} - -static gboolean -gtk_secure_entry_retrieve_surrounding_cb(GtkIMContext * context, - GtkSecureEntry * entry) -{ - gtk_im_context_set_surrounding(context, - entry->text, - entry->n_bytes, - g_utf8_offset_to_pointer(entry->text, - entry-> - current_pos) - - entry->text); - - return TRUE; -} - -static gboolean -gtk_secure_entry_delete_surrounding_cb(GtkIMContext * slave G_GNUC_UNUSED, - gint offset, - gint n_chars, - GtkSecureEntry * entry) -{ - gtk_editable_delete_text(GTK_EDITABLE(entry), - entry->current_pos + offset, - entry->current_pos + offset + n_chars); - - return TRUE; -} - -/* Internal functions - */ - -/* Used for im_commit_cb and inserting Unicode chars */ -static void -gtk_secure_entry_enter_text(GtkSecureEntry * entry, const gchar * str) -{ - GtkEditable *editable = GTK_EDITABLE(entry); - gint tmp_pos; - - if (gtk_editable_get_selection_bounds(editable, NULL, NULL)) - gtk_editable_delete_selection(editable); - else { - if (entry->overwrite_mode) - gtk_secure_entry_delete_from_cursor(entry, GTK_DELETE_CHARS, - 1); - } - - tmp_pos = entry->current_pos; - gtk_editable_insert_text(editable, str, strlen(str), &tmp_pos); - gtk_secure_entry_set_position_internal(entry, tmp_pos, FALSE); -} - -/* All changes to entry->current_pos and entry->selection_bound - * should go through this function. - */ -static void -gtk_secure_entry_set_positions(GtkSecureEntry * entry, - gint current_pos, gint selection_bound) -{ - gboolean changed = FALSE; - - g_object_freeze_notify(G_OBJECT(entry)); - - if (current_pos != -1 && entry->current_pos != current_pos) { - entry->current_pos = current_pos; - changed = TRUE; - - g_object_notify(G_OBJECT(entry), "cursor_position"); - } - - if (selection_bound != -1 && entry->selection_bound != selection_bound) { - entry->selection_bound = selection_bound; - changed = TRUE; - - g_object_notify(G_OBJECT(entry), "selection_bound"); - } - - g_object_thaw_notify(G_OBJECT(entry)); - - if (changed) - gtk_secure_entry_recompute(entry); -} - -static void -gtk_secure_entry_reset_layout(GtkSecureEntry * entry) -{ - if (entry->cached_layout) { - g_object_unref(entry->cached_layout); - entry->cached_layout = NULL; - } -} - -static void -update_im_cursor_location(GtkSecureEntry * entry) -{ - GdkRectangle area; - gint strong_x; - gint strong_xoffset; - gint area_width, area_height; - - gtk_secure_entry_get_cursor_locations(entry, &strong_x, NULL); - get_text_area_size(entry, NULL, NULL, &area_width, &area_height); - - strong_xoffset = strong_x - entry->scroll_offset; - if (strong_xoffset < 0) { - strong_xoffset = 0; - } else if (strong_xoffset > area_width) { - strong_xoffset = area_width; - } - area.x = strong_xoffset; - area.y = 0; - area.width = 0; - area.height = area_height; - - gtk_im_context_set_cursor_location(entry->im_context, &area); -} - -static gboolean -recompute_idle_func(gpointer data) -{ - GtkSecureEntry *entry; - - GDK_THREADS_ENTER(); - - entry = GTK_SECURE_ENTRY(data); - - entry->recompute_idle = 0; - - if (gtk_widget_has_screen(GTK_WIDGET(entry))) { - gtk_secure_entry_adjust_scroll(entry); - gtk_secure_entry_queue_draw(entry); - - update_im_cursor_location(entry); - } - - GDK_THREADS_LEAVE(); - - return FALSE; -} - -static void -gtk_secure_entry_recompute(GtkSecureEntry * entry) -{ - gtk_secure_entry_reset_layout(entry); - gtk_secure_entry_check_cursor_blink(entry); - - if (!entry->recompute_idle) { - entry->recompute_idle = g_idle_add_full(G_PRIORITY_HIGH_IDLE + 15, /* between resize and redraw */ - recompute_idle_func, entry, - NULL); - } -} - -static void -append_char(GString * str, gunichar ch, gint count) -{ - gint i; - gint char_len; - gchar buf[7]; - - char_len = g_unichar_to_utf8(ch, buf); - - i = 0; - while (i < count) { - g_string_append_len(str, buf, char_len); - ++i; - } -} - -static PangoLayout * -gtk_secure_entry_create_layout(GtkSecureEntry * entry, - gboolean include_preedit) -{ - GtkWidget *widget = GTK_WIDGET(entry); - PangoLayout *layout = gtk_widget_create_pango_layout(widget, NULL); - PangoAttrList *tmp_attrs = pango_attr_list_new(); - - gchar *preedit_string = NULL; - gint preedit_length = 0; - PangoAttrList *preedit_attrs = NULL; - - pango_layout_set_single_paragraph_mode(layout, TRUE); - - if (include_preedit) { - gtk_im_context_get_preedit_string(entry->im_context, - &preedit_string, &preedit_attrs, - NULL); - preedit_length = entry->preedit_length; - } - - if (preedit_length) { - GString *tmp_string = g_string_new(NULL); - - gint cursor_index = g_utf8_offset_to_pointer(entry->text, - entry->current_pos) - - entry->text; - - gint ch_len; - gint preedit_len_chars; - gunichar invisible_char; - - ch_len = g_utf8_strlen(entry->text, entry->n_bytes); - preedit_len_chars = g_utf8_strlen(preedit_string, -1); - ch_len += preedit_len_chars; - - if (entry->invisible_char != 0) - invisible_char = entry->invisible_char; - else - invisible_char = ' '; /* just pick a char */ - - append_char(tmp_string, invisible_char, ch_len); - - /* Fix cursor index to point to invisible char corresponding - * to the preedit, fix preedit_length to be the length of - * the invisible chars representing the preedit - */ - cursor_index = - g_utf8_offset_to_pointer(tmp_string->str, - entry->current_pos) - - tmp_string->str; - preedit_length = - preedit_len_chars * g_unichar_to_utf8(invisible_char, - NULL); - - pango_layout_set_text(layout, tmp_string->str, tmp_string->len); - - pango_attr_list_splice(tmp_attrs, preedit_attrs, - cursor_index, preedit_length); - - g_string_free(tmp_string, TRUE); - } else { - PangoDirection pango_dir; - - pango_dir = pango_find_base_dir(entry->text, entry->n_bytes); - if (pango_dir == PANGO_DIRECTION_NEUTRAL) { - if (gtk_widget_has_focus (widget)) { - GdkDisplay *display = gtk_widget_get_display(widget); - GdkKeymap *keymap = gdk_keymap_get_for_display(display); - pango_dir = gdk_keymap_get_direction(keymap); - } else { - if (gtk_widget_get_direction(widget) == GTK_TEXT_DIR_LTR) - pango_dir = PANGO_DIRECTION_LTR; - else - pango_dir = PANGO_DIRECTION_RTL; - } - } - - pango_context_set_base_dir(gtk_widget_get_pango_context(widget), - pango_dir); - - pango_layout_set_alignment(layout, pango_dir); - - entry->resolved_dir = pango_dir; - - { - GString *str = g_string_new(NULL); - gunichar invisible_char; - - if (entry->invisible_char != 0) - invisible_char = entry->invisible_char; - else - invisible_char = ' '; /* just pick a char */ - - append_char(str, invisible_char, entry->text_length); - pango_layout_set_text(layout, str->str, str->len); - g_string_free(str, TRUE); - } - } - - pango_layout_set_attributes(layout, tmp_attrs); - - if (preedit_string) - g_free(preedit_string); - if (preedit_attrs) - pango_attr_list_unref(preedit_attrs); - - pango_attr_list_unref(tmp_attrs); - - return layout; -} - -static PangoLayout * -gtk_secure_entry_ensure_layout(GtkSecureEntry * entry, - gboolean include_preedit) -{ - if (entry->preedit_length > 0 && - !include_preedit != !entry->cache_includes_preedit) - gtk_secure_entry_reset_layout(entry); - - if (!entry->cached_layout) { - entry->cached_layout = - gtk_secure_entry_create_layout(entry, include_preedit); - entry->cache_includes_preedit = include_preedit; - } - - return entry->cached_layout; -} - -static void -get_layout_position(GtkSecureEntry * entry, gint * x, gint * y) -{ - PangoLayout *layout; - PangoRectangle logical_rect; - gint area_width, area_height; - gint y_pos; - PangoLayoutLine *line; - - layout = gtk_secure_entry_ensure_layout(entry, TRUE); - - get_text_area_size(entry, NULL, NULL, &area_width, &area_height); - - area_height = PANGO_SCALE * (area_height - 2 * INNER_BORDER); - - line = pango_layout_get_lines(layout)->data; - pango_layout_line_get_extents(line, NULL, &logical_rect); - - /* Align primarily for locale's ascent/descent */ - y_pos = ((area_height - entry->ascent - entry->descent) / 2 + - entry->ascent + logical_rect.y); - - /* Now see if we need to adjust to fit in actual drawn string */ - if (logical_rect.height > area_height) - y_pos = (area_height - logical_rect.height) / 2; - else if (y_pos < 0) - y_pos = 0; - else if (y_pos + logical_rect.height > area_height) - y_pos = area_height - logical_rect.height; - - y_pos = INNER_BORDER + y_pos / PANGO_SCALE; - - if (x) - *x = INNER_BORDER - entry->scroll_offset; - - if (y) - *y = y_pos; -} - -static void -gtk_secure_entry_draw_text(GtkSecureEntry * entry) -{ - GtkWidget *widget = GTK_WIDGET(entry); - PangoLayoutLine *line; - GtkStyle *style; - - if (entry->invisible_char == 0) - return; - - if (gtk_widget_is_drawable (widget)) { - PangoLayout *layout = gtk_secure_entry_ensure_layout(entry, TRUE); - gint x, y; - gint start_pos, end_pos; - - get_layout_position(entry, &x, &y); - - style = gtk_widget_get_style (widget); - gdk_draw_layout(entry->text_area, - style->text_gc[gtk_widget_get_state (widget)], - x, y, layout); - - if (gtk_editable_get_selection_bounds - (GTK_EDITABLE(entry), &start_pos, &end_pos)) { - gint *ranges; - gint n_ranges, i; - PangoRectangle logical_rect; - const gchar *text = pango_layout_get_text(layout); - gint start_index = - g_utf8_offset_to_pointer(text, start_pos) - text; - gint end_index = - g_utf8_offset_to_pointer(text, end_pos) - text; -#if GTK_CHECK_VERSION(2, 90, 5) - cairo_region_t *clip_region = cairo_region_create(); -#else - GdkRegion *clip_region = gdk_region_new(); -#endif - GdkGC *text_gc; - GdkGC *selection_gc; - - line = pango_layout_get_lines(layout)->data; - - pango_layout_line_get_x_ranges(line, start_index, end_index, - &ranges, &n_ranges); - - pango_layout_get_extents(layout, NULL, &logical_rect); - - if (gtk_widget_has_focus (widget)) { - selection_gc = style->base_gc[GTK_STATE_SELECTED]; - text_gc = style->text_gc[GTK_STATE_SELECTED]; - } else { - selection_gc = style->base_gc[GTK_STATE_ACTIVE]; - text_gc = style->text_gc[GTK_STATE_ACTIVE]; - } - - for (i = 0; i < n_ranges; i++) { - GdkRectangle rect; - - rect.x = - INNER_BORDER - entry->scroll_offset + - ranges[2 * i] / PANGO_SCALE; - rect.y = y; - rect.width = - (ranges[2 * i + 1] - ranges[2 * i]) / PANGO_SCALE; - rect.height = logical_rect.height / PANGO_SCALE; - - gdk_draw_rectangle(entry->text_area, selection_gc, TRUE, - rect.x, rect.y, rect.width, - rect.height); -#if GTK_CHECK_VERSION(2, 90, 5) - cairo_region_union_rectangle (clip_region, &rect); -#else - gdk_region_union_with_rect(clip_region, &rect); -#endif - } - - gdk_gc_set_clip_region(text_gc, clip_region); - gdk_draw_layout(entry->text_area, text_gc, x, y, layout); - gdk_gc_set_clip_region(text_gc, NULL); - -#if GTK_CHECK_VERSION(2, 90, 5) - cairo_region_destroy(clip_region); -#else - gdk_region_destroy(clip_region); -#endif - g_free(ranges); - } - } -} - -static void -draw_insertion_cursor(GtkSecureEntry * entry, - GdkRectangle * cursor_location, - gboolean is_primary, - PangoDirection direction, gboolean draw_arrow) -{ - GtkWidget *widget = GTK_WIDGET(entry); - GtkTextDirection text_dir; - - if (direction == PANGO_DIRECTION_LTR) - text_dir = GTK_TEXT_DIR_LTR; - else - text_dir = GTK_TEXT_DIR_RTL; - - gtk_draw_insertion_cursor(widget, entry->text_area, NULL, - cursor_location, - is_primary, text_dir, draw_arrow); -} - -static void -gtk_secure_entry_draw_cursor(GtkSecureEntry * entry) -{ - GtkWidget *widget = GTK_WIDGET(entry); - GdkKeymap *keymap = - gdk_keymap_get_for_display(gtk_widget_get_display - (widget)); - PangoDirection keymap_direction = gdk_keymap_get_direction(keymap); - - if (gtk_widget_is_drawable (widget)) { - GdkRectangle cursor_location; - gboolean split_cursor; - - gint xoffset = INNER_BORDER - entry->scroll_offset; - gint strong_x, weak_x; - gint text_area_height; - PangoDirection dir1 = PANGO_DIRECTION_NEUTRAL; - PangoDirection dir2 = PANGO_DIRECTION_NEUTRAL; - gint x1 = 0; - gint x2 = 0; - - gdk_drawable_get_size(entry->text_area, NULL, &text_area_height); - - gtk_secure_entry_get_cursor_locations(entry, &strong_x, &weak_x); - - g_object_get(gtk_widget_get_settings(widget), - "gtk-split-cursor", &split_cursor, NULL); - - dir1 = entry->resolved_dir; - - if (split_cursor) { - x1 = strong_x; - - if (weak_x != strong_x) { - dir2 = - (entry->resolved_dir == - PANGO_DIRECTION_LTR) ? PANGO_DIRECTION_RTL : - PANGO_DIRECTION_LTR; - x2 = weak_x; - } - } else { - if (keymap_direction == entry->resolved_dir) - x1 = strong_x; - else - x1 = weak_x; - } - - cursor_location.x = xoffset + x1; - cursor_location.y = INNER_BORDER; - cursor_location.width = 0; - cursor_location.height = text_area_height - 2 * INNER_BORDER; - - draw_insertion_cursor(entry, - &cursor_location, TRUE, dir1, - dir2 != PANGO_DIRECTION_NEUTRAL); - - if (dir2 != PANGO_DIRECTION_NEUTRAL) { - cursor_location.x = xoffset + x2; - draw_insertion_cursor(entry, - &cursor_location, FALSE, dir2, TRUE); - } - } -} - -static void -gtk_secure_entry_queue_draw(GtkSecureEntry * entry) -{ - if (gtk_widget_get_realized (GTK_WIDGET(entry))) - gdk_window_invalidate_rect(entry->text_area, NULL, FALSE); -} - -static void -gtk_secure_entry_reset_im_context(GtkSecureEntry * entry) -{ - if (entry->need_im_reset) { - entry->need_im_reset = 0; - gtk_im_context_reset(entry->im_context); - } -} - -static gint -gtk_secure_entry_find_position(GtkSecureEntry * entry, gint x) -{ - PangoLayout *layout; - PangoLayoutLine *line; - gint _index; - gint pos; - gboolean trailing; - const gchar *text; - gint cursor_index; - - layout = gtk_secure_entry_ensure_layout(entry, TRUE); - text = pango_layout_get_text(layout); - cursor_index = - g_utf8_offset_to_pointer(text, entry->current_pos) - text; - - line = pango_layout_get_lines(layout)->data; - pango_layout_line_x_to_index(line, x * PANGO_SCALE, &_index, &trailing); - - if (_index >= cursor_index && entry->preedit_length) { - if (_index >= cursor_index + entry->preedit_length) - _index -= entry->preedit_length; - else { - _index = cursor_index; - trailing = 0; - } - } - - pos = g_utf8_pointer_to_offset(text, text + _index); - pos += trailing; - - return pos; -} - -static void -gtk_secure_entry_get_cursor_locations(GtkSecureEntry * entry, - gint * strong_x, gint * weak_x) -{ - if (!entry->invisible_char) { - if (strong_x) - *strong_x = 0; - - if (weak_x) - *weak_x = 0; - } else { - PangoLayout *layout = gtk_secure_entry_ensure_layout(entry, TRUE); - const gchar *text = pango_layout_get_text(layout); - PangoRectangle strong_pos, weak_pos; - gint _index; - - _index = - g_utf8_offset_to_pointer(text, - entry->current_pos + - entry->preedit_cursor) - text; - - pango_layout_get_cursor_pos(layout, _index, &strong_pos, &weak_pos); - - if (strong_x) - *strong_x = strong_pos.x / PANGO_SCALE; - - if (weak_x) - *weak_x = weak_pos.x / PANGO_SCALE; - } -} - -static void -gtk_secure_entry_adjust_scroll(GtkSecureEntry * entry) -{ - gint min_offset, max_offset; - gint text_area_width, text_width; - gint strong_x, weak_x; - gint strong_xoffset, weak_xoffset; - PangoLayout *layout; - PangoLayoutLine *line; - PangoRectangle logical_rect; - - if (!gtk_widget_get_realized (GTK_WIDGET(entry))) - return; - - gdk_drawable_get_size(entry->text_area, &text_area_width, NULL); - text_area_width -= 2 * INNER_BORDER; - - layout = gtk_secure_entry_ensure_layout(entry, TRUE); - line = pango_layout_get_lines(layout)->data; - - pango_layout_line_get_extents(line, NULL, &logical_rect); - - /* Display as much text as we can */ - - text_width = PANGO_PIXELS(logical_rect.width); - - if (text_width > text_area_width) { - min_offset = 0; - max_offset = text_width - text_area_width; - } else { - min_offset = 0; - max_offset = min_offset; - } - - entry->scroll_offset = - CLAMP(entry->scroll_offset, min_offset, max_offset); - - /* And make sure cursors are on screen. Note that the cursor is - * actually drawn one pixel into the INNER_BORDER space on - * the right, when the scroll is at the utmost right. This - * looks better to to me than confining the cursor inside the - * border entirely, though it means that the cursor gets one - * pixel closer to the the edge of the widget on the right than - * on the left. This might need changing if one changed - * INNER_BORDER from 2 to 1, as one would do on a - * small-screen-real-estate display. - * - * We always make sure that the strong cursor is on screen, and - * put the weak cursor on screen if possible. - */ - - gtk_secure_entry_get_cursor_locations(entry, &strong_x, &weak_x); - - strong_xoffset = strong_x - entry->scroll_offset; - - if (strong_xoffset < 0) { - entry->scroll_offset += strong_xoffset; - strong_xoffset = 0; - } else if (strong_xoffset > text_area_width) { - entry->scroll_offset += strong_xoffset - text_area_width; - strong_xoffset = text_area_width; - } - - weak_xoffset = weak_x - entry->scroll_offset; - - if (weak_xoffset < 0 - && strong_xoffset - weak_xoffset <= text_area_width) { - entry->scroll_offset += weak_xoffset; - } else if (weak_xoffset > text_area_width && - strong_xoffset - (weak_xoffset - text_area_width) >= 0) { - entry->scroll_offset += weak_xoffset - text_area_width; - } - - g_object_notify(G_OBJECT(entry), "scroll_offset"); -} - -static gint -gtk_secure_entry_move_visually(GtkSecureEntry * entry, - gint start, gint count) -{ - gint _index; - PangoLayout *layout = gtk_secure_entry_ensure_layout(entry, FALSE); - const gchar *text; - - text = pango_layout_get_text(layout); - - _index = g_utf8_offset_to_pointer(text, start) - text; - - while (count != 0) { - int new_index, new_trailing; - gboolean split_cursor; - gboolean strong; - - g_object_get(gtk_widget_get_settings(GTK_WIDGET(entry)), - "gtk-split-cursor", &split_cursor, NULL); - - if (split_cursor) - strong = TRUE; - else { - GdkKeymap *keymap = - gdk_keymap_get_for_display(gtk_widget_get_display - (GTK_WIDGET(entry))); - PangoDirection keymap_direction = - gdk_keymap_get_direction(keymap); - - strong = keymap_direction == entry->resolved_dir; - } - - if (count > 0) { - pango_layout_move_cursor_visually(layout, strong, _index, 0, 1, - &new_index, &new_trailing); - count--; - } else { - pango_layout_move_cursor_visually(layout, strong, _index, 0, -1, - &new_index, &new_trailing); - count++; - } - - if (new_index < 0 || new_index == G_MAXINT) - break; - - _index = new_index; - - while (new_trailing--) - _index = g_utf8_next_char(text + new_index) - text; - } - - return g_utf8_pointer_to_offset(text, text + _index); -} - -static gint -gtk_secure_entry_move_logically(GtkSecureEntry * entry, - gint start, gint count) -{ - gint new_pos = start; - - /* Prevent any leak of information */ - new_pos = CLAMP(start + count, 0, entry->text_length); - - return new_pos; -} - -/* Public API - */ - -GtkWidget * -gtk_secure_entry_new(void) -{ - return g_object_new(GTK_TYPE_SECURE_ENTRY, NULL); -} - -/** - * gtk_secure_entry_new_with_max_length: - * @max: the maximum length of the entry, or 0 for no maximum. - * (other than the maximum length of entries.) The value passed in will - * be clamped to the range 0-65536. - * - * Creates a new #GtkSecureEntry widget with the given maximum length. - * - * Note: the existence of this function is inconsistent - * with the rest of the GTK+ API. The normal setup would - * be to just require the user to make an extra call - * to gtk_secure_entry_set_max_length() instead. It is not - * expected that this function will be removed, but - * it would be better practice not to use it. - * - * Return value: a new #GtkSecureEntry. - **/ -GtkWidget * -gtk_secure_entry_new_with_max_length(gint max) -{ - GtkSecureEntry *entry; - - max = CLAMP(max, 0, MAX_SIZE); - - entry = g_object_new(GTK_TYPE_SECURE_ENTRY, NULL); - entry->text_max_length = max; - - return GTK_WIDGET(entry); -} - -void -gtk_secure_entry_set_text(GtkSecureEntry * entry, const gchar * text) -{ - gint tmp_pos; - - g_return_if_fail(GTK_IS_SECURE_ENTRY(entry)); - g_return_if_fail(text != NULL); - - /* Actually setting the text will affect the cursor and selection; - * if the contents don't actually change, this will look odd to the user. - */ - if (strcmp(entry->text, text) == 0) - return; - - gtk_editable_delete_text(GTK_EDITABLE(entry), 0, -1); - - tmp_pos = 0; - gtk_editable_insert_text(GTK_EDITABLE(entry), text, strlen(text), - &tmp_pos); -} - -/** - * gtk_secure_entry_set_invisible_char: - * @entry: a #GtkSecureEntry - * @ch: a Unicode character - * - * Sets the character to use in place of the actual text when - * gtk_secure_entry_set_visibility() has been called to set text visibility - * to %FALSE. i.e. this is the character used in "password mode" to - * show the user how many characters have been typed. The default - * invisible char is an asterisk ('*'). If you set the invisible char - * to 0, then the user will get no feedback at all; there will be - * no text on the screen as they type. - * - **/ -void -gtk_secure_entry_set_invisible_char(GtkSecureEntry * entry, gunichar ch) -{ - g_return_if_fail(GTK_IS_SECURE_ENTRY(entry)); - - if (ch == entry->invisible_char) - return; - - entry->invisible_char = ch; - g_object_notify(G_OBJECT(entry), "invisible_char"); - gtk_secure_entry_recompute(entry); -} - -/** - * gtk_secure_entry_get_invisible_char: - * @entry: a #GtkSecureEntry - * - * Retrieves the character displayed in place of the real characters - * for entries with visisbility set to false. See gtk_secure_entry_set_invisible_char(). - * - * Return value: the current invisible char, or 0, if the entry does not - * show invisible text at all. - **/ -gunichar -gtk_secure_entry_get_invisible_char(GtkSecureEntry * entry) -{ - g_return_val_if_fail(GTK_IS_SECURE_ENTRY(entry), 0); - - return entry->invisible_char; -} - -/** - * gtk_secure_entry_get_text: - * @entry: a #GtkSecureEntry - * - * Retrieves the contents of the entry widget. - * See also gtk_editable_get_chars(). - * - * Return value: a pointer to the contents of the widget as a - * string. This string points to internally allocated - * storage in the widget and must not be freed, modified or - * stored. - **/ -G_CONST_RETURN gchar * -gtk_secure_entry_get_text(GtkSecureEntry * entry) -{ - g_return_val_if_fail(GTK_IS_SECURE_ENTRY(entry), NULL); - - return entry->text; -} - -/** - * gtk_secure_entry_set_max_length: - * @entry: a #GtkSecureEntry. - * @max: the maximum length of the entry, or 0 for no maximum. - * (other than the maximum length of entries.) The value passed in will - * be clamped to the range 0-65536. - * - * Sets the maximum allowed length of the contents of the widget. If - * the current contents are longer than the given length, then they - * will be truncated to fit. - **/ -void -gtk_secure_entry_set_max_length(GtkSecureEntry * entry, gint max) -{ - g_return_if_fail(GTK_IS_SECURE_ENTRY(entry)); - - max = CLAMP(max, 0, MAX_SIZE); - - if (max > 0 && entry->text_length > max) - gtk_editable_delete_text(GTK_EDITABLE(entry), max, -1); - - entry->text_max_length = max; - g_object_notify(G_OBJECT(entry), "max_length"); -} - -/** - * gtk_secure_entry_get_max_length: - * @entry: a #GtkSecureEntry - * - * Retrieves the maximum allowed length of the text in - * @entry. See gtk_secure_entry_set_max_length(). - * - * Return value: the maximum allowed number of characters - * in #GtkSecureEntry, or 0 if there is no maximum. - **/ -gint -gtk_secure_entry_get_max_length(GtkSecureEntry * entry) -{ - g_return_val_if_fail(GTK_IS_SECURE_ENTRY(entry), 0); - - return entry->text_max_length; -} - -/** - * gtk_secure_entry_set_activates_default: - * @entry: a #GtkSecureEntry - * @setting: %TRUE to activate window's default widget on Enter keypress - * - * If @setting is %TRUE, pressing Enter in the @entry will activate the default - * widget for the window containing the entry. This usually means that - * the dialog box containing the entry will be closed, since the default - * widget is usually one of the dialog buttons. - * - * (For experts: if @setting is %TRUE, the entry calls - * gtk_window_activate_default() on the window containing the entry, in - * the default handler for the "activate" signal.) - * - **/ -void -gtk_secure_entry_set_activates_default(GtkSecureEntry * entry, - gboolean setting) -{ - g_return_if_fail(GTK_IS_SECURE_ENTRY(entry)); - setting = setting != FALSE; - - if (setting != entry->activates_default) { - entry->activates_default = setting; - g_object_notify(G_OBJECT(entry), "activates_default"); - } -} - -/** - * gtk_secure_entry_get_activates_default: - * @entry: a #GtkSecureEntry - * - * Retrieves the value set by gtk_secure_entry_set_activates_default(). - * - * Return value: %TRUE if the entry will activate the default widget - **/ -gboolean -gtk_secure_entry_get_activates_default(GtkSecureEntry * entry) -{ - g_return_val_if_fail(GTK_IS_SECURE_ENTRY(entry), FALSE); - - return entry->activates_default; -} - -/** - * gtk_secure_entry_set_width_chars: - * @entry: a #GtkSecureEntry - * @n_chars: width in chars - * - * Changes the size request of the entry to be about the right size - * for @n_chars characters. Note that it changes the size - * <emphasis>request</emphasis>, the size can still be affected by - * how you pack the widget into containers. If @n_chars is -1, the - * size reverts to the default entry size. - * - **/ -void -gtk_secure_entry_set_width_chars(GtkSecureEntry * entry, gint n_chars) -{ - g_return_if_fail(GTK_IS_SECURE_ENTRY(entry)); - - if (entry->width_chars != n_chars) { - entry->width_chars = n_chars; - g_object_notify(G_OBJECT(entry), "width_chars"); - gtk_widget_queue_resize(GTK_WIDGET(entry)); - } -} - -/** - * gtk_secure_entry_get_width_chars: - * @entry: a #GtkSecureEntry - * - * Gets the value set by gtk_secure_entry_set_width_chars(). - * - * Return value: number of chars to request space for, or negative if unset - **/ -gint -gtk_secure_entry_get_width_chars(GtkSecureEntry * entry) -{ - g_return_val_if_fail(GTK_IS_SECURE_ENTRY(entry), 0); - - return entry->width_chars; -} - -/** - * gtk_secure_entry_set_has_frame: - * @entry: a #GtkSecureEntry - * @setting: new value - * - * Sets whether the entry has a beveled frame around it. - **/ -void -gtk_secure_entry_set_has_frame(GtkSecureEntry * entry, gboolean setting) -{ - g_return_if_fail(GTK_IS_SECURE_ENTRY(entry)); - - setting = (setting != FALSE); - - if (entry->has_frame == setting) - return; - - gtk_widget_queue_resize(GTK_WIDGET(entry)); - entry->has_frame = setting; - g_object_notify(G_OBJECT(entry), "has_frame"); -} - -/** - * gtk_secure_entry_get_has_frame: - * @entry: a #GtkSecureEntry - * - * Gets the value set by gtk_secure_entry_set_has_frame(). - * - * Return value: whether the entry has a beveled frame - **/ -gboolean -gtk_secure_entry_get_has_frame(GtkSecureEntry * entry) -{ - g_return_val_if_fail(GTK_IS_SECURE_ENTRY(entry), FALSE); - - return entry->has_frame; -} - - -/** - * gtk_secure_entry_get_layout: - * @entry: a #GtkSecureEntry - * - * Gets the #PangoLayout used to display the entry. - * The layout is useful to e.g. convert text positions to - * pixel positions, in combination with gtk_secure_entry_get_layout_offsets(). - * The returned layout is owned by the entry so need not be - * freed by the caller. - * - * Keep in mind that the layout text may contain a preedit string, so - * gtk_secure_entry_layout_index_to_text_index() and - * gtk_secure_entry_text_index_to_layout_index() are needed to convert byte - * indices in the layout to byte indices in the entry contents. - * - * Return value: the #PangoLayout for this entry - **/ -PangoLayout * -gtk_secure_entry_get_layout(GtkSecureEntry * entry) -{ - PangoLayout *layout; - - g_return_val_if_fail(GTK_IS_SECURE_ENTRY(entry), NULL); - - layout = gtk_secure_entry_ensure_layout(entry, TRUE); - - return layout; -} - - -/** - * gtk_secure_entry_layout_index_to_text_index: - * @entry: a #GtkSecureEntry - * @layout_index: byte index into the entry layout text - * - * Converts from a position in the entry contents (returned - * by gtk_secure_entry_get_text()) to a position in the - * entry's #PangoLayout (returned by gtk_secure_entry_get_layout(), - * with text retrieved via pango_layout_get_text()). - * - * Return value: byte index into the entry contents - **/ -gint -gtk_secure_entry_layout_index_to_text_index(GtkSecureEntry * entry, - gint layout_index) -{ - PangoLayout *layout; - const gchar *text; - gint cursor_index; - - g_return_val_if_fail(GTK_IS_SECURE_ENTRY(entry), 0); - - layout = gtk_secure_entry_ensure_layout(entry, TRUE); - text = pango_layout_get_text(layout); - cursor_index = - g_utf8_offset_to_pointer(text, entry->current_pos) - text; - - if (layout_index >= cursor_index && entry->preedit_length) { - if (layout_index >= cursor_index + entry->preedit_length) - layout_index -= entry->preedit_length; - else - layout_index = cursor_index; - } - - return layout_index; -} - -/** - * gtk_secure_entry_text_index_to_layout_index: - * @entry: a #GtkSecureEntry - * @text_index: byte index into the entry contents - * - * Converts from a position in the entry's #PangoLayout(returned by - * gtk_secure_entry_get_layout()) to a position in the entry contents - * (returned by gtk_secure_entry_get_text()). - * - * Return value: byte index into the entry layout text - **/ -gint -gtk_secure_entry_text_index_to_layout_index(GtkSecureEntry * entry, - gint text_index) -{ - PangoLayout *layout; - const gchar *text; - gint cursor_index; - g_return_val_if_fail(GTK_IS_SECURE_ENTRY(entry), 0); - - layout = gtk_secure_entry_ensure_layout(entry, TRUE); - text = pango_layout_get_text(layout); - cursor_index = - g_utf8_offset_to_pointer(text, entry->current_pos) - text; - - if (text_index > cursor_index) - text_index += entry->preedit_length; - - return text_index; -} - -/** - * gtk_secure_entry_get_layout_offsets: - * @entry: a #GtkSecureEntry - * @x: location to store X offset of layout, or %NULL - * @y: location to store Y offset of layout, or %NULL - * - * - * Obtains the position of the #PangoLayout used to render text - * in the entry, in widget coordinates. Useful if you want to line - * up the text in an entry with some other text, e.g. when using the - * entry to implement editable cells in a sheet widget. - * - * Also useful to convert mouse events into coordinates inside the - * #PangoLayout, e.g. to take some action if some part of the entry text - * is clicked. - * - * Note that as the user scrolls around in the entry the offsets will - * change; you'll need to connect to the "notify::scroll_offset" - * signal to track this. Remember when using the #PangoLayout - * functions you need to convert to and from pixels using - * PANGO_PIXELS() or #PANGO_SCALE. - * - * Keep in mind that the layout text may contain a preedit string, so - * gtk_secure_entry_layout_index_to_text_index() and - * gtk_secure_entry_text_index_to_layout_index() are needed to convert byte - * indices in the layout to byte indices in the entry contents. - * - **/ -void -gtk_secure_entry_get_layout_offsets(GtkSecureEntry * entry, - gint * x, gint * y) -{ - gint text_area_x, text_area_y; - - g_return_if_fail(GTK_IS_SECURE_ENTRY(entry)); - - /* this gets coords relative to text area */ - get_layout_position(entry, x, y); - - /* convert to widget coords */ - get_text_area_size(entry, &text_area_x, &text_area_y, NULL, NULL); - - if (x) - *x += text_area_x; - - if (y) - *y += text_area_y; -} - -static gboolean -gtk_secure_entry_mnemonic_activate(GtkWidget * widget, - gboolean group_cycling G_GNUC_UNUSED) -{ - gtk_widget_grab_focus(widget); - return TRUE; -} - -/* We display the cursor when - * - * - the selection is empty, AND - * - the widget has focus - */ - -#define CURSOR_ON_MULTIPLIER 0.66 -#define CURSOR_OFF_MULTIPLIER 0.34 -#define CURSOR_PEND_MULTIPLIER 1.0 - -static gboolean -cursor_blinks(GtkSecureEntry * entry) -{ - GtkWidget *widget = GTK_WIDGET(entry); - GtkSettings *settings = gtk_widget_get_settings(widget); - gboolean blink; - - if (gtk_widget_has_focus (widget) && - entry->selection_bound == entry->current_pos) { - g_object_get(settings, "gtk-cursor-blink", &blink, NULL); - return blink; - } else - return FALSE; -} - -static gint -get_cursor_time(GtkSecureEntry * entry) -{ - GtkSettings *settings = gtk_widget_get_settings(GTK_WIDGET(entry)); - gint blinktime; - - g_object_get(settings, "gtk-cursor-blink-time", &blinktime, NULL); - - return blinktime; -} - -static void -show_cursor(GtkSecureEntry * entry) -{ - GtkWidget *widget = GTK_WIDGET(entry); - - if (!entry->cursor_visible) { - entry->cursor_visible = TRUE; - - if (gtk_widget_has_focus (widget) - && entry->selection_bound == entry->current_pos) - gtk_widget_queue_draw(widget); - } -} - -static void -hide_cursor(GtkSecureEntry * entry) -{ - GtkWidget *widget = GTK_WIDGET(entry); - - if (entry->cursor_visible) { - entry->cursor_visible = FALSE; - - if (gtk_widget_has_focus (widget) - && entry->selection_bound == entry->current_pos) - gtk_widget_queue_draw(widget); - } -} - -/* - * Blink! - */ -static gint -blink_cb(gpointer data) -{ - GtkSecureEntry *entry; - GtkWidget *widget; - - GDK_THREADS_ENTER(); - - entry = GTK_SECURE_ENTRY(data); - widget = GTK_WIDGET (entry); - - if (!gtk_widget_has_focus (widget)) { - g_warning - ("GtkSecureEntry - did not receive focus-out-event. If you\n" - "connect a handler to this signal, it must return\n" - "FALSE so the entry gets the event as well"); - } - - g_assert(gtk_widget_has_focus (widget)); - g_assert(entry->selection_bound == entry->current_pos); - - if (entry->cursor_visible) { - hide_cursor(entry); - entry->blink_timeout = - g_timeout_add(get_cursor_time(entry) * CURSOR_OFF_MULTIPLIER, - blink_cb, entry); - } else { - show_cursor(entry); - entry->blink_timeout = - g_timeout_add(get_cursor_time(entry) * CURSOR_ON_MULTIPLIER, - blink_cb, entry); - } - - GDK_THREADS_LEAVE(); - - /* Remove ourselves */ - return FALSE; -} - -static void -gtk_secure_entry_check_cursor_blink(GtkSecureEntry * entry) -{ - if (cursor_blinks(entry)) { - if (!entry->blink_timeout) { - entry->blink_timeout = - g_timeout_add(get_cursor_time(entry) * - CURSOR_ON_MULTIPLIER, blink_cb, entry); - show_cursor(entry); - } - } else { - if (entry->blink_timeout) { - g_source_remove(entry->blink_timeout); - entry->blink_timeout = 0; - } - - entry->cursor_visible = TRUE; - } - -} - -static void -gtk_secure_entry_pend_cursor_blink(GtkSecureEntry * entry) -{ - if (cursor_blinks(entry)) { - if (entry->blink_timeout != 0) - g_source_remove(entry->blink_timeout); - - entry->blink_timeout = - g_timeout_add(get_cursor_time(entry) * CURSOR_PEND_MULTIPLIER, - blink_cb, entry); - show_cursor(entry); - } -} - -static inline gboolean -keyval_is_cursor_move(guint keyval) -{ - if (keyval == GDK_Up || keyval == GDK_KP_Up) - return TRUE; - - if (keyval == GDK_Down || keyval == GDK_KP_Down) - return TRUE; - - if (keyval == GDK_Page_Up) - return TRUE; - - if (keyval == GDK_Page_Down) - return TRUE; - - return FALSE; -} - -/* stolen from gtkmarshalers.c */ - -#define g_marshal_value_peek_enum(v) (v)->data[0].v_int -#define g_marshal_value_peek_int(v) (v)->data[0].v_int -#define g_marshal_value_peek_boolean(v) (v)->data[0].v_int - -/* VOID:ENUM,INT,BOOLEAN (gtkmarshalers.list:64) */ -static void -_gtk_marshal_VOID__ENUM_INT_BOOLEAN(GClosure * closure, - GValue * return_value G_GNUC_UNUSED, - guint n_param_values, - const GValue * param_values, - gpointer invocation_hint G_GNUC_UNUSED, - gpointer marshal_data) -{ - typedef void (*GMarshalFunc_VOID__ENUM_INT_BOOLEAN) (gpointer data1, - gint arg_1, - gint arg_2, - gboolean arg_3, - gpointer data2); - register GMarshalFunc_VOID__ENUM_INT_BOOLEAN callback; - register GCClosure *cc = (GCClosure *) closure; - register gpointer data1, data2; - - g_return_if_fail(n_param_values == 4); - - if (G_CCLOSURE_SWAP_DATA(closure)) { - data1 = closure->data; - data2 = g_value_peek_pointer(param_values + 0); - } else { - data1 = g_value_peek_pointer(param_values + 0); - data2 = closure->data; - } - callback = - (GMarshalFunc_VOID__ENUM_INT_BOOLEAN) (marshal_data ? marshal_data - : cc->callback); - - callback(data1, - g_marshal_value_peek_enum(param_values + 1), - g_marshal_value_peek_int(param_values + 2), - g_marshal_value_peek_boolean(param_values + 3), data2); -} - -static void -_gtk_marshal_VOID__ENUM_INT(GClosure * closure, - GValue * return_value G_GNUC_UNUSED, - guint n_param_values, - const GValue * param_values, - gpointer invocation_hint G_GNUC_UNUSED, - gpointer marshal_data) -{ - typedef void (*GMarshalFunc_VOID__ENUM_INT) (gpointer data1, - gint arg_1, - gint arg_2, - gpointer data2); - register GMarshalFunc_VOID__ENUM_INT callback; - register GCClosure *cc = (GCClosure *) closure; - register gpointer data1, data2; - - g_return_if_fail(n_param_values == 3); - - if (G_CCLOSURE_SWAP_DATA(closure)) { - data1 = closure->data; - data2 = g_value_peek_pointer(param_values + 0); - } else { - data1 = g_value_peek_pointer(param_values + 0); - data2 = closure->data; - } - callback = - (GMarshalFunc_VOID__ENUM_INT) (marshal_data ? marshal_data : cc-> - callback); - - callback(data1, - g_marshal_value_peek_enum(param_values + 1), - g_marshal_value_peek_int(param_values + 2), data2); -} |