]> Pileus Git - ~andy/gtk/blob - gtk/gtkentry.c
28ca10ba3c45430d5fab0fab01ace678734d86ff
[~andy/gtk] / gtk / gtkentry.c
1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* GTK - The GIMP Toolkit
3  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
4  * Copyright (C) 2004-2006 Christian Hammond
5  * Copyright (C) 2008 Cody Russell
6  * Copyright (C) 2008 Red Hat, Inc.
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this library; if not, write to the
20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21  * Boston, MA 02111-1307, USA.
22  */
23
24 /*
25  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
26  * file for a list of people on the GTK+ Team.  See the ChangeLog
27  * files for a list of changes.  These files are distributed with
28  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
29  */
30
31 #include "config.h"
32
33 #include <math.h>
34 #include <string.h>
35
36 #include "gtkbindings.h"
37 #include "gtkcelleditable.h"
38 #include "gtkclipboard.h"
39 #include "gtkdnd.h"
40 #include "gtkentry.h"
41 #include "gtkentrybuffer.h"
42 #include "gtkiconhelperprivate.h"
43 #include "gtkimagemenuitem.h"
44 #include "gtkimcontextsimple.h"
45 #include "gtkimmulticontext.h"
46 #include "gtkintl.h"
47 #include "gtklabel.h"
48 #include "gtkmain.h"
49 #include "gtkmarshalers.h"
50 #include "gtkmenu.h"
51 #include "gtkmenuitem.h"
52 #include "gtkseparatormenuitem.h"
53 #include "gtkselection.h"
54 #include "gtksettings.h"
55 #include "gtkspinbutton.h"
56 #include "gtkstock.h"
57 #include "gtktextutil.h"
58 #include "gtkwindow.h"
59 #include "gtktreeview.h"
60 #include "gtktreeselection.h"
61 #include "gtktypebuiltins.h"
62 #include "gtkprivate.h"
63 #include "gtkentryprivate.h"
64 #include "gtkcelllayout.h"
65 #include "gtktooltip.h"
66 #include "gtkiconfactory.h"
67 #include "gtkicontheme.h"
68 #include "gtkwidgetprivate.h"
69 #include "gtkstylecontextprivate.h"
70
71 #include "a11y/gtkentryaccessible.h"
72
73 /**
74  * SECTION:gtkentry
75  * @Short_description: A single line text entry field
76  * @Title: GtkEntry
77  * @See_also: #GtkTextView, #GtkEntryCompletion
78  *
79  * The #GtkEntry widget is a single line text entry
80  * widget. A fairly large set of key bindings are supported
81  * by default. If the entered text is longer than the allocation
82  * of the widget, the widget will scroll so that the cursor
83  * position is visible.
84  *
85  * When using an entry for passwords and other sensitive information,
86  * it can be put into "password mode" using gtk_entry_set_visibility().
87  * In this mode, entered text is displayed using a 'invisible' character.
88  * By default, GTK+ picks the best invisible character that is available
89  * in the current font, but it can be changed with
90  * gtk_entry_set_invisible_char(). Since 2.16, GTK+ displays a warning
91  * when Caps Lock or input methods might interfere with entering text in
92  * a password entry. The warning can be turned off with the
93  * #GtkEntry:caps-lock-warning property.
94  *
95  * Since 2.16, GtkEntry has the ability to display progress or activity
96  * information behind the text. To make an entry display such information,
97  * use gtk_entry_set_progress_fraction() or gtk_entry_set_progress_pulse_step().
98  *
99  * Additionally, GtkEntry can show icons at either side of the entry. These
100  * icons can be activatable by clicking, can be set up as drag source and
101  * can have tooltips. To add an icon, use gtk_entry_set_icon_from_gicon() or
102  * one of the various other functions that set an icon from a stock id, an
103  * icon name or a pixbuf. To trigger an action when the user clicks an icon,
104  * connect to the #GtkEntry::icon-press signal. To allow DND operations
105  * from an icon, use gtk_entry_set_icon_drag_source(). To set a tooltip on
106  * an icon, use gtk_entry_set_icon_tooltip_text() or the corresponding function
107  * for markup.
108  *
109  * Note that functionality or information that is only available by clicking
110  * on an icon in an entry may not be accessible at all to users which are not
111  * able to use a mouse or other pointing device. It is therefore recommended
112  * that any such functionality should also be available by other means, e.g.
113  * via the context menu of the entry.
114  */
115
116
117 #define GTK_ENTRY_COMPLETION_KEY "gtk-entry-completion-key"
118
119 #define MIN_ENTRY_WIDTH  150
120 #define DRAW_TIMEOUT     20
121 #define COMPLETION_TIMEOUT 300
122 #define PASSWORD_HINT_MAX 8
123 #define PAGE_STEP 14
124
125 #define MAX_ICONS 2
126
127 #define IS_VALID_ICON_POSITION(pos)               \
128   ((pos) == GTK_ENTRY_ICON_PRIMARY ||                   \
129    (pos) == GTK_ENTRY_ICON_SECONDARY)
130
131 static const GtkBorder default_inner_border = { 2, 2, 2, 2 };
132 static GQuark          quark_inner_border   = 0;
133 static GQuark          quark_password_hint  = 0;
134 static GQuark          quark_cursor_hadjustment = 0;
135 static GQuark          quark_capslock_feedback = 0;
136
137 typedef struct _EntryIconInfo EntryIconInfo;
138 typedef struct _GtkEntryPasswordHint GtkEntryPasswordHint;
139 typedef struct _GtkEntryCapslockFeedback GtkEntryCapslockFeedback;
140
141 struct _GtkEntryPrivate
142 {
143   EntryIconInfo         *icons[MAX_ICONS];
144
145   GtkEntryBuffer        *buffer;
146   GtkIMContext          *im_context;
147   GtkShadowType          shadow_type;
148   GtkWidget             *popup_menu;
149
150   GdkDevice             *completion_device;
151   GdkWindow             *text_area;
152
153   PangoLayout           *cached_layout;
154
155   gchar        *im_module;
156
157   gdouble       progress_fraction;
158   gdouble       progress_pulse_fraction;
159   gdouble       progress_pulse_current;
160
161   gchar        *placeholder_text;
162
163   gfloat        xalign;
164
165   gint          ascent;                     /* font ascent in pango units  */
166   gint          current_pos;
167   gint          descent;                    /* font descent in pango units */
168   gint          dnd_position;               /* In chars, -1 == no DND cursor */
169   gint          drag_start_x;
170   gint          drag_start_y;
171   gint          focus_width;
172   gint          insert_pos;
173   gint          selection_bound;
174   gint          scroll_offset;
175   gint          start_x;
176   gint          start_y;
177   gint          width_chars;
178
179   gunichar      invisible_char;
180
181   guint         button;
182   guint         blink_time;                  /* time in msec the cursor has blinked since last user event */
183   guint         blink_timeout;
184   guint         recompute_idle;
185
186   guint16       x_text_size;                 /* allocated size, in bytes */
187   guint16       x_n_bytes;                   /* length in use, in bytes */
188
189   guint16       preedit_length;              /* length of preedit string, in bytes */
190   guint16       preedit_cursor;              /* offset of cursor within preedit string, in chars */
191
192   guint         editable                : 1;
193   guint         in_drag                 : 1;
194   guint         overwrite_mode          : 1;
195   guint         visible                 : 1;
196
197   guint         activates_default       : 1;
198   guint         cache_includes_preedit  : 1;
199   guint         caps_lock_warning       : 1;
200   guint         caps_lock_warning_shown : 1;
201   guint         change_count            : 8;
202   guint         cursor_visible          : 1;
203   guint         editing_canceled        : 1; /* Only used by GtkCellRendererText */
204   guint         has_frame               : 1;
205   guint         in_click                : 1; /* Flag so we don't select all when clicking in entry to focus in */
206   guint         is_cell_renderer        : 1;
207   guint         invisible_char_set      : 1;
208   guint         interior_focus          : 1;
209   guint         mouse_cursor_obscured   : 1;
210   guint         need_im_reset           : 1;
211   guint         progress_pulse_mode     : 1;
212   guint         progress_pulse_way_back : 1;
213   guint         real_changed            : 1;
214   guint         resolved_dir            : 4; /* PangoDirection */
215   guint         select_words            : 1;
216   guint         select_lines            : 1;
217   guint         truncate_multiline      : 1;
218 };
219
220 struct _EntryIconInfo
221 {
222   GdkWindow *window;
223   gchar *tooltip;
224   guint insensitive    : 1;
225   guint nonactivatable : 1;
226   guint prelight       : 1;
227   guint in_drag        : 1;
228   guint pressed        : 1;
229
230   GtkIconHelper *icon_helper;
231
232   GtkTargetList *target_list;
233   GdkDragAction actions;
234 };
235
236 struct _GtkEntryPasswordHint
237 {
238   gint position;      /* Position (in text) of the last password hint */
239   guint source_id;    /* Timeout source id */
240 };
241
242 struct _GtkEntryCapslockFeedback
243 {
244   GtkWidget *entry;
245   GtkWidget *window;
246   GtkWidget *label;
247 };
248
249 enum {
250   ACTIVATE,
251   POPULATE_POPUP,
252   MOVE_CURSOR,
253   INSERT_AT_CURSOR,
254   DELETE_FROM_CURSOR,
255   BACKSPACE,
256   CUT_CLIPBOARD,
257   COPY_CLIPBOARD,
258   PASTE_CLIPBOARD,
259   TOGGLE_OVERWRITE,
260   ICON_PRESS,
261   ICON_RELEASE,
262   PREEDIT_CHANGED,
263   LAST_SIGNAL
264 };
265
266 enum {
267   PROP_0,
268   PROP_BUFFER,
269   PROP_CURSOR_POSITION,
270   PROP_SELECTION_BOUND,
271   PROP_EDITABLE,
272   PROP_MAX_LENGTH,
273   PROP_VISIBILITY,
274   PROP_HAS_FRAME,
275   PROP_INNER_BORDER,
276   PROP_INVISIBLE_CHAR,
277   PROP_ACTIVATES_DEFAULT,
278   PROP_WIDTH_CHARS,
279   PROP_SCROLL_OFFSET,
280   PROP_TEXT,
281   PROP_XALIGN,
282   PROP_TRUNCATE_MULTILINE,
283   PROP_SHADOW_TYPE,
284   PROP_OVERWRITE_MODE,
285   PROP_TEXT_LENGTH,
286   PROP_INVISIBLE_CHAR_SET,
287   PROP_CAPS_LOCK_WARNING,
288   PROP_PROGRESS_FRACTION,
289   PROP_PROGRESS_PULSE_STEP,
290   PROP_PIXBUF_PRIMARY,
291   PROP_PIXBUF_SECONDARY,
292   PROP_STOCK_PRIMARY,
293   PROP_STOCK_SECONDARY,
294   PROP_ICON_NAME_PRIMARY,
295   PROP_ICON_NAME_SECONDARY,
296   PROP_GICON_PRIMARY,
297   PROP_GICON_SECONDARY,
298   PROP_STORAGE_TYPE_PRIMARY,
299   PROP_STORAGE_TYPE_SECONDARY,
300   PROP_ACTIVATABLE_PRIMARY,
301   PROP_ACTIVATABLE_SECONDARY,
302   PROP_SENSITIVE_PRIMARY,
303   PROP_SENSITIVE_SECONDARY,
304   PROP_TOOLTIP_TEXT_PRIMARY,
305   PROP_TOOLTIP_TEXT_SECONDARY,
306   PROP_TOOLTIP_MARKUP_PRIMARY,
307   PROP_TOOLTIP_MARKUP_SECONDARY,
308   PROP_IM_MODULE,
309   PROP_EDITING_CANCELED,
310   PROP_PLACEHOLDER_TEXT,
311   PROP_COMPLETION
312 };
313
314 static guint signals[LAST_SIGNAL] = { 0 };
315
316 typedef enum {
317   CURSOR_STANDARD,
318   CURSOR_DND
319 } CursorType;
320
321 typedef enum
322 {
323   DISPLAY_NORMAL,       /* The entry text is being shown */
324   DISPLAY_INVISIBLE,    /* In invisible mode, text replaced by (eg) bullets */
325   DISPLAY_BLANK         /* In invisible mode, nothing shown at all */
326 } DisplayMode;
327
328 /* GObject methods
329  */
330 static void   gtk_entry_editable_init        (GtkEditableInterface *iface);
331 static void   gtk_entry_cell_editable_init   (GtkCellEditableIface *iface);
332 static void   gtk_entry_set_property         (GObject          *object,
333                                               guint             prop_id,
334                                               const GValue     *value,
335                                               GParamSpec       *pspec);
336 static void   gtk_entry_get_property         (GObject          *object,
337                                               guint             prop_id,
338                                               GValue           *value,
339                                               GParamSpec       *pspec);
340 static void   gtk_entry_finalize             (GObject          *object);
341 static void   gtk_entry_dispose              (GObject          *object);
342
343 /* GtkWidget methods
344  */
345 static void   gtk_entry_destroy              (GtkWidget        *widget);
346 static void   gtk_entry_realize              (GtkWidget        *widget);
347 static void   gtk_entry_unrealize            (GtkWidget        *widget);
348 static void   gtk_entry_map                  (GtkWidget        *widget);
349 static void   gtk_entry_unmap                (GtkWidget        *widget);
350 static void   gtk_entry_get_preferred_width  (GtkWidget        *widget,
351                                               gint             *minimum,
352                                               gint             *natural);
353 static void   gtk_entry_get_preferred_height (GtkWidget        *widget,
354                                               gint             *minimum,
355                                               gint             *natural);
356 static void   gtk_entry_size_allocate        (GtkWidget        *widget,
357                                               GtkAllocation    *allocation);
358 static void   gtk_entry_draw_frame           (GtkWidget        *widget,
359                                               GtkStyleContext  *context,
360                                               cairo_t          *cr);
361 static void   gtk_entry_draw_progress        (GtkWidget        *widget,
362                                               GtkStyleContext  *context,
363                                               cairo_t          *cr);
364 static gint   gtk_entry_draw                 (GtkWidget        *widget,
365                                               cairo_t          *cr);
366 static gint   gtk_entry_button_press         (GtkWidget        *widget,
367                                               GdkEventButton   *event);
368 static gint   gtk_entry_button_release       (GtkWidget        *widget,
369                                               GdkEventButton   *event);
370 static gint   gtk_entry_enter_notify         (GtkWidget        *widget,
371                                               GdkEventCrossing *event);
372 static gint   gtk_entry_leave_notify         (GtkWidget        *widget,
373                                               GdkEventCrossing *event);
374 static gint   gtk_entry_motion_notify        (GtkWidget        *widget,
375                                               GdkEventMotion   *event);
376 static gint   gtk_entry_key_press            (GtkWidget        *widget,
377                                               GdkEventKey      *event);
378 static gint   gtk_entry_key_release          (GtkWidget        *widget,
379                                               GdkEventKey      *event);
380 static gint   gtk_entry_focus_in             (GtkWidget        *widget,
381                                               GdkEventFocus    *event);
382 static gint   gtk_entry_focus_out            (GtkWidget        *widget,
383                                               GdkEventFocus    *event);
384 static void   gtk_entry_grab_focus           (GtkWidget        *widget);
385 static void   gtk_entry_style_updated        (GtkWidget        *widget);
386 static gboolean gtk_entry_query_tooltip      (GtkWidget        *widget,
387                                               gint              x,
388                                               gint              y,
389                                               gboolean          keyboard_tip,
390                                               GtkTooltip       *tooltip);
391 static void   gtk_entry_direction_changed    (GtkWidget        *widget,
392                                               GtkTextDirection  previous_dir);
393 static void   gtk_entry_state_flags_changed  (GtkWidget        *widget,
394                                               GtkStateFlags     previous_state);
395 static void   gtk_entry_screen_changed       (GtkWidget        *widget,
396                                               GdkScreen        *old_screen);
397
398 static gboolean gtk_entry_drag_drop          (GtkWidget        *widget,
399                                               GdkDragContext   *context,
400                                               gint              x,
401                                               gint              y,
402                                               guint             time);
403 static gboolean gtk_entry_drag_motion        (GtkWidget        *widget,
404                                               GdkDragContext   *context,
405                                               gint              x,
406                                               gint              y,
407                                               guint             time);
408 static void     gtk_entry_drag_leave         (GtkWidget        *widget,
409                                               GdkDragContext   *context,
410                                               guint             time);
411 static void     gtk_entry_drag_data_received (GtkWidget        *widget,
412                                               GdkDragContext   *context,
413                                               gint              x,
414                                               gint              y,
415                                               GtkSelectionData *selection_data,
416                                               guint             info,
417                                               guint             time);
418 static void     gtk_entry_drag_data_get      (GtkWidget        *widget,
419                                               GdkDragContext   *context,
420                                               GtkSelectionData *selection_data,
421                                               guint             info,
422                                               guint             time);
423 static void     gtk_entry_drag_data_delete   (GtkWidget        *widget,
424                                               GdkDragContext   *context);
425 static void     gtk_entry_drag_begin         (GtkWidget        *widget,
426                                               GdkDragContext   *context);
427 static void     gtk_entry_drag_end           (GtkWidget        *widget,
428                                               GdkDragContext   *context);
429
430
431 /* GtkEditable method implementations
432  */
433 static void     gtk_entry_insert_text          (GtkEditable *editable,
434                                                 const gchar *new_text,
435                                                 gint         new_text_length,
436                                                 gint        *position);
437 static void     gtk_entry_delete_text          (GtkEditable *editable,
438                                                 gint         start_pos,
439                                                 gint         end_pos);
440 static gchar *  gtk_entry_get_chars            (GtkEditable *editable,
441                                                 gint         start_pos,
442                                                 gint         end_pos);
443 static void     gtk_entry_real_set_position    (GtkEditable *editable,
444                                                 gint         position);
445 static gint     gtk_entry_get_position         (GtkEditable *editable);
446 static void     gtk_entry_set_selection_bounds (GtkEditable *editable,
447                                                 gint         start,
448                                                 gint         end);
449 static gboolean gtk_entry_get_selection_bounds (GtkEditable *editable,
450                                                 gint        *start,
451                                                 gint        *end);
452
453 /* GtkCellEditable method implementations
454  */
455 static void gtk_entry_start_editing (GtkCellEditable *cell_editable,
456                                      GdkEvent        *event);
457
458 /* Default signal handlers
459  */
460 static void gtk_entry_real_insert_text   (GtkEditable     *editable,
461                                           const gchar     *new_text,
462                                           gint             new_text_length,
463                                           gint            *position);
464 static void gtk_entry_real_delete_text   (GtkEditable     *editable,
465                                           gint             start_pos,
466                                           gint             end_pos);
467 static void gtk_entry_move_cursor        (GtkEntry        *entry,
468                                           GtkMovementStep  step,
469                                           gint             count,
470                                           gboolean         extend_selection);
471 static void gtk_entry_insert_at_cursor   (GtkEntry        *entry,
472                                           const gchar     *str);
473 static void gtk_entry_delete_from_cursor (GtkEntry        *entry,
474                                           GtkDeleteType    type,
475                                           gint             count);
476 static void gtk_entry_backspace          (GtkEntry        *entry);
477 static void gtk_entry_cut_clipboard      (GtkEntry        *entry);
478 static void gtk_entry_copy_clipboard     (GtkEntry        *entry);
479 static void gtk_entry_paste_clipboard    (GtkEntry        *entry);
480 static void gtk_entry_toggle_overwrite   (GtkEntry        *entry);
481 static void gtk_entry_select_all         (GtkEntry        *entry);
482 static void gtk_entry_real_activate      (GtkEntry        *entry);
483 static gboolean gtk_entry_popup_menu     (GtkWidget       *widget);
484
485 static void keymap_direction_changed     (GdkKeymap       *keymap,
486                                           GtkEntry        *entry);
487 static void keymap_state_changed         (GdkKeymap       *keymap,
488                                           GtkEntry        *entry);
489 static void remove_capslock_feedback     (GtkEntry        *entry);
490
491 /* IM Context Callbacks
492  */
493 static void     gtk_entry_commit_cb               (GtkIMContext *context,
494                                                    const gchar  *str,
495                                                    GtkEntry     *entry);
496 static void     gtk_entry_preedit_changed_cb      (GtkIMContext *context,
497                                                    GtkEntry     *entry);
498 static gboolean gtk_entry_retrieve_surrounding_cb (GtkIMContext *context,
499                                                    GtkEntry     *entry);
500 static gboolean gtk_entry_delete_surrounding_cb   (GtkIMContext *context,
501                                                    gint          offset,
502                                                    gint          n_chars,
503                                                    GtkEntry     *entry);
504
505 /* Internal routines
506  */
507 static void         gtk_entry_enter_text               (GtkEntry       *entry,
508                                                         const gchar    *str);
509 static void         gtk_entry_set_positions            (GtkEntry       *entry,
510                                                         gint            current_pos,
511                                                         gint            selection_bound);
512 static void         gtk_entry_draw_text                (GtkEntry       *entry,
513                                                         cairo_t        *cr);
514 static void         gtk_entry_draw_cursor              (GtkEntry       *entry,
515                                                         cairo_t        *cr,
516                                                         CursorType      type);
517 static PangoLayout *gtk_entry_ensure_layout            (GtkEntry       *entry,
518                                                         gboolean        include_preedit);
519 static void         gtk_entry_reset_layout             (GtkEntry       *entry);
520 static void         gtk_entry_recompute                (GtkEntry       *entry);
521 static gint         gtk_entry_find_position            (GtkEntry       *entry,
522                                                         gint            x);
523 static void         gtk_entry_get_cursor_locations     (GtkEntry       *entry,
524                                                         CursorType      type,
525                                                         gint           *strong_x,
526                                                         gint           *weak_x);
527 static void         gtk_entry_adjust_scroll            (GtkEntry       *entry);
528 static gint         gtk_entry_move_visually            (GtkEntry       *editable,
529                                                         gint            start,
530                                                         gint            count);
531 static gint         gtk_entry_move_logically           (GtkEntry       *entry,
532                                                         gint            start,
533                                                         gint            count);
534 static gint         gtk_entry_move_forward_word        (GtkEntry       *entry,
535                                                         gint            start,
536                                                         gboolean        allow_whitespace);
537 static gint         gtk_entry_move_backward_word       (GtkEntry       *entry,
538                                                         gint            start,
539                                                         gboolean        allow_whitespace);
540 static void         gtk_entry_delete_whitespace        (GtkEntry       *entry);
541 static void         gtk_entry_select_word              (GtkEntry       *entry);
542 static void         gtk_entry_select_line              (GtkEntry       *entry);
543 static void         gtk_entry_paste                    (GtkEntry       *entry,
544                                                         GdkAtom         selection);
545 static void         gtk_entry_update_primary_selection (GtkEntry       *entry);
546 static void         gtk_entry_do_popup                 (GtkEntry       *entry,
547                                                         GdkEventButton *event);
548 static gboolean     gtk_entry_mnemonic_activate        (GtkWidget      *widget,
549                                                         gboolean        group_cycling);
550 static void         gtk_entry_check_cursor_blink       (GtkEntry       *entry);
551 static void         gtk_entry_pend_cursor_blink        (GtkEntry       *entry);
552 static void         gtk_entry_reset_blink_time         (GtkEntry       *entry);
553 static void         gtk_entry_get_text_area_size       (GtkEntry       *entry,
554                                                         gint           *x,
555                                                         gint           *y,
556                                                         gint           *width,
557                                                         gint           *height);
558 static void         get_text_area_size                 (GtkEntry       *entry,
559                                                         gint           *x,
560                                                         gint           *y,
561                                                         gint           *width,
562                                                         gint           *height);
563 static void         get_frame_size                     (GtkEntry       *entry,
564                                                         gboolean        relative_to_window,
565                                                         gint           *x,
566                                                         gint           *y,
567                                                         gint           *width,
568                                                         gint           *height);
569 static void         gtk_entry_move_adjustments         (GtkEntry             *entry);
570 static GdkPixbuf *  gtk_entry_ensure_pixbuf            (GtkEntry             *entry,
571                                                         GtkEntryIconPosition  icon_pos);
572 static void         gtk_entry_update_cached_style_values(GtkEntry      *entry);
573
574 /* Completion */
575 static gint         gtk_entry_completion_timeout       (gpointer            data);
576 static gboolean     gtk_entry_completion_key_press     (GtkWidget          *widget,
577                                                         GdkEventKey        *event,
578                                                         gpointer            user_data);
579 static void         gtk_entry_completion_changed       (GtkWidget          *entry,
580                                                         gpointer            user_data);
581 static gboolean     check_completion_callback          (GtkEntryCompletion *completion);
582 static void         clear_completion_callback          (GtkEntry           *entry,
583                                                         GParamSpec         *pspec);
584 static gboolean     accept_completion_callback         (GtkEntry           *entry);
585 static void         completion_insert_text_callback    (GtkEntry           *entry,
586                                                         const gchar        *text,
587                                                         gint                length,
588                                                         gint                position,
589                                                         GtkEntryCompletion *completion);
590 static void         completion_changed                 (GtkEntryCompletion *completion,
591                                                         GParamSpec         *pspec,
592                                                         gpointer            data);
593 static void         disconnect_completion_signals      (GtkEntry           *entry,
594                                                         GtkEntryCompletion *completion);
595 static void         connect_completion_signals         (GtkEntry           *entry,
596                                                         GtkEntryCompletion *completion);
597
598 static void         begin_change                       (GtkEntry *entry);
599 static void         end_change                         (GtkEntry *entry);
600 static void         emit_changed                       (GtkEntry *entry);
601
602 static void         buffer_inserted_text               (GtkEntryBuffer *buffer, 
603                                                         guint           position,
604                                                         const gchar    *chars,
605                                                         guint           n_chars,
606                                                         GtkEntry       *entry);
607 static void         buffer_deleted_text                (GtkEntryBuffer *buffer, 
608                                                         guint           position,
609                                                         guint           n_chars,
610                                                         GtkEntry       *entry);
611 static void         buffer_notify_text                 (GtkEntryBuffer *buffer, 
612                                                         GParamSpec     *spec,
613                                                         GtkEntry       *entry);
614 static void         buffer_notify_length               (GtkEntryBuffer *buffer, 
615                                                         GParamSpec     *spec,
616                                                         GtkEntry       *entry);
617 static void         buffer_notify_max_length           (GtkEntryBuffer *buffer, 
618                                                         GParamSpec     *spec,
619                                                         GtkEntry       *entry);
620 static void         buffer_connect_signals             (GtkEntry       *entry);
621 static void         buffer_disconnect_signals          (GtkEntry       *entry);
622 static GtkEntryBuffer *get_buffer                      (GtkEntry       *entry);
623
624 G_DEFINE_TYPE_WITH_CODE (GtkEntry, gtk_entry, GTK_TYPE_WIDGET,
625                          G_IMPLEMENT_INTERFACE (GTK_TYPE_EDITABLE,
626                                                 gtk_entry_editable_init)
627                          G_IMPLEMENT_INTERFACE (GTK_TYPE_CELL_EDITABLE,
628                                                 gtk_entry_cell_editable_init))
629
630 static void
631 add_move_binding (GtkBindingSet  *binding_set,
632                   guint           keyval,
633                   guint           modmask,
634                   GtkMovementStep step,
635                   gint            count)
636 {
637   g_return_if_fail ((modmask & GDK_SHIFT_MASK) == 0);
638   
639   gtk_binding_entry_add_signal (binding_set, keyval, modmask,
640                                 "move-cursor", 3,
641                                 G_TYPE_ENUM, step,
642                                 G_TYPE_INT, count,
643                                 G_TYPE_BOOLEAN, FALSE);
644
645   /* Selection-extending version */
646   gtk_binding_entry_add_signal (binding_set, keyval, modmask | GDK_SHIFT_MASK,
647                                 "move-cursor", 3,
648                                 G_TYPE_ENUM, step,
649                                 G_TYPE_INT, count,
650                                 G_TYPE_BOOLEAN, TRUE);
651 }
652
653 static void
654 gtk_entry_class_init (GtkEntryClass *class)
655 {
656   GObjectClass *gobject_class = G_OBJECT_CLASS (class);
657   GtkWidgetClass *widget_class;
658   GtkBindingSet *binding_set;
659
660   widget_class = (GtkWidgetClass*) class;
661
662   gobject_class->dispose = gtk_entry_dispose;
663   gobject_class->finalize = gtk_entry_finalize;
664   gobject_class->set_property = gtk_entry_set_property;
665   gobject_class->get_property = gtk_entry_get_property;
666
667   widget_class->destroy = gtk_entry_destroy;
668   widget_class->map = gtk_entry_map;
669   widget_class->unmap = gtk_entry_unmap;
670   widget_class->realize = gtk_entry_realize;
671   widget_class->unrealize = gtk_entry_unrealize;
672   widget_class->get_preferred_width = gtk_entry_get_preferred_width;
673   widget_class->get_preferred_height = gtk_entry_get_preferred_height;
674   widget_class->size_allocate = gtk_entry_size_allocate;
675   widget_class->draw = gtk_entry_draw;
676   widget_class->enter_notify_event = gtk_entry_enter_notify;
677   widget_class->leave_notify_event = gtk_entry_leave_notify;
678   widget_class->button_press_event = gtk_entry_button_press;
679   widget_class->button_release_event = gtk_entry_button_release;
680   widget_class->motion_notify_event = gtk_entry_motion_notify;
681   widget_class->key_press_event = gtk_entry_key_press;
682   widget_class->key_release_event = gtk_entry_key_release;
683   widget_class->focus_in_event = gtk_entry_focus_in;
684   widget_class->focus_out_event = gtk_entry_focus_out;
685   widget_class->grab_focus = gtk_entry_grab_focus;
686   widget_class->style_updated = gtk_entry_style_updated;
687   widget_class->query_tooltip = gtk_entry_query_tooltip;
688   widget_class->drag_begin = gtk_entry_drag_begin;
689   widget_class->drag_end = gtk_entry_drag_end;
690   widget_class->direction_changed = gtk_entry_direction_changed;
691   widget_class->state_flags_changed = gtk_entry_state_flags_changed;
692   widget_class->screen_changed = gtk_entry_screen_changed;
693   widget_class->mnemonic_activate = gtk_entry_mnemonic_activate;
694
695   widget_class->drag_drop = gtk_entry_drag_drop;
696   widget_class->drag_motion = gtk_entry_drag_motion;
697   widget_class->drag_leave = gtk_entry_drag_leave;
698   widget_class->drag_data_received = gtk_entry_drag_data_received;
699   widget_class->drag_data_get = gtk_entry_drag_data_get;
700   widget_class->drag_data_delete = gtk_entry_drag_data_delete;
701
702   widget_class->popup_menu = gtk_entry_popup_menu;
703
704   class->move_cursor = gtk_entry_move_cursor;
705   class->insert_at_cursor = gtk_entry_insert_at_cursor;
706   class->delete_from_cursor = gtk_entry_delete_from_cursor;
707   class->backspace = gtk_entry_backspace;
708   class->cut_clipboard = gtk_entry_cut_clipboard;
709   class->copy_clipboard = gtk_entry_copy_clipboard;
710   class->paste_clipboard = gtk_entry_paste_clipboard;
711   class->toggle_overwrite = gtk_entry_toggle_overwrite;
712   class->activate = gtk_entry_real_activate;
713   class->get_text_area_size = gtk_entry_get_text_area_size;
714   
715   quark_inner_border = g_quark_from_static_string ("gtk-entry-inner-border");
716   quark_password_hint = g_quark_from_static_string ("gtk-entry-password-hint");
717   quark_cursor_hadjustment = g_quark_from_static_string ("gtk-hadjustment");
718   quark_capslock_feedback = g_quark_from_static_string ("gtk-entry-capslock-feedback");
719
720   g_object_class_override_property (gobject_class,
721                                     PROP_EDITING_CANCELED,
722                                     "editing-canceled");
723
724   g_object_class_install_property (gobject_class,
725                                    PROP_BUFFER,
726                                    g_param_spec_object ("buffer",
727                                                         P_("Text Buffer"),
728                                                         P_("Text buffer object which actually stores entry text"),
729                                                         GTK_TYPE_ENTRY_BUFFER,
730                                                         GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));
731
732   g_object_class_install_property (gobject_class,
733                                    PROP_CURSOR_POSITION,
734                                    g_param_spec_int ("cursor-position",
735                                                      P_("Cursor Position"),
736                                                      P_("The current position of the insertion cursor in chars"),
737                                                      0,
738                                                      GTK_ENTRY_BUFFER_MAX_SIZE,
739                                                      0,
740                                                      GTK_PARAM_READABLE));
741   
742   g_object_class_install_property (gobject_class,
743                                    PROP_SELECTION_BOUND,
744                                    g_param_spec_int ("selection-bound",
745                                                      P_("Selection Bound"),
746                                                      P_("The position of the opposite end of the selection from the cursor in chars"),
747                                                      0,
748                                                      GTK_ENTRY_BUFFER_MAX_SIZE,
749                                                      0,
750                                                      GTK_PARAM_READABLE));
751   
752   g_object_class_install_property (gobject_class,
753                                    PROP_EDITABLE,
754                                    g_param_spec_boolean ("editable",
755                                                          P_("Editable"),
756                                                          P_("Whether the entry contents can be edited"),
757                                                          TRUE,
758                                                          GTK_PARAM_READWRITE));
759   
760   g_object_class_install_property (gobject_class,
761                                    PROP_MAX_LENGTH,
762                                    g_param_spec_int ("max-length",
763                                                      P_("Maximum length"),
764                                                      P_("Maximum number of characters for this entry. Zero if no maximum"),
765                                                      0,
766                                                      GTK_ENTRY_BUFFER_MAX_SIZE,
767                                                      0,
768                                                      GTK_PARAM_READWRITE));
769   g_object_class_install_property (gobject_class,
770                                    PROP_VISIBILITY,
771                                    g_param_spec_boolean ("visibility",
772                                                          P_("Visibility"),
773                                                          P_("FALSE displays the \"invisible char\" instead of the actual text (password mode)"),
774                                                          TRUE,
775                                                          GTK_PARAM_READWRITE));
776
777   g_object_class_install_property (gobject_class,
778                                    PROP_HAS_FRAME,
779                                    g_param_spec_boolean ("has-frame",
780                                                          P_("Has Frame"),
781                                                          P_("FALSE removes outside bevel from entry"),
782                                                          TRUE,
783                                                          GTK_PARAM_READWRITE));
784
785   /**
786    * GtkEntry:inner-border:
787    *
788    * Sets the text area's border between the text and the frame.
789    *
790    * Deprecated: 3.4: Use the standard border and padding CSS properties;
791    *   the value of this style property is ignored.
792    */
793   g_object_class_install_property (gobject_class,
794                                    PROP_INNER_BORDER,
795                                    g_param_spec_boxed ("inner-border",
796                                                        P_("Inner Border"),
797                                                        P_("Border between text and frame. Overrides the inner-border style property"),
798                                                        GTK_TYPE_BORDER,
799                                                        GTK_PARAM_READWRITE |
800                                                        G_PARAM_DEPRECATED));
801
802   g_object_class_install_property (gobject_class,
803                                    PROP_INVISIBLE_CHAR,
804                                    g_param_spec_unichar ("invisible-char",
805                                                          P_("Invisible character"),
806                                                          P_("The character to use when masking entry contents (in \"password mode\")"),
807                                                          '*',
808                                                          GTK_PARAM_READWRITE));
809
810   g_object_class_install_property (gobject_class,
811                                    PROP_ACTIVATES_DEFAULT,
812                                    g_param_spec_boolean ("activates-default",
813                                                          P_("Activates default"),
814                                                          P_("Whether to activate the default widget (such as the default button in a dialog) when Enter is pressed"),
815                                                          FALSE,
816                                                          GTK_PARAM_READWRITE));
817   g_object_class_install_property (gobject_class,
818                                    PROP_WIDTH_CHARS,
819                                    g_param_spec_int ("width-chars",
820                                                      P_("Width in chars"),
821                                                      P_("Number of characters to leave space for in the entry"),
822                                                      -1,
823                                                      G_MAXINT,
824                                                      -1,
825                                                      GTK_PARAM_READWRITE));
826
827   g_object_class_install_property (gobject_class,
828                                    PROP_SCROLL_OFFSET,
829                                    g_param_spec_int ("scroll-offset",
830                                                      P_("Scroll offset"),
831                                                      P_("Number of pixels of the entry scrolled off the screen to the left"),
832                                                      0,
833                                                      G_MAXINT,
834                                                      0,
835                                                      GTK_PARAM_READABLE));
836
837   g_object_class_install_property (gobject_class,
838                                    PROP_TEXT,
839                                    g_param_spec_string ("text",
840                                                         P_("Text"),
841                                                         P_("The contents of the entry"),
842                                                         "",
843                                                         GTK_PARAM_READWRITE));
844
845   /**
846    * GtkEntry:xalign:
847    *
848    * The horizontal alignment, from 0 (left) to 1 (right). 
849    * Reversed for RTL layouts.
850    * 
851    * Since: 2.4
852    */
853   g_object_class_install_property (gobject_class,
854                                    PROP_XALIGN,
855                                    g_param_spec_float ("xalign",
856                                                        P_("X align"),
857                                                        P_("The horizontal alignment, from 0 (left) to 1 (right). Reversed for RTL layouts."),
858                                                        0.0,
859                                                        1.0,
860                                                        0.0,
861                                                        GTK_PARAM_READWRITE));
862
863   /**
864    * GtkEntry:truncate-multiline:
865    *
866    * When %TRUE, pasted multi-line text is truncated to the first line.
867    *
868    * Since: 2.10
869    */
870   g_object_class_install_property (gobject_class,
871                                    PROP_TRUNCATE_MULTILINE,
872                                    g_param_spec_boolean ("truncate-multiline",
873                                                          P_("Truncate multiline"),
874                                                          P_("Whether to truncate multiline pastes to one line."),
875                                                          FALSE,
876                                                          GTK_PARAM_READWRITE));
877
878   /**
879    * GtkEntry:shadow-type:
880    *
881    * Which kind of shadow to draw around the entry when 
882    * #GtkEntry:has-frame is set to %TRUE.
883    *
884    * Since: 2.12
885    */
886   g_object_class_install_property (gobject_class,
887                                    PROP_SHADOW_TYPE,
888                                    g_param_spec_enum ("shadow-type",
889                                                       P_("Shadow type"),
890                                                       P_("Which kind of shadow to draw around the entry when has-frame is set"),
891                                                       GTK_TYPE_SHADOW_TYPE,
892                                                       GTK_SHADOW_IN,
893                                                       GTK_PARAM_READWRITE));
894
895   /**
896    * GtkEntry:overwrite-mode:
897    *
898    * If text is overwritten when typing in the #GtkEntry.
899    *
900    * Since: 2.14
901    */
902   g_object_class_install_property (gobject_class,
903                                    PROP_OVERWRITE_MODE,
904                                    g_param_spec_boolean ("overwrite-mode",
905                                                          P_("Overwrite mode"),
906                                                          P_("Whether new text overwrites existing text"),
907                                                          FALSE,
908                                                          GTK_PARAM_READWRITE));
909
910   /**
911    * GtkEntry:text-length:
912    *
913    * The length of the text in the #GtkEntry.
914    *
915    * Since: 2.14
916    */
917   g_object_class_install_property (gobject_class,
918                                    PROP_TEXT_LENGTH,
919                                    g_param_spec_uint ("text-length",
920                                                       P_("Text length"),
921                                                       P_("Length of the text currently in the entry"),
922                                                       0, 
923                                                       G_MAXUINT16,
924                                                       0,
925                                                       GTK_PARAM_READABLE));
926   /**
927    * GtkEntry:invisible-char-set:
928    *
929    * Whether the invisible char has been set for the #GtkEntry.
930    *
931    * Since: 2.16
932    */
933   g_object_class_install_property (gobject_class,
934                                    PROP_INVISIBLE_CHAR_SET,
935                                    g_param_spec_boolean ("invisible-char-set",
936                                                          P_("Invisible character set"),
937                                                          P_("Whether the invisible character has been set"),
938                                                          FALSE,
939                                                          GTK_PARAM_READWRITE));
940
941   /**
942    * GtkEntry:caps-lock-warning
943    *
944    * Whether password entries will show a warning when Caps Lock is on.
945    *
946    * Note that the warning is shown using a secondary icon, and thus
947    * does not work if you are using the secondary icon position for some 
948    * other purpose.
949    *
950    * Since: 2.16
951    */
952   g_object_class_install_property (gobject_class,
953                                    PROP_CAPS_LOCK_WARNING,
954                                    g_param_spec_boolean ("caps-lock-warning",
955                                                          P_("Caps Lock warning"),
956                                                          P_("Whether password entries will show a warning when Caps Lock is on"),
957                                                          TRUE,
958                                                          GTK_PARAM_READWRITE));
959
960   /**
961    * GtkEntry:progress-fraction:
962    *
963    * The current fraction of the task that's been completed.
964    *
965    * Since: 2.16
966    */
967   g_object_class_install_property (gobject_class,
968                                    PROP_PROGRESS_FRACTION,
969                                    g_param_spec_double ("progress-fraction",
970                                                         P_("Progress Fraction"),
971                                                         P_("The current fraction of the task that's been completed"),
972                                                         0.0,
973                                                         1.0,
974                                                         0.0,
975                                                         GTK_PARAM_READWRITE));
976
977   /**
978    * GtkEntry:progress-pulse-step:
979    *
980    * The fraction of total entry width to move the progress
981    * bouncing block for each call to gtk_entry_progress_pulse().
982    *
983    * Since: 2.16
984    */
985   g_object_class_install_property (gobject_class,
986                                    PROP_PROGRESS_PULSE_STEP,
987                                    g_param_spec_double ("progress-pulse-step",
988                                                         P_("Progress Pulse Step"),
989                                                         P_("The fraction of total entry width to move the progress bouncing block for each call to gtk_entry_progress_pulse()"),
990                                                         0.0,
991                                                         1.0,
992                                                         0.1,
993                                                         GTK_PARAM_READWRITE));
994
995   /**
996   * GtkEntry:placeholder-text:
997   *
998   * The text that will be displayed in the #GtkEntry when it is empty
999   * and unfocused.
1000   *
1001   * Since: 3.2
1002   */
1003  g_object_class_install_property (gobject_class,
1004                                   PROP_PLACEHOLDER_TEXT,
1005                                   g_param_spec_string ("placeholder-text",
1006                                                        P_("Placeholder text"),
1007                                                        P_("Show text in the entry when it's empty and unfocused"),
1008                                                        NULL,
1009                                                        GTK_PARAM_READWRITE));
1010
1011    /**
1012    * GtkEntry:primary-icon-pixbuf:
1013    *
1014    * A pixbuf to use as the primary icon for the entry.
1015    *
1016    * Since: 2.16
1017    */
1018   g_object_class_install_property (gobject_class,
1019                                    PROP_PIXBUF_PRIMARY,
1020                                    g_param_spec_object ("primary-icon-pixbuf",
1021                                                         P_("Primary pixbuf"),
1022                                                         P_("Primary pixbuf for the entry"),
1023                                                         GDK_TYPE_PIXBUF,
1024                                                         GTK_PARAM_READWRITE));
1025   
1026   /**
1027    * GtkEntry:secondary-icon-pixbuf:
1028    *
1029    * An pixbuf to use as the secondary icon for the entry.
1030    *
1031    * Since: 2.16
1032    */
1033   g_object_class_install_property (gobject_class,
1034                                    PROP_PIXBUF_SECONDARY,
1035                                    g_param_spec_object ("secondary-icon-pixbuf",
1036                                                         P_("Secondary pixbuf"),
1037                                                         P_("Secondary pixbuf for the entry"),
1038                                                         GDK_TYPE_PIXBUF,
1039                                                         GTK_PARAM_READWRITE));
1040
1041   /**
1042    * GtkEntry:primary-icon-stock:
1043    *
1044    * The stock id to use for the primary icon for the entry.
1045    *
1046    * Since: 2.16
1047    */
1048   g_object_class_install_property (gobject_class,
1049                                    PROP_STOCK_PRIMARY,
1050                                    g_param_spec_string ("primary-icon-stock",
1051                                                         P_("Primary stock ID"),
1052                                                         P_("Stock ID for primary icon"),
1053                                                         NULL,
1054                                                         GTK_PARAM_READWRITE));
1055
1056   /**
1057    * GtkEntry:secondary-icon-stock:
1058    *
1059    * The stock id to use for the secondary icon for the entry.
1060    *
1061    * Since: 2.16
1062    */
1063   g_object_class_install_property (gobject_class,
1064                                    PROP_STOCK_SECONDARY,
1065                                    g_param_spec_string ("secondary-icon-stock",
1066                                                         P_("Secondary stock ID"),
1067                                                         P_("Stock ID for secondary icon"),
1068                                                         NULL,
1069                                                         GTK_PARAM_READWRITE));
1070   
1071   /**
1072    * GtkEntry:primary-icon-name:
1073    *
1074    * The icon name to use for the primary icon for the entry.
1075    *
1076    * Since: 2.16
1077    */
1078   g_object_class_install_property (gobject_class,
1079                                    PROP_ICON_NAME_PRIMARY,
1080                                    g_param_spec_string ("primary-icon-name",
1081                                                         P_("Primary icon name"),
1082                                                         P_("Icon name for primary icon"),
1083                                                         NULL,
1084                                                         GTK_PARAM_READWRITE));
1085   
1086   /**
1087    * GtkEntry:secondary-icon-name:
1088    *
1089    * The icon name to use for the secondary icon for the entry.
1090    *
1091    * Since: 2.16
1092    */
1093   g_object_class_install_property (gobject_class,
1094                                    PROP_ICON_NAME_SECONDARY,
1095                                    g_param_spec_string ("secondary-icon-name",
1096                                                         P_("Secondary icon name"),
1097                                                         P_("Icon name for secondary icon"),
1098                                                         NULL,
1099                                                         GTK_PARAM_READWRITE));
1100   
1101   /**
1102    * GtkEntry:primary-icon-gicon:
1103    *
1104    * The #GIcon to use for the primary icon for the entry.
1105    *
1106    * Since: 2.16
1107    */
1108   g_object_class_install_property (gobject_class,
1109                                    PROP_GICON_PRIMARY,
1110                                    g_param_spec_object ("primary-icon-gicon",
1111                                                         P_("Primary GIcon"),
1112                                                         P_("GIcon for primary icon"),
1113                                                         G_TYPE_ICON,
1114                                                         GTK_PARAM_READWRITE));
1115   
1116   /**
1117    * GtkEntry:secondary-icon-gicon:
1118    *
1119    * The #GIcon to use for the secondary icon for the entry.
1120    *
1121    * Since: 2.16
1122    */
1123   g_object_class_install_property (gobject_class,
1124                                    PROP_GICON_SECONDARY,
1125                                    g_param_spec_object ("secondary-icon-gicon",
1126                                                         P_("Secondary GIcon"),
1127                                                         P_("GIcon for secondary icon"),
1128                                                         G_TYPE_ICON,
1129                                                         GTK_PARAM_READWRITE));
1130   
1131   /**
1132    * GtkEntry:primary-icon-storage-type:
1133    *
1134    * The representation which is used for the primary icon of the entry.
1135    *
1136    * Since: 2.16
1137    */
1138   g_object_class_install_property (gobject_class,
1139                                    PROP_STORAGE_TYPE_PRIMARY,
1140                                    g_param_spec_enum ("primary-icon-storage-type",
1141                                                       P_("Primary storage type"),
1142                                                       P_("The representation being used for primary icon"),
1143                                                       GTK_TYPE_IMAGE_TYPE,
1144                                                       GTK_IMAGE_EMPTY,
1145                                                       GTK_PARAM_READABLE));
1146   
1147   /**
1148    * GtkEntry:secondary-icon-storage-type:
1149    *
1150    * The representation which is used for the secondary icon of the entry.
1151    *
1152    * Since: 2.16
1153    */
1154   g_object_class_install_property (gobject_class,
1155                                    PROP_STORAGE_TYPE_SECONDARY,
1156                                    g_param_spec_enum ("secondary-icon-storage-type",
1157                                                       P_("Secondary storage type"),
1158                                                       P_("The representation being used for secondary icon"),
1159                                                       GTK_TYPE_IMAGE_TYPE,
1160                                                       GTK_IMAGE_EMPTY,
1161                                                       GTK_PARAM_READABLE));
1162   
1163   /**
1164    * GtkEntry:primary-icon-activatable:
1165    *
1166    * Whether the primary icon is activatable.
1167    *
1168    * GTK+ emits the #GtkEntry::icon-press and #GtkEntry::icon-release 
1169    * signals only on sensitive, activatable icons. 
1170    *
1171    * Sensitive, but non-activatable icons can be used for purely 
1172    * informational purposes.
1173    *
1174    * Since: 2.16
1175    */
1176   g_object_class_install_property (gobject_class,
1177                                    PROP_ACTIVATABLE_PRIMARY,
1178                                    g_param_spec_boolean ("primary-icon-activatable",
1179                                                          P_("Primary icon activatable"),
1180                                                          P_("Whether the primary icon is activatable"),
1181                                                          TRUE,
1182                                                          GTK_PARAM_READWRITE));
1183   
1184   /**
1185    * GtkEntry:secondary-icon-activatable:
1186    *
1187    * Whether the secondary icon is activatable.
1188    *
1189    * GTK+ emits the #GtkEntry::icon-press and #GtkEntry::icon-release 
1190    * signals only on sensitive, activatable icons.
1191    *
1192    * Sensitive, but non-activatable icons can be used for purely 
1193    * informational purposes.
1194    *
1195    * Since: 2.16
1196    */
1197   g_object_class_install_property (gobject_class,
1198                                    PROP_ACTIVATABLE_SECONDARY,
1199                                    g_param_spec_boolean ("secondary-icon-activatable",
1200                                                          P_("Secondary icon activatable"),
1201                                                          P_("Whether the secondary icon is activatable"),
1202                                                          TRUE,
1203                                                          GTK_PARAM_READWRITE));
1204   
1205   
1206   /**
1207    * GtkEntry:primary-icon-sensitive:
1208    *
1209    * Whether the primary icon is sensitive.
1210    *
1211    * An insensitive icon appears grayed out. GTK+ does not emit the 
1212    * #GtkEntry::icon-press and #GtkEntry::icon-release signals and 
1213    * does not allow DND from insensitive icons.
1214    *
1215    * An icon should be set insensitive if the action that would trigger
1216    * when clicked is currently not available.
1217    * 
1218    * Since: 2.16
1219    */
1220   g_object_class_install_property (gobject_class,
1221                                    PROP_SENSITIVE_PRIMARY,
1222                                    g_param_spec_boolean ("primary-icon-sensitive",
1223                                                          P_("Primary icon sensitive"),
1224                                                          P_("Whether the primary icon is sensitive"),
1225                                                          TRUE,
1226                                                          GTK_PARAM_READWRITE));
1227   
1228   /**
1229    * GtkEntry:secondary-icon-sensitive:
1230    *
1231    * Whether the secondary icon is sensitive.
1232    *
1233    * An insensitive icon appears grayed out. GTK+ does not emit the 
1234    * #GtkEntry::icon-press and #GtkEntry::icon-release signals and 
1235    * does not allow DND from insensitive icons.
1236    *
1237    * An icon should be set insensitive if the action that would trigger
1238    * when clicked is currently not available.
1239    *
1240    * Since: 2.16
1241    */
1242   g_object_class_install_property (gobject_class,
1243                                    PROP_SENSITIVE_SECONDARY,
1244                                    g_param_spec_boolean ("secondary-icon-sensitive",
1245                                                          P_("Secondary icon sensitive"),
1246                                                          P_("Whether the secondary icon is sensitive"),
1247                                                          TRUE,
1248                                                          GTK_PARAM_READWRITE));
1249   
1250   /**
1251    * GtkEntry:primary-icon-tooltip-text:
1252    * 
1253    * The contents of the tooltip on the primary icon.
1254    *
1255    * Also see gtk_entry_set_icon_tooltip_text().
1256    *
1257    * Since: 2.16
1258    */
1259   g_object_class_install_property (gobject_class,
1260                                    PROP_TOOLTIP_TEXT_PRIMARY,
1261                                    g_param_spec_string ("primary-icon-tooltip-text",
1262                                                         P_("Primary icon tooltip text"),
1263                                                         P_("The contents of the tooltip on the primary icon"),                              
1264                                                         NULL,
1265                                                         GTK_PARAM_READWRITE));
1266   
1267   /**
1268    * GtkEntry:secondary-icon-tooltip-text:
1269    * 
1270    * The contents of the tooltip on the secondary icon.
1271    *
1272    * Also see gtk_entry_set_icon_tooltip_text().
1273    *
1274    * Since: 2.16
1275    */
1276   g_object_class_install_property (gobject_class,
1277                                    PROP_TOOLTIP_TEXT_SECONDARY,
1278                                    g_param_spec_string ("secondary-icon-tooltip-text",
1279                                                         P_("Secondary icon tooltip text"),
1280                                                         P_("The contents of the tooltip on the secondary icon"),                              
1281                                                         NULL,
1282                                                         GTK_PARAM_READWRITE));
1283
1284   /**
1285    * GtkEntry:primary-icon-tooltip-markup:
1286    * 
1287    * The contents of the tooltip on the primary icon, which is marked up
1288    * with the <link linkend="PangoMarkupFormat">Pango text markup 
1289    * language</link>.
1290    *
1291    * Also see gtk_entry_set_icon_tooltip_markup().
1292    *
1293    * Since: 2.16
1294    */
1295   g_object_class_install_property (gobject_class,
1296                                    PROP_TOOLTIP_MARKUP_PRIMARY,
1297                                    g_param_spec_string ("primary-icon-tooltip-markup",
1298                                                         P_("Primary icon tooltip markup"),
1299                                                         P_("The contents of the tooltip on the primary icon"),                              
1300                                                         NULL,
1301                                                         GTK_PARAM_READWRITE));
1302
1303   /**
1304    * GtkEntry:secondary-icon-tooltip-markup:
1305    * 
1306    * The contents of the tooltip on the secondary icon, which is marked up
1307    * with the <link linkend="PangoMarkupFormat">Pango text markup 
1308    * language</link>.
1309    *
1310    * Also see gtk_entry_set_icon_tooltip_markup().
1311    *
1312    * Since: 2.16
1313    */
1314   g_object_class_install_property (gobject_class,
1315                                    PROP_TOOLTIP_MARKUP_SECONDARY,
1316                                    g_param_spec_string ("secondary-icon-tooltip-markup",
1317                                                         P_("Secondary icon tooltip markup"),
1318                                                         P_("The contents of the tooltip on the secondary icon"),                              
1319                                                         NULL,
1320                                                         GTK_PARAM_READWRITE));
1321
1322   /**
1323    * GtkEntry:im-module:
1324    *
1325    * Which IM (input method) module should be used for this entry. 
1326    * See #GtkIMContext.
1327    * 
1328    * Setting this to a non-%NULL value overrides the
1329    * system-wide IM module setting. See the GtkSettings 
1330    * #GtkSettings:gtk-im-module property.
1331    *
1332    * Since: 2.16
1333    */  
1334   g_object_class_install_property (gobject_class,
1335                                    PROP_IM_MODULE,
1336                                    g_param_spec_string ("im-module",
1337                                                         P_("IM module"),
1338                                                         P_("Which IM module should be used"),
1339                                                         NULL,
1340                                                         GTK_PARAM_READWRITE));
1341
1342   /**
1343    * GtkEntry:completion:
1344    *
1345    * The auxiliary completion object to use with the entry.
1346    *
1347    * Since: 3.2
1348    */     
1349   g_object_class_install_property (gobject_class,
1350                                    PROP_COMPLETION,
1351                                    g_param_spec_object ("completion",
1352                                                         P_("Completion"),
1353                                                         P_("The auxiliary completion object"),
1354                                                         GTK_TYPE_ENTRY_COMPLETION,
1355                                                         GTK_PARAM_READWRITE));
1356
1357   /**
1358    * GtkEntry:icon-prelight:
1359    *
1360    * The prelight style property determines whether activatable
1361    * icons prelight on mouseover.
1362    *
1363    * Since: 2.16
1364    */
1365   gtk_widget_class_install_style_property (widget_class,
1366                                            g_param_spec_boolean ("icon-prelight",
1367                                                                  P_("Icon Prelight"),
1368                                                                  P_("Whether activatable icons should prelight when hovered"),
1369                                                                  TRUE,
1370                                                                  GTK_PARAM_READABLE));
1371
1372   /**
1373    * GtkEntry:progress-border:
1374    *
1375    * The border around the progress bar in the entry.
1376    *
1377    * Since: 2.16
1378    *
1379    * Deprecated: 3.4: Use the standard margin CSS property;
1380    *   the value of this style property is ignored.
1381    */
1382   gtk_widget_class_install_style_property (widget_class,
1383                                            g_param_spec_boxed ("progress-border",
1384                                                                P_("Progress Border"),
1385                                                                P_("Border around the progress bar"),
1386                                                                GTK_TYPE_BORDER,
1387                                                                GTK_PARAM_READABLE |
1388                                                                G_PARAM_DEPRECATED));
1389   
1390   /**
1391    * GtkEntry:invisible-char:
1392    *
1393    * The invisible character is used when masking entry contents (in
1394    * \"password mode\")"). When it is not explicitly set with the
1395    * #GtkEntry::invisible-char property, GTK+ determines the character
1396    * to use from a list of possible candidates, depending on availability
1397    * in the current font.
1398    *
1399    * This style property allows the theme to prepend a character
1400    * to the list of candidates.
1401    *
1402    * Since: 2.18
1403    */
1404   gtk_widget_class_install_style_property (widget_class,
1405                                            g_param_spec_unichar ("invisible-char",
1406                                                                  P_("Invisible character"),
1407                                                                  P_("The character to use when masking entry contents (in \"password mode\")"),
1408                                                                  0,
1409                                                                  GTK_PARAM_READABLE));
1410   
1411   /**
1412    * GtkEntry::populate-popup:
1413    * @entry: The entry on which the signal is emitted
1414    * @menu: the menu that is being populated
1415    *
1416    * The ::populate-popup signal gets emitted before showing the 
1417    * context menu of the entry. 
1418    *
1419    * If you need to add items to the context menu, connect
1420    * to this signal and append your menuitems to the @menu.
1421    */
1422   signals[POPULATE_POPUP] =
1423     g_signal_new (I_("populate-popup"),
1424                   G_OBJECT_CLASS_TYPE (gobject_class),
1425                   G_SIGNAL_RUN_LAST,
1426                   G_STRUCT_OFFSET (GtkEntryClass, populate_popup),
1427                   NULL, NULL,
1428                   _gtk_marshal_VOID__OBJECT,
1429                   G_TYPE_NONE, 1,
1430                   GTK_TYPE_MENU);
1431   
1432  /* Action signals */
1433   
1434   /**
1435    * GtkEntry::activate:
1436    * @entry: The entry on which the signal is emitted
1437    *
1438    * A  <link linkend="keybinding-signals">keybinding signal</link>
1439    * which gets emitted when the user activates the entry.
1440    * 
1441    * Applications should not connect to it, but may emit it with
1442    * g_signal_emit_by_name() if they need to control activation 
1443    * programmatically.
1444    *
1445    * The default bindings for this signal are all forms of the Enter key.
1446    */
1447   signals[ACTIVATE] =
1448     g_signal_new (I_("activate"),
1449                   G_OBJECT_CLASS_TYPE (gobject_class),
1450                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1451                   G_STRUCT_OFFSET (GtkEntryClass, activate),
1452                   NULL, NULL,
1453                   _gtk_marshal_VOID__VOID,
1454                   G_TYPE_NONE, 0);
1455   widget_class->activate_signal = signals[ACTIVATE];
1456
1457   /**
1458    * GtkEntry::move-cursor:
1459    * @entry: the object which received the signal
1460    * @step: the granularity of the move, as a #GtkMovementStep
1461    * @count: the number of @step units to move
1462    * @extend_selection: %TRUE if the move should extend the selection
1463    *
1464    * The ::move-cursor signal is a
1465    * <link linkend="keybinding-signals">keybinding signal</link>
1466    * which gets emitted when the user initiates a cursor movement.
1467    * If the cursor is not visible in @entry, this signal causes
1468    * the viewport to be moved instead.
1469    *
1470    * Applications should not connect to it, but may emit it with
1471    * g_signal_emit_by_name() if they need to control the cursor
1472    * programmatically.
1473    *
1474    * The default bindings for this signal come in two variants,
1475    * the variant with the Shift modifier extends the selection,
1476    * the variant without the Shift modifer does not.
1477    * There are too many key combinations to list them all here.
1478    * <itemizedlist>
1479    * <listitem>Arrow keys move by individual characters/lines</listitem>
1480    * <listitem>Ctrl-arrow key combinations move by words/paragraphs</listitem>
1481    * <listitem>Home/End keys move to the ends of the buffer</listitem>
1482    * </itemizedlist>
1483    */
1484   signals[MOVE_CURSOR] = 
1485     g_signal_new (I_("move-cursor"),
1486                   G_OBJECT_CLASS_TYPE (gobject_class),
1487                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1488                   G_STRUCT_OFFSET (GtkEntryClass, move_cursor),
1489                   NULL, NULL,
1490                   _gtk_marshal_VOID__ENUM_INT_BOOLEAN,
1491                   G_TYPE_NONE, 3,
1492                   GTK_TYPE_MOVEMENT_STEP,
1493                   G_TYPE_INT,
1494                   G_TYPE_BOOLEAN);
1495
1496   /**
1497    * GtkEntry::insert-at-cursor:
1498    * @entry: the object which received the signal
1499    * @string: the string to insert
1500    *
1501    * The ::insert-at-cursor signal is a
1502    * <link linkend="keybinding-signals">keybinding signal</link>
1503    * which gets emitted when the user initiates the insertion of a
1504    * fixed string at the cursor.
1505    *
1506    * This signal has no default bindings.
1507    */
1508   signals[INSERT_AT_CURSOR] = 
1509     g_signal_new (I_("insert-at-cursor"),
1510                   G_OBJECT_CLASS_TYPE (gobject_class),
1511                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1512                   G_STRUCT_OFFSET (GtkEntryClass, insert_at_cursor),
1513                   NULL, NULL,
1514                   _gtk_marshal_VOID__STRING,
1515                   G_TYPE_NONE, 1,
1516                   G_TYPE_STRING);
1517
1518   /**
1519    * GtkEntry::delete-from-cursor:
1520    * @entry: the object which received the signal
1521    * @type: the granularity of the deletion, as a #GtkDeleteType
1522    * @count: the number of @type units to delete
1523    *
1524    * The ::delete-from-cursor signal is a
1525    * <link linkend="keybinding-signals">keybinding signal</link>
1526    * which gets emitted when the user initiates a text deletion.
1527    *
1528    * If the @type is %GTK_DELETE_CHARS, GTK+ deletes the selection
1529    * if there is one, otherwise it deletes the requested number
1530    * of characters.
1531    *
1532    * The default bindings for this signal are
1533    * Delete for deleting a character and Ctrl-Delete for
1534    * deleting a word.
1535    */
1536   signals[DELETE_FROM_CURSOR] = 
1537     g_signal_new (I_("delete-from-cursor"),
1538                   G_OBJECT_CLASS_TYPE (gobject_class),
1539                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1540                   G_STRUCT_OFFSET (GtkEntryClass, delete_from_cursor),
1541                   NULL, NULL,
1542                   _gtk_marshal_VOID__ENUM_INT,
1543                   G_TYPE_NONE, 2,
1544                   GTK_TYPE_DELETE_TYPE,
1545                   G_TYPE_INT);
1546
1547   /**
1548    * GtkEntry::backspace:
1549    * @entry: the object which received the signal
1550    *
1551    * The ::backspace signal is a
1552    * <link linkend="keybinding-signals">keybinding signal</link>
1553    * which gets emitted when the user asks for it.
1554    *
1555    * The default bindings for this signal are
1556    * Backspace and Shift-Backspace.
1557    */
1558   signals[BACKSPACE] =
1559     g_signal_new (I_("backspace"),
1560                   G_OBJECT_CLASS_TYPE (gobject_class),
1561                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1562                   G_STRUCT_OFFSET (GtkEntryClass, backspace),
1563                   NULL, NULL,
1564                   _gtk_marshal_VOID__VOID,
1565                   G_TYPE_NONE, 0);
1566
1567   /**
1568    * GtkEntry::cut-clipboard:
1569    * @entry: the object which received the signal
1570    *
1571    * The ::cut-clipboard signal is a
1572    * <link linkend="keybinding-signals">keybinding signal</link>
1573    * which gets emitted to cut the selection to the clipboard.
1574    *
1575    * The default bindings for this signal are
1576    * Ctrl-x and Shift-Delete.
1577    */
1578   signals[CUT_CLIPBOARD] =
1579     g_signal_new (I_("cut-clipboard"),
1580                   G_OBJECT_CLASS_TYPE (gobject_class),
1581                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1582                   G_STRUCT_OFFSET (GtkEntryClass, cut_clipboard),
1583                   NULL, NULL,
1584                   _gtk_marshal_VOID__VOID,
1585                   G_TYPE_NONE, 0);
1586
1587   /**
1588    * GtkEntry::copy-clipboard:
1589    * @entry: the object which received the signal
1590    *
1591    * The ::copy-clipboard signal is a
1592    * <link linkend="keybinding-signals">keybinding signal</link>
1593    * which gets emitted to copy the selection to the clipboard.
1594    *
1595    * The default bindings for this signal are
1596    * Ctrl-c and Ctrl-Insert.
1597    */
1598   signals[COPY_CLIPBOARD] =
1599     g_signal_new (I_("copy-clipboard"),
1600                   G_OBJECT_CLASS_TYPE (gobject_class),
1601                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1602                   G_STRUCT_OFFSET (GtkEntryClass, copy_clipboard),
1603                   NULL, NULL,
1604                   _gtk_marshal_VOID__VOID,
1605                   G_TYPE_NONE, 0);
1606
1607   /**
1608    * GtkEntry::paste-clipboard:
1609    * @entry: the object which received the signal
1610    *
1611    * The ::paste-clipboard signal is a
1612    * <link linkend="keybinding-signals">keybinding signal</link>
1613    * which gets emitted to paste the contents of the clipboard
1614    * into the text view.
1615    *
1616    * The default bindings for this signal are
1617    * Ctrl-v and Shift-Insert.
1618    */
1619   signals[PASTE_CLIPBOARD] =
1620     g_signal_new (I_("paste-clipboard"),
1621                   G_OBJECT_CLASS_TYPE (gobject_class),
1622                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1623                   G_STRUCT_OFFSET (GtkEntryClass, paste_clipboard),
1624                   NULL, NULL,
1625                   _gtk_marshal_VOID__VOID,
1626                   G_TYPE_NONE, 0);
1627
1628   /**
1629    * GtkEntry::toggle-overwrite:
1630    * @entry: the object which received the signal
1631    *
1632    * The ::toggle-overwrite signal is a
1633    * <link linkend="keybinding-signals">keybinding signal</link>
1634    * which gets emitted to toggle the overwrite mode of the entry.
1635    *
1636    * The default bindings for this signal is Insert.
1637    */
1638   signals[TOGGLE_OVERWRITE] =
1639     g_signal_new (I_("toggle-overwrite"),
1640                   G_OBJECT_CLASS_TYPE (gobject_class),
1641                   G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1642                   G_STRUCT_OFFSET (GtkEntryClass, toggle_overwrite),
1643                   NULL, NULL,
1644                   _gtk_marshal_VOID__VOID,
1645                   G_TYPE_NONE, 0);
1646
1647   /**
1648    * GtkEntry::icon-press:
1649    * @entry: The entry on which the signal is emitted
1650    * @icon_pos: The position of the clicked icon
1651    * @event: (type Gdk.EventButton): the button press event
1652    *
1653    * The ::icon-press signal is emitted when an activatable icon
1654    * is clicked.
1655    *
1656    * Since: 2.16
1657    */
1658   signals[ICON_PRESS] =
1659     g_signal_new (I_("icon-press"),
1660                   G_TYPE_FROM_CLASS (gobject_class),
1661                   G_SIGNAL_RUN_LAST,
1662                   0,
1663                   NULL, NULL,
1664                   _gtk_marshal_VOID__ENUM_BOXED,
1665                   G_TYPE_NONE, 2,
1666                   GTK_TYPE_ENTRY_ICON_POSITION,
1667                   GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
1668   
1669   /**
1670    * GtkEntry::icon-release:
1671    * @entry: The entry on which the signal is emitted
1672    * @icon_pos: The position of the clicked icon
1673    * @event: (type Gdk.EventButton): the button release event
1674    *
1675    * The ::icon-release signal is emitted on the button release from a
1676    * mouse click over an activatable icon.
1677    *
1678    * Since: 2.16
1679    */
1680   signals[ICON_RELEASE] =
1681     g_signal_new (I_("icon-release"),
1682                   G_TYPE_FROM_CLASS (gobject_class),
1683                   G_SIGNAL_RUN_LAST,
1684                   0,
1685                   NULL, NULL,
1686                   _gtk_marshal_VOID__ENUM_BOXED,
1687                   G_TYPE_NONE, 2,
1688                   GTK_TYPE_ENTRY_ICON_POSITION,
1689                   GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
1690
1691   /**
1692    * GtkEntry::preedit-changed:
1693    * @entry: the object which received the signal
1694    * @preedit: the current preedit string
1695    *
1696    * If an input method is used, the typed text will not immediately
1697    * be committed to the buffer. So if you are interested in the text,
1698    * connect to this signal.
1699    *
1700    * Since: 2.20
1701    */
1702   signals[PREEDIT_CHANGED] =
1703     g_signal_new_class_handler (I_("preedit-changed"),
1704                                 G_OBJECT_CLASS_TYPE (gobject_class),
1705                                 G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
1706                                 NULL,
1707                                 NULL, NULL,
1708                                 _gtk_marshal_VOID__STRING,
1709                                 G_TYPE_NONE, 1,
1710                                 G_TYPE_STRING);
1711
1712
1713   /*
1714    * Key bindings
1715    */
1716
1717   binding_set = gtk_binding_set_by_class (class);
1718
1719   /* Moving the insertion point */
1720   add_move_binding (binding_set, GDK_KEY_Right, 0,
1721                     GTK_MOVEMENT_VISUAL_POSITIONS, 1);
1722   
1723   add_move_binding (binding_set, GDK_KEY_Left, 0,
1724                     GTK_MOVEMENT_VISUAL_POSITIONS, -1);
1725
1726   add_move_binding (binding_set, GDK_KEY_KP_Right, 0,
1727                     GTK_MOVEMENT_VISUAL_POSITIONS, 1);
1728   
1729   add_move_binding (binding_set, GDK_KEY_KP_Left, 0,
1730                     GTK_MOVEMENT_VISUAL_POSITIONS, -1);
1731   
1732   add_move_binding (binding_set, GDK_KEY_Right, GDK_CONTROL_MASK,
1733                     GTK_MOVEMENT_WORDS, 1);
1734
1735   add_move_binding (binding_set, GDK_KEY_Left, GDK_CONTROL_MASK,
1736                     GTK_MOVEMENT_WORDS, -1);
1737
1738   add_move_binding (binding_set, GDK_KEY_KP_Right, GDK_CONTROL_MASK,
1739                     GTK_MOVEMENT_WORDS, 1);
1740
1741   add_move_binding (binding_set, GDK_KEY_KP_Left, GDK_CONTROL_MASK,
1742                     GTK_MOVEMENT_WORDS, -1);
1743   
1744   add_move_binding (binding_set, GDK_KEY_Home, 0,
1745                     GTK_MOVEMENT_DISPLAY_LINE_ENDS, -1);
1746
1747   add_move_binding (binding_set, GDK_KEY_End, 0,
1748                     GTK_MOVEMENT_DISPLAY_LINE_ENDS, 1);
1749
1750   add_move_binding (binding_set, GDK_KEY_KP_Home, 0,
1751                     GTK_MOVEMENT_DISPLAY_LINE_ENDS, -1);
1752
1753   add_move_binding (binding_set, GDK_KEY_KP_End, 0,
1754                     GTK_MOVEMENT_DISPLAY_LINE_ENDS, 1);
1755   
1756   add_move_binding (binding_set, GDK_KEY_Home, GDK_CONTROL_MASK,
1757                     GTK_MOVEMENT_BUFFER_ENDS, -1);
1758
1759   add_move_binding (binding_set, GDK_KEY_End, GDK_CONTROL_MASK,
1760                     GTK_MOVEMENT_BUFFER_ENDS, 1);
1761
1762   add_move_binding (binding_set, GDK_KEY_KP_Home, GDK_CONTROL_MASK,
1763                     GTK_MOVEMENT_BUFFER_ENDS, -1);
1764
1765   add_move_binding (binding_set, GDK_KEY_KP_End, GDK_CONTROL_MASK,
1766                     GTK_MOVEMENT_BUFFER_ENDS, 1);
1767
1768   /* Select all
1769    */
1770   gtk_binding_entry_add_signal (binding_set, GDK_KEY_a, GDK_CONTROL_MASK,
1771                                 "move-cursor", 3,
1772                                 GTK_TYPE_MOVEMENT_STEP, GTK_MOVEMENT_BUFFER_ENDS,
1773                                 G_TYPE_INT, -1,
1774                                 G_TYPE_BOOLEAN, FALSE);
1775   gtk_binding_entry_add_signal (binding_set, GDK_KEY_a, GDK_CONTROL_MASK,
1776                                 "move-cursor", 3,
1777                                 GTK_TYPE_MOVEMENT_STEP, GTK_MOVEMENT_BUFFER_ENDS,
1778                                 G_TYPE_INT, 1,
1779                                 G_TYPE_BOOLEAN, TRUE);  
1780
1781   gtk_binding_entry_add_signal (binding_set, GDK_KEY_slash, GDK_CONTROL_MASK,
1782                                 "move-cursor", 3,
1783                                 GTK_TYPE_MOVEMENT_STEP, GTK_MOVEMENT_BUFFER_ENDS,
1784                                 G_TYPE_INT, -1,
1785                                 G_TYPE_BOOLEAN, FALSE);
1786   gtk_binding_entry_add_signal (binding_set, GDK_KEY_slash, GDK_CONTROL_MASK,
1787                                 "move-cursor", 3,
1788                                 GTK_TYPE_MOVEMENT_STEP, GTK_MOVEMENT_BUFFER_ENDS,
1789                                 G_TYPE_INT, 1,
1790                                 G_TYPE_BOOLEAN, TRUE);  
1791   /* Unselect all 
1792    */
1793   gtk_binding_entry_add_signal (binding_set, GDK_KEY_backslash, GDK_CONTROL_MASK,
1794                                 "move-cursor", 3,
1795                                 GTK_TYPE_MOVEMENT_STEP, GTK_MOVEMENT_VISUAL_POSITIONS,
1796                                 G_TYPE_INT, 0,
1797                                 G_TYPE_BOOLEAN, FALSE);
1798   gtk_binding_entry_add_signal (binding_set, GDK_KEY_a, GDK_SHIFT_MASK | GDK_CONTROL_MASK,
1799                                 "move-cursor", 3,
1800                                 GTK_TYPE_MOVEMENT_STEP, GTK_MOVEMENT_VISUAL_POSITIONS,
1801                                 G_TYPE_INT, 0,
1802                                 G_TYPE_BOOLEAN, FALSE);
1803
1804   /* Activate
1805    */
1806   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Return, 0,
1807                                 "activate", 0);
1808   gtk_binding_entry_add_signal (binding_set, GDK_KEY_ISO_Enter, 0,
1809                                 "activate", 0);
1810   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Enter, 0,
1811                                 "activate", 0);
1812   
1813   /* Deleting text */
1814   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Delete, 0,
1815                                 "delete-from-cursor", 2,
1816                                 G_TYPE_ENUM, GTK_DELETE_CHARS,
1817                                 G_TYPE_INT, 1);
1818
1819   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Delete, 0,
1820                                 "delete-from-cursor", 2,
1821                                 G_TYPE_ENUM, GTK_DELETE_CHARS,
1822                                 G_TYPE_INT, 1);
1823   
1824   gtk_binding_entry_add_signal (binding_set, GDK_KEY_BackSpace, 0,
1825                                 "backspace", 0);
1826
1827   /* Make this do the same as Backspace, to help with mis-typing */
1828   gtk_binding_entry_add_signal (binding_set, GDK_KEY_BackSpace, GDK_SHIFT_MASK,
1829                                 "backspace", 0);
1830
1831   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Delete, GDK_CONTROL_MASK,
1832                                 "delete-from-cursor", 2,
1833                                 G_TYPE_ENUM, GTK_DELETE_WORD_ENDS,
1834                                 G_TYPE_INT, 1);
1835
1836   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Delete, GDK_CONTROL_MASK,
1837                                 "delete-from-cursor", 2,
1838                                 G_TYPE_ENUM, GTK_DELETE_WORD_ENDS,
1839                                 G_TYPE_INT, 1);
1840   
1841   gtk_binding_entry_add_signal (binding_set, GDK_KEY_BackSpace, GDK_CONTROL_MASK,
1842                                 "delete-from-cursor", 2,
1843                                 G_TYPE_ENUM, GTK_DELETE_WORD_ENDS,
1844                                 G_TYPE_INT, -1);
1845
1846   /* Cut/copy/paste */
1847
1848   gtk_binding_entry_add_signal (binding_set, GDK_KEY_x, GDK_CONTROL_MASK,
1849                                 "cut-clipboard", 0);
1850   gtk_binding_entry_add_signal (binding_set, GDK_KEY_c, GDK_CONTROL_MASK,
1851                                 "copy-clipboard", 0);
1852   gtk_binding_entry_add_signal (binding_set, GDK_KEY_v, GDK_CONTROL_MASK,
1853                                 "paste-clipboard", 0);
1854
1855   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Delete, GDK_SHIFT_MASK,
1856                                 "cut-clipboard", 0);
1857   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Insert, GDK_CONTROL_MASK,
1858                                 "copy-clipboard", 0);
1859   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Insert, GDK_SHIFT_MASK,
1860                                 "paste-clipboard", 0);
1861
1862   /* Overwrite */
1863   gtk_binding_entry_add_signal (binding_set, GDK_KEY_Insert, 0,
1864                                 "toggle-overwrite", 0);
1865   gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Insert, 0,
1866                                 "toggle-overwrite", 0);
1867
1868   /**
1869    * GtkEntry:inner-border:
1870    *
1871    * Sets the text area's border between the text and the frame.
1872    *
1873    * Since: 2.10
1874    *
1875    * Deprecated: 3.4: Use the standard border and padding CSS properties;
1876    *   the value of this style property is ignored.
1877    */
1878   gtk_widget_class_install_style_property (widget_class,
1879                                            g_param_spec_boxed ("inner-border",
1880                                                                P_("Inner Border"),
1881                                                                P_("Border between text and frame."),
1882                                                                GTK_TYPE_BORDER,
1883                                                                GTK_PARAM_READABLE |
1884                                                                G_PARAM_DEPRECATED));
1885
1886   g_type_class_add_private (gobject_class, sizeof (GtkEntryPrivate));
1887
1888   gtk_widget_class_set_accessible_type (widget_class, GTK_TYPE_ENTRY_ACCESSIBLE);
1889 }
1890
1891 static void
1892 gtk_entry_editable_init (GtkEditableInterface *iface)
1893 {
1894   iface->do_insert_text = gtk_entry_insert_text;
1895   iface->do_delete_text = gtk_entry_delete_text;
1896   iface->insert_text = gtk_entry_real_insert_text;
1897   iface->delete_text = gtk_entry_real_delete_text;
1898   iface->get_chars = gtk_entry_get_chars;
1899   iface->set_selection_bounds = gtk_entry_set_selection_bounds;
1900   iface->get_selection_bounds = gtk_entry_get_selection_bounds;
1901   iface->set_position = gtk_entry_real_set_position;
1902   iface->get_position = gtk_entry_get_position;
1903 }
1904
1905 static void
1906 gtk_entry_cell_editable_init (GtkCellEditableIface *iface)
1907 {
1908   iface->start_editing = gtk_entry_start_editing;
1909 }
1910
1911 /* for deprecated properties */
1912 static void
1913 gtk_entry_do_set_inner_border (GtkEntry *entry,
1914                                const GtkBorder *border)
1915 {
1916   if (border)
1917     g_object_set_qdata_full (G_OBJECT (entry), quark_inner_border,
1918                              gtk_border_copy (border),
1919                              (GDestroyNotify) gtk_border_free);
1920   else
1921     g_object_set_qdata (G_OBJECT (entry), quark_inner_border, NULL);
1922
1923   g_object_notify (G_OBJECT (entry), "inner-border");
1924 }
1925
1926 static const GtkBorder *
1927 gtk_entry_do_get_inner_border (GtkEntry *entry)
1928 {
1929   return g_object_get_qdata (G_OBJECT (entry), quark_inner_border);
1930 }
1931
1932 static void
1933 gtk_entry_set_property (GObject         *object,
1934                         guint            prop_id,
1935                         const GValue    *value,
1936                         GParamSpec      *pspec)
1937 {
1938   GtkEntry *entry = GTK_ENTRY (object);
1939   GtkEntryPrivate *priv = entry->priv;
1940
1941   switch (prop_id)
1942     {
1943     case PROP_BUFFER:
1944       gtk_entry_set_buffer (entry, g_value_get_object (value));
1945       break;
1946
1947     case PROP_EDITABLE:
1948       {
1949         gboolean new_value = g_value_get_boolean (value);
1950
1951         if (new_value != priv->editable)
1952           {
1953             GtkWidget *widget = GTK_WIDGET (entry);
1954
1955             if (!new_value)
1956               {
1957                 _gtk_entry_reset_im_context (entry);
1958                 if (gtk_widget_has_focus (widget))
1959                   gtk_im_context_focus_out (priv->im_context);
1960
1961                 priv->preedit_length = 0;
1962                 priv->preedit_cursor = 0;
1963               }
1964
1965             priv->editable = new_value;
1966
1967             if (new_value && gtk_widget_has_focus (widget))
1968               gtk_im_context_focus_in (priv->im_context);
1969
1970             gtk_widget_queue_draw (widget);
1971           }
1972       }
1973       break;
1974
1975     case PROP_MAX_LENGTH:
1976       gtk_entry_set_max_length (entry, g_value_get_int (value));
1977       break;
1978       
1979     case PROP_VISIBILITY:
1980       gtk_entry_set_visibility (entry, g_value_get_boolean (value));
1981       break;
1982
1983     case PROP_HAS_FRAME:
1984       gtk_entry_set_has_frame (entry, g_value_get_boolean (value));
1985       break;
1986
1987     case PROP_INNER_BORDER:
1988       gtk_entry_do_set_inner_border (entry, g_value_get_boxed (value));
1989       break;
1990
1991     case PROP_INVISIBLE_CHAR:
1992       gtk_entry_set_invisible_char (entry, g_value_get_uint (value));
1993       break;
1994
1995     case PROP_ACTIVATES_DEFAULT:
1996       gtk_entry_set_activates_default (entry, g_value_get_boolean (value));
1997       break;
1998
1999     case PROP_WIDTH_CHARS:
2000       gtk_entry_set_width_chars (entry, g_value_get_int (value));
2001       break;
2002
2003     case PROP_TEXT:
2004       gtk_entry_set_text (entry, g_value_get_string (value));
2005       break;
2006
2007     case PROP_XALIGN:
2008       gtk_entry_set_alignment (entry, g_value_get_float (value));
2009       break;
2010
2011     case PROP_TRUNCATE_MULTILINE:
2012       priv->truncate_multiline = g_value_get_boolean (value);
2013       break;
2014
2015     case PROP_SHADOW_TYPE:
2016       priv->shadow_type = g_value_get_enum (value);
2017       break;
2018
2019     case PROP_OVERWRITE_MODE:
2020       gtk_entry_set_overwrite_mode (entry, g_value_get_boolean (value));
2021       break;
2022
2023     case PROP_INVISIBLE_CHAR_SET:
2024       if (g_value_get_boolean (value))
2025         priv->invisible_char_set = TRUE;
2026       else
2027         gtk_entry_unset_invisible_char (entry);
2028       break;
2029
2030     case PROP_CAPS_LOCK_WARNING:
2031       priv->caps_lock_warning = g_value_get_boolean (value);
2032       break;
2033
2034     case PROP_PROGRESS_FRACTION:
2035       gtk_entry_set_progress_fraction (entry, g_value_get_double (value));
2036       break;
2037
2038     case PROP_PROGRESS_PULSE_STEP:
2039       gtk_entry_set_progress_pulse_step (entry, g_value_get_double (value));
2040       break;
2041
2042     case PROP_PLACEHOLDER_TEXT:
2043       gtk_entry_set_placeholder_text (entry, g_value_get_string (value));
2044       break;
2045
2046     case PROP_PIXBUF_PRIMARY:
2047       gtk_entry_set_icon_from_pixbuf (entry,
2048                                       GTK_ENTRY_ICON_PRIMARY,
2049                                       g_value_get_object (value));
2050       break;
2051
2052     case PROP_PIXBUF_SECONDARY:
2053       gtk_entry_set_icon_from_pixbuf (entry,
2054                                       GTK_ENTRY_ICON_SECONDARY,
2055                                       g_value_get_object (value));
2056       break;
2057
2058     case PROP_STOCK_PRIMARY:
2059       gtk_entry_set_icon_from_stock (entry,
2060                                      GTK_ENTRY_ICON_PRIMARY,
2061                                      g_value_get_string (value));
2062       break;
2063
2064     case PROP_STOCK_SECONDARY:
2065       gtk_entry_set_icon_from_stock (entry,
2066                                      GTK_ENTRY_ICON_SECONDARY,
2067                                      g_value_get_string (value));
2068       break;
2069
2070     case PROP_ICON_NAME_PRIMARY:
2071       gtk_entry_set_icon_from_icon_name (entry,
2072                                          GTK_ENTRY_ICON_PRIMARY,
2073                                          g_value_get_string (value));
2074       break;
2075
2076     case PROP_ICON_NAME_SECONDARY:
2077       gtk_entry_set_icon_from_icon_name (entry,
2078                                          GTK_ENTRY_ICON_SECONDARY,
2079                                          g_value_get_string (value));
2080       break;
2081
2082     case PROP_GICON_PRIMARY:
2083       gtk_entry_set_icon_from_gicon (entry,
2084                                      GTK_ENTRY_ICON_PRIMARY,
2085                                      g_value_get_object (value));
2086       break;
2087
2088     case PROP_GICON_SECONDARY:
2089       gtk_entry_set_icon_from_gicon (entry,
2090                                      GTK_ENTRY_ICON_SECONDARY,
2091                                      g_value_get_object (value));
2092       break;
2093
2094     case PROP_ACTIVATABLE_PRIMARY:
2095       gtk_entry_set_icon_activatable (entry,
2096                                       GTK_ENTRY_ICON_PRIMARY,
2097                                       g_value_get_boolean (value));
2098       break;
2099
2100     case PROP_ACTIVATABLE_SECONDARY:
2101       gtk_entry_set_icon_activatable (entry,
2102                                       GTK_ENTRY_ICON_SECONDARY,
2103                                       g_value_get_boolean (value));
2104       break;
2105
2106     case PROP_SENSITIVE_PRIMARY:
2107       gtk_entry_set_icon_sensitive (entry,
2108                                     GTK_ENTRY_ICON_PRIMARY,
2109                                     g_value_get_boolean (value));
2110       break;
2111
2112     case PROP_SENSITIVE_SECONDARY:
2113       gtk_entry_set_icon_sensitive (entry,
2114                                     GTK_ENTRY_ICON_SECONDARY,
2115                                     g_value_get_boolean (value));
2116       break;
2117
2118     case PROP_TOOLTIP_TEXT_PRIMARY:
2119       gtk_entry_set_icon_tooltip_text (entry,
2120                                        GTK_ENTRY_ICON_PRIMARY,
2121                                        g_value_get_string (value));
2122       break;
2123
2124     case PROP_TOOLTIP_TEXT_SECONDARY:
2125       gtk_entry_set_icon_tooltip_text (entry,
2126                                        GTK_ENTRY_ICON_SECONDARY,
2127                                        g_value_get_string (value));
2128       break;
2129
2130     case PROP_TOOLTIP_MARKUP_PRIMARY:
2131       gtk_entry_set_icon_tooltip_markup (entry,
2132                                          GTK_ENTRY_ICON_PRIMARY,
2133                                          g_value_get_string (value));
2134       break;
2135
2136     case PROP_TOOLTIP_MARKUP_SECONDARY:
2137       gtk_entry_set_icon_tooltip_markup (entry,
2138                                          GTK_ENTRY_ICON_SECONDARY,
2139                                          g_value_get_string (value));
2140       break;
2141
2142     case PROP_IM_MODULE:
2143       g_free (priv->im_module);
2144       priv->im_module = g_value_dup_string (value);
2145       if (GTK_IS_IM_MULTICONTEXT (priv->im_context))
2146         gtk_im_multicontext_set_context_id (GTK_IM_MULTICONTEXT (priv->im_context), priv->im_module);
2147       break;
2148
2149     case PROP_EDITING_CANCELED:
2150       priv->editing_canceled = g_value_get_boolean (value);
2151       break;
2152
2153     case PROP_COMPLETION:
2154       gtk_entry_set_completion (entry, GTK_ENTRY_COMPLETION (g_value_get_object (value)));
2155       break;
2156
2157     case PROP_SCROLL_OFFSET:
2158     case PROP_CURSOR_POSITION:
2159     default:
2160       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
2161       break;
2162     }
2163 }
2164
2165 static void
2166 gtk_entry_get_property (GObject         *object,
2167                         guint            prop_id,
2168                         GValue          *value,
2169                         GParamSpec      *pspec)
2170 {
2171   GtkEntry *entry = GTK_ENTRY (object);
2172   GtkEntryPrivate *priv = entry->priv;
2173
2174   switch (prop_id)
2175     {
2176     case PROP_BUFFER:
2177       g_value_set_object (value, gtk_entry_get_buffer (entry));
2178       break;
2179
2180     case PROP_CURSOR_POSITION:
2181       g_value_set_int (value, priv->current_pos);
2182       break;
2183
2184     case PROP_SELECTION_BOUND:
2185       g_value_set_int (value, priv->selection_bound);
2186       break;
2187
2188     case PROP_EDITABLE:
2189       g_value_set_boolean (value, priv->editable);
2190       break;
2191
2192     case PROP_MAX_LENGTH:
2193       g_value_set_int (value, gtk_entry_buffer_get_max_length (get_buffer (entry)));
2194       break;
2195
2196     case PROP_VISIBILITY:
2197       g_value_set_boolean (value, priv->visible);
2198       break;
2199
2200     case PROP_HAS_FRAME:
2201       g_value_set_boolean (value, priv->has_frame);
2202       break;
2203
2204     case PROP_INNER_BORDER:
2205       g_value_set_boxed (value, gtk_entry_do_get_inner_border (entry));
2206       break;
2207
2208     case PROP_INVISIBLE_CHAR:
2209       g_value_set_uint (value, priv->invisible_char);
2210       break;
2211
2212     case PROP_ACTIVATES_DEFAULT:
2213       g_value_set_boolean (value, priv->activates_default);
2214       break;
2215
2216     case PROP_WIDTH_CHARS:
2217       g_value_set_int (value, priv->width_chars);
2218       break;
2219
2220     case PROP_SCROLL_OFFSET:
2221       g_value_set_int (value, priv->scroll_offset);
2222       break;
2223
2224     case PROP_TEXT:
2225       g_value_set_string (value, gtk_entry_get_text (entry));
2226       break;
2227
2228     case PROP_XALIGN:
2229       g_value_set_float (value, gtk_entry_get_alignment (entry));
2230       break;
2231
2232     case PROP_TRUNCATE_MULTILINE:
2233       g_value_set_boolean (value, priv->truncate_multiline);
2234       break;
2235
2236     case PROP_SHADOW_TYPE:
2237       g_value_set_enum (value, priv->shadow_type);
2238       break;
2239
2240     case PROP_OVERWRITE_MODE:
2241       g_value_set_boolean (value, priv->overwrite_mode);
2242       break;
2243
2244     case PROP_TEXT_LENGTH:
2245       g_value_set_uint (value, gtk_entry_buffer_get_length (get_buffer (entry)));
2246       break;
2247
2248     case PROP_INVISIBLE_CHAR_SET:
2249       g_value_set_boolean (value, priv->invisible_char_set);
2250       break;
2251
2252     case PROP_IM_MODULE:
2253       g_value_set_string (value, priv->im_module);
2254       break;
2255
2256     case PROP_CAPS_LOCK_WARNING:
2257       g_value_set_boolean (value, priv->caps_lock_warning);
2258       break;
2259
2260     case PROP_PROGRESS_FRACTION:
2261       g_value_set_double (value, priv->progress_fraction);
2262       break;
2263
2264     case PROP_PROGRESS_PULSE_STEP:
2265       g_value_set_double (value, priv->progress_pulse_fraction);
2266       break;
2267
2268     case PROP_PLACEHOLDER_TEXT:
2269       g_value_set_string (value, gtk_entry_get_placeholder_text (entry));
2270       break;
2271
2272     case PROP_PIXBUF_PRIMARY:
2273       g_value_set_object (value,
2274                           gtk_entry_get_icon_pixbuf (entry,
2275                                                      GTK_ENTRY_ICON_PRIMARY));
2276       break;
2277
2278     case PROP_PIXBUF_SECONDARY:
2279       g_value_set_object (value,
2280                           gtk_entry_get_icon_pixbuf (entry,
2281                                                      GTK_ENTRY_ICON_SECONDARY));
2282       break;
2283
2284     case PROP_STOCK_PRIMARY:
2285       g_value_set_string (value,
2286                           gtk_entry_get_icon_stock (entry,
2287                                                     GTK_ENTRY_ICON_PRIMARY));
2288       break;
2289
2290     case PROP_STOCK_SECONDARY:
2291       g_value_set_string (value,
2292                           gtk_entry_get_icon_stock (entry,
2293                                                     GTK_ENTRY_ICON_SECONDARY));
2294       break;
2295
2296     case PROP_ICON_NAME_PRIMARY:
2297       g_value_set_string (value,
2298                           gtk_entry_get_icon_name (entry,
2299                                                    GTK_ENTRY_ICON_PRIMARY));
2300       break;
2301
2302     case PROP_ICON_NAME_SECONDARY:
2303       g_value_set_string (value,
2304                           gtk_entry_get_icon_name (entry,
2305                                                    GTK_ENTRY_ICON_SECONDARY));
2306       break;
2307
2308     case PROP_GICON_PRIMARY:
2309       g_value_set_object (value,
2310                           gtk_entry_get_icon_gicon (entry,
2311                                                     GTK_ENTRY_ICON_PRIMARY));
2312       break;
2313
2314     case PROP_GICON_SECONDARY:
2315       g_value_set_object (value,
2316                           gtk_entry_get_icon_gicon (entry,
2317                                                     GTK_ENTRY_ICON_SECONDARY));
2318       break;
2319
2320     case PROP_STORAGE_TYPE_PRIMARY:
2321       g_value_set_enum (value,
2322                         gtk_entry_get_icon_storage_type (entry, 
2323                                                          GTK_ENTRY_ICON_PRIMARY));
2324       break;
2325
2326     case PROP_STORAGE_TYPE_SECONDARY:
2327       g_value_set_enum (value,
2328                         gtk_entry_get_icon_storage_type (entry, 
2329                                                          GTK_ENTRY_ICON_SECONDARY));
2330       break;
2331
2332     case PROP_ACTIVATABLE_PRIMARY:
2333       g_value_set_boolean (value,
2334                            gtk_entry_get_icon_activatable (entry, GTK_ENTRY_ICON_PRIMARY));
2335       break;
2336
2337     case PROP_ACTIVATABLE_SECONDARY:
2338       g_value_set_boolean (value,
2339                            gtk_entry_get_icon_activatable (entry, GTK_ENTRY_ICON_SECONDARY));
2340       break;
2341
2342     case PROP_SENSITIVE_PRIMARY:
2343       g_value_set_boolean (value,
2344                            gtk_entry_get_icon_sensitive (entry, GTK_ENTRY_ICON_PRIMARY));
2345       break;
2346
2347     case PROP_SENSITIVE_SECONDARY:
2348       g_value_set_boolean (value,
2349                            gtk_entry_get_icon_sensitive (entry, GTK_ENTRY_ICON_SECONDARY));
2350       break;
2351
2352     case PROP_TOOLTIP_TEXT_PRIMARY:
2353       g_value_take_string (value,
2354                            gtk_entry_get_icon_tooltip_text (entry, GTK_ENTRY_ICON_PRIMARY));
2355       break;
2356
2357     case PROP_TOOLTIP_TEXT_SECONDARY:
2358       g_value_take_string (value,
2359                            gtk_entry_get_icon_tooltip_text (entry, GTK_ENTRY_ICON_SECONDARY));
2360       break;
2361
2362     case PROP_TOOLTIP_MARKUP_PRIMARY:
2363       g_value_take_string (value,
2364                            gtk_entry_get_icon_tooltip_markup (entry, GTK_ENTRY_ICON_PRIMARY));
2365       break;
2366
2367     case PROP_TOOLTIP_MARKUP_SECONDARY:
2368       g_value_take_string (value,
2369                            gtk_entry_get_icon_tooltip_markup (entry, GTK_ENTRY_ICON_SECONDARY));
2370       break;
2371
2372     case PROP_EDITING_CANCELED:
2373       g_value_set_boolean (value,
2374                            priv->editing_canceled);
2375       break;
2376
2377     case PROP_COMPLETION:
2378       g_value_set_object (value, G_OBJECT (gtk_entry_get_completion (entry)));
2379       break;
2380
2381     default:
2382       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
2383       break;
2384     }
2385 }
2386
2387 static gunichar
2388 find_invisible_char (GtkWidget *widget)
2389 {
2390   PangoLayout *layout;
2391   PangoAttrList *attr_list;
2392   gint i;
2393   gunichar invisible_chars [] = {
2394     0,
2395     0x25cf, /* BLACK CIRCLE */
2396     0x2022, /* BULLET */
2397     0x2731, /* HEAVY ASTERISK */
2398     0x273a  /* SIXTEEN POINTED ASTERISK */
2399   };
2400
2401   gtk_widget_style_get (widget,
2402                         "invisible-char", &invisible_chars[0],
2403                         NULL);
2404
2405   layout = gtk_widget_create_pango_layout (widget, NULL);
2406
2407   attr_list = pango_attr_list_new ();
2408   pango_attr_list_insert (attr_list, pango_attr_fallback_new (FALSE));
2409
2410   pango_layout_set_attributes (layout, attr_list);
2411   pango_attr_list_unref (attr_list);
2412
2413   for (i = (invisible_chars[0] != 0 ? 0 : 1); i < G_N_ELEMENTS (invisible_chars); i++)
2414     {
2415       gchar text[7] = { 0, };
2416       gint len, count;
2417
2418       len = g_unichar_to_utf8 (invisible_chars[i], text);
2419       pango_layout_set_text (layout, text, len);
2420
2421       count = pango_layout_get_unknown_glyphs_count (layout);
2422
2423       if (count == 0)
2424         {
2425           g_object_unref (layout);
2426           return invisible_chars[i];
2427         }
2428     }
2429
2430   g_object_unref (layout);
2431
2432   return '*';
2433 }
2434
2435 static void
2436 gtk_entry_init (GtkEntry *entry)
2437 {
2438   GtkStyleContext *context;
2439   GtkEntryPrivate *priv;
2440
2441   entry->priv = G_TYPE_INSTANCE_GET_PRIVATE (entry,
2442                                              GTK_TYPE_ENTRY,
2443                                              GtkEntryPrivate);
2444   priv = entry->priv;
2445
2446   gtk_widget_set_can_focus (GTK_WIDGET (entry), TRUE);
2447   gtk_widget_set_has_window (GTK_WIDGET (entry), FALSE);
2448
2449   priv->editable = TRUE;
2450   priv->visible = TRUE;
2451   priv->dnd_position = -1;
2452   priv->width_chars = -1;
2453   priv->is_cell_renderer = FALSE;
2454   priv->editing_canceled = FALSE;
2455   priv->has_frame = TRUE;
2456   priv->truncate_multiline = FALSE;
2457   priv->shadow_type = GTK_SHADOW_IN;
2458   priv->xalign = 0.0;
2459   priv->caps_lock_warning = TRUE;
2460   priv->caps_lock_warning_shown = FALSE;
2461   priv->progress_fraction = 0.0;
2462   priv->progress_pulse_fraction = 0.1;
2463
2464   gtk_drag_dest_set (GTK_WIDGET (entry),
2465                      GTK_DEST_DEFAULT_HIGHLIGHT,
2466                      NULL, 0,
2467                      GDK_ACTION_COPY | GDK_ACTION_MOVE);
2468   gtk_drag_dest_add_text_targets (GTK_WIDGET (entry));
2469
2470   /* This object is completely private. No external entity can gain a reference
2471    * to it; so we create it here and destroy it in finalize().
2472    */
2473   priv->im_context = gtk_im_multicontext_new ();
2474
2475   g_signal_connect (priv->im_context, "commit",
2476                     G_CALLBACK (gtk_entry_commit_cb), entry);
2477   g_signal_connect (priv->im_context, "preedit-changed",
2478                     G_CALLBACK (gtk_entry_preedit_changed_cb), entry);
2479   g_signal_connect (priv->im_context, "retrieve-surrounding",
2480                     G_CALLBACK (gtk_entry_retrieve_surrounding_cb), entry);
2481   g_signal_connect (priv->im_context, "delete-surrounding",
2482                     G_CALLBACK (gtk_entry_delete_surrounding_cb), entry);
2483
2484   context = gtk_widget_get_style_context (GTK_WIDGET (entry));
2485   gtk_style_context_add_class (context, GTK_STYLE_CLASS_ENTRY);
2486
2487   gtk_entry_update_cached_style_values (entry);
2488 }
2489
2490 static void
2491 gtk_entry_prepare_context_for_icon (GtkEntry             *entry,
2492                                     GtkStyleContext      *context,
2493                                     GtkEntryIconPosition  icon_pos)
2494 {
2495   GtkEntryPrivate *priv = entry->priv;
2496   EntryIconInfo *icon_info = priv->icons[icon_pos];
2497   GtkWidget *widget;
2498   GtkStateFlags state;
2499
2500   widget = GTK_WIDGET (entry);
2501   state = gtk_widget_get_state_flags (widget);
2502
2503   state &= ~(GTK_STATE_FLAG_PRELIGHT);
2504
2505   if ((state & GTK_STATE_FLAG_INSENSITIVE) || icon_info->insensitive)
2506     state |= GTK_STATE_FLAG_INSENSITIVE;
2507   else if (icon_info->prelight)
2508     state |= GTK_STATE_FLAG_PRELIGHT;
2509
2510   gtk_style_context_save (context);
2511
2512   gtk_style_context_set_state (context, state);
2513   gtk_style_context_add_class (context, GTK_STYLE_CLASS_IMAGE);
2514
2515   if (gtk_widget_get_direction (GTK_WIDGET (entry)) == GTK_TEXT_DIR_RTL) 
2516     {
2517       if (icon_pos == GTK_ENTRY_ICON_PRIMARY)
2518         gtk_style_context_add_class (context, GTK_STYLE_CLASS_RIGHT);
2519       else
2520         gtk_style_context_add_class (context, GTK_STYLE_CLASS_LEFT);
2521     }
2522   else
2523     {
2524       if (icon_pos == GTK_ENTRY_ICON_PRIMARY)
2525         gtk_style_context_add_class (context, GTK_STYLE_CLASS_LEFT);
2526       else
2527         gtk_style_context_add_class (context, GTK_STYLE_CLASS_RIGHT);
2528     }
2529 }
2530
2531 static gint
2532 get_icon_width (GtkEntry             *entry,
2533                 GtkEntryIconPosition  icon_pos)
2534 {
2535   GtkEntryPrivate *priv = entry->priv;
2536   EntryIconInfo *icon_info = priv->icons[icon_pos];
2537   GtkStyleContext *context;
2538   GtkBorder padding;
2539   gint width;
2540
2541   if (!icon_info)
2542     return 0;
2543
2544   context = gtk_widget_get_style_context (GTK_WIDGET (entry));
2545   gtk_entry_prepare_context_for_icon (entry, context, icon_pos);
2546   gtk_style_context_get_padding (context, 0, &padding);
2547
2548   _gtk_icon_helper_get_size (icon_info->icon_helper, context,
2549                              &width, NULL);
2550   gtk_style_context_restore (context);
2551
2552   if (width > 0)
2553     width += padding.left + padding.right;
2554
2555   return width;
2556 }
2557
2558 static void
2559 get_icon_allocations (GtkEntry      *entry,
2560                       GtkAllocation *primary,
2561                       GtkAllocation *secondary)
2562
2563 {
2564   GtkEntryPrivate *priv = entry->priv;
2565   gint x, y, width, height;
2566
2567   get_text_area_size (entry, &x, &y, &width, &height);
2568
2569   if (gtk_widget_has_focus (GTK_WIDGET (entry)) && !priv->interior_focus)
2570     y += priv->focus_width;
2571
2572   primary->y = y;
2573   primary->height = height;
2574   primary->width = get_icon_width (entry, GTK_ENTRY_ICON_PRIMARY);
2575
2576   secondary->y = y;
2577   secondary->height = height;
2578   secondary->width = get_icon_width (entry, GTK_ENTRY_ICON_SECONDARY);
2579
2580   if (gtk_widget_get_direction (GTK_WIDGET (entry)) == GTK_TEXT_DIR_RTL)
2581     {
2582       primary->x = x + width - primary->width;
2583       secondary->x = x;
2584     }
2585   else
2586     {
2587       primary->x = x;
2588       secondary->x = x + width - secondary->width;
2589     }
2590 }
2591
2592
2593 static void
2594 begin_change (GtkEntry *entry)
2595 {
2596   GtkEntryPrivate *priv = entry->priv;
2597
2598   priv->change_count++;
2599
2600   g_object_freeze_notify (G_OBJECT (entry));
2601 }
2602
2603 static void
2604 end_change (GtkEntry *entry)
2605 {
2606   GtkEditable *editable = GTK_EDITABLE (entry);
2607   GtkEntryPrivate *priv = entry->priv;
2608
2609   g_return_if_fail (priv->change_count > 0);
2610
2611   g_object_thaw_notify (G_OBJECT (entry));
2612
2613   priv->change_count--;
2614
2615   if (priv->change_count == 0)
2616     {
2617        if (priv->real_changed)
2618          {
2619            g_signal_emit_by_name (editable, "changed");
2620            priv->real_changed = FALSE;
2621          }
2622     }
2623 }
2624
2625 static void
2626 emit_changed (GtkEntry *entry)
2627 {
2628   GtkEditable *editable = GTK_EDITABLE (entry);
2629   GtkEntryPrivate *priv = entry->priv;
2630
2631   if (priv->change_count == 0)
2632     g_signal_emit_by_name (editable, "changed");
2633   else
2634     priv->real_changed = TRUE;
2635 }
2636
2637 static void
2638 gtk_entry_destroy (GtkWidget *widget)
2639 {
2640   GtkEntry *entry = GTK_ENTRY (widget);
2641   GtkEntryPrivate *priv = entry->priv;
2642
2643   priv->current_pos = priv->selection_bound = 0;
2644   _gtk_entry_reset_im_context (entry);
2645   gtk_entry_reset_layout (entry);
2646
2647   if (priv->blink_timeout)
2648     {
2649       g_source_remove (priv->blink_timeout);
2650       priv->blink_timeout = 0;
2651     }
2652
2653   if (priv->recompute_idle)
2654     {
2655       g_source_remove (priv->recompute_idle);
2656       priv->recompute_idle = 0;
2657     }
2658
2659   GTK_WIDGET_CLASS (gtk_entry_parent_class)->destroy (widget);
2660 }
2661
2662 static void
2663 gtk_entry_dispose (GObject *object)
2664 {
2665   GtkEntry *entry = GTK_ENTRY (object);
2666   GtkEntryPrivate *priv = entry->priv;
2667   GdkKeymap *keymap;
2668
2669   gtk_entry_set_icon_from_pixbuf (entry, GTK_ENTRY_ICON_PRIMARY, NULL);
2670   gtk_entry_set_icon_tooltip_markup (entry, GTK_ENTRY_ICON_PRIMARY, NULL);
2671   gtk_entry_set_icon_from_pixbuf (entry, GTK_ENTRY_ICON_SECONDARY, NULL);
2672   gtk_entry_set_icon_tooltip_markup (entry, GTK_ENTRY_ICON_SECONDARY, NULL);
2673
2674   if (priv->buffer)
2675     {
2676       buffer_disconnect_signals (entry);
2677       g_object_unref (priv->buffer);
2678       priv->buffer = NULL;
2679     }
2680
2681   keymap = gdk_keymap_get_for_display (gtk_widget_get_display (GTK_WIDGET (object)));
2682   g_signal_handlers_disconnect_by_func (keymap, keymap_state_changed, entry);
2683   g_signal_handlers_disconnect_by_func (keymap, keymap_direction_changed, entry);
2684   G_OBJECT_CLASS (gtk_entry_parent_class)->dispose (object);
2685 }
2686
2687 static void
2688 gtk_entry_finalize (GObject *object)
2689 {
2690   GtkEntry *entry = GTK_ENTRY (object);
2691   GtkEntryPrivate *priv = entry->priv;
2692   EntryIconInfo *icon_info = NULL;
2693   gint i;
2694
2695   for (i = 0; i < MAX_ICONS; i++)
2696     {
2697       if ((icon_info = priv->icons[i]) != NULL)
2698         {
2699           if (icon_info->target_list != NULL)
2700             {
2701               gtk_target_list_unref (icon_info->target_list);
2702               icon_info->target_list = NULL;
2703             }
2704
2705           g_clear_object (&icon_info->icon_helper);
2706
2707           g_slice_free (EntryIconInfo, icon_info);
2708           priv->icons[i] = NULL;
2709         }
2710     }
2711
2712   gtk_entry_set_completion (entry, NULL);
2713
2714   if (priv->cached_layout)
2715     g_object_unref (priv->cached_layout);
2716
2717   g_object_unref (priv->im_context);
2718
2719   if (priv->blink_timeout)
2720     g_source_remove (priv->blink_timeout);
2721
2722   if (priv->recompute_idle)
2723     g_source_remove (priv->recompute_idle);
2724
2725   g_free (priv->placeholder_text);
2726   g_free (priv->im_module);
2727
2728   G_OBJECT_CLASS (gtk_entry_parent_class)->finalize (object);
2729 }
2730
2731 static DisplayMode
2732 gtk_entry_get_display_mode (GtkEntry *entry)
2733 {
2734   GtkEntryPrivate *priv = entry->priv;
2735
2736   if (priv->visible)
2737     return DISPLAY_NORMAL;
2738
2739   if (priv->invisible_char == 0 && priv->invisible_char_set)
2740     return DISPLAY_BLANK;
2741
2742   return DISPLAY_INVISIBLE;
2743 }
2744
2745 static gchar*
2746 gtk_entry_get_display_text (GtkEntry *entry,
2747                             gint      start_pos,
2748                             gint      end_pos)
2749 {
2750   GtkEntryPasswordHint *password_hint;
2751   GtkEntryPrivate *priv;
2752   gunichar invisible_char;
2753   const gchar *start;
2754   const gchar *end;
2755   const gchar *text;
2756   gchar char_str[7];
2757   gint char_len;
2758   GString *str;
2759   guint length;
2760   gint i;
2761
2762   priv = entry->priv;
2763   text = gtk_entry_buffer_get_text (get_buffer (entry));
2764   length = gtk_entry_buffer_get_length (get_buffer (entry));
2765
2766   if (end_pos < 0)
2767     end_pos = length;
2768   if (start_pos > length)
2769     start_pos = length;
2770
2771   if (end_pos <= start_pos)
2772       return g_strdup ("");
2773   else if (priv->visible)
2774     {
2775       start = g_utf8_offset_to_pointer (text, start_pos);
2776       end = g_utf8_offset_to_pointer (start, end_pos - start_pos);
2777       return g_strndup (start, end - start);
2778     }
2779   else
2780     {
2781       str = g_string_sized_new (length * 2);
2782
2783       /* Figure out what our invisible char is and encode it */
2784       if (!priv->invisible_char)
2785           invisible_char = priv->invisible_char_set ? ' ' : '*';
2786       else
2787           invisible_char = priv->invisible_char;
2788       char_len = g_unichar_to_utf8 (invisible_char, char_str);
2789
2790       /*
2791        * Add hidden characters for each character in the text
2792        * buffer. If there is a password hint, then keep that
2793        * character visible.
2794        */
2795
2796       password_hint = g_object_get_qdata (G_OBJECT (entry), quark_password_hint);
2797       for (i = start_pos; i < end_pos; ++i)
2798         {
2799           if (password_hint && i == password_hint->position)
2800             {
2801               start = g_utf8_offset_to_pointer (text, i);
2802               g_string_append_len (str, start, g_utf8_next_char (start) - start);
2803             }
2804           else
2805             {
2806               g_string_append_len (str, char_str, char_len);
2807             }
2808         }
2809
2810       return g_string_free (str, FALSE);
2811     }
2812 }
2813
2814 static void
2815 update_cursors (GtkWidget *widget)
2816 {
2817   GtkEntry *entry = GTK_ENTRY (widget);
2818   GtkEntryPrivate *priv = entry->priv;
2819   EntryIconInfo *icon_info = NULL;
2820   GdkDisplay *display;
2821   GdkCursor *cursor;
2822   gint i;
2823
2824   for (i = 0; i < MAX_ICONS; i++)
2825     {
2826       if ((icon_info = priv->icons[i]) != NULL)
2827         {
2828           if (!_gtk_icon_helper_get_is_empty (icon_info->icon_helper) && 
2829               icon_info->window != NULL)
2830             gdk_window_show_unraised (icon_info->window);
2831
2832           /* The icon windows are not children of the visible entry window,
2833            * thus we can't just inherit the xterm cursor. Slight complication 
2834            * here is that for the entry, insensitive => arrow cursor, but for 
2835            * an icon in a sensitive entry, insensitive => xterm cursor.
2836            */
2837           if (gtk_widget_is_sensitive (widget) &&
2838               (icon_info->insensitive || 
2839                (icon_info->nonactivatable && icon_info->target_list == NULL)))
2840             {
2841               display = gtk_widget_get_display (widget);
2842               cursor = gdk_cursor_new_for_display (display, GDK_XTERM);
2843               gdk_window_set_cursor (icon_info->window, cursor);
2844               g_object_unref (cursor);
2845             }
2846           else
2847             {
2848               gdk_window_set_cursor (icon_info->window, NULL);
2849             }
2850         }
2851     }
2852 }
2853
2854 static void
2855 realize_icon_info (GtkWidget            *widget, 
2856                    GtkEntryIconPosition  icon_pos)
2857 {
2858   GtkEntry *entry = GTK_ENTRY (widget);
2859   GtkEntryPrivate *priv = entry->priv;
2860   EntryIconInfo *icon_info = priv->icons[icon_pos];
2861   GdkWindowAttr attributes;
2862   gint attributes_mask;
2863
2864   g_return_if_fail (icon_info != NULL);
2865
2866   attributes.x = 0;
2867   attributes.y = 0;
2868   attributes.width = 1;
2869   attributes.height = 1;
2870   attributes.window_type = GDK_WINDOW_CHILD;
2871   attributes.wclass = GDK_INPUT_ONLY;
2872   attributes.event_mask = gtk_widget_get_events (widget);
2873   attributes.event_mask |= (GDK_BUTTON_PRESS_MASK |
2874                                 GDK_BUTTON_RELEASE_MASK |
2875                                 GDK_BUTTON1_MOTION_MASK |
2876                                 GDK_BUTTON3_MOTION_MASK |
2877                                 GDK_POINTER_MOTION_HINT_MASK |
2878                                 GDK_POINTER_MOTION_MASK |
2879                                 GDK_ENTER_NOTIFY_MASK |
2880                             GDK_LEAVE_NOTIFY_MASK);
2881   attributes_mask = GDK_WA_X | GDK_WA_Y;
2882
2883   icon_info->window = gdk_window_new (gtk_widget_get_window (widget),
2884                                       &attributes,
2885                                       attributes_mask);
2886   gdk_window_set_user_data (icon_info->window, widget);
2887
2888   gtk_widget_queue_resize (widget);
2889 }
2890
2891 static EntryIconInfo*
2892 construct_icon_info (GtkWidget            *widget, 
2893                      GtkEntryIconPosition  icon_pos)
2894 {
2895   GtkEntry *entry = GTK_ENTRY (widget);
2896   GtkEntryPrivate *priv = entry->priv;
2897   EntryIconInfo *icon_info;
2898
2899   g_return_val_if_fail (priv->icons[icon_pos] == NULL, NULL);
2900
2901   icon_info = g_slice_new0 (EntryIconInfo);
2902   priv->icons[icon_pos] = icon_info;
2903
2904   icon_info->icon_helper = _gtk_icon_helper_new ();
2905
2906   if (gtk_widget_get_realized (widget))
2907     realize_icon_info (widget, icon_pos);
2908
2909   return icon_info;
2910 }
2911
2912 static void
2913 gtk_entry_map (GtkWidget *widget)
2914 {
2915   GtkEntry *entry = GTK_ENTRY (widget);
2916   GtkEntryPrivate *priv = entry->priv;
2917   EntryIconInfo *icon_info = NULL;
2918   gint i;
2919
2920   GTK_WIDGET_CLASS (gtk_entry_parent_class)->map (widget);
2921
2922   gdk_window_show (priv->text_area);
2923
2924   for (i = 0; i < MAX_ICONS; i++)
2925     {
2926       if ((icon_info = priv->icons[i]) != NULL)
2927         {
2928           if (!_gtk_icon_helper_get_is_empty (icon_info->icon_helper) &&
2929               icon_info->window != NULL)
2930             gdk_window_show (icon_info->window);
2931         }
2932     }
2933
2934   update_cursors (widget);
2935 }
2936
2937 static void
2938 gtk_entry_unmap (GtkWidget *widget)
2939 {
2940   GtkEntry *entry = GTK_ENTRY (widget);
2941   GtkEntryPrivate *priv = entry->priv;
2942   EntryIconInfo *icon_info = NULL;
2943   gint i;
2944
2945   for (i = 0; i < MAX_ICONS; i++)
2946     {
2947       if ((icon_info = priv->icons[i]) != NULL)
2948         {
2949           if (!_gtk_icon_helper_get_is_empty (icon_info->icon_helper) && 
2950               icon_info->window != NULL)
2951             gdk_window_hide (icon_info->window);
2952         }
2953     }
2954
2955   gdk_window_hide (priv->text_area);
2956
2957   GTK_WIDGET_CLASS (gtk_entry_parent_class)->unmap (widget);
2958 }
2959
2960 static void
2961 gtk_entry_realize (GtkWidget *widget)
2962 {
2963   GtkEntry *entry;
2964   GtkEntryPrivate *priv;
2965   EntryIconInfo *icon_info;
2966   GdkWindow *window;
2967   GdkWindowAttr attributes;
2968   gint attributes_mask;
2969   gint frame_x, frame_y;
2970   int i;
2971
2972   gtk_widget_set_realized (widget, TRUE);
2973   window = gtk_widget_get_parent_window (widget);
2974   gtk_widget_set_window (widget, window);
2975   g_object_ref (window);
2976
2977   entry = GTK_ENTRY (widget);
2978   priv = entry->priv;
2979
2980   attributes.window_type = GDK_WINDOW_CHILD;
2981   attributes.wclass = GDK_INPUT_ONLY;
2982   attributes.event_mask = gtk_widget_get_events (widget);
2983   attributes.event_mask |= (GDK_BUTTON_PRESS_MASK |
2984                             GDK_BUTTON_RELEASE_MASK |
2985                             GDK_BUTTON1_MOTION_MASK |
2986                             GDK_BUTTON3_MOTION_MASK |
2987                             GDK_POINTER_MOTION_HINT_MASK |
2988                             GDK_POINTER_MOTION_MASK |
2989                             GDK_ENTER_NOTIFY_MASK |
2990                             GDK_LEAVE_NOTIFY_MASK);
2991   attributes_mask = GDK_WA_X | GDK_WA_Y;
2992
2993   get_text_area_size (entry, &attributes.x, &attributes.y, &attributes.width, &attributes.height);
2994
2995   get_frame_size (entry, TRUE, &frame_x, &frame_y, NULL, NULL);
2996   attributes.x += frame_x;
2997   attributes.y += frame_y;
2998
2999   if (gtk_widget_is_sensitive (widget))
3000     {
3001       attributes.cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget), GDK_XTERM);
3002       attributes_mask |= GDK_WA_CURSOR;
3003     }
3004
3005   priv->text_area = gdk_window_new (gtk_widget_get_window (widget),
3006                                     &attributes,
3007                                     attributes_mask);
3008
3009   gdk_window_set_user_data (priv->text_area, entry);
3010
3011   if (attributes_mask & GDK_WA_CURSOR)
3012     g_object_unref (attributes.cursor);
3013
3014   gtk_im_context_set_client_window (priv->im_context, priv->text_area);
3015
3016   gtk_entry_adjust_scroll (entry);
3017   gtk_entry_update_primary_selection (entry);
3018
3019
3020   /* If the icon positions are already setup, create their windows.
3021    * Otherwise if they don't exist yet, then construct_icon_info()
3022    * will create the windows once the widget is already realized.
3023    */
3024   for (i = 0; i < MAX_ICONS; i++)
3025     {
3026       if ((icon_info = priv->icons[i]) != NULL)
3027         {
3028           if (icon_info->window == NULL)
3029             realize_icon_info (widget, i);
3030         }
3031     }
3032 }
3033
3034 static void
3035 gtk_entry_unrealize (GtkWidget *widget)
3036 {
3037   GtkEntry *entry = GTK_ENTRY (widget);
3038   GtkEntryPrivate *priv = entry->priv;
3039   GtkClipboard *clipboard;
3040   EntryIconInfo *icon_info;
3041   gint i;
3042
3043   gtk_entry_reset_layout (entry);
3044   
3045   gtk_im_context_set_client_window (priv->im_context, NULL);
3046
3047   clipboard = gtk_widget_get_clipboard (widget, GDK_SELECTION_PRIMARY);
3048   if (gtk_clipboard_get_owner (clipboard) == G_OBJECT (entry))
3049     gtk_clipboard_clear (clipboard);
3050   
3051   if (priv->text_area)
3052     {
3053       gdk_window_set_user_data (priv->text_area, NULL);
3054       gdk_window_destroy (priv->text_area);
3055       priv->text_area = NULL;
3056     }
3057
3058   if (priv->popup_menu)
3059     {
3060       gtk_widget_destroy (priv->popup_menu);
3061       priv->popup_menu = NULL;
3062     }
3063
3064   GTK_WIDGET_CLASS (gtk_entry_parent_class)->unrealize (widget);
3065
3066   for (i = 0; i < MAX_ICONS; i++)
3067     {
3068       if ((icon_info = priv->icons[i]) != NULL)
3069         {
3070           if (icon_info->window != NULL)
3071             {
3072               gdk_window_destroy (icon_info->window);
3073               icon_info->window = NULL;
3074             }
3075         }
3076     }
3077 }
3078
3079 void
3080 _gtk_entry_get_borders (GtkEntry *entry,
3081                         GtkBorder *border_out)
3082 {
3083   GtkEntryPrivate *priv = entry->priv;
3084   GtkWidget *widget = GTK_WIDGET (entry);
3085   GtkBorder tmp = { 0, 0, 0, 0 };
3086   GtkStyleContext *context;
3087
3088   context = gtk_widget_get_style_context (widget);
3089   gtk_style_context_get_padding (context, 0, &tmp);
3090
3091   if (priv->has_frame)
3092     {
3093       GtkBorder border;
3094
3095       gtk_style_context_get_border (context, 0, &border);
3096       tmp.top += border.top;
3097       tmp.right += border.right;
3098       tmp.bottom += border.bottom;
3099       tmp.left += border.left;
3100     }
3101
3102   if (!priv->interior_focus)
3103     {
3104       tmp.top += priv->focus_width;
3105       tmp.right += priv->focus_width;
3106       tmp.bottom += priv->focus_width;
3107       tmp.left += priv->focus_width;
3108     }
3109
3110   if (border_out != NULL)
3111     *border_out = tmp;
3112 }
3113
3114 static void
3115 gtk_entry_get_preferred_width (GtkWidget *widget,
3116                                gint      *minimum,
3117                                gint      *natural)
3118 {
3119   GtkEntry *entry = GTK_ENTRY (widget);
3120   GtkEntryPrivate *priv = entry->priv;
3121   PangoFontMetrics *metrics;
3122   GtkBorder borders;
3123   PangoContext *context;
3124   GtkStyleContext *style_context;
3125   GtkStateFlags state;
3126   gint icon_widths = 0;
3127   gint icon_width, i;
3128   gint width;
3129
3130   context = gtk_widget_get_pango_context (widget);
3131
3132   style_context = gtk_widget_get_style_context (widget);
3133   state = gtk_widget_get_state_flags (widget);
3134
3135   metrics = pango_context_get_metrics (context,
3136                                        gtk_style_context_get_font (style_context, state),
3137                                        pango_context_get_language (context));
3138
3139   _gtk_entry_get_borders (entry, &borders);
3140
3141   if (priv->width_chars < 0)
3142     width = MIN_ENTRY_WIDTH + borders.left + borders.right;
3143   else
3144     {
3145       gint char_width = pango_font_metrics_get_approximate_char_width (metrics);
3146       gint digit_width = pango_font_metrics_get_approximate_digit_width (metrics);
3147       gint char_pixels = (MAX (char_width, digit_width) + PANGO_SCALE - 1) / PANGO_SCALE;
3148
3149       width = char_pixels * priv->width_chars + borders.left + borders.right;
3150     }
3151
3152   for (i = 0; i < MAX_ICONS; i++)
3153     {
3154       icon_width = get_icon_width (entry, i);
3155       if (icon_width > 0)
3156         icon_widths += icon_width;
3157     }
3158
3159   if (icon_widths > width)
3160     width += icon_widths;
3161
3162   pango_font_metrics_unref (metrics);
3163
3164   *minimum = width;
3165   *natural = width;
3166 }
3167
3168 static void
3169 gtk_entry_get_preferred_height (GtkWidget *widget,
3170                                 gint      *minimum,
3171                                 gint      *natural)
3172 {
3173   GtkEntry *entry = GTK_ENTRY (widget);
3174   GtkEntryPrivate *priv = entry->priv;
3175   PangoFontMetrics *metrics;
3176   GtkBorder borders;
3177   GtkStyleContext *style_context;
3178   GtkStateFlags state;
3179   PangoContext *context;
3180   gint height;
3181
3182   context = gtk_widget_get_pango_context (widget);
3183
3184   style_context = gtk_widget_get_style_context (widget);
3185   state = gtk_widget_get_state_flags (widget);
3186
3187   metrics = pango_context_get_metrics (context,
3188                                        gtk_style_context_get_font (style_context, state),
3189                                        pango_context_get_language (context));
3190
3191   priv->ascent = pango_font_metrics_get_ascent (metrics);
3192   priv->descent = pango_font_metrics_get_descent (metrics);
3193
3194   _gtk_entry_get_borders (entry, &borders);
3195
3196   height = PANGO_PIXELS (priv->ascent + priv->descent) + borders.top + borders.bottom;
3197
3198   pango_font_metrics_unref (metrics);
3199
3200   *minimum = height;
3201   *natural = height;
3202 }
3203
3204 static void
3205 place_windows (GtkEntry *entry)
3206 {
3207   GtkWidget *widget = GTK_WIDGET (entry);
3208   GtkEntryPrivate *priv = entry->priv;
3209   gint x, y, width, height;
3210   gint frame_x, frame_y;
3211   GtkAllocation primary;
3212   GtkAllocation secondary;
3213   EntryIconInfo *icon_info = NULL;
3214
3215   get_frame_size (entry, TRUE, &frame_x, &frame_y, NULL, NULL);
3216   get_text_area_size (entry, &x, &y, &width, &height);
3217   get_icon_allocations (entry, &primary, &secondary);
3218
3219   if (gtk_widget_has_focus (widget) && !priv->interior_focus)
3220     y += priv->focus_width;
3221
3222   if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
3223     x += secondary.width;
3224   else
3225     x += primary.width;
3226   width -= primary.width + secondary.width;
3227
3228   x += frame_x;
3229   y += frame_y;
3230   primary.x += frame_x;
3231   primary.y += frame_y;
3232   secondary.x += frame_x;
3233   secondary.y += frame_y;
3234
3235   if ((icon_info = priv->icons[GTK_ENTRY_ICON_PRIMARY]) != NULL)
3236     gdk_window_move_resize (icon_info->window,
3237                             primary.x, primary.y,
3238                             primary.width, primary.height);
3239
3240   if ((icon_info = priv->icons[GTK_ENTRY_ICON_SECONDARY]) != NULL)
3241     gdk_window_move_resize (icon_info->window,
3242                             secondary.x, secondary.y,
3243                             secondary.width, secondary.height);
3244
3245   gdk_window_move_resize (priv->text_area, x, y, width, height);
3246 }
3247
3248 static void
3249 gtk_entry_get_text_area_size (GtkEntry *entry,
3250                               gint     *x,
3251                               gint     *y,
3252                               gint     *width,
3253                               gint     *height)
3254 {
3255   GtkEntryPrivate *priv = entry->priv;
3256   GtkWidget *widget = GTK_WIDGET (entry);
3257   GtkAllocation allocation;
3258   GtkRequisition requisition;
3259   gint req_height;
3260   gint frame_height;
3261   GtkBorder borders;
3262
3263   gtk_widget_get_preferred_size (widget, &requisition, NULL);
3264   req_height = requisition.height - gtk_widget_get_margin_top (widget) - gtk_widget_get_margin_bottom (widget);
3265
3266   gtk_widget_get_allocation (widget, &allocation);
3267   _gtk_entry_get_borders (entry, &borders);
3268
3269   if (gtk_widget_get_realized (widget))
3270     get_frame_size (entry, TRUE, NULL, NULL, NULL, &frame_height);
3271   else
3272     frame_height = req_height;
3273
3274   if (gtk_widget_has_focus (widget) && !priv->interior_focus)
3275     frame_height -= 2 * priv->focus_width;
3276
3277   if (x)
3278     *x = borders.left;
3279
3280   if (y)
3281     *y = floor ((frame_height - req_height) / 2) + borders.top;
3282
3283   if (width)
3284     *width = allocation.width - borders.left - borders.right;
3285
3286   if (height)
3287     *height = req_height - borders.top - borders.bottom;
3288 }
3289
3290 static void
3291 get_text_area_size (GtkEntry *entry,
3292                     gint     *x,
3293                     gint     *y,
3294                     gint     *width,
3295                     gint     *height)
3296 {
3297   GtkEntryClass *class;
3298
3299   g_return_if_fail (GTK_IS_ENTRY (entry));
3300
3301   class = GTK_ENTRY_GET_CLASS (entry);
3302
3303   if (class->get_text_area_size)
3304     class->get_text_area_size (entry, x, y, width, height);
3305 }
3306
3307
3308 static void
3309 get_frame_size (GtkEntry *entry,
3310                 gboolean  relative_to_window,
3311                 gint     *x,
3312                 gint     *y,
3313                 gint     *width,
3314                 gint     *height)
3315 {
3316   GtkEntryPrivate *priv = entry->priv;
3317   GtkAllocation allocation;
3318   GtkRequisition requisition;
3319   GtkWidget *widget = GTK_WIDGET (entry);
3320   gint req_height;
3321
3322   gtk_widget_get_preferred_size (widget, &requisition, NULL);
3323
3324   req_height = requisition.height - gtk_widget_get_margin_top (widget) - gtk_widget_get_margin_bottom (widget);
3325
3326   gtk_widget_get_allocation (widget, &allocation);
3327
3328   if (x)
3329     *x = relative_to_window ? allocation.x : 0;
3330
3331   if (y)
3332     {
3333       if (priv->is_cell_renderer)
3334         *y = 0;
3335       else
3336         *y = (allocation.height - req_height) / 2;
3337
3338       if (relative_to_window)
3339         *y += allocation.y;
3340     }
3341
3342   if (width)
3343     *width = allocation.width;
3344
3345   if (height)
3346     {
3347       if (priv->is_cell_renderer)
3348         *height = allocation.height;
3349       else
3350         *height = req_height;
3351     }
3352 }
3353
3354 static void
3355 gtk_entry_size_allocate (GtkWidget     *widget,
3356                          GtkAllocation *allocation)
3357 {
3358   GtkEntry *entry = GTK_ENTRY (widget);
3359
3360   gtk_widget_set_allocation (widget, allocation);
3361
3362   if (gtk_widget_get_realized (widget))
3363     {
3364       GtkEntryCompletion* completion;
3365
3366       place_windows (entry);
3367       gtk_entry_recompute (entry);
3368
3369       completion = gtk_entry_get_completion (entry);
3370       if (completion && gtk_widget_get_mapped (completion->priv->popup_window))
3371         _gtk_entry_completion_resize_popup (completion);
3372     }
3373 }
3374
3375 static gboolean
3376 should_prelight (GtkEntry             *entry,
3377                  GtkEntryIconPosition  icon_pos)
3378 {
3379   GtkEntryPrivate *priv = entry->priv;
3380   EntryIconInfo *icon_info = priv->icons[icon_pos];
3381   gboolean prelight;
3382
3383   if (!icon_info)
3384     return FALSE;
3385
3386   if (icon_info->nonactivatable && icon_info->target_list == NULL)
3387     return FALSE;
3388
3389   if (icon_info->pressed)
3390     return FALSE;
3391
3392   gtk_widget_style_get (GTK_WIDGET (entry),
3393                         "icon-prelight", &prelight,
3394                         NULL);
3395
3396   return prelight;
3397 }
3398
3399 static void
3400 draw_icon (GtkWidget            *widget,
3401            cairo_t              *cr,
3402            GtkEntryIconPosition  icon_pos)
3403 {
3404   GtkEntry *entry = GTK_ENTRY (widget);
3405   GtkEntryPrivate *priv = entry->priv;
3406   EntryIconInfo *icon_info = priv->icons[icon_pos];
3407   gint x, y, width, height, pix_width, pix_height;
3408   GtkStyleContext *context;
3409   GtkBorder padding;
3410
3411   if (!icon_info)
3412     return;
3413
3414   width = gdk_window_get_width (icon_info->window);
3415   height = gdk_window_get_height (icon_info->window);
3416
3417   /* size_allocate hasn't been called yet. These are the default values.
3418    */
3419   if (width == 1 || height == 1)
3420     return;
3421
3422   cairo_save (cr);
3423   gtk_cairo_transform_to_window (cr, widget, icon_info->window);
3424
3425   context = gtk_widget_get_style_context (widget);
3426   gtk_entry_prepare_context_for_icon (entry, context, icon_pos);
3427   _gtk_icon_helper_get_size (icon_info->icon_helper, context,
3428                              &pix_width, &pix_height);
3429   gtk_style_context_get_padding (context, 0, &padding);
3430
3431   x = MAX (0, padding.left);
3432   y = MAX (0, (height - pix_height) / 2);
3433
3434   _gtk_icon_helper_draw (icon_info->icon_helper,
3435                          context, cr,
3436                          x, y);
3437
3438   gtk_style_context_restore (context);
3439   cairo_restore (cr);
3440 }
3441
3442
3443 static void
3444 gtk_entry_draw_frame (GtkWidget       *widget,
3445                       GtkStyleContext *context,
3446                       cairo_t         *cr)
3447 {
3448   GtkEntry *entry = GTK_ENTRY (widget);
3449   GtkEntryPrivate *priv = entry->priv;
3450   gint x = 0, y = 0, width, height;
3451   gint frame_x, frame_y;
3452
3453   cairo_save (cr);
3454
3455   get_frame_size (GTK_ENTRY (widget), FALSE, &frame_x, &frame_y, &width, &height);
3456
3457   cairo_translate (cr, frame_x, frame_y);
3458
3459   /* Fix a problem with some themes which assume that entry->text_area's
3460    * width equals widget->window's width
3461    * http://bugzilla.gnome.org/show_bug.cgi?id=466000 */
3462   if (GTK_IS_SPIN_BUTTON (widget))
3463     {
3464       GtkBorder borders;
3465
3466       gtk_entry_get_text_area_size (GTK_ENTRY (widget), &x, NULL, &width, NULL);
3467       _gtk_entry_get_borders (GTK_ENTRY (widget), &borders);
3468
3469       x -= borders.left;
3470       width += borders.left + borders.right;
3471     }
3472
3473   if (gtk_widget_has_focus (widget) && !priv->interior_focus)
3474     {
3475       x += priv->focus_width;
3476       y += priv->focus_width;
3477       width -= 2 * priv->focus_width;
3478       height -= 2 * priv->focus_width;
3479     }
3480
3481   gtk_render_background (context, cr,
3482                          x, y, width, height);
3483
3484   if (priv->has_frame)
3485     gtk_render_frame (context, cr,
3486                       x, y, width, height);
3487
3488   gtk_entry_draw_progress (widget, context, cr);
3489
3490   if (gtk_widget_has_visible_focus (widget) && !priv->interior_focus)
3491     {
3492       x -= priv->focus_width;
3493       y -= priv->focus_width;
3494       width += 2 * priv->focus_width;
3495       height += 2 * priv->focus_width;
3496
3497       gtk_render_focus (context, cr,
3498                         0, 0, width, height);
3499     }
3500
3501   cairo_restore (cr);
3502 }
3503
3504 static void
3505 gtk_entry_prepare_context_for_progress (GtkEntry *entry,
3506                                         GtkStyleContext *context)
3507 {
3508   GtkEntryPrivate *private = entry->priv;
3509
3510   gtk_style_context_save (context);
3511   gtk_style_context_add_class (context, GTK_STYLE_CLASS_PROGRESSBAR);
3512   if (private->progress_pulse_mode)
3513     gtk_style_context_add_class (context, GTK_STYLE_CLASS_PULSE);
3514 }
3515
3516 static void
3517 get_progress_area (GtkWidget *widget,
3518                    gint       *x,
3519                    gint       *y,
3520                    gint       *width,
3521                    gint       *height)
3522 {
3523   GtkEntry *entry = GTK_ENTRY (widget);
3524   GtkEntryPrivate *private = entry->priv;
3525   GtkStyleContext *context;
3526   GtkBorder margin;
3527
3528   get_frame_size (GTK_ENTRY (widget), FALSE, NULL, NULL, width, height);
3529   *x = 0;
3530   *y = 0;
3531
3532   if (!private->interior_focus)
3533     {
3534       *x -= private->focus_width;
3535       *y -= private->focus_width;
3536       *width += 2 * private->focus_width;
3537       *height += 2 * private->focus_width;
3538     }
3539
3540   context = gtk_widget_get_style_context (widget);
3541   gtk_entry_prepare_context_for_progress (entry, context);
3542   gtk_style_context_get_margin (context, 0, &margin);
3543
3544   gtk_style_context_restore (context);
3545
3546   *x += margin.left;
3547   *y += margin.top;
3548   *width -= margin.left + margin.right;
3549   *height -= margin.top + margin.bottom;
3550
3551   if (private->progress_pulse_mode)
3552     {
3553       gdouble value = private->progress_pulse_current;
3554
3555       *x += (gint) floor(value * (*width));
3556       *width = (gint) ceil(private->progress_pulse_fraction * (*width));
3557     }
3558   else if (private->progress_fraction > 0)
3559     {
3560       gdouble value = private->progress_fraction;
3561
3562       if (gtk_widget_get_direction (GTK_WIDGET (entry)) == GTK_TEXT_DIR_RTL)
3563         {
3564           gint bar_width;
3565
3566           bar_width = floor(value * (*width) + 0.5);
3567           *x += *width - bar_width;
3568           *width = bar_width;
3569         }
3570       else
3571         {
3572           *width = (gint) floor(value * (*width) + 0.5);
3573         }
3574     }
3575   else
3576     {
3577       *width = 0;
3578       *height = 0;
3579     }
3580 }
3581
3582 static void
3583 gtk_entry_draw_progress (GtkWidget       *widget,
3584                          GtkStyleContext *context,
3585                          cairo_t         *cr)
3586 {
3587   GtkEntry *entry = GTK_ENTRY (widget);
3588   GtkEntryPrivate *private = entry->priv;
3589   gint x, y, width, height;
3590
3591   get_progress_area (widget, &x, &y, &width, &height);
3592
3593   if ((width <= 0) || (height <= 0))
3594     return;
3595  
3596   gtk_entry_prepare_context_for_progress (entry, context);
3597   gtk_render_activity (context, cr,
3598                        x, y, width, height);
3599
3600   gtk_style_context_restore (context);
3601 }
3602
3603 static gint
3604 gtk_entry_draw (GtkWidget *widget,
3605                 cairo_t   *cr)
3606 {
3607   GtkEntry *entry = GTK_ENTRY (widget);
3608   GtkStyleContext *context;
3609   GtkEntryPrivate *priv = entry->priv;
3610   int i;
3611
3612   context = gtk_widget_get_style_context (widget);
3613
3614   /* Draw entry_bg, shadow, progress and focus */
3615   gtk_entry_draw_frame (widget, context, cr);
3616
3617   /* Draw text and cursor */
3618   cairo_save (cr);
3619
3620   gtk_cairo_transform_to_window (cr, widget, priv->text_area);
3621
3622   if (priv->dnd_position != -1)
3623     gtk_entry_draw_cursor (GTK_ENTRY (widget), cr, CURSOR_DND);
3624   
3625   gtk_entry_draw_text (GTK_ENTRY (widget), cr);
3626
3627   /* When no text is being displayed at all, don't show the cursor */
3628   if (gtk_entry_get_display_mode (entry) != DISPLAY_BLANK &&
3629       gtk_widget_has_focus (widget) &&
3630       priv->selection_bound == priv->current_pos && priv->cursor_visible)
3631     gtk_entry_draw_cursor (GTK_ENTRY (widget), cr, CURSOR_STANDARD);
3632
3633   cairo_restore (cr);
3634
3635   /* Draw icons */
3636   for (i = 0; i < MAX_ICONS; i++)
3637     {
3638       EntryIconInfo *icon_info = priv->icons[i];
3639
3640       if (icon_info != NULL)
3641         draw_icon (widget, cr, i);
3642     }
3643
3644   return FALSE;
3645 }
3646
3647 static gint
3648 gtk_entry_enter_notify (GtkWidget *widget,
3649                         GdkEventCrossing *event)
3650 {
3651   GtkEntry *entry = GTK_ENTRY (widget);
3652   GtkEntryPrivate *priv = entry->priv;
3653   gint i;
3654
3655   for (i = 0; i < MAX_ICONS; i++)
3656     {
3657       EntryIconInfo *icon_info = priv->icons[i];
3658
3659       if (icon_info != NULL && event->window == icon_info->window)
3660         {
3661           if (should_prelight (entry, i))
3662             {
3663               icon_info->prelight = TRUE;
3664               gtk_widget_queue_draw (widget);
3665             }
3666
3667           break;
3668         }
3669     }
3670
3671     return FALSE;
3672 }
3673
3674 static gint
3675 gtk_entry_leave_notify (GtkWidget        *widget,
3676                         GdkEventCrossing *event)
3677 {
3678   GtkEntry *entry = GTK_ENTRY (widget);
3679   GtkEntryPrivate *priv = entry->priv;
3680   gint i;
3681
3682   for (i = 0; i < MAX_ICONS; i++)
3683     {
3684       EntryIconInfo *icon_info = priv->icons[i];
3685
3686       if (icon_info != NULL && event->window == icon_info->window)
3687         {
3688           /* a grab means that we may never see the button release */
3689           if (event->mode == GDK_CROSSING_GRAB || event->mode == GDK_CROSSING_GTK_GRAB)
3690             icon_info->pressed = FALSE;
3691
3692           if (should_prelight (entry, i))
3693             {
3694               icon_info->prelight = FALSE;
3695               gtk_widget_queue_draw (widget);
3696             }
3697
3698           break;
3699         }
3700     }
3701
3702   return FALSE;
3703 }
3704
3705 static void
3706 gtk_entry_get_pixel_ranges (GtkEntry  *entry,
3707                             gint     **ranges,
3708                             gint      *n_ranges)
3709 {
3710   gint start_char, end_char;
3711
3712   if (gtk_editable_get_selection_bounds (GTK_EDITABLE (entry), &start_char, &end_char))
3713     {
3714       PangoLayout *layout = gtk_entry_ensure_layout (entry, TRUE);
3715       PangoLayoutLine *line = pango_layout_get_lines_readonly (layout)->data;
3716       const char *text = pango_layout_get_text (layout);
3717       gint start_index = g_utf8_offset_to_pointer (text, start_char) - text;
3718       gint end_index = g_utf8_offset_to_pointer (text, end_char) - text;
3719       gint real_n_ranges, i;
3720
3721       pango_layout_line_get_x_ranges (line, start_index, end_index, ranges, &real_n_ranges);
3722
3723       if (ranges)
3724         {
3725           gint *r = *ranges;
3726           
3727           for (i = 0; i < real_n_ranges; ++i)
3728             {
3729               r[2 * i + 1] = (r[2 * i + 1] - r[2 * i]) / PANGO_SCALE;
3730               r[2 * i] = r[2 * i] / PANGO_SCALE;
3731             }
3732         }
3733       
3734       if (n_ranges)
3735         *n_ranges = real_n_ranges;
3736     }
3737   else
3738     {
3739       if (n_ranges)
3740         *n_ranges = 0;
3741       if (ranges)
3742         *ranges = NULL;
3743     }
3744 }
3745
3746 static gboolean
3747 in_selection (GtkEntry *entry,
3748               gint      x)
3749 {
3750   gint *ranges;
3751   gint n_ranges, i;
3752   gint retval = FALSE;
3753
3754   gtk_entry_get_pixel_ranges (entry, &ranges, &n_ranges);
3755
3756   for (i = 0; i < n_ranges; ++i)
3757     {
3758       if (x >= ranges[2 * i] && x < ranges[2 * i] + ranges[2 * i + 1])
3759         {
3760           retval = TRUE;
3761           break;
3762         }
3763     }
3764
3765   g_free (ranges);
3766   return retval;
3767 }
3768               
3769 static gint
3770 gtk_entry_button_press (GtkWidget      *widget,
3771                         GdkEventButton *event)
3772 {
3773   GtkEntry *entry = GTK_ENTRY (widget);
3774   GtkEditable *editable = GTK_EDITABLE (widget);
3775   GtkEntryPrivate *priv = entry->priv;
3776   EntryIconInfo *icon_info = NULL;
3777   gint tmp_pos;
3778   gint sel_start, sel_end;
3779   gint i;
3780
3781   for (i = 0; i < MAX_ICONS; i++)
3782     {
3783       icon_info = priv->icons[i];
3784
3785       if (!icon_info || icon_info->insensitive)
3786         continue;
3787
3788       if (event->window == icon_info->window)
3789         {
3790           if (should_prelight (entry, i))
3791             {
3792               icon_info->prelight = FALSE;
3793               gtk_widget_queue_draw (widget);
3794             }
3795
3796           priv->start_x = event->x;
3797           priv->start_y = event->y;
3798           icon_info->pressed = TRUE;
3799
3800           if (!icon_info->nonactivatable)
3801             g_signal_emit (entry, signals[ICON_PRESS], 0, i, event);
3802
3803           return TRUE;
3804         }
3805     }
3806
3807   if (event->window != priv->text_area ||
3808       (priv->button && event->button != priv->button))
3809     return FALSE;
3810
3811   gtk_entry_reset_blink_time (entry);
3812
3813   priv->button = event->button;
3814   
3815   if (!gtk_widget_has_focus (widget))
3816     {
3817       priv->in_click = TRUE;
3818       gtk_widget_grab_focus (widget);
3819       priv->in_click = FALSE;
3820     }
3821
3822   tmp_pos = gtk_entry_find_position (entry, event->x + priv->scroll_offset);
3823
3824   if (gdk_event_triggers_context_menu ((GdkEvent *) event))
3825     {
3826       gtk_entry_do_popup (entry, event);
3827       priv->button = 0; /* Don't wait for release, since the menu will gtk_grab_add */
3828
3829       return TRUE;
3830     }
3831   else if (event->button == GDK_BUTTON_PRIMARY)
3832     {
3833       gboolean have_selection = gtk_editable_get_selection_bounds (editable, &sel_start, &sel_end);
3834
3835       priv->select_words = FALSE;
3836       priv->select_lines = FALSE;
3837
3838       if (event->state &
3839           gtk_widget_get_modifier_mask (widget,
3840                                         GDK_MODIFIER_INTENT_EXTEND_SELECTION))
3841         {
3842           _gtk_entry_reset_im_context (entry);
3843
3844           if (!have_selection) /* select from the current position to the clicked position */
3845             sel_start = sel_end = priv->current_pos;
3846           
3847           if (tmp_pos > sel_start && tmp_pos < sel_end)
3848             {
3849               /* Truncate current selection, but keep it as big as possible */
3850               if (tmp_pos - sel_start > sel_end - tmp_pos)
3851                 gtk_entry_set_positions (entry, sel_start, tmp_pos);
3852               else
3853                 gtk_entry_set_positions (entry, tmp_pos, sel_end);
3854             }
3855           else
3856             {
3857               gboolean extend_to_left;
3858               gint start, end;
3859
3860               /* Figure out what click selects and extend current selection */
3861               switch (event->type)
3862                 {
3863                 case GDK_BUTTON_PRESS:
3864                   gtk_entry_set_positions (entry, tmp_pos, tmp_pos);
3865                   break;
3866                   
3867                 case GDK_2BUTTON_PRESS:
3868                   priv->select_words = TRUE;
3869                   gtk_entry_select_word (entry);
3870                   break;
3871                   
3872                 case GDK_3BUTTON_PRESS:
3873                   priv->select_lines = TRUE;
3874                   gtk_entry_select_line (entry);
3875                   break;
3876
3877                 default:
3878                   break;
3879                 }
3880
3881               start = MIN (priv->current_pos, priv->selection_bound);
3882               start = MIN (sel_start, start);
3883               
3884               end = MAX (priv->current_pos, priv->selection_bound);
3885               end = MAX (sel_end, end);
3886
3887               if (tmp_pos == sel_start || tmp_pos == sel_end)
3888                 extend_to_left = (tmp_pos == start);
3889               else
3890                 extend_to_left = (end == sel_end);
3891               
3892               if (extend_to_left)
3893                 gtk_entry_set_positions (entry, start, end);
3894               else
3895                 gtk_entry_set_positions (entry, end, start);
3896             }
3897         }
3898       else /* no shift key */
3899         switch (event->type)
3900         {
3901         case GDK_BUTTON_PRESS:
3902           if (in_selection (entry, event->x + priv->scroll_offset))
3903             {
3904               /* Click inside the selection - we'll either start a drag, or
3905                * clear the selection
3906                */
3907               priv->in_drag = TRUE;
3908               priv->drag_start_x = event->x + priv->scroll_offset;
3909               priv->drag_start_y = event->y;
3910             }
3911           else
3912             gtk_editable_set_position (editable, tmp_pos);
3913           break;
3914  
3915         case GDK_2BUTTON_PRESS:
3916           /* We ALWAYS receive a GDK_BUTTON_PRESS immediately before 
3917            * receiving a GDK_2BUTTON_PRESS so we need to reset
3918            * priv->in_drag which may have been set above
3919            */
3920           priv->in_drag = FALSE;
3921           priv->select_words = TRUE;
3922           gtk_entry_select_word (entry);
3923           break;
3924         
3925         case GDK_3BUTTON_PRESS:
3926           /* We ALWAYS receive a GDK_BUTTON_PRESS immediately before
3927            * receiving a GDK_3BUTTON_PRESS so we need to reset
3928            * priv->in_drag which may have been set above
3929            */
3930           priv->in_drag = FALSE;
3931           priv->select_lines = TRUE;
3932           gtk_entry_select_line (entry);
3933           break;
3934
3935         default:
3936           break;
3937         }
3938
3939       return TRUE;
3940     }
3941   else if (event->button == GDK_BUTTON_MIDDLE && event->type == GDK_BUTTON_PRESS)
3942     {
3943       if (priv->editable)
3944         {
3945           priv->insert_pos = tmp_pos;
3946           gtk_entry_paste (entry, GDK_SELECTION_PRIMARY);
3947           return TRUE;
3948         }
3949       else
3950         {
3951           gtk_widget_error_bell (widget);
3952         }
3953     }
3954
3955   return FALSE;
3956 }
3957
3958 static gint
3959 gtk_entry_button_release (GtkWidget      *widget,
3960                           GdkEventButton *event)
3961 {
3962   GtkEntry *entry = GTK_ENTRY (widget);
3963   GtkEntryPrivate *priv = entry->priv;
3964   EntryIconInfo *icon_info = NULL;
3965   gint i;
3966
3967   for (i = 0; i < MAX_ICONS; i++)
3968     {
3969       icon_info = priv->icons[i];
3970
3971       if (!icon_info || icon_info->insensitive)
3972         continue;
3973
3974       if (event->window == icon_info->window)
3975         {
3976           icon_info->pressed = FALSE;
3977
3978           if (should_prelight (entry, i) &&
3979               event->x >= 0 && event->y >= 0 &&
3980               event->x < gdk_window_get_width (icon_info->window) &&
3981               event->y < gdk_window_get_height (icon_info->window))
3982             {
3983               icon_info->prelight = TRUE;
3984               gtk_widget_queue_draw (widget);
3985             }
3986
3987           if (!icon_info->nonactivatable)
3988             g_signal_emit (entry, signals[ICON_RELEASE], 0, i, event);
3989
3990           return TRUE;
3991         }
3992     }
3993
3994   if (event->window != priv->text_area || priv->button != event->button)
3995     return FALSE;
3996
3997   if (priv->in_drag)
3998     {
3999       gint tmp_pos = gtk_entry_find_position (entry, priv->drag_start_x);
4000
4001       gtk_editable_set_position (GTK_EDITABLE (entry), tmp_pos);
4002
4003       priv->in_drag = 0;
4004     }
4005   
4006   priv->button = 0;
4007   
4008   gtk_entry_update_primary_selection (entry);
4009               
4010   return TRUE;
4011 }
4012
4013 static gchar *
4014 _gtk_entry_get_selected_text (GtkEntry *entry)
4015 {
4016   GtkEditable *editable = GTK_EDITABLE (entry);
4017   gint         start_text, end_text;
4018   gchar       *text = NULL;
4019
4020   if (gtk_editable_get_selection_bounds (editable, &start_text, &end_text))
4021     text = gtk_editable_get_chars (editable, start_text, end_text);
4022
4023   return text;
4024 }
4025
4026 static gint
4027 gtk_entry_motion_notify (GtkWidget      *widget,
4028                          GdkEventMotion *event)
4029 {
4030   GtkEntry *entry = GTK_ENTRY (widget);
4031   GtkEntryPrivate *priv = entry->priv;
4032   EntryIconInfo *icon_info = NULL;
4033   gint tmp_pos;
4034   gint i;
4035
4036   for (i = 0; i < MAX_ICONS; i++)
4037     {
4038       icon_info = priv->icons[i];
4039
4040       if (!icon_info || icon_info->insensitive)
4041         continue;
4042
4043       if (event->window == icon_info->window)
4044         {
4045           if (icon_info->pressed &&
4046               icon_info->target_list != NULL &&
4047               gtk_drag_check_threshold (widget,
4048                                         priv->start_x,
4049                                         priv->start_y,
4050                                         event->x,
4051                                         event->y))
4052             {
4053               icon_info->in_drag = TRUE;
4054               icon_info->pressed = FALSE;
4055               gtk_drag_begin (widget,
4056                               icon_info->target_list,
4057                               icon_info->actions,
4058                               1,
4059                               (GdkEvent*)event);
4060             }
4061
4062           return TRUE;
4063         }
4064     }
4065
4066   if (priv->mouse_cursor_obscured)
4067     {
4068       GdkCursor *cursor;
4069
4070       cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget), GDK_XTERM);
4071       gdk_window_set_cursor (priv->text_area, cursor);
4072       g_object_unref (cursor);
4073       priv->mouse_cursor_obscured = FALSE;
4074     }
4075
4076   if (event->window != priv->text_area || priv->button != GDK_BUTTON_PRIMARY)
4077     return FALSE;
4078
4079   if (priv->select_lines)
4080     return TRUE;
4081
4082   gdk_event_request_motions (event);
4083
4084   if (priv->in_drag)
4085     {
4086       if (gtk_entry_get_display_mode (entry) == DISPLAY_NORMAL &&
4087           gtk_drag_check_threshold (widget,
4088                                     priv->drag_start_x, priv->drag_start_y,
4089                                     event->x + priv->scroll_offset, event->y))
4090         {
4091           GdkDragContext *context;
4092           GtkTargetList  *target_list = gtk_target_list_new (NULL, 0);
4093           guint actions = priv->editable ? GDK_ACTION_COPY | GDK_ACTION_MOVE : GDK_ACTION_COPY;
4094           gchar *text = NULL;
4095           cairo_surface_t *surface;
4096
4097           gtk_target_list_add_text_targets (target_list, 0);
4098
4099           text = _gtk_entry_get_selected_text (entry);
4100           surface = _gtk_text_util_create_drag_icon (widget, text, -1);
4101
4102           context = gtk_drag_begin (widget, target_list, actions,
4103                                     priv->button, (GdkEvent *)event);
4104           
4105           if (surface)
4106             gtk_drag_set_icon_surface (context, surface);
4107           else
4108             gtk_drag_set_icon_default (context);
4109           
4110           if (surface)
4111             cairo_surface_destroy (surface);
4112           g_free (text);
4113
4114           priv->in_drag = FALSE;
4115           priv->button = 0;
4116           
4117           gtk_target_list_unref (target_list);
4118         }
4119     }
4120   else
4121     {
4122       if (event->y < 0)
4123         tmp_pos = 0;
4124       else if (event->y >= gdk_window_get_height (priv->text_area))
4125         tmp_pos = gtk_entry_buffer_get_length (get_buffer (entry));
4126       else
4127         tmp_pos = gtk_entry_find_position (entry, event->x + priv->scroll_offset);
4128
4129       if (priv->select_words)
4130         {
4131           gint min, max;
4132           gint old_min, old_max;
4133           gint pos, bound;
4134           
4135           min = gtk_entry_move_backward_word (entry, tmp_pos, TRUE);
4136           max = gtk_entry_move_forward_word (entry, tmp_pos, TRUE);
4137
4138           pos = priv->current_pos;
4139           bound = priv->selection_bound;
4140
4141           old_min = MIN(priv->current_pos, priv->selection_bound);
4142           old_max = MAX(priv->current_pos, priv->selection_bound);
4143           
4144           if (min < old_min)
4145             {
4146               pos = min;
4147               bound = old_max;
4148             }
4149           else if (old_max < max) 
4150             {
4151               pos = max;
4152               bound = old_min;
4153             }
4154           else if (pos == old_min) 
4155             {
4156               if (priv->current_pos != min)
4157                 pos = max;
4158             }
4159           else 
4160             {
4161               if (priv->current_pos != max)
4162                 pos = min;
4163             }
4164         
4165           gtk_entry_set_positions (entry, pos, bound);
4166         }
4167       else
4168         gtk_entry_set_positions (entry, tmp_pos, -1);
4169     }
4170       
4171   return TRUE;
4172 }
4173
4174 static void
4175 set_invisible_cursor (GdkWindow *window)
4176 {
4177   GdkDisplay *display;
4178   GdkCursor *cursor;
4179
4180   display = gdk_window_get_display (window);
4181   cursor = gdk_cursor_new_for_display (display, GDK_BLANK_CURSOR);
4182
4183   gdk_window_set_cursor (window, cursor);
4184
4185   g_object_unref (cursor);
4186 }
4187
4188 static void
4189 gtk_entry_obscure_mouse_cursor (GtkEntry *entry)
4190 {
4191   GtkEntryPrivate *priv = entry->priv;
4192
4193   if (priv->mouse_cursor_obscured)
4194     return;
4195
4196   set_invisible_cursor (priv->text_area);
4197
4198   priv->mouse_cursor_obscured = TRUE;
4199 }
4200
4201 static gint
4202 gtk_entry_key_press (GtkWidget   *widget,
4203                      GdkEventKey *event)
4204 {
4205   GtkEntry *entry = GTK_ENTRY (widget);
4206   GtkEntryPrivate *priv = entry->priv;
4207
4208   gtk_entry_reset_blink_time (entry);
4209   gtk_entry_pend_cursor_blink (entry);
4210
4211   if (priv->editable)
4212     {
4213       if (gtk_im_context_filter_keypress (priv->im_context, event))
4214         {
4215           gtk_entry_obscure_mouse_cursor (entry);
4216           priv->need_im_reset = TRUE;
4217           return TRUE;
4218         }
4219     }
4220
4221   if (event->keyval == GDK_KEY_Return || 
4222       event->keyval == GDK_KEY_KP_Enter || 
4223       event->keyval == GDK_KEY_ISO_Enter || 
4224       event->keyval == GDK_KEY_Escape)
4225     {
4226       GtkEntryCompletion *completion = gtk_entry_get_completion (entry);
4227
4228       if (completion && completion->priv->completion_timeout)
4229         {
4230           g_source_remove (completion->priv->completion_timeout);
4231           completion->priv->completion_timeout = 0;
4232         }
4233
4234       _gtk_entry_reset_im_context (entry);
4235     }
4236
4237   if (GTK_WIDGET_CLASS (gtk_entry_parent_class)->key_press_event (widget, event))
4238     /* Activate key bindings
4239      */
4240     return TRUE;
4241
4242   if (!priv->editable && event->length)
4243     gtk_widget_error_bell (widget);
4244
4245   return FALSE;
4246 }
4247
4248 static gint
4249 gtk_entry_key_release (GtkWidget   *widget,
4250                        GdkEventKey *event)
4251 {
4252   GtkEntry *entry = GTK_ENTRY (widget);
4253   GtkEntryPrivate *priv = entry->priv;
4254
4255   if (priv->editable)
4256     {
4257       if (gtk_im_context_filter_keypress (priv->im_context, event))
4258         {
4259           priv->need_im_reset = TRUE;
4260           return TRUE;
4261         }
4262     }
4263
4264   return GTK_WIDGET_CLASS (gtk_entry_parent_class)->key_release_event (widget, event);
4265 }
4266
4267 static gint
4268 gtk_entry_focus_in (GtkWidget     *widget,
4269                     GdkEventFocus *event)
4270 {
4271   GtkEntry *entry = GTK_ENTRY (widget);
4272   GtkEntryPrivate *priv = entry->priv;
4273   GdkKeymap *keymap;
4274
4275   gtk_widget_queue_draw (widget);
4276
4277   keymap = gdk_keymap_get_for_display (gtk_widget_get_display (widget));
4278
4279   if (priv->editable)
4280     {
4281       priv->need_im_reset = TRUE;
4282       gtk_im_context_focus_in (priv->im_context);
4283       keymap_state_changed (keymap, entry);
4284       g_signal_connect (keymap, "state-changed", 
4285                         G_CALLBACK (keymap_state_changed), entry);
4286     }
4287
4288   g_signal_connect (keymap, "direction-changed",
4289                     G_CALLBACK (keymap_direction_changed), entry);
4290
4291   if (gtk_entry_buffer_get_bytes (get_buffer (entry)) == 0 &&
4292       priv->placeholder_text != NULL)
4293     {
4294       gtk_entry_recompute (entry);
4295     }
4296   else
4297     {
4298       gtk_entry_reset_blink_time (entry);
4299       gtk_entry_check_cursor_blink (entry);
4300     }
4301
4302   return FALSE;
4303 }
4304
4305 static gint
4306 gtk_entry_focus_out (GtkWidget     *widget,
4307                      GdkEventFocus *event)
4308 {
4309   GtkEntry *entry = GTK_ENTRY (widget);
4310   GtkEntryPrivate *priv = entry->priv;
4311   GtkEntryCompletion *completion;
4312   GdkKeymap *keymap;
4313
4314   gtk_widget_queue_draw (widget);
4315
4316   keymap = gdk_keymap_get_for_display (gtk_widget_get_display (widget));
4317
4318   if (priv->editable)
4319     {
4320       priv->need_im_reset = TRUE;
4321       gtk_im_context_focus_out (priv->im_context);
4322       remove_capslock_feedback (entry);
4323     }
4324
4325   if (gtk_entry_buffer_get_bytes (get_buffer (entry)) == 0 &&
4326       priv->placeholder_text != NULL)
4327     {
4328       gtk_entry_recompute (entry);
4329     }
4330   else
4331     {
4332       gtk_entry_check_cursor_blink (entry);
4333     }
4334
4335   g_signal_handlers_disconnect_by_func (keymap, keymap_state_changed, entry);
4336   g_signal_handlers_disconnect_by_func (keymap, keymap_direction_changed, entry);
4337
4338   completion = gtk_entry_get_completion (entry);
4339   if (completion)
4340     _gtk_entry_completion_popdown (completion);
4341
4342   return FALSE;
4343 }
4344
4345 static void
4346 gtk_entry_grab_focus (GtkWidget *widget)
4347 {
4348   GtkEntry *entry = GTK_ENTRY (widget);
4349   GtkEntryPrivate *priv = entry->priv;
4350   gboolean select_on_focus;
4351
4352   GTK_WIDGET_CLASS (gtk_entry_parent_class)->grab_focus (widget);
4353
4354   if (priv->editable && !priv->in_click)
4355     {
4356       g_object_get (gtk_widget_get_settings (widget),
4357                     "gtk-entry-select-on-focus",
4358                     &select_on_focus,
4359                     NULL);
4360
4361       if (select_on_focus)
4362         gtk_editable_select_region (GTK_EDITABLE (widget), 0, -1);
4363     }
4364 }
4365
4366 static void
4367 gtk_entry_direction_changed (GtkWidget        *widget,
4368                              GtkTextDirection  previous_dir)
4369 {
4370   GtkEntry *entry = GTK_ENTRY (widget);
4371
4372   gtk_entry_recompute (entry);
4373
4374   GTK_WIDGET_CLASS (gtk_entry_parent_class)->direction_changed (widget, previous_dir);
4375 }
4376
4377 static void
4378 gtk_entry_state_flags_changed (GtkWidget     *widget,
4379                                GtkStateFlags  previous_state)
4380 {
4381   GtkEntry *entry = GTK_ENTRY (widget);
4382   GtkEntryPrivate *priv = entry->priv;
4383   GdkCursor *cursor;
4384
4385   if (gtk_widget_get_realized (widget))
4386     {
4387       if (gtk_widget_is_sensitive (widget))
4388         cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget), GDK_XTERM);
4389       else
4390         cursor = NULL;
4391
4392       gdk_window_set_cursor (priv->text_area, cursor);
4393
4394       if (cursor)
4395         g_object_unref (cursor);
4396
4397       priv->mouse_cursor_obscured = FALSE;
4398
4399       update_cursors (widget);
4400     }
4401
4402   if (!gtk_widget_is_sensitive (widget))
4403     {
4404       /* Clear any selection */
4405       gtk_editable_select_region (GTK_EDITABLE (entry), priv->current_pos, priv->current_pos);
4406     }
4407
4408   gtk_entry_update_cached_style_values (entry);
4409 }
4410
4411 static void
4412 gtk_entry_screen_changed (GtkWidget *widget,
4413                           GdkScreen *old_screen)
4414 {
4415   gtk_entry_recompute (GTK_ENTRY (widget));
4416 }
4417
4418 /* GtkEditable method implementations
4419  */
4420 static void
4421 gtk_entry_insert_text (GtkEditable *editable,
4422                        const gchar *new_text,
4423                        gint         new_text_length,
4424                        gint        *position)
4425 {
4426   g_object_ref (editable);
4427
4428   /*
4429    * The incoming text may a password or other secret. We make sure
4430    * not to copy it into temporary buffers.
4431    */
4432
4433   g_signal_emit_by_name (editable, "insert-text", new_text, new_text_length, position);
4434
4435   g_object_unref (editable);
4436 }
4437
4438 static void
4439 gtk_entry_delete_text (GtkEditable *editable,
4440                        gint         start_pos,
4441                        gint         end_pos)
4442 {
4443   g_object_ref (editable);
4444
4445   g_signal_emit_by_name (editable, "delete-text", start_pos, end_pos);
4446
4447   g_object_unref (editable);
4448 }
4449
4450 static gchar *    
4451 gtk_entry_get_chars      (GtkEditable   *editable,
4452                           gint           start_pos,
4453                           gint           end_pos)
4454 {
4455   GtkEntry *entry = GTK_ENTRY (editable);
4456   const gchar *text;
4457   gint text_length;
4458   gint start_index, end_index;
4459
4460   text = gtk_entry_buffer_get_text (get_buffer (entry));
4461   text_length = gtk_entry_buffer_get_length (get_buffer (entry));
4462
4463   if (end_pos < 0)
4464     end_pos = text_length;
4465
4466   start_pos = MIN (text_length, start_pos);
4467   end_pos = MIN (text_length, end_pos);
4468
4469   start_index = g_utf8_offset_to_pointer (text, start_pos) - text;
4470   end_index = g_utf8_offset_to_pointer (text, end_pos) - text;
4471
4472   return g_strndup (text + start_index, end_index - start_index);
4473 }
4474
4475 static void
4476 gtk_entry_real_set_position (GtkEditable *editable,
4477                              gint         position)
4478 {
4479   GtkEntry *entry = GTK_ENTRY (editable);
4480   GtkEntryPrivate *priv = entry->priv;
4481
4482   guint length;
4483
4484   length = gtk_entry_buffer_get_length (get_buffer (entry));
4485   if (position < 0 || position > length)
4486     position = length;
4487
4488   if (position != priv->current_pos ||
4489       position != priv->selection_bound)
4490     {
4491       _gtk_entry_reset_im_context (entry);
4492       gtk_entry_set_positions (entry, position, position);
4493     }
4494 }
4495
4496 static gint
4497 gtk_entry_get_position (GtkEditable *editable)
4498 {
4499   GtkEntry *entry = GTK_ENTRY (editable);
4500   GtkEntryPrivate *priv = entry->priv;
4501
4502   return priv->current_pos;
4503 }
4504
4505 static void
4506 gtk_entry_set_selection_bounds (GtkEditable *editable,
4507                                 gint         start,
4508                                 gint         end)
4509 {
4510   GtkEntry *entry = GTK_ENTRY (editable);
4511   guint length;
4512
4513   length = gtk_entry_buffer_get_length (get_buffer (entry));
4514   if (start < 0)
4515     start = length;
4516   if (end < 0)
4517     end = length;
4518   
4519   _gtk_entry_reset_im_context (entry);
4520
4521   gtk_entry_set_positions (entry,
4522                            MIN (end, length),
4523                            MIN (start, length));
4524
4525   gtk_entry_update_primary_selection (entry);
4526 }
4527
4528 static gboolean
4529 gtk_entry_get_selection_bounds (GtkEditable *editable,
4530                                 gint        *start,
4531                                 gint        *end)
4532 {
4533   GtkEntry *entry = GTK_ENTRY (editable);
4534   GtkEntryPrivate *priv = entry->priv;
4535
4536   *start = priv->selection_bound;
4537   *end = priv->current_pos;
4538
4539   return (priv->selection_bound != priv->current_pos);
4540 }
4541
4542 static void
4543 icon_theme_changed (GtkEntry *entry)
4544 {
4545   GtkEntryPrivate *priv = entry->priv;
4546   gint i;
4547
4548   for (i = 0; i < MAX_ICONS; i++)
4549     {
4550       EntryIconInfo *icon_info = priv->icons[i];
4551       if (icon_info != NULL) 
4552         _gtk_icon_helper_invalidate (icon_info->icon_helper);
4553     }
4554
4555   gtk_widget_queue_draw (GTK_WIDGET (entry));
4556 }
4557
4558 static void
4559 gtk_entry_update_cached_style_values (GtkEntry *entry)
4560 {
4561   GtkEntryPrivate *priv = entry->priv;
4562   gint focus_width;
4563   gboolean interior_focus;
4564
4565   gtk_widget_style_get (GTK_WIDGET (entry),
4566                         "focus-line-width", &focus_width,
4567                         "interior-focus", &interior_focus,
4568                         NULL);
4569   priv->focus_width = focus_width;
4570   priv->interior_focus = interior_focus;
4571
4572   if (!priv->invisible_char_set)
4573     {
4574       gunichar ch = find_invisible_char (GTK_WIDGET (entry));
4575
4576       if (priv->invisible_char != ch)
4577         {
4578           priv->invisible_char = ch;
4579           g_object_notify (G_OBJECT (entry), "invisible-char");
4580         }
4581     }
4582 }
4583
4584 static void 
4585 gtk_entry_style_updated (GtkWidget *widget)
4586 {
4587   GtkEntry *entry = GTK_ENTRY (widget);
4588
4589   GTK_WIDGET_CLASS (gtk_entry_parent_class)->style_updated (widget);
4590
4591   gtk_entry_update_cached_style_values (entry);
4592
4593   gtk_entry_recompute (entry);
4594
4595   icon_theme_changed (entry);
4596 }
4597
4598 /* GtkCellEditable method implementations
4599  */
4600 static void
4601 gtk_cell_editable_entry_activated (GtkEntry *entry, gpointer data)
4602 {
4603   gtk_cell_editable_editing_done (GTK_CELL_EDITABLE (entry));
4604   gtk_cell_editable_remove_widget (GTK_CELL_EDITABLE (entry));
4605 }
4606
4607 static gboolean
4608 gtk_cell_editable_key_press_event (GtkEntry    *entry,
4609                                    GdkEventKey *key_event,
4610                                    gpointer     data)
4611 {
4612   GtkEntryPrivate *priv = entry->priv;
4613
4614   if (key_event->keyval == GDK_KEY_Escape)
4615     {
4616       priv->editing_canceled = TRUE;
4617       gtk_cell_editable_editing_done (GTK_CELL_EDITABLE (entry));
4618       gtk_cell_editable_remove_widget (GTK_CELL_EDITABLE (entry));
4619
4620       return TRUE;
4621     }
4622
4623   /* override focus */
4624   if (key_event->keyval == GDK_KEY_Up || key_event->keyval == GDK_KEY_Down)
4625     {
4626       gtk_cell_editable_editing_done (GTK_CELL_EDITABLE (entry));
4627       gtk_cell_editable_remove_widget (GTK_CELL_EDITABLE (entry));
4628
4629       return TRUE;
4630     }
4631
4632   return FALSE;
4633 }
4634
4635 static void
4636 gtk_entry_start_editing (GtkCellEditable *cell_editable,
4637                          GdkEvent        *event)
4638 {
4639   GtkEntry *entry = GTK_ENTRY (cell_editable);
4640   GtkEntryPrivate *priv = entry->priv;
4641
4642   priv->is_cell_renderer = TRUE;
4643
4644   g_signal_connect (cell_editable, "activate",
4645                     G_CALLBACK (gtk_cell_editable_entry_activated), NULL);
4646   g_signal_connect (cell_editable, "key-press-event",
4647                     G_CALLBACK (gtk_cell_editable_key_press_event), NULL);
4648 }
4649
4650 static void
4651 gtk_entry_password_hint_free (GtkEntryPasswordHint *password_hint)
4652 {
4653   if (password_hint->source_id)
4654     g_source_remove (password_hint->source_id);
4655
4656   g_slice_free (GtkEntryPasswordHint, password_hint);
4657 }
4658
4659
4660 static gboolean
4661 gtk_entry_remove_password_hint (gpointer data)
4662 {
4663   GtkEntryPasswordHint *password_hint = g_object_get_qdata (data, quark_password_hint);
4664   password_hint->position = -1;
4665
4666   /* Force the string to be redrawn, but now without a visible character */
4667   gtk_entry_recompute (GTK_ENTRY (data));
4668   return FALSE;
4669 }
4670
4671 /* Default signal handlers
4672  */
4673 static void
4674 gtk_entry_real_insert_text (GtkEditable *editable,
4675                             const gchar *new_text,
4676                             gint         new_text_length,
4677                             gint        *position)
4678 {
4679   guint n_inserted;
4680   gint n_chars;
4681
4682   n_chars = g_utf8_strlen (new_text, new_text_length);
4683
4684   /*
4685    * The actual insertion into the buffer. This will end up firing the
4686    * following signal handlers: buffer_inserted_text(), buffer_notify_display_text(),
4687    * buffer_notify_text(), buffer_notify_length()
4688    */
4689   begin_change (GTK_ENTRY (editable));
4690
4691   n_inserted = gtk_entry_buffer_insert_text (get_buffer (GTK_ENTRY (editable)), *position, new_text, n_chars);
4692
4693   end_change (GTK_ENTRY (editable));
4694
4695   if (n_inserted != n_chars)
4696       gtk_widget_error_bell (GTK_WIDGET (editable));
4697
4698   *position += n_inserted;
4699 }
4700
4701 static void
4702 gtk_entry_real_delete_text (GtkEditable *editable,
4703                             gint         start_pos,
4704                             gint         end_pos)
4705 {
4706   /*
4707    * The actual deletion from the buffer. This will end up firing the
4708    * following signal handlers: buffer_deleted_text(), buffer_notify_display_text(),
4709    * buffer_notify_text(), buffer_notify_length()
4710    */
4711
4712   begin_change (GTK_ENTRY (editable));
4713
4714   gtk_entry_buffer_delete_text (get_buffer (GTK_ENTRY (editable)), start_pos, end_pos - start_pos);
4715
4716   end_change (GTK_ENTRY (editable));
4717 }
4718
4719 /* GtkEntryBuffer signal handlers
4720  */
4721 static void
4722 buffer_inserted_text (GtkEntryBuffer *buffer,
4723                       guint           position,
4724                       const gchar    *chars,
4725                       guint           n_chars,
4726                       GtkEntry       *entry)
4727 {
4728   GtkEntryPrivate *priv = entry->priv;
4729   guint password_hint_timeout;
4730   guint current_pos;
4731   gint selection_bound;
4732
4733   current_pos = priv->current_pos;
4734   if (current_pos > position)
4735     current_pos += n_chars;
4736
4737   selection_bound = priv->selection_bound;
4738   if (selection_bound > position)
4739     selection_bound += n_chars;
4740
4741   gtk_entry_set_positions (entry, current_pos, selection_bound);
4742
4743   /* Calculate the password hint if it needs to be displayed. */
4744   if (n_chars == 1 && !priv->visible)
4745     {
4746       g_object_get (gtk_widget_get_settings (GTK_WIDGET (entry)),
4747                     "gtk-entry-password-hint-timeout", &password_hint_timeout,
4748                     NULL);
4749
4750       if (password_hint_timeout > 0)
4751         {
4752           GtkEntryPasswordHint *password_hint = g_object_get_qdata (G_OBJECT (entry),
4753                                                                     quark_password_hint);
4754           if (!password_hint)
4755             {
4756               password_hint = g_slice_new0 (GtkEntryPasswordHint);
4757               g_object_set_qdata_full (G_OBJECT (entry), quark_password_hint, password_hint,
4758                                        (GDestroyNotify)gtk_entry_password_hint_free);
4759             }
4760
4761           password_hint->position = position;
4762           if (password_hint->source_id)
4763             g_source_remove (password_hint->source_id);
4764           password_hint->source_id = gdk_threads_add_timeout (password_hint_timeout,
4765                                                               (GSourceFunc)gtk_entry_remove_password_hint, entry);
4766         }
4767     }
4768 }
4769
4770 static void
4771 buffer_deleted_text (GtkEntryBuffer *buffer,
4772                      guint           position,
4773                      guint           n_chars,
4774                      GtkEntry       *entry)
4775 {
4776   GtkEntryPrivate *priv = entry->priv;
4777   guint end_pos = position + n_chars;
4778   gint selection_bound;
4779   guint current_pos;
4780
4781   current_pos = priv->current_pos;
4782   if (current_pos > position)
4783     current_pos -= MIN (current_pos, end_pos) - position;
4784
4785   selection_bound = priv->selection_bound;
4786   if (selection_bound > position)
4787     selection_bound -= MIN (selection_bound, end_pos) - position;
4788
4789   gtk_entry_set_positions (entry, current_pos, selection_bound);
4790
4791   /* We might have deleted the selection */
4792   gtk_entry_update_primary_selection (entry);
4793
4794   /* Disable the password hint if one exists. */
4795   if (!priv->visible)
4796     {
4797       GtkEntryPasswordHint *password_hint = g_object_get_qdata (G_OBJECT (entry),
4798                                                                 quark_password_hint);
4799       if (password_hint)
4800         {
4801           if (password_hint->source_id)
4802             g_source_remove (password_hint->source_id);
4803           password_hint->source_id = 0;
4804           password_hint->position = -1;
4805         }
4806     }
4807 }
4808
4809 static void
4810 buffer_notify_text (GtkEntryBuffer *buffer,
4811                     GParamSpec     *spec,
4812                     GtkEntry       *entry)
4813 {
4814   gtk_entry_recompute (entry);
4815   emit_changed (entry);
4816   g_object_notify (G_OBJECT (entry), "text");
4817 }
4818
4819 static void
4820 buffer_notify_length (GtkEntryBuffer *buffer,
4821                       GParamSpec     *spec,
4822                       GtkEntry       *entry)
4823 {
4824   g_object_notify (G_OBJECT (entry), "text-length");
4825 }
4826
4827 static void
4828 buffer_notify_max_length (GtkEntryBuffer *buffer,
4829                           GParamSpec     *spec,
4830                           GtkEntry       *entry)
4831 {
4832   g_object_notify (G_OBJECT (entry), "max-length");
4833 }
4834
4835 static void
4836 buffer_connect_signals (GtkEntry *entry)
4837 {
4838   g_signal_connect (get_buffer (entry), "inserted-text", G_CALLBACK (buffer_inserted_text), entry);
4839   g_signal_connect (get_buffer (entry), "deleted-text", G_CALLBACK (buffer_deleted_text), entry);
4840   g_signal_connect (get_buffer (entry), "notify::text", G_CALLBACK (buffer_notify_text), entry);
4841   g_signal_connect (get_buffer (entry), "notify::length", G_CALLBACK (buffer_notify_length), entry);
4842   g_signal_connect (get_buffer (entry), "notify::max-length", G_CALLBACK (buffer_notify_max_length), entry);
4843 }
4844
4845 static void
4846 buffer_disconnect_signals (GtkEntry *entry)
4847 {
4848   g_signal_handlers_disconnect_by_func (get_buffer (entry), buffer_inserted_text, entry);
4849   g_signal_handlers_disconnect_by_func (get_buffer (entry), buffer_deleted_text, entry);
4850   g_signal_handlers_disconnect_by_func (get_buffer (entry), buffer_notify_text, entry);
4851   g_signal_handlers_disconnect_by_func (get_buffer (entry), buffer_notify_length, entry);
4852   g_signal_handlers_disconnect_by_func (get_buffer (entry), buffer_notify_max_length, entry);
4853 }
4854
4855 /* Compute the X position for an offset that corresponds to the "more important
4856  * cursor position for that offset. We use this when trying to guess to which
4857  * end of the selection we should go to when the user hits the left or
4858  * right arrow key.
4859  */
4860 static gint
4861 get_better_cursor_x (GtkEntry *entry,
4862                      gint      offset)
4863 {
4864   GtkEntryPrivate *priv = entry->priv;
4865   GdkKeymap *keymap = gdk_keymap_get_for_display (gtk_widget_get_display (GTK_WIDGET (entry)));
4866   PangoDirection keymap_direction = gdk_keymap_get_direction (keymap);
4867   gboolean split_cursor;
4868   
4869   PangoLayout *layout = gtk_entry_ensure_layout (entry, TRUE);
4870   const gchar *text = pango_layout_get_text (layout);
4871   gint index = g_utf8_offset_to_pointer (text, offset) - text;
4872   
4873   PangoRectangle strong_pos, weak_pos;
4874   
4875   g_object_get (gtk_widget_get_settings (GTK_WIDGET (entry)),
4876                 "gtk-split-cursor", &split_cursor,
4877                 NULL);
4878
4879   pango_layout_get_cursor_pos (layout, index, &strong_pos, &weak_pos);
4880
4881   if (split_cursor)
4882     return strong_pos.x / PANGO_SCALE;
4883   else
4884     return (keymap_direction == priv->resolved_dir) ? strong_pos.x / PANGO_SCALE : weak_pos.x / PANGO_SCALE;
4885 }
4886
4887 static void
4888 gtk_entry_move_cursor (GtkEntry       *entry,
4889                        GtkMovementStep step,
4890                        gint            count,
4891                        gboolean        extend_selection)
4892 {
4893   GtkEntryPrivate *priv = entry->priv;
4894   gint new_pos = priv->current_pos;
4895
4896   _gtk_entry_reset_im_context (entry);
4897
4898   if (priv->current_pos != priv->selection_bound && !extend_selection)
4899     {
4900       /* If we have a current selection and aren't extending it, move to the
4901        * start/or end of the selection as appropriate
4902        */
4903       switch (step)
4904         {
4905         case GTK_MOVEMENT_VISUAL_POSITIONS:
4906           {
4907             gint current_x = get_better_cursor_x (entry, priv->current_pos);
4908             gint bound_x = get_better_cursor_x (entry, priv->selection_bound);
4909
4910             if (count <= 0)
4911               new_pos = current_x < bound_x ? priv->current_pos : priv->selection_bound;
4912             else 
4913               new_pos = current_x > bound_x ? priv->current_pos : priv->selection_bound;
4914             break;
4915           }
4916         case GTK_MOVEMENT_LOGICAL_POSITIONS:
4917         case GTK_MOVEMENT_WORDS:
4918           if (count < 0)
4919             new_pos = MIN (priv->current_pos, priv->selection_bound);
4920           else
4921             new_pos = MAX (priv->current_pos, priv->selection_bound);
4922           break;
4923         case GTK_MOVEMENT_DISPLAY_LINE_ENDS:
4924         case GTK_MOVEMENT_PARAGRAPH_ENDS:
4925         case GTK_MOVEMENT_BUFFER_ENDS:
4926           new_pos = count < 0 ? 0 : gtk_entry_buffer_get_length (get_buffer (entry));
4927           break;
4928         case GTK_MOVEMENT_DISPLAY_LINES:
4929         case GTK_MOVEMENT_PARAGRAPHS:
4930         case GTK_MOVEMENT_PAGES:
4931         case GTK_MOVEMENT_HORIZONTAL_PAGES:
4932           break;
4933         }
4934     }
4935   else
4936     {
4937       switch (step)
4938         {
4939         case GTK_MOVEMENT_LOGICAL_POSITIONS:
4940           new_pos = gtk_entry_move_logically (entry, new_pos, count);
4941           break;
4942         case GTK_MOVEMENT_VISUAL_POSITIONS:
4943           new_pos = gtk_entry_move_visually (entry, new_pos, count);
4944           if (priv->current_pos == new_pos)
4945             {
4946               if (!extend_selection)
4947                 {
4948                   if (!gtk_widget_keynav_failed (GTK_WIDGET (entry),
4949                                                  count > 0 ?
4950                                                  GTK_DIR_RIGHT : GTK_DIR_LEFT))
4951                     {
4952                       GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (entry));
4953
4954                       if (toplevel)
4955                         gtk_widget_child_focus (toplevel,
4956                                                 count > 0 ?
4957                                                 GTK_DIR_RIGHT : GTK_DIR_LEFT);
4958                     }
4959                 }
4960               else
4961                 {
4962                   gtk_widget_error_bell (GTK_WIDGET (entry));
4963                 }
4964             }
4965           break;
4966         case GTK_MOVEMENT_WORDS:
4967           while (count > 0)
4968             {
4969               new_pos = gtk_entry_move_forward_word (entry, new_pos, FALSE);
4970               count--;
4971             }
4972           while (count < 0)
4973             {
4974               new_pos = gtk_entry_move_backward_word (entry, new_pos, FALSE);
4975               count++;
4976             }
4977           if (priv->current_pos == new_pos)
4978             gtk_widget_error_bell (GTK_WIDGET (entry));
4979           break;
4980         case GTK_MOVEMENT_DISPLAY_LINE_ENDS:
4981         case GTK_MOVEMENT_PARAGRAPH_ENDS:
4982         case GTK_MOVEMENT_BUFFER_ENDS:
4983           new_pos = count < 0 ? 0 : gtk_entry_buffer_get_length (get_buffer (entry));
4984           if (priv->current_pos == new_pos)
4985             gtk_widget_error_bell (GTK_WIDGET (entry));
4986           break;
4987         case GTK_MOVEMENT_DISPLAY_LINES:
4988         case GTK_MOVEMENT_PARAGRAPHS:
4989         case GTK_MOVEMENT_PAGES:
4990         case GTK_MOVEMENT_HORIZONTAL_PAGES:
4991           break;
4992         }
4993     }
4994
4995   if (extend_selection)
4996     gtk_editable_select_region (GTK_EDITABLE (entry), priv->selection_bound, new_pos);
4997   else
4998     gtk_editable_set_position (GTK_EDITABLE (entry), new_pos);
4999   
5000   gtk_entry_pend_cursor_blink (entry);
5001 }
5002
5003 static void
5004 gtk_entry_insert_at_cursor (GtkEntry    *entry,
5005                             const gchar *str)
5006 {
5007   GtkEntryPrivate *priv = entry->priv;
5008   GtkEditable *editable = GTK_EDITABLE (entry);
5009   gint pos = priv->current_pos;
5010
5011   if (priv->editable)
5012     {
5013       _gtk_entry_reset_im_context (entry);
5014
5015       gtk_editable_insert_text (editable, str, -1, &pos);
5016       gtk_editable_set_position (editable, pos);
5017     }
5018 }
5019
5020 static void
5021 gtk_entry_delete_from_cursor (GtkEntry       *entry,
5022                               GtkDeleteType   type,
5023                               gint            count)
5024 {
5025   GtkEntryPrivate *priv = entry->priv;
5026   GtkEditable *editable = GTK_EDITABLE (entry);
5027   gint start_pos = priv->current_pos;
5028   gint end_pos = priv->current_pos;
5029   gint old_n_bytes = gtk_entry_buffer_get_bytes (get_buffer (entry));
5030   
5031   _gtk_entry_reset_im_context (entry);
5032
5033   if (!priv->editable)
5034     {
5035       gtk_widget_error_bell (GTK_WIDGET (entry));
5036       return;
5037     }
5038
5039   if (priv->selection_bound != priv->current_pos)
5040     {
5041       gtk_editable_delete_selection (editable);
5042       return;
5043     }
5044   
5045   switch (type)
5046     {
5047     case GTK_DELETE_CHARS:
5048       end_pos = gtk_entry_move_logically (entry, priv->current_pos, count);
5049       gtk_editable_delete_text (editable, MIN (start_pos, end_pos), MAX (start_pos, end_pos));
5050       break;
5051     case GTK_DELETE_WORDS:
5052       if (count < 0)
5053         {
5054           /* Move to end of current word, or if not on a word, end of previous word */
5055           end_pos = gtk_entry_move_backward_word (entry, end_pos, FALSE);
5056           end_pos = gtk_entry_move_forward_word (entry, end_pos, FALSE);
5057         }
5058       else if (count > 0)
5059         {
5060           /* Move to beginning of current word, or if not on a word, begining of next word */
5061           start_pos = gtk_entry_move_forward_word (entry, start_pos, FALSE);
5062           start_pos = gtk_entry_move_backward_word (entry, start_pos, FALSE);
5063         }
5064         
5065       /* Fall through */
5066     case GTK_DELETE_WORD_ENDS:
5067       while (count < 0)
5068         {
5069           start_pos = gtk_entry_move_backward_word (entry, start_pos, FALSE);
5070           count++;
5071         }
5072       while (count > 0)
5073         {
5074           end_pos = gtk_entry_move_forward_word (entry, end_pos, FALSE);
5075           count--;
5076         }
5077       gtk_editable_delete_text (editable, start_pos, end_pos);
5078       break;
5079     case GTK_DELETE_DISPLAY_LINE_ENDS:
5080     case GTK_DELETE_PARAGRAPH_ENDS:
5081       if (count < 0)
5082         gtk_editable_delete_text (editable, 0, priv->current_pos);
5083       else
5084         gtk_editable_delete_text (editable, priv->current_pos, -1);
5085       break;
5086     case GTK_DELETE_DISPLAY_LINES:
5087     case GTK_DELETE_PARAGRAPHS:
5088       gtk_editable_delete_text (editable, 0, -1);  
5089       break;
5090     case GTK_DELETE_WHITESPACE:
5091       gtk_entry_delete_whitespace (entry);
5092       break;
5093     }
5094
5095   if (gtk_entry_buffer_get_bytes (get_buffer (entry)) == old_n_bytes)
5096     gtk_widget_error_bell (GTK_WIDGET (entry));
5097
5098   gtk_entry_pend_cursor_blink (entry);
5099 }
5100
5101 static void
5102 gtk_entry_backspace (GtkEntry *entry)
5103 {
5104   GtkEntryPrivate *priv = entry->priv;
5105   GtkEditable *editable = GTK_EDITABLE (entry);
5106   gint prev_pos;
5107
5108   _gtk_entry_reset_im_context (entry);
5109
5110   if (!priv->editable)
5111     {
5112       gtk_widget_error_bell (GTK_WIDGET (entry));
5113       return;
5114     }
5115
5116   if (priv->selection_bound != priv->current_pos)
5117     {
5118       gtk_editable_delete_selection (editable);
5119       return;
5120     }
5121
5122   prev_pos = gtk_entry_move_logically (entry, priv->current_pos, -1);
5123
5124   if (prev_pos < priv->current_pos)
5125     {
5126       PangoLayout *layout = gtk_entry_ensure_layout (entry, FALSE);
5127       PangoLogAttr *log_attrs;
5128       gint n_attrs;
5129
5130       pango_layout_get_log_attrs (layout, &log_attrs, &n_attrs);
5131
5132       /* Deleting parts of characters */
5133       if (log_attrs[priv->current_pos].backspace_deletes_character)
5134         {
5135           gchar *cluster_text;
5136           gchar *normalized_text;
5137           glong  len;
5138
5139           cluster_text = gtk_entry_get_display_text (entry, prev_pos,
5140                                                      priv->current_pos);
5141           normalized_text = g_utf8_normalize (cluster_text,
5142                                               strlen (cluster_text),
5143                                               G_NORMALIZE_NFD);
5144           len = g_utf8_strlen (normalized_text, -1);
5145
5146           gtk_editable_delete_text (editable, prev_pos, priv->current_pos);
5147           if (len > 1)
5148             {
5149               gint pos = priv->current_pos;
5150
5151               gtk_editable_insert_text (editable, normalized_text,
5152                                         g_utf8_offset_to_pointer (normalized_text, len - 1) - normalized_text,
5153                                         &pos);
5154               gtk_editable_set_position (editable, pos);
5155             }
5156
5157           g_free (normalized_text);
5158           g_free (cluster_text);
5159         }
5160       else
5161         {
5162           gtk_editable_delete_text (editable, prev_pos, priv->current_pos);
5163         }
5164       
5165       g_free (log_attrs);
5166     }
5167   else
5168     {
5169       gtk_widget_error_bell (GTK_WIDGET (entry));
5170     }
5171
5172   gtk_entry_pend_cursor_blink (entry);
5173 }
5174
5175 static void
5176 gtk_entry_copy_clipboard (GtkEntry *entry)
5177 {
5178   GtkEntryPrivate *priv = entry->priv;
5179   GtkEditable *editable = GTK_EDITABLE (entry);
5180   gint start, end;
5181   gchar *str;
5182
5183   if (gtk_editable_get_selection_bounds (editable, &start, &end))
5184     {
5185       if (!priv->visible)
5186         {
5187           gtk_widget_error_bell (GTK_WIDGET (entry));
5188           return;
5189         }
5190
5191       str = gtk_entry_get_display_text (entry, start, end);
5192       gtk_clipboard_set_text (gtk_widget_get_clipboard (GTK_WIDGET (entry),
5193                                                         GDK_SELECTION_CLIPBOARD),
5194                               str, -1);
5195       g_free (str);
5196     }
5197 }
5198
5199 static void
5200 gtk_entry_cut_clipboard (GtkEntry *entry)
5201 {
5202   GtkEntryPrivate *priv = entry->priv;
5203   GtkEditable *editable = GTK_EDITABLE (entry);
5204   gint start, end;
5205
5206   if (!priv->visible)
5207     {
5208       gtk_widget_error_bell (GTK_WIDGET (entry));
5209       return;
5210     }
5211
5212   gtk_entry_copy_clipboard (entry);
5213
5214   if (priv->editable)
5215     {
5216       if (gtk_editable_get_selection_bounds (editable, &start, &end))
5217         gtk_editable_delete_text (editable, start, end);
5218     }
5219   else
5220     {
5221       gtk_widget_error_bell (GTK_WIDGET (entry));
5222     }
5223 }
5224
5225 static void
5226 gtk_entry_paste_clipboard (GtkEntry *entry)
5227 {
5228   GtkEntryPrivate *priv = entry->priv;
5229
5230   if (priv->editable)
5231     gtk_entry_paste (entry, GDK_SELECTION_CLIPBOARD);
5232   else
5233     gtk_widget_error_bell (GTK_WIDGET (entry));
5234 }
5235
5236 static void
5237 gtk_entry_delete_cb (GtkEntry *entry)
5238 {
5239   GtkEntryPrivate *priv = entry->priv;
5240   GtkEditable *editable = GTK_EDITABLE (entry);
5241   gint start, end;
5242
5243   if (priv->editable)
5244     {
5245       if (gtk_editable_get_selection_bounds (editable, &start, &end))
5246         gtk_editable_delete_text (editable, start, end);
5247     }
5248 }
5249
5250 static void
5251 gtk_entry_toggle_overwrite (GtkEntry *entry)
5252 {
5253   GtkEntryPrivate *priv = entry->priv;
5254
5255   priv->overwrite_mode = !priv->overwrite_mode;
5256   gtk_entry_pend_cursor_blink (entry);
5257   gtk_widget_queue_draw (GTK_WIDGET (entry));
5258 }
5259
5260 static void
5261 gtk_entry_select_all (GtkEntry *entry)
5262 {
5263   gtk_entry_select_line (entry);
5264 }
5265
5266 static void
5267 gtk_entry_real_activate (GtkEntry *entry)
5268 {
5269   GtkEntryPrivate *priv = entry->priv;
5270   GtkWindow *window;
5271   GtkWidget *default_widget, *focus_widget;
5272   GtkWidget *toplevel;
5273   GtkWidget *widget;
5274
5275   widget = GTK_WIDGET (entry);
5276
5277   if (priv->activates_default)
5278     {
5279       toplevel = gtk_widget_get_toplevel (widget);
5280       if (GTK_IS_WINDOW (toplevel))
5281         {
5282           window = GTK_WINDOW (toplevel);
5283
5284           if (window)
5285             {
5286               default_widget = gtk_window_get_default_widget (window);
5287               focus_widget = gtk_window_get_focus (window);
5288               if (widget != default_widget &&
5289                   !(widget == focus_widget && (!default_widget || !gtk_widget_get_sensitive (default_widget))))
5290                 gtk_window_activate_default (window);
5291             }
5292         }
5293     }
5294 }
5295
5296 static void
5297 keymap_direction_changed (GdkKeymap *keymap,
5298                           GtkEntry  *entry)
5299 {
5300   gtk_entry_recompute (entry);
5301 }
5302
5303 /* IM Context Callbacks
5304  */
5305
5306 static void
5307 gtk_entry_commit_cb (GtkIMContext *context,
5308                      const gchar  *str,
5309                      GtkEntry     *entry)
5310 {
5311   GtkEntryPrivate *priv = entry->priv;
5312
5313   if (priv->editable)
5314     gtk_entry_enter_text (entry, str);
5315 }
5316
5317 static void 
5318 gtk_entry_preedit_changed_cb (GtkIMContext *context,
5319                               GtkEntry     *entry)
5320 {
5321   GtkEntryPrivate *priv = entry->priv;
5322
5323   if (priv->editable)
5324     {
5325       gchar *preedit_string;
5326       gint cursor_pos;
5327
5328       gtk_im_context_get_preedit_string (priv->im_context,
5329                                          &preedit_string, NULL,
5330                                          &cursor_pos);
5331       g_signal_emit (entry, signals[PREEDIT_CHANGED], 0, preedit_string);
5332       priv->preedit_length = strlen (preedit_string);
5333       cursor_pos = CLAMP (cursor_pos, 0, g_utf8_strlen (preedit_string, -1));
5334       priv->preedit_cursor = cursor_pos;
5335       g_free (preedit_string);
5336     
5337       gtk_entry_recompute (entry);
5338     }
5339 }
5340
5341 static gboolean
5342 gtk_entry_retrieve_surrounding_cb (GtkIMContext *context,
5343                                    GtkEntry     *entry)
5344 {
5345   GtkEntryPrivate *priv = entry->priv;
5346   gchar *text;
5347
5348   /* XXXX ??? does this even make sense when text is not visible? Should we return FALSE? */
5349   text = gtk_entry_get_display_text (entry, 0, -1);
5350   gtk_im_context_set_surrounding (context, text, strlen (text), /* Length in bytes */
5351                                   g_utf8_offset_to_pointer (text, priv->current_pos) - text);
5352   g_free (text);
5353
5354   return TRUE;
5355 }
5356
5357 static gboolean
5358 gtk_entry_delete_surrounding_cb (GtkIMContext *slave,
5359                                  gint          offset,
5360                                  gint          n_chars,
5361                                  GtkEntry     *entry)
5362 {
5363   GtkEntryPrivate *priv = entry->priv;
5364
5365   if (priv->editable)
5366     gtk_editable_delete_text (GTK_EDITABLE (entry),
5367                               priv->current_pos + offset,
5368                               priv->current_pos + offset + n_chars);
5369
5370   return TRUE;
5371 }
5372
5373 /* Internal functions
5374  */
5375
5376 /* Used for im_commit_cb and inserting Unicode chars */
5377 static void
5378 gtk_entry_enter_text (GtkEntry       *entry,
5379                       const gchar    *str)
5380 {
5381   GtkEntryPrivate *priv = entry->priv;
5382   GtkEditable *editable = GTK_EDITABLE (entry);
5383   gint tmp_pos;
5384   gboolean old_need_im_reset;
5385
5386   old_need_im_reset = priv->need_im_reset;
5387   priv->need_im_reset = FALSE;
5388
5389   if (gtk_editable_get_selection_bounds (editable, NULL, NULL))
5390     gtk_editable_delete_selection (editable);
5391   else
5392     {
5393       if (priv->overwrite_mode)
5394         gtk_entry_delete_from_cursor (entry, GTK_DELETE_CHARS, 1);
5395     }
5396
5397   tmp_pos = priv->current_pos;
5398   gtk_editable_insert_text (editable, str, strlen (str), &tmp_pos);
5399   gtk_editable_set_position (editable, tmp_pos);
5400
5401   priv->need_im_reset = old_need_im_reset;
5402 }
5403
5404 /* All changes to priv->current_pos and priv->selection_bound
5405  * should go through this function.
5406  */
5407 static void
5408 gtk_entry_set_positions (GtkEntry *entry,
5409                          gint      current_pos,
5410                          gint      selection_bound)
5411 {
5412   GtkEntryPrivate *priv = entry->priv;
5413   gboolean changed = FALSE;
5414
5415   g_object_freeze_notify (G_OBJECT (entry));
5416   
5417   if (current_pos != -1 &&
5418       priv->current_pos != current_pos)
5419     {
5420       priv->current_pos = current_pos;
5421       changed = TRUE;
5422
5423       g_object_notify (G_OBJECT (entry), "cursor-position");
5424     }
5425
5426   if (selection_bound != -1 &&
5427       priv->selection_bound != selection_bound)
5428     {
5429       priv->selection_bound = selection_bound;
5430       changed = TRUE;
5431       
5432       g_object_notify (G_OBJECT (entry), "selection-bound");
5433     }
5434
5435   g_object_thaw_notify (G_OBJECT (entry));
5436
5437   if (changed) 
5438     {
5439       gtk_entry_move_adjustments (entry);
5440       gtk_entry_recompute (entry);
5441     }
5442 }
5443
5444 static void
5445 gtk_entry_reset_layout (GtkEntry *entry)
5446 {
5447   GtkEntryPrivate *priv = entry->priv;
5448
5449   if (priv->cached_layout)
5450     {
5451       g_object_unref (priv->cached_layout);
5452       priv->cached_layout = NULL;
5453     }
5454 }
5455
5456 static void
5457 update_im_cursor_location (GtkEntry *entry)
5458 {
5459   GtkEntryPrivate *priv = entry->priv;
5460   GdkRectangle area;
5461   gint strong_x;
5462   gint strong_xoffset;
5463   gint area_width, area_height;
5464
5465   gtk_entry_get_cursor_locations (entry, CURSOR_STANDARD, &strong_x, NULL);
5466   gtk_entry_get_text_area_size (entry, NULL, NULL, &area_width, &area_height);
5467
5468   strong_xoffset = strong_x - priv->scroll_offset;
5469   if (strong_xoffset < 0)
5470     {
5471       strong_xoffset = 0;
5472     }
5473   else if (strong_xoffset > area_width)
5474     {
5475       strong_xoffset = area_width;
5476     }
5477   area.x = strong_xoffset;
5478   area.y = 0;
5479   area.width = 0;
5480   area.height = area_height;
5481
5482   gtk_im_context_set_cursor_location (priv->im_context, &area);
5483 }
5484
5485 static gboolean
5486 recompute_idle_func (gpointer data)
5487 {
5488   GtkEntry *entry = GTK_ENTRY (data);
5489   GtkEntryPrivate *priv = entry->priv;
5490
5491   priv->recompute_idle = 0;
5492
5493   if (gtk_widget_has_screen (GTK_WIDGET (entry)))
5494     {
5495       gtk_entry_adjust_scroll (entry);
5496       gtk_widget_queue_draw (GTK_WIDGET (entry));
5497
5498       update_im_cursor_location (entry);
5499     }
5500
5501   return FALSE;
5502 }
5503
5504 static void
5505 gtk_entry_recompute (GtkEntry *entry)
5506 {
5507   GtkEntryPrivate *priv = entry->priv;
5508
5509   gtk_entry_reset_layout (entry);
5510   gtk_entry_check_cursor_blink (entry);
5511
5512   if (!priv->recompute_idle)
5513     {
5514       priv->recompute_idle = gdk_threads_add_idle_full (G_PRIORITY_HIGH_IDLE + 15, /* between resize and redraw */
5515                                                recompute_idle_func, entry, NULL); 
5516     }
5517 }
5518
5519 static void
5520 gtk_entry_get_placeholder_text_color (GtkEntry   *entry,
5521                                       PangoColor *color)
5522 {
5523   GtkWidget *widget = GTK_WIDGET (entry);
5524   GtkStyleContext *context;
5525   GdkRGBA fg = { 0.5, 0.5, 0.5 };
5526
5527   context = gtk_widget_get_style_context (widget);
5528   gtk_style_context_lookup_color (context, "placeholder_text_color", &fg);
5529
5530   color->red = CLAMP (fg.red * 65535. + 0.5, 0, 65535);
5531   color->green = CLAMP (fg.green * 65535. + 0.5, 0, 65535);
5532   color->blue = CLAMP (fg.blue * 65535. + 0.5, 0, 65535);
5533 }
5534
5535 static inline gboolean
5536 show_placeholder_text (GtkEntry *entry)
5537 {
5538   GtkEntryPrivate *priv = entry->priv;
5539
5540   if (!gtk_widget_has_focus (GTK_WIDGET (entry)) &&
5541       gtk_entry_buffer_get_bytes (get_buffer (entry)) == 0 &&
5542       priv->placeholder_text != NULL)
5543     return TRUE;
5544
5545   return FALSE;
5546 }
5547
5548 static PangoLayout *
5549 gtk_entry_create_layout (GtkEntry *entry,
5550                          gboolean  include_preedit)
5551 {
5552   GtkEntryPrivate *priv = entry->priv;
5553   GtkWidget *widget = GTK_WIDGET (entry);
5554   PangoLayout *layout = gtk_widget_create_pango_layout (widget, NULL);
5555   PangoAttrList *tmp_attrs = pango_attr_list_new ();
5556   gboolean placeholder_layout = show_placeholder_text (entry);
5557
5558   gchar *preedit_string = NULL;
5559   gint preedit_length = 0;
5560   PangoAttrList *preedit_attrs = NULL;
5561
5562   gchar *display;
5563   guint n_bytes;
5564
5565   pango_layout_set_single_paragraph_mode (layout, TRUE);
5566
5567   display = placeholder_layout ? g_strdup (priv->placeholder_text) : gtk_entry_get_display_text (entry, 0, -1);
5568   n_bytes = strlen (display);
5569
5570   if (!placeholder_layout && include_preedit)
5571     {
5572       gtk_im_context_get_preedit_string (priv->im_context,
5573                                          &preedit_string, &preedit_attrs, NULL);
5574       preedit_length = priv->preedit_length;
5575     }
5576   else if (placeholder_layout)
5577     {
5578       PangoColor color;
5579       PangoAttribute *attr;
5580
5581       gtk_entry_get_placeholder_text_color (entry, &color);
5582       attr = pango_attr_foreground_new (color.red, color.green, color.blue);
5583       attr->start_index = 0;
5584       attr->end_index = G_MAXINT;
5585       pango_attr_list_insert (tmp_attrs, attr);
5586     }
5587
5588   if (preedit_length)
5589     {
5590       GString *tmp_string = g_string_new (display);
5591       gint cursor_index = g_utf8_offset_to_pointer (display, priv->current_pos) - display;
5592
5593       g_string_insert (tmp_string, cursor_index, preedit_string);
5594       
5595       pango_layout_set_text (layout, tmp_string->str, tmp_string->len);
5596       
5597       pango_attr_list_splice (tmp_attrs, preedit_attrs,
5598                               cursor_index, preedit_length);
5599       
5600       g_string_free (tmp_string, TRUE);
5601     }
5602   else
5603     {
5604       PangoDirection pango_dir;
5605       
5606       if (gtk_entry_get_display_mode (entry) == DISPLAY_NORMAL)
5607         pango_dir = pango_find_base_dir (display, n_bytes);
5608       else
5609         pango_dir = PANGO_DIRECTION_NEUTRAL;
5610
5611       if (pango_dir == PANGO_DIRECTION_NEUTRAL)
5612         {
5613           if (gtk_widget_has_focus (widget))
5614             {
5615               GdkDisplay *display = gtk_widget_get_display (widget);
5616               GdkKeymap *keymap = gdk_keymap_get_for_display (display);
5617               if (gdk_keymap_get_direction (keymap) == PANGO_DIRECTION_RTL)
5618                 pango_dir = PANGO_DIRECTION_RTL;
5619               else
5620                 pango_dir = PANGO_DIRECTION_LTR;
5621             }
5622           else
5623             {
5624               if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
5625                 pango_dir = PANGO_DIRECTION_RTL;
5626               else
5627                 pango_dir = PANGO_DIRECTION_LTR;
5628             }
5629         }
5630
5631       pango_context_set_base_dir (gtk_widget_get_pango_context (widget),
5632                                   pango_dir);
5633
5634       priv->resolved_dir = pango_dir;
5635
5636       pango_layout_set_text (layout, display, n_bytes);
5637     }
5638       
5639   pango_layout_set_attributes (layout, tmp_attrs);
5640
5641   g_free (preedit_string);
5642   g_free (display);
5643
5644   if (preedit_attrs)
5645     pango_attr_list_unref (preedit_attrs);
5646       
5647   pango_attr_list_unref (tmp_attrs);
5648
5649   return layout;
5650 }
5651
5652 static PangoLayout *
5653 gtk_entry_ensure_layout (GtkEntry *entry,
5654                          gboolean  include_preedit)
5655 {
5656   GtkEntryPrivate *priv = entry->priv;
5657
5658   if (priv->preedit_length > 0 &&
5659       !include_preedit != !priv->cache_includes_preedit)
5660     gtk_entry_reset_layout (entry);
5661
5662   if (!priv->cached_layout)
5663     {
5664       priv->cached_layout = gtk_entry_create_layout (entry, include_preedit);
5665       priv->cache_includes_preedit = include_preedit;
5666     }
5667
5668   return priv->cached_layout;
5669 }
5670
5671 static void
5672 get_layout_position (GtkEntry *entry,
5673                      gint     *x,
5674                      gint     *y)
5675 {
5676   GtkEntryPrivate *priv = entry->priv;
5677   PangoLayout *layout;
5678   PangoRectangle logical_rect;
5679   gint area_width, area_height;
5680   gint y_pos;
5681   PangoLayoutLine *line;
5682   
5683   layout = gtk_entry_ensure_layout (entry, TRUE);
5684
5685   gtk_entry_get_text_area_size (entry, NULL, NULL, &area_width, &area_height);
5686   area_height = PANGO_SCALE * area_height;
5687
5688   line = pango_layout_get_lines_readonly (layout)->data;
5689   pango_layout_line_get_extents (line, NULL, &logical_rect);
5690   
5691   /* Align primarily for locale's ascent/descent */
5692   y_pos = ((area_height - priv->ascent - priv->descent) / 2 +
5693            priv->ascent + logical_rect.y);
5694
5695   /* Now see if we need to adjust to fit in actual drawn string */
5696   if (logical_rect.height > area_height)
5697     y_pos = (area_height - logical_rect.height) / 2;
5698   else if (y_pos < 0)
5699     y_pos = 0;
5700   else if (y_pos + logical_rect.height > area_height)
5701     y_pos = area_height - logical_rect.height;
5702   
5703   y_pos = y_pos / PANGO_SCALE;
5704
5705   if (x)
5706     *x = - priv->scroll_offset;
5707
5708   if (y)
5709     *y = y_pos;
5710 }
5711
5712 static void
5713 draw_text_with_color (GtkEntry *entry,
5714                       cairo_t  *cr,
5715                       GdkRGBA  *default_color)
5716 {
5717   GtkEntryPrivate *priv = entry->priv;
5718   PangoLayout *layout = gtk_entry_ensure_layout (entry, TRUE);
5719   GtkWidget *widget;
5720   gint x, y;
5721   gint start_pos, end_pos;
5722
5723   widget = GTK_WIDGET (entry);
5724
5725   cairo_save (cr);
5726
5727   get_layout_position (entry, &x, &y);
5728
5729   cairo_move_to (cr, x, y);
5730   gdk_cairo_set_source_rgba (cr, default_color);
5731   pango_cairo_show_layout (cr, layout);
5732
5733   if (gtk_editable_get_selection_bounds (GTK_EDITABLE (entry), &start_pos, &end_pos))
5734     {
5735       gint *ranges;
5736       gint n_ranges, i;
5737       PangoRectangle logical_rect;
5738       GdkRGBA selection_color, text_color;
5739       GtkStyleContext *context;
5740       GtkStateFlags state;
5741
5742       context = gtk_widget_get_style_context (widget);
5743       pango_layout_get_pixel_extents (layout, NULL, &logical_rect);
5744       gtk_entry_get_pixel_ranges (entry, &ranges, &n_ranges);
5745
5746       state = gtk_widget_get_state_flags (widget);
5747       state |= GTK_STATE_FLAG_SELECTED;
5748
5749       gtk_style_context_get_background_color (context, state, &selection_color);
5750       gtk_style_context_get_color (context, state, &text_color);
5751
5752       for (i = 0; i < n_ranges; ++i)
5753         cairo_rectangle (cr,
5754                          - priv->scroll_offset + ranges[2 * i],
5755                          y,
5756                          ranges[2 * i + 1],
5757                          logical_rect.height);
5758
5759       cairo_clip (cr);
5760           
5761       gdk_cairo_set_source_rgba (cr, &selection_color);
5762       cairo_paint (cr);
5763
5764       cairo_move_to (cr, x, y);
5765       gdk_cairo_set_source_rgba (cr, &text_color);
5766       pango_cairo_show_layout (cr, layout);
5767   
5768       g_free (ranges);
5769     }
5770   cairo_restore (cr);
5771 }
5772
5773 static void
5774 gtk_entry_draw_text (GtkEntry *entry,
5775                      cairo_t  *cr)
5776 {
5777   GtkEntryPrivate *priv = entry->priv;
5778   GtkWidget *widget = GTK_WIDGET (entry);
5779   GtkStateFlags state = 0;
5780   GdkRGBA text_color, bar_text_color;
5781   GtkStyleContext *context;
5782   gint width, height;
5783   gint progress_x, progress_y, progress_width, progress_height;
5784   gint clip_width, clip_height;
5785
5786   /* Nothing to display at all */
5787   if (gtk_entry_get_display_mode (entry) == DISPLAY_BLANK)
5788     return;
5789
5790   state = gtk_widget_get_state_flags (widget);
5791   context = gtk_widget_get_style_context (widget);
5792
5793   gtk_style_context_get_color (context, state, &text_color);
5794
5795   /* Get foreground color for progressbars */
5796   gtk_entry_prepare_context_for_progress (entry, context);
5797   gtk_style_context_get_color (context, state, &bar_text_color);
5798   gtk_style_context_restore (context);
5799
5800   get_progress_area (widget,
5801                      &progress_x, &progress_y,
5802                      &progress_width, &progress_height);
5803
5804   cairo_save (cr);
5805
5806   clip_width = gdk_window_get_width (priv->text_area);
5807   clip_height = gdk_window_get_height (priv->text_area);
5808   cairo_rectangle (cr, 0, 0, clip_width, clip_height);
5809   cairo_clip (cr);
5810
5811   /* If the color is the same, or the progress area has a zero
5812    * size, then we only need to draw once. */
5813   if (gdk_rgba_equal (&text_color, &bar_text_color) ||
5814       ((progress_width == 0) || (progress_height == 0)))
5815     {
5816       draw_text_with_color (entry, cr, &text_color);
5817     }
5818   else
5819     {
5820       int frame_x, frame_y, area_x, area_y;
5821
5822       width = gdk_window_get_width (priv->text_area);
5823       height = gdk_window_get_height (priv->text_area);
5824
5825       cairo_save (cr);
5826
5827       cairo_set_fill_rule (cr, CAIRO_FILL_RULE_EVEN_ODD);
5828       cairo_rectangle (cr, 0, 0, width, height);
5829
5830       /* progres area is frame-relative, we need it text-area window
5831        * relative */
5832       get_frame_size (entry, TRUE, &frame_x, &frame_y, NULL, NULL);
5833       gdk_window_get_position (priv->text_area, &area_x, &area_y);
5834       progress_x += frame_x - area_x;
5835       progress_y += frame_y - area_y;
5836
5837       cairo_rectangle (cr, progress_x, progress_y,
5838                        progress_width, progress_height);
5839       cairo_clip (cr);
5840       cairo_set_fill_rule (cr, CAIRO_FILL_RULE_WINDING);
5841   
5842       draw_text_with_color (entry, cr, &text_color);
5843       cairo_restore (cr);
5844
5845       cairo_save (cr);
5846
5847       cairo_rectangle (cr, progress_x, progress_y,
5848                        progress_width, progress_height);
5849       cairo_clip (cr);
5850
5851       draw_text_with_color (entry, cr, &bar_text_color);
5852
5853       cairo_restore (cr);
5854     }
5855
5856   cairo_restore (cr);
5857 }
5858
5859 static void
5860 gtk_entry_draw_cursor (GtkEntry  *entry,
5861                        cairo_t   *cr,
5862                        CursorType type)
5863 {
5864   GtkEntryPrivate *priv = entry->priv;
5865   GtkWidget *widget = GTK_WIDGET (entry);
5866   GtkStyleContext *context;
5867   PangoRectangle cursor_rect;
5868   gint cursor_index;
5869   gboolean block;
5870   gboolean block_at_line_end;
5871   PangoLayout *layout;
5872   const char *text;
5873
5874   context = gtk_widget_get_style_context (widget);
5875
5876   layout = gtk_entry_ensure_layout (entry, TRUE);
5877   text = pango_layout_get_text (layout);
5878   cursor_index = g_utf8_offset_to_pointer (text, priv->current_pos + priv->preedit_cursor) - text;
5879
5880   if (!priv->overwrite_mode)
5881     block = FALSE;
5882   else
5883     block = _gtk_text_util_get_block_cursor_location (layout,
5884                                                       cursor_index, &cursor_rect, &block_at_line_end);
5885
5886   if (!block)
5887     {
5888       gtk_render_insertion_cursor (context, cr,
5889                                    - priv->scroll_offset, 0,
5890                                    layout, cursor_index, priv->resolved_dir);
5891     }
5892   else /* overwrite_mode */
5893     {
5894       GdkRGBA cursor_color;
5895       GdkRectangle rect;
5896       gint x, y;
5897
5898       cairo_save (cr);
5899
5900       get_layout_position (entry, &x, &y);
5901
5902       rect.x = PANGO_PIXELS (cursor_rect.x) + x;
5903       rect.y = PANGO_PIXELS (cursor_rect.y) + y;
5904       rect.width = PANGO_PIXELS (cursor_rect.width);
5905       rect.height = PANGO_PIXELS (cursor_rect.height);
5906
5907       _gtk_style_context_get_cursor_color (context, &cursor_color, NULL);
5908       gdk_cairo_set_source_rgba (cr, &cursor_color);
5909       gdk_cairo_rectangle (cr, &rect);
5910       cairo_fill (cr);
5911
5912       if (!block_at_line_end)
5913         {
5914           GtkStateFlags state;
5915           GdkRGBA color;
5916
5917           state = gtk_widget_get_state_flags (widget);
5918           gtk_style_context_get_background_color (context, state, &color);
5919
5920           gdk_cairo_rectangle (cr, &rect);
5921           cairo_clip (cr);
5922           cairo_move_to (cr, x, y);
5923           gdk_cairo_set_source_rgba (cr, &color);
5924           pango_cairo_show_layout (cr, layout);
5925         }
5926
5927       cairo_restore (cr);
5928     }
5929 }
5930
5931 void
5932 _gtk_entry_reset_im_context (GtkEntry *entry)
5933 {
5934   GtkEntryPrivate *priv = entry->priv;
5935
5936   if (priv->need_im_reset)
5937     {
5938       priv->need_im_reset = FALSE;
5939       gtk_im_context_reset (priv->im_context);
5940     }
5941 }
5942
5943 /**
5944  * gtk_entry_reset_im_context:
5945  * @entry: a #GtkEntry
5946  *
5947  * Reset the input method context of the entry if needed.
5948  *
5949  * This can be necessary in the case where modifying the buffer
5950  * would confuse on-going input method behavior.
5951  *
5952  * Since: 2.22
5953  */
5954 void
5955 gtk_entry_reset_im_context (GtkEntry *entry)
5956 {
5957   g_return_if_fail (GTK_IS_ENTRY (entry));
5958
5959   _gtk_entry_reset_im_context (entry);
5960 }
5961
5962 /**
5963  * gtk_entry_im_context_filter_keypress:
5964  * @entry: a #GtkEntry
5965  * @event: (type Gdk.EventKey): the key event
5966  *
5967  * Allow the #GtkEntry input method to internally handle key press
5968  * and release events. If this function returns %TRUE, then no further
5969  * processing should be done for this key event. See
5970  * gtk_im_context_filter_keypress().
5971  *
5972  * Note that you are expected to call this function from your handler
5973  * when overriding key event handling. This is needed in the case when
5974  * you need to insert your own key handling between the input method
5975  * and the default key event handling of the #GtkEntry.
5976  * See gtk_text_view_reset_im_context() for an example of use.
5977  *
5978  * Return value: %TRUE if the input method handled the key event.
5979  *
5980  * Since: 2.22
5981  */
5982 gboolean
5983 gtk_entry_im_context_filter_keypress (GtkEntry    *entry,
5984                                       GdkEventKey *event)
5985 {
5986   GtkEntryPrivate *priv;
5987
5988   g_return_val_if_fail (GTK_IS_ENTRY (entry), FALSE);
5989
5990   priv = entry->priv;
5991
5992   return gtk_im_context_filter_keypress (priv->im_context, event);
5993 }
5994
5995 GtkIMContext*
5996 _gtk_entry_get_im_context (GtkEntry *entry)
5997 {
5998   return entry->priv->im_context;
5999 }
6000
6001 static gint
6002 gtk_entry_find_position (GtkEntry *entry,
6003                          gint      x)
6004 {
6005   GtkEntryPrivate *priv = entry->priv;
6006   PangoLayout *layout;
6007   PangoLayoutLine *line;
6008   gint index;
6009   gint pos;
6010   gint trailing;
6011   const gchar *text;
6012   gint cursor_index;
6013   
6014   layout = gtk_entry_ensure_layout (entry, TRUE);
6015   text = pango_layout_get_text (layout);
6016   cursor_index = g_utf8_offset_to_pointer (text, priv->current_pos) - text;
6017
6018   line = pango_layout_get_lines_readonly (layout)->data;
6019   pango_layout_line_x_to_index (line, x * PANGO_SCALE, &index, &trailing);
6020
6021   if (index >= cursor_index && priv->preedit_length)
6022     {
6023       if (index >= cursor_index + priv->preedit_length)
6024         index -= priv->preedit_length;
6025       else
6026         {
6027           index = cursor_index;
6028           trailing = 0;
6029         }
6030     }
6031
6032   pos = g_utf8_pointer_to_offset (text, text + index);
6033   pos += trailing;
6034
6035   return pos;
6036 }
6037
6038 static void
6039 gtk_entry_get_cursor_locations (GtkEntry   *entry,
6040                                 CursorType  type,
6041                                 gint       *strong_x,
6042                                 gint       *weak_x)
6043 {
6044   GtkEntryPrivate *priv = entry->priv;
6045   DisplayMode mode = gtk_entry_get_display_mode (entry);
6046
6047   /* Nothing to display at all, so no cursor is relevant */
6048   if (mode == DISPLAY_BLANK)
6049     {
6050       if (strong_x)
6051         *strong_x = 0;
6052       
6053       if (weak_x)
6054         *weak_x = 0;
6055     }
6056   else
6057     {
6058       PangoLayout *layout = gtk_entry_ensure_layout (entry, TRUE);
6059       const gchar *text = pango_layout_get_text (layout);
6060       PangoRectangle strong_pos, weak_pos;
6061       gint index;
6062   
6063       if (type == CURSOR_STANDARD)
6064         {
6065           index = g_utf8_offset_to_pointer (text, priv->current_pos + priv->preedit_cursor) - text;
6066         }
6067       else /* type == CURSOR_DND */
6068         {
6069           index = g_utf8_offset_to_pointer (text, priv->dnd_position) - text;
6070
6071           if (priv->dnd_position > priv->current_pos)
6072             {
6073               if (mode == DISPLAY_NORMAL)
6074                 index += priv->preedit_length;
6075               else
6076                 {
6077                   gint preedit_len_chars = g_utf8_strlen (text, -1) - gtk_entry_buffer_get_length (get_buffer (entry));
6078                   index += preedit_len_chars * g_unichar_to_utf8 (priv->invisible_char, NULL);
6079                 }
6080             }
6081         }
6082       
6083       pango_layout_get_cursor_pos (layout, index, &strong_pos, &weak_pos);
6084       
6085       if (strong_x)
6086         *strong_x = strong_pos.x / PANGO_SCALE;
6087       
6088       if (weak_x)
6089         *weak_x = weak_pos.x / PANGO_SCALE;
6090     }
6091 }
6092
6093 static void
6094 gtk_entry_adjust_scroll (GtkEntry *entry)
6095 {
6096   GtkEntryPrivate *priv = entry->priv;
6097   gint min_offset, max_offset;
6098   gint text_area_width, text_width;
6099   GtkBorder borders;
6100   gint strong_x, weak_x;
6101   gint strong_xoffset, weak_xoffset;
6102   gfloat xalign;
6103   PangoLayout *layout;
6104   PangoLayoutLine *line;
6105   PangoRectangle logical_rect;
6106
6107   if (!gtk_widget_get_realized (GTK_WIDGET (entry)))
6108     return;
6109
6110   text_area_width = gdk_window_get_width (priv->text_area);
6111
6112   if (text_area_width < 0)
6113     text_area_width = 0;
6114
6115   layout = gtk_entry_ensure_layout (entry, TRUE);
6116   line = pango_layout_get_lines_readonly (layout)->data;
6117
6118   pango_layout_line_get_extents (line, NULL, &logical_rect);
6119
6120   /* Display as much text as we can */
6121
6122   if (priv->resolved_dir == PANGO_DIRECTION_LTR)
6123       xalign = priv->xalign;
6124   else
6125       xalign = 1.0 - priv->xalign;
6126
6127   text_width = PANGO_PIXELS(logical_rect.width);
6128
6129   if (text_width > text_area_width)
6130     {
6131       min_offset = 0;
6132       max_offset = text_width - text_area_width;
6133     }
6134   else
6135     {
6136       min_offset = (text_width - text_area_width) * xalign;
6137       max_offset = min_offset;
6138     }
6139
6140   priv->scroll_offset = CLAMP (priv->scroll_offset, min_offset, max_offset);
6141
6142   /* And make sure cursors are on screen. Note that the cursor is
6143    * actually drawn one pixel into the INNER_BORDER space on
6144    * the right, when the scroll is at the utmost right. This
6145    * looks better to to me than confining the cursor inside the
6146    * border entirely, though it means that the cursor gets one
6147    * pixel closer to the edge of the widget on the right than
6148    * on the left. This might need changing if one changed
6149    * INNER_BORDER from 2 to 1, as one would do on a
6150    * small-screen-real-estate display.
6151    *
6152    * We always make sure that the strong cursor is on screen, and
6153    * put the weak cursor on screen if possible.
6154    */
6155
6156   gtk_entry_get_cursor_locations (entry, CURSOR_STANDARD, &strong_x, &weak_x);
6157   
6158   strong_xoffset = strong_x - priv->scroll_offset;
6159
6160   if (strong_xoffset < 0)
6161     {
6162       priv->scroll_offset += strong_xoffset;
6163       strong_xoffset = 0;
6164     }
6165   else if (strong_xoffset > text_area_width)
6166     {
6167       priv->scroll_offset += strong_xoffset - text_area_width;
6168       strong_xoffset = text_area_width;
6169     }
6170
6171   weak_xoffset = weak_x - priv->scroll_offset;
6172
6173   if (weak_xoffset < 0 && strong_xoffset - weak_xoffset <= text_area_width)
6174     {
6175       priv->scroll_offset += weak_xoffset;
6176     }
6177   else if (weak_xoffset > text_area_width &&
6178            strong_xoffset - (weak_xoffset - text_area_width) >= 0)
6179     {
6180       priv->scroll_offset += weak_xoffset - text_area_width;
6181     }
6182
6183   g_object_notify (G_OBJECT (entry), "scroll-offset");
6184 }
6185
6186 static void
6187 gtk_entry_move_adjustments (GtkEntry *entry)
6188 {
6189   GtkWidget *widget = GTK_WIDGET (entry);
6190   GtkAllocation allocation;
6191   GtkAdjustment *adjustment;
6192   PangoContext *context;
6193   PangoFontMetrics *metrics;
6194   GtkStyleContext *style_context;
6195   GtkStateFlags state;
6196   GtkBorder borders;
6197   gint x, layout_x;
6198   gint char_width;
6199
6200   adjustment = g_object_get_qdata (G_OBJECT (entry), quark_cursor_hadjustment);
6201   if (!adjustment)
6202     return;
6203
6204   gtk_widget_get_allocation (widget, &allocation);
6205
6206   /* Cursor position, layout offset, border width, and widget allocation */
6207   gtk_entry_get_cursor_locations (entry, CURSOR_STANDARD, &x, NULL);
6208   get_layout_position (entry, &layout_x, NULL);
6209   _gtk_entry_get_borders (entry, &borders);
6210   x += allocation.x + layout_x + borders.left;
6211
6212   /* Approximate width of a char, so user can see what is ahead/behind */
6213   context = gtk_widget_get_pango_context (widget);
6214   style_context = gtk_widget_get_style_context (widget);
6215   state = gtk_widget_get_state_flags (widget);
6216
6217   metrics = pango_context_get_metrics (context,
6218                                        gtk_style_context_get_font (style_context, state),
6219                                        pango_context_get_language (context));
6220   char_width = pango_font_metrics_get_approximate_char_width (metrics) / PANGO_SCALE;
6221
6222   /* Scroll it */
6223   gtk_adjustment_clamp_page (adjustment, 
6224                              x - (char_width + 1),   /* one char + one pixel before */
6225                              x + (char_width + 2));  /* one char + cursor + one pixel after */
6226 }
6227
6228 static gint
6229 gtk_entry_move_visually (GtkEntry *entry,
6230                          gint      start,
6231                          gint      count)
6232 {
6233   GtkEntryPrivate *priv = entry->priv;
6234   gint index;
6235   PangoLayout *layout = gtk_entry_ensure_layout (entry, FALSE);
6236   const gchar *text;
6237
6238   text = pango_layout_get_text (layout);
6239   
6240   index = g_utf8_offset_to_pointer (text, start) - text;
6241
6242   while (count != 0)
6243     {
6244       int new_index, new_trailing;
6245       gboolean split_cursor;
6246       gboolean strong;
6247
6248       g_object_get (gtk_widget_get_settings (GTK_WIDGET (entry)),
6249                     "gtk-split-cursor", &split_cursor,
6250                     NULL);
6251
6252       if (split_cursor)
6253         strong = TRUE;
6254       else
6255         {
6256           GdkKeymap *keymap = gdk_keymap_get_for_display (gtk_widget_get_display (GTK_WIDGET (entry)));
6257           PangoDirection keymap_direction = gdk_keymap_get_direction (keymap);
6258
6259           strong = keymap_direction == priv->resolved_dir;
6260         }
6261       
6262       if (count > 0)
6263         {
6264           pango_layout_move_cursor_visually (layout, strong, index, 0, 1, &new_index, &new_trailing);
6265           count--;
6266         }
6267       else
6268         {
6269           pango_layout_move_cursor_visually (layout, strong, index, 0, -1, &new_index, &new_trailing);
6270           count++;
6271         }
6272
6273       if (new_index < 0)
6274         index = 0;
6275       else if (new_index != G_MAXINT)
6276         index = new_index;
6277       
6278       while (new_trailing--)
6279         index = g_utf8_next_char (text + index) - text;
6280     }
6281   
6282   return g_utf8_pointer_to_offset (text, text + index);
6283 }
6284
6285 static gint
6286 gtk_entry_move_logically (GtkEntry *entry,
6287                           gint      start,
6288                           gint      count)
6289 {
6290   gint new_pos = start;
6291   guint length;
6292
6293   length = gtk_entry_buffer_get_length (get_buffer (entry));
6294
6295   /* Prevent any leak of information */
6296   if (gtk_entry_get_display_mode (entry) != DISPLAY_NORMAL)
6297     {
6298       new_pos = CLAMP (start + count, 0, length);
6299     }
6300   else
6301     {
6302       PangoLayout *layout = gtk_entry_ensure_layout (entry, FALSE);
6303       PangoLogAttr *log_attrs;
6304       gint n_attrs;
6305
6306       pango_layout_get_log_attrs (layout, &log_attrs, &n_attrs);
6307
6308       while (count > 0 && new_pos < length)
6309         {
6310           do
6311             new_pos++;
6312           while (new_pos < length && !log_attrs[new_pos].is_cursor_position);
6313           
6314           count--;
6315         }
6316       while (count < 0 && new_pos > 0)
6317         {
6318           do
6319             new_pos--;
6320           while (new_pos > 0 && !log_attrs[new_pos].is_cursor_position);
6321           
6322           count++;
6323         }
6324       
6325       g_free (log_attrs);
6326     }
6327
6328   return new_pos;
6329 }
6330
6331 static gint
6332 gtk_entry_move_forward_word (GtkEntry *entry,
6333                              gint      start,
6334                              gboolean  allow_whitespace)
6335 {
6336   gint new_pos = start;
6337   guint length;
6338
6339   length = gtk_entry_buffer_get_length (get_buffer (entry));
6340
6341   /* Prevent any leak of information */
6342   if (gtk_entry_get_display_mode (entry) != DISPLAY_NORMAL)
6343     {
6344       new_pos = length;
6345     }
6346   else if (new_pos < length)
6347     {
6348       PangoLayout *layout = gtk_entry_ensure_layout (entry, FALSE);
6349       PangoLogAttr *log_attrs;
6350       gint n_attrs;
6351
6352       pango_layout_get_log_attrs (layout, &log_attrs, &n_attrs);
6353       
6354       /* Find the next word boundary */
6355       new_pos++;
6356       while (new_pos < n_attrs - 1 && !(log_attrs[new_pos].is_word_end ||
6357                                         (log_attrs[new_pos].is_word_start && allow_whitespace)))
6358         new_pos++;
6359
6360       g_free (log_attrs);
6361     }
6362
6363   return new_pos;
6364 }
6365
6366
6367 static gint
6368 gtk_entry_move_backward_word (GtkEntry *entry,
6369                               gint      start,
6370                               gboolean  allow_whitespace)
6371 {
6372   gint new_pos = start;
6373
6374   /* Prevent any leak of information */
6375   if (gtk_entry_get_display_mode (entry) != DISPLAY_NORMAL)
6376     {
6377       new_pos = 0;
6378     }
6379   else if (start > 0)
6380     {
6381       PangoLayout *layout = gtk_entry_ensure_layout (entry, FALSE);
6382       PangoLogAttr *log_attrs;
6383       gint n_attrs;
6384
6385       pango_layout_get_log_attrs (layout, &log_attrs, &n_attrs);
6386
6387       new_pos = start - 1;
6388
6389       /* Find the previous word boundary */
6390       while (new_pos > 0 && !(log_attrs[new_pos].is_word_start || 
6391                               (log_attrs[new_pos].is_word_end && allow_whitespace)))
6392         new_pos--;
6393
6394       g_free (log_attrs);
6395     }
6396
6397   return new_pos;
6398 }
6399
6400 static void
6401 gtk_entry_delete_whitespace (GtkEntry *entry)
6402 {
6403   GtkEntryPrivate *priv = entry->priv;
6404   PangoLayout *layout = gtk_entry_ensure_layout (entry, FALSE);
6405   PangoLogAttr *log_attrs;
6406   gint n_attrs;
6407   gint start, end;
6408
6409   pango_layout_get_log_attrs (layout, &log_attrs, &n_attrs);
6410
6411   start = end = priv->current_pos;
6412   
6413   while (start > 0 && log_attrs[start-1].is_white)
6414     start--;
6415
6416   while (end < n_attrs && log_attrs[end].is_white)
6417     end++;
6418
6419   g_free (log_attrs);
6420
6421   if (start != end)
6422     gtk_editable_delete_text (GTK_EDITABLE (entry), start, end);
6423 }
6424
6425
6426 static void
6427 gtk_entry_select_word (GtkEntry *entry)
6428 {
6429   GtkEntryPrivate *priv = entry->priv;
6430   gint start_pos = gtk_entry_move_backward_word (entry, priv->current_pos, TRUE);
6431   gint end_pos = gtk_entry_move_forward_word (entry, priv->current_pos, TRUE);
6432
6433   gtk_editable_select_region (GTK_EDITABLE (entry), start_pos, end_pos);
6434 }
6435
6436 static void
6437 gtk_entry_select_line (GtkEntry *entry)
6438 {
6439   gtk_editable_select_region (GTK_EDITABLE (entry), 0, -1);
6440 }
6441
6442 static gint
6443 truncate_multiline (const gchar *text)
6444 {
6445   gint length;
6446
6447   for (length = 0;
6448        text[length] && text[length] != '\n' && text[length] != '\r';
6449        length++);
6450
6451   return length;
6452 }
6453
6454 static void
6455 paste_received (GtkClipboard *clipboard,
6456                 const gchar  *text,
6457                 gpointer      data)
6458 {
6459   GtkEntry *entry = GTK_ENTRY (data);
6460   GtkEditable *editable = GTK_EDITABLE (entry);
6461   GtkEntryPrivate *priv = entry->priv;
6462
6463   if (priv->button == GDK_BUTTON_MIDDLE)
6464     {
6465       gint pos, start, end;
6466       pos = priv->insert_pos;
6467       gtk_editable_get_selection_bounds (editable, &start, &end);
6468       if (!((start <= pos && pos <= end) || (end <= pos && pos <= start)))
6469         gtk_editable_select_region (editable, pos, pos);
6470     }
6471       
6472   if (text)
6473     {
6474       gint pos, start, end;
6475       gint length = -1;
6476       gboolean popup_completion;
6477       GtkEntryCompletion *completion;
6478
6479       completion = gtk_entry_get_completion (entry);
6480
6481       if (priv->truncate_multiline)
6482         length = truncate_multiline (text);
6483
6484       /* only complete if the selection is at the end */
6485       popup_completion = (gtk_entry_buffer_get_length (get_buffer (entry)) ==
6486                           MAX (priv->current_pos, priv->selection_bound));
6487
6488       if (completion)
6489         {
6490           if (gtk_widget_get_mapped (completion->priv->popup_window))
6491             _gtk_entry_completion_popdown (completion);
6492
6493           if (!popup_completion && completion->priv->changed_id > 0)
6494             g_signal_handler_block (entry, completion->priv->changed_id);
6495         }
6496
6497       begin_change (entry);
6498       if (gtk_editable_get_selection_bounds (editable, &start, &end))
6499         gtk_editable_delete_text (editable, start, end);
6500
6501       pos = priv->current_pos;
6502       gtk_editable_insert_text (editable, text, length, &pos);
6503       gtk_editable_set_position (editable, pos);
6504       end_change (entry);
6505
6506       if (completion &&
6507           !popup_completion && completion->priv->changed_id > 0)
6508         g_signal_handler_unblock (entry, completion->priv->changed_id);
6509     }
6510
6511   g_object_unref (entry);
6512 }
6513
6514 static void
6515 gtk_entry_paste (GtkEntry *entry,
6516                  GdkAtom   selection)
6517 {
6518   g_object_ref (entry);
6519   gtk_clipboard_request_text (gtk_widget_get_clipboard (GTK_WIDGET (entry), selection),
6520                               paste_received, entry);
6521 }
6522
6523 static void
6524 primary_get_cb (GtkClipboard     *clipboard,
6525                 GtkSelectionData *selection_data,
6526                 guint             info,
6527                 gpointer          data)
6528 {
6529   GtkEntry *entry = GTK_ENTRY (data);
6530   gint start, end;
6531   
6532   if (gtk_editable_get_selection_bounds (GTK_EDITABLE (entry), &start, &end))
6533     {
6534       gchar *str = gtk_entry_get_display_text (entry, start, end);
6535       gtk_selection_data_set_text (selection_data, str, -1);
6536       g_free (str);
6537     }
6538 }
6539
6540 static void
6541 primary_clear_cb (GtkClipboard *clipboard,
6542                   gpointer      data)
6543 {
6544   GtkEntry *entry = GTK_ENTRY (data);
6545   GtkEntryPrivate *priv = entry->priv;
6546
6547   gtk_editable_select_region (GTK_EDITABLE (entry), priv->current_pos, priv->current_pos);
6548 }
6549
6550 static void
6551 gtk_entry_update_primary_selection (GtkEntry *entry)
6552 {
6553   GtkTargetList *list;
6554   GtkTargetEntry *targets;
6555   GtkClipboard *clipboard;
6556   gint start, end;
6557   gint n_targets;
6558
6559   if (!gtk_widget_get_realized (GTK_WIDGET (entry)))
6560     return;
6561
6562   list = gtk_target_list_new (NULL, 0);
6563   gtk_target_list_add_text_targets (list, 0);
6564
6565   targets = gtk_target_table_new_from_list (list, &n_targets);
6566
6567   clipboard = gtk_widget_get_clipboard (GTK_WIDGET (entry), GDK_SELECTION_PRIMARY);
6568   
6569   if (gtk_editable_get_selection_bounds (GTK_EDITABLE (entry), &start, &end))
6570     {
6571       if (!gtk_clipboard_set_with_owner (clipboard, targets, n_targets,
6572                                          primary_get_cb, primary_clear_cb, G_OBJECT (entry)))
6573         primary_clear_cb (clipboard, entry);
6574     }
6575   else
6576     {
6577       if (gtk_clipboard_get_owner (clipboard) == G_OBJECT (entry))
6578         gtk_clipboard_clear (clipboard);
6579     }
6580
6581   gtk_target_table_free (targets, n_targets);
6582   gtk_target_list_unref (list);
6583 }
6584
6585 static void
6586 gtk_entry_clear (GtkEntry             *entry,
6587                  GtkEntryIconPosition  icon_pos)
6588 {
6589   GtkEntryPrivate *priv = entry->priv;
6590   EntryIconInfo *icon_info = priv->icons[icon_pos];
6591   GtkImageType storage_type;
6592
6593   if (icon_info && _gtk_icon_helper_get_is_empty (icon_info->icon_helper))
6594     return;
6595
6596   g_object_freeze_notify (G_OBJECT (entry));
6597
6598   /* Explicitly check, as the pointer may become invalidated
6599    * during destruction.
6600    */
6601   if (GDK_IS_WINDOW (icon_info->window))
6602     gdk_window_hide (icon_info->window);
6603
6604   storage_type = _gtk_icon_helper_get_storage_type (icon_info->icon_helper);
6605
6606   switch (storage_type)
6607     {
6608     case GTK_IMAGE_PIXBUF:
6609       g_object_notify (G_OBJECT (entry),
6610                        icon_pos == GTK_ENTRY_ICON_PRIMARY ? "primary-icon-pixbuf" : "secondary-icon-pixbuf");
6611       break;
6612
6613     case GTK_IMAGE_STOCK:
6614       g_object_notify (G_OBJECT (entry),
6615                        icon_pos == GTK_ENTRY_ICON_PRIMARY ? "primary-icon-stock" : "secondary-icon-stock");
6616       break;
6617
6618     case GTK_IMAGE_ICON_NAME:
6619       g_object_notify (G_OBJECT (entry),
6620                        icon_pos == GTK_ENTRY_ICON_PRIMARY ? "primary-icon-name" : "secondary-icon-name");
6621       break;
6622
6623     case GTK_IMAGE_GICON:
6624       g_object_notify (G_OBJECT (entry),
6625                        icon_pos == GTK_ENTRY_ICON_PRIMARY ? "primary-icon-gicon" : "secondary-icon-gicon");
6626       break;
6627
6628     default:
6629       g_assert_not_reached ();
6630       break;
6631     }
6632
6633   _gtk_icon_helper_clear (icon_info->icon_helper);
6634
6635   g_object_notify (G_OBJECT (entry),
6636                    icon_pos == GTK_ENTRY_ICON_PRIMARY ? "primary-icon-storage-type" : "secondary-icon-storage-type");
6637
6638   g_object_thaw_notify (G_OBJECT (entry));
6639 }
6640
6641 static GdkPixbuf *
6642 gtk_entry_ensure_pixbuf (GtkEntry             *entry,
6643                          GtkEntryIconPosition  icon_pos)
6644 {
6645   GtkEntryPrivate *priv = entry->priv;
6646   EntryIconInfo *icon_info = priv->icons[icon_pos];
6647   GtkStyleContext *context;
6648   GdkPixbuf *pix;
6649
6650   context = gtk_widget_get_style_context (GTK_WIDGET (entry));
6651   gtk_entry_prepare_context_for_icon (entry, context, icon_pos);
6652
6653   pix = _gtk_icon_helper_ensure_pixbuf (icon_info->icon_helper,
6654                                         context);
6655
6656   gtk_style_context_restore (context);
6657
6658   return pix;
6659 }
6660
6661 /* Public API
6662  */
6663
6664 /**
6665  * gtk_entry_new:
6666  *
6667  * Creates a new entry.
6668  *
6669  * Return value: a new #GtkEntry.
6670  */
6671 GtkWidget*
6672 gtk_entry_new (void)
6673 {
6674   return g_object_new (GTK_TYPE_ENTRY, NULL);
6675 }
6676
6677 /**
6678  * gtk_entry_new_with_buffer:
6679  * @buffer: The buffer to use for the new #GtkEntry.
6680  *
6681  * Creates a new entry with the specified text buffer.
6682  *
6683  * Return value: a new #GtkEntry
6684  *
6685  * Since: 2.18
6686  */
6687 GtkWidget*
6688 gtk_entry_new_with_buffer (GtkEntryBuffer *buffer)
6689 {
6690   g_return_val_if_fail (GTK_IS_ENTRY_BUFFER (buffer), NULL);
6691   return g_object_new (GTK_TYPE_ENTRY, "buffer", buffer, NULL);
6692 }
6693
6694 static GtkEntryBuffer*
6695 get_buffer (GtkEntry *entry)
6696 {
6697   GtkEntryPrivate *priv = entry->priv;
6698
6699   if (priv->buffer == NULL)
6700     {
6701       GtkEntryBuffer *buffer;
6702       buffer = gtk_entry_buffer_new (NULL, 0);
6703       gtk_entry_set_buffer (entry, buffer);
6704       g_object_unref (buffer);
6705     }
6706
6707   return priv->buffer;
6708 }
6709
6710 /**
6711  * gtk_entry_get_buffer:
6712  * @entry: a #GtkEntry
6713  *
6714  * Get the #GtkEntryBuffer object which holds the text for
6715  * this widget.
6716  *
6717  * Since: 2.18
6718  *
6719  * Returns: (transfer none): A #GtkEntryBuffer object.
6720  */
6721 GtkEntryBuffer*
6722 gtk_entry_get_buffer (GtkEntry *entry)
6723 {
6724   g_return_val_if_fail (GTK_IS_ENTRY (entry), NULL);
6725
6726   return get_buffer (entry);
6727 }
6728
6729 /**
6730  * gtk_entry_set_buffer:
6731  * @entry: a #GtkEntry
6732  * @buffer: a #GtkEntryBuffer
6733  *
6734  * Set the #GtkEntryBuffer object which holds the text for
6735  * this widget.
6736  *
6737  * Since: 2.18
6738  */
6739 void
6740 gtk_entry_set_buffer (GtkEntry       *entry,
6741                       GtkEntryBuffer *buffer)
6742 {
6743   GtkEntryPrivate *priv;
6744   GObject *obj;
6745
6746   g_return_if_fail (GTK_IS_ENTRY (entry));
6747
6748   priv = entry->priv;
6749
6750   if (buffer)
6751     {
6752       g_return_if_fail (GTK_IS_ENTRY_BUFFER (buffer));
6753       g_object_ref (buffer);
6754     }
6755
6756   if (priv->buffer)
6757     {
6758       buffer_disconnect_signals (entry);
6759       g_object_unref (priv->buffer);
6760     }
6761
6762   priv->buffer = buffer;
6763
6764   if (priv->buffer)
6765      buffer_connect_signals (entry);
6766
6767   obj = G_OBJECT (entry);
6768   g_object_freeze_notify (obj);
6769   g_object_notify (obj, "buffer");
6770   g_object_notify (obj, "text");
6771   g_object_notify (obj, "text-length");
6772   g_object_notify (obj, "max-length");
6773   g_object_notify (obj, "visibility");
6774   g_object_notify (obj, "invisible-char");
6775   g_object_notify (obj, "invisible-char-set");
6776   g_object_thaw_notify (obj);
6777
6778   gtk_editable_set_position (GTK_EDITABLE (entry), 0);
6779   gtk_entry_recompute (entry);
6780 }
6781
6782 /**
6783  * gtk_entry_get_text_area:
6784  * @entry: a #GtkEntry
6785  * @text_area: (out): Return location for the text area.
6786  *
6787  * Gets the area where the entry's text is drawn. This function is
6788  * useful when drawing something to the entry in a draw callback.
6789  *
6790  * If the entry is not realized, @text_area is filled with zeros.
6791  *
6792  * See also gtk_entry_get_icon_area().
6793  *
6794  * Since: 3.0
6795  **/
6796 void
6797 gtk_entry_get_text_area (GtkEntry     *entry,
6798                          GdkRectangle *text_area)
6799 {
6800   GtkEntryPrivate *priv;
6801
6802   g_return_if_fail (GTK_IS_ENTRY (entry));
6803   g_return_if_fail (text_area != NULL);
6804
6805   priv = entry->priv;
6806
6807   if (priv->text_area)
6808     {
6809       GtkAllocation allocation;
6810       gint x, y;
6811
6812       gtk_widget_get_allocation (GTK_WIDGET (entry), &allocation);
6813       gdk_window_get_position (priv->text_area, &x, &y);
6814
6815       text_area->x = x - allocation.x;
6816       text_area->y = y - allocation.y;
6817       text_area->width = gdk_window_get_width (priv->text_area);
6818       text_area->height = gdk_window_get_height (priv->text_area);
6819     }
6820   else
6821     {
6822       text_area->x = 0;
6823       text_area->y = 0;
6824       text_area->width = 0;
6825       text_area->height = 0;
6826     }
6827 }
6828
6829 /**
6830  * gtk_entry_set_text:
6831  * @entry: a #GtkEntry
6832  * @text: the new text
6833  *
6834  * Sets the text in the widget to the given
6835  * value, replacing the current contents.
6836  *
6837  * See gtk_entry_buffer_set_text().
6838  */
6839 void
6840 gtk_entry_set_text (GtkEntry    *entry,
6841                     const gchar *text)
6842 {
6843   gint tmp_pos;
6844   GtkEntryCompletion *completion;
6845
6846   g_return_if_fail (GTK_IS_ENTRY (entry));
6847   g_return_if_fail (text != NULL);
6848
6849   /* Actually setting the text will affect the cursor and selection;
6850    * if the contents don't actually change, this will look odd to the user.
6851    */
6852   if (strcmp (gtk_entry_buffer_get_text (get_buffer (entry)), text) == 0)
6853     return;
6854
6855   completion = gtk_entry_get_completion (entry);
6856   if (completion && completion->priv->changed_id > 0)
6857     g_signal_handler_block (entry, completion->priv->changed_id);
6858
6859   begin_change (entry);
6860   gtk_editable_delete_text (GTK_EDITABLE (entry), 0, -1);
6861   tmp_pos = 0;
6862   gtk_editable_insert_text (GTK_EDITABLE (entry), text, strlen (text), &tmp_pos);
6863   end_change (entry);
6864
6865   if (completion && completion->priv->changed_id > 0)
6866     g_signal_handler_unblock (entry, completion->priv->changed_id);
6867 }
6868
6869 /**
6870  * gtk_entry_set_visibility:
6871  * @entry: a #GtkEntry
6872  * @visible: %TRUE if the contents of the entry are displayed
6873  *           as plaintext
6874  *
6875  * Sets whether the contents of the entry are visible or not. 
6876  * When visibility is set to %FALSE, characters are displayed 
6877  * as the invisible char, and will also appear that way when 
6878  * the text in the entry widget is copied elsewhere.
6879  *
6880  * By default, GTK+ picks the best invisible character available
6881  * in the current font, but it can be changed with
6882  * gtk_entry_set_invisible_char().
6883  */
6884 void
6885 gtk_entry_set_visibility (GtkEntry *entry,
6886                           gboolean visible)
6887 {
6888   GtkEntryPrivate *priv;
6889
6890   g_return_if_fail (GTK_IS_ENTRY (entry));
6891
6892   priv = entry->priv;
6893
6894   visible = visible != FALSE;
6895
6896   if (priv->visible != visible)
6897     {
6898       priv->visible = visible;
6899
6900       g_object_notify (G_OBJECT (entry), "visibility");
6901       gtk_entry_recompute (entry);
6902     }
6903 }
6904
6905 /**
6906  * gtk_entry_get_visibility:
6907  * @entry: a #GtkEntry
6908  *
6909  * Retrieves whether the text in @entry is visible. See
6910  * gtk_entry_set_visibility().
6911  *
6912  * Return value: %TRUE if the text is currently visible
6913  **/
6914 gboolean
6915 gtk_entry_get_visibility (GtkEntry *entry)
6916 {
6917   g_return_val_if_fail (GTK_IS_ENTRY (entry), FALSE);
6918
6919   return entry->priv->visible;
6920 }
6921
6922 /**
6923  * gtk_entry_set_invisible_char:
6924  * @entry: a #GtkEntry
6925  * @ch: a Unicode character
6926  * 
6927  * Sets the character to use in place of the actual text when
6928  * gtk_entry_set_visibility() has been called to set text visibility
6929  * to %FALSE. i.e. this is the character used in "password mode" to
6930  * show the user how many characters have been typed. By default, GTK+
6931  * picks the best invisible char available in the current font. If you
6932  * set the invisible char to 0, then the user will get no feedback
6933  * at all; there will be no text on the screen as they type.
6934  **/
6935 void
6936 gtk_entry_set_invisible_char (GtkEntry *entry,
6937                               gunichar  ch)
6938 {
6939   GtkEntryPrivate *priv;
6940
6941   g_return_if_fail (GTK_IS_ENTRY (entry));
6942
6943   priv = entry->priv;
6944
6945   if (!priv->invisible_char_set)
6946     {
6947       priv->invisible_char_set = TRUE;
6948       g_object_notify (G_OBJECT (entry), "invisible-char-set");
6949     }
6950
6951   if (ch == priv->invisible_char)
6952     return;
6953
6954   priv->invisible_char = ch;
6955   g_object_notify (G_OBJECT (entry), "invisible-char");
6956   gtk_entry_recompute (entry);  
6957 }
6958
6959 /**
6960  * gtk_entry_get_invisible_char:
6961  * @entry: a #GtkEntry
6962  *
6963  * Retrieves the character displayed in place of the real characters
6964  * for entries with visibility set to false. See gtk_entry_set_invisible_char().
6965  *
6966  * Return value: the current invisible char, or 0, if the entry does not
6967  *               show invisible text at all. 
6968  **/
6969 gunichar
6970 gtk_entry_get_invisible_char (GtkEntry *entry)
6971 {
6972   g_return_val_if_fail (GTK_IS_ENTRY (entry), 0);
6973
6974   return entry->priv->invisible_char;
6975 }
6976
6977 /**
6978  * gtk_entry_unset_invisible_char:
6979  * @entry: a #GtkEntry
6980  *
6981  * Unsets the invisible char previously set with
6982  * gtk_entry_set_invisible_char(). So that the
6983  * default invisible char is used again.
6984  *
6985  * Since: 2.16
6986  **/
6987 void
6988 gtk_entry_unset_invisible_char (GtkEntry *entry)
6989 {
6990   GtkEntryPrivate *priv;
6991   gunichar ch;
6992
6993   g_return_if_fail (GTK_IS_ENTRY (entry));
6994
6995   priv = entry->priv;
6996
6997   if (!priv->invisible_char_set)
6998     return;
6999
7000   priv->invisible_char_set = FALSE;
7001   ch = find_invisible_char (GTK_WIDGET (entry));
7002
7003   if (priv->invisible_char != ch)
7004     {
7005       priv->invisible_char = ch;
7006       g_object_notify (G_OBJECT (entry), "invisible-char");
7007     }
7008
7009   g_object_notify (G_OBJECT (entry), "invisible-char-set");
7010   gtk_entry_recompute (entry);
7011 }
7012
7013 /**
7014  * gtk_entry_set_overwrite_mode:
7015  * @entry: a #GtkEntry
7016  * @overwrite: new value
7017  * 
7018  * Sets whether the text is overwritten when typing in the #GtkEntry.
7019  *
7020  * Since: 2.14
7021  **/
7022 void
7023 gtk_entry_set_overwrite_mode (GtkEntry *entry,
7024                               gboolean  overwrite)
7025 {
7026   GtkEntryPrivate *priv = entry->priv;
7027
7028   g_return_if_fail (GTK_IS_ENTRY (entry));
7029
7030   if (priv->overwrite_mode == overwrite)
7031     return;
7032   
7033   gtk_entry_toggle_overwrite (entry);
7034
7035   g_object_notify (G_OBJECT (entry), "overwrite-mode");
7036 }
7037
7038 /**
7039  * gtk_entry_get_overwrite_mode:
7040  * @entry: a #GtkEntry
7041  * 
7042  * Gets the value set by gtk_entry_set_overwrite_mode().
7043  * 
7044  * Return value: whether the text is overwritten when typing.
7045  *
7046  * Since: 2.14
7047  **/
7048 gboolean
7049 gtk_entry_get_overwrite_mode (GtkEntry *entry)
7050 {
7051   g_return_val_if_fail (GTK_IS_ENTRY (entry), FALSE);
7052
7053   return entry->priv->overwrite_mode;
7054 }
7055
7056 /**
7057  * gtk_entry_get_text:
7058  * @entry: a #GtkEntry
7059  *
7060  * Retrieves the contents of the entry widget.
7061  * See also gtk_editable_get_chars().
7062  *
7063  * This is equivalent to:
7064  *
7065  * <informalexample><programlisting>
7066  * gtk_entry_buffer_get_text (gtk_entry_get_buffer (entry));
7067  * </programlisting></informalexample>
7068  *
7069  * Return value: a pointer to the contents of the widget as a
7070  *      string. This string points to internally allocated
7071  *      storage in the widget and must not be freed, modified or
7072  *      stored.
7073  **/
7074 const gchar*
7075 gtk_entry_get_text (GtkEntry *entry)
7076 {
7077   g_return_val_if_fail (GTK_IS_ENTRY (entry), NULL);
7078
7079   return gtk_entry_buffer_get_text (get_buffer (entry));
7080 }
7081
7082 /**
7083  * gtk_entry_set_max_length:
7084  * @entry: a #GtkEntry
7085  * @max: the maximum length of the entry, or 0 for no maximum.
7086  *   (other than the maximum length of entries.) The value passed in will
7087  *   be clamped to the range 0-65536.
7088  * 
7089  * Sets the maximum allowed length of the contents of the widget. If
7090  * the current contents are longer than the given length, then they
7091  * will be truncated to fit.
7092  *
7093  * This is equivalent to:
7094  *
7095  * <informalexample><programlisting>
7096  * gtk_entry_buffer_set_max_length (gtk_entry_get_buffer (entry), max);
7097  * </programlisting></informalexample>
7098  **/
7099 void
7100 gtk_entry_set_max_length (GtkEntry     *entry,
7101                           gint          max)
7102 {
7103   g_return_if_fail (GTK_IS_ENTRY (entry));
7104   gtk_entry_buffer_set_max_length (get_buffer (entry), max);
7105 }
7106
7107 /**
7108  * gtk_entry_get_max_length:
7109  * @entry: a #GtkEntry
7110  *
7111  * Retrieves the maximum allowed length of the text in
7112  * @entry. See gtk_entry_set_max_length().
7113  *
7114  * This is equivalent to:
7115  *
7116  * <informalexample><programlisting>
7117  * gtk_entry_buffer_get_max_length (gtk_entry_get_buffer (entry));
7118  * </programlisting></informalexample>
7119  *
7120  * Return value: the maximum allowed number of characters
7121  *               in #GtkEntry, or 0 if there is no maximum.
7122  **/
7123 gint
7124 gtk_entry_get_max_length (GtkEntry *entry)
7125 {
7126   g_return_val_if_fail (GTK_IS_ENTRY (entry), 0);
7127
7128   return gtk_entry_buffer_get_max_length (get_buffer (entry));
7129 }
7130
7131 /**
7132  * gtk_entry_get_text_length:
7133  * @entry: a #GtkEntry
7134  *
7135  * Retrieves the current length of the text in
7136  * @entry. 
7137  *
7138  * This is equivalent to:
7139  *
7140  * <informalexample><programlisting>
7141  * gtk_entry_buffer_get_length (gtk_entry_get_buffer (entry));
7142  * </programlisting></informalexample>
7143  *
7144  * Return value: the current number of characters
7145  *               in #GtkEntry, or 0 if there are none.
7146  *
7147  * Since: 2.14
7148  **/
7149 guint16
7150 gtk_entry_get_text_length (GtkEntry *entry)
7151 {
7152   g_return_val_if_fail (GTK_IS_ENTRY (entry), 0);
7153
7154   return gtk_entry_buffer_get_length (get_buffer (entry));
7155 }
7156
7157 /**
7158  * gtk_entry_set_activates_default:
7159  * @entry: a #GtkEntry
7160  * @setting: %TRUE to activate window's default widget on Enter keypress
7161  *
7162  * If @setting is %TRUE, pressing Enter in the @entry will activate the default
7163  * widget for the window containing the entry. This usually means that
7164  * the dialog box containing the entry will be closed, since the default
7165  * widget is usually one of the dialog buttons.
7166  *
7167  * (For experts: if @setting is %TRUE, the entry calls
7168  * gtk_window_activate_default() on the window containing the entry, in
7169  * the default handler for the #GtkWidget::activate signal.)
7170  **/
7171 void
7172 gtk_entry_set_activates_default (GtkEntry *entry,
7173                                  gboolean  setting)
7174 {
7175   GtkEntryPrivate *priv;
7176
7177   g_return_if_fail (GTK_IS_ENTRY (entry));
7178
7179   priv = entry->priv;
7180
7181   setting = setting != FALSE;
7182
7183   if (setting != priv->activates_default)
7184     {
7185       priv->activates_default = setting;
7186       g_object_notify (G_OBJECT (entry), "activates-default");
7187     }
7188 }
7189
7190 /**
7191  * gtk_entry_get_activates_default:
7192  * @entry: a #GtkEntry
7193  * 
7194  * Retrieves the value set by gtk_entry_set_activates_default().
7195  * 
7196  * Return value: %TRUE if the entry will activate the default widget
7197  **/
7198 gboolean
7199 gtk_entry_get_activates_default (GtkEntry *entry)
7200 {
7201   g_return_val_if_fail (GTK_IS_ENTRY (entry), FALSE);
7202
7203   return entry->priv->activates_default;
7204 }
7205
7206 /**
7207  * gtk_entry_set_width_chars:
7208  * @entry: a #GtkEntry
7209  * @n_chars: width in chars
7210  *
7211  * Changes the size request of the entry to be about the right size
7212  * for @n_chars characters. Note that it changes the size
7213  * <emphasis>request</emphasis>, the size can still be affected by
7214  * how you pack the widget into containers. If @n_chars is -1, the
7215  * size reverts to the default entry size.
7216  **/
7217 void
7218 gtk_entry_set_width_chars (GtkEntry *entry,
7219                            gint      n_chars)
7220 {
7221   GtkEntryPrivate *priv;
7222
7223   g_return_if_fail (GTK_IS_ENTRY (entry));
7224
7225   priv = entry->priv;
7226
7227   if (priv->width_chars != n_chars)
7228     {
7229       priv->width_chars = n_chars;
7230       g_object_notify (G_OBJECT (entry), "width-chars");
7231       gtk_widget_queue_resize (GTK_WIDGET (entry));
7232     }
7233 }
7234
7235 /**
7236  * gtk_entry_get_width_chars:
7237  * @entry: a #GtkEntry
7238  * 
7239  * Gets the value set by gtk_entry_set_width_chars().
7240  * 
7241  * Return value: number of chars to request space for, or negative if unset
7242  **/
7243 gint
7244 gtk_entry_get_width_chars (GtkEntry *entry)
7245 {
7246   g_return_val_if_fail (GTK_IS_ENTRY (entry), 0);
7247
7248   return entry->priv->width_chars;
7249 }
7250
7251 /**
7252  * gtk_entry_set_has_frame:
7253  * @entry: a #GtkEntry
7254  * @setting: new value
7255  * 
7256  * Sets whether the entry has a beveled frame around it.
7257  **/
7258 void
7259 gtk_entry_set_has_frame (GtkEntry *entry,
7260                          gboolean  setting)
7261 {
7262   GtkEntryPrivate *priv;
7263
7264   g_return_if_fail (GTK_IS_ENTRY (entry));
7265
7266   priv = entry->priv;
7267
7268   setting = (setting != FALSE);
7269
7270   if (priv->has_frame == setting)
7271     return;
7272
7273   gtk_widget_queue_resize (GTK_WIDGET (entry));
7274   priv->has_frame = setting;
7275   g_object_notify (G_OBJECT (entry), "has-frame");
7276 }
7277
7278 /**
7279  * gtk_entry_get_has_frame:
7280  * @entry: a #GtkEntry
7281  * 
7282  * Gets the value set by gtk_entry_set_has_frame().
7283  * 
7284  * Return value: whether the entry has a beveled frame
7285  **/
7286 gboolean
7287 gtk_entry_get_has_frame (GtkEntry *entry)
7288 {
7289   g_return_val_if_fail (GTK_IS_ENTRY (entry), FALSE);
7290
7291   return entry->priv->has_frame;
7292 }
7293
7294 /**
7295  * gtk_entry_set_inner_border:
7296  * @entry: a #GtkEntry
7297  * @border: (allow-none): a #GtkBorder, or %NULL
7298  *
7299  * Sets %entry's inner-border property to %border, or clears it if %NULL
7300  * is passed. The inner-border is the area around the entry's text, but
7301  * inside its frame.
7302  *
7303  * If set, this property overrides the inner-border style property.
7304  * Overriding the style-provided border is useful when you want to do
7305  * in-place editing of some text in a canvas or list widget, where
7306  * pixel-exact positioning of the entry is important.
7307  *
7308  * Since: 2.10
7309  *
7310  * Deprecated: 3.4: Use the standard border and padding CSS properties;
7311  *   the value set with this function is ignored by #GtkEntry.
7312  **/
7313 void
7314 gtk_entry_set_inner_border (GtkEntry        *entry,
7315                             const GtkBorder *border)
7316 {
7317   g_return_if_fail (GTK_IS_ENTRY (entry));
7318
7319   gtk_entry_do_set_inner_border (entry, border);
7320 }
7321
7322 /**
7323  * gtk_entry_get_inner_border:
7324  * @entry: a #GtkEntry
7325  *
7326  * This function returns the entry's #GtkEntry:inner-border property. See
7327  * gtk_entry_set_inner_border() for more information.
7328  *
7329  * Return value: (transfer none): the entry's #GtkBorder, or %NULL if none was set.
7330  *
7331  * Since: 2.10
7332  *
7333  * Deprecated: 3.4: Use the standard border and padding CSS properties;
7334  *   the value returned by this function is ignored by #GtkEntry.
7335  **/
7336 const GtkBorder *
7337 gtk_entry_get_inner_border (GtkEntry *entry)
7338 {
7339   g_return_val_if_fail (GTK_IS_ENTRY (entry), NULL);
7340
7341   return gtk_entry_do_get_inner_border (entry);
7342 }
7343
7344 /**
7345  * gtk_entry_get_layout:
7346  * @entry: a #GtkEntry
7347  * 
7348  * Gets the #PangoLayout used to display the entry.
7349  * The layout is useful to e.g. convert text positions to
7350  * pixel positions, in combination with gtk_entry_get_layout_offsets().
7351  * The returned layout is owned by the entry and must not be 
7352  * modified or freed by the caller.
7353  *
7354  * Keep in mind that the layout text may contain a preedit string, so
7355  * gtk_entry_layout_index_to_text_index() and
7356  * gtk_entry_text_index_to_layout_index() are needed to convert byte
7357  * indices in the layout to byte indices in the entry contents.
7358  *
7359  * Return value: (transfer none): the #PangoLayout for this entry
7360  **/
7361 PangoLayout*
7362 gtk_entry_get_layout (GtkEntry *entry)
7363 {
7364   PangoLayout *layout;
7365   
7366   g_return_val_if_fail (GTK_IS_ENTRY (entry), NULL);
7367
7368   layout = gtk_entry_ensure_layout (entry, TRUE);
7369
7370   return layout;
7371 }
7372
7373
7374 /**
7375  * gtk_entry_layout_index_to_text_index:
7376  * @entry: a #GtkEntry
7377  * @layout_index: byte index into the entry layout text
7378  * 
7379  * Converts from a position in the entry contents (returned
7380  * by gtk_entry_get_text()) to a position in the
7381  * entry's #PangoLayout (returned by gtk_entry_get_layout(),
7382  * with text retrieved via pango_layout_get_text()).
7383  * 
7384  * Return value: byte index into the entry contents
7385  **/
7386 gint
7387 gtk_entry_layout_index_to_text_index (GtkEntry *entry,
7388                                       gint      layout_index)
7389 {
7390   GtkEntryPrivate *priv;
7391   PangoLayout *layout;
7392   const gchar *text;
7393   gint cursor_index;
7394   
7395   g_return_val_if_fail (GTK_IS_ENTRY (entry), 0);
7396
7397   priv = entry->priv;
7398
7399   layout = gtk_entry_ensure_layout (entry, TRUE);
7400   text = pango_layout_get_text (layout);
7401   cursor_index = g_utf8_offset_to_pointer (text, priv->current_pos) - text;
7402
7403   if (layout_index >= cursor_index && priv->preedit_length)
7404     {
7405       if (layout_index >= cursor_index + priv->preedit_length)
7406         layout_index -= priv->preedit_length;
7407       else
7408         layout_index = cursor_index;
7409     }
7410
7411   return layout_index;
7412 }
7413
7414 /**
7415  * gtk_entry_text_index_to_layout_index:
7416  * @entry: a #GtkEntry
7417  * @text_index: byte index into the entry contents
7418  * 
7419  * Converts from a position in the entry's #PangoLayout (returned by
7420  * gtk_entry_get_layout()) to a position in the entry contents
7421  * (returned by gtk_entry_get_text()).
7422  * 
7423  * Return value: byte index into the entry layout text
7424  **/
7425 gint
7426 gtk_entry_text_index_to_layout_index (GtkEntry *entry,
7427                                       gint      text_index)
7428 {
7429   GtkEntryPrivate *priv;
7430   PangoLayout *layout;
7431   const gchar *text;
7432   gint cursor_index;
7433
7434   g_return_val_if_fail (GTK_IS_ENTRY (entry), 0);
7435
7436   priv = entry->priv;
7437
7438   layout = gtk_entry_ensure_layout (entry, TRUE);
7439   text = pango_layout_get_text (layout);
7440   cursor_index = g_utf8_offset_to_pointer (text, priv->current_pos) - text;
7441
7442   if (text_index > cursor_index)
7443     text_index += priv->preedit_length;
7444
7445   return text_index;
7446 }
7447
7448 /**
7449  * gtk_entry_get_layout_offsets:
7450  * @entry: a #GtkEntry
7451  * @x: (out) (allow-none): location to store X offset of layout, or %NULL
7452  * @y: (out) (allow-none): location to store Y offset of layout, or %NULL
7453  *
7454  *
7455  * Obtains the position of the #PangoLayout used to render text
7456  * in the entry, in widget coordinates. Useful if you want to line
7457  * up the text in an entry with some other text, e.g. when using the
7458  * entry to implement editable cells in a sheet widget.
7459  *
7460  * Also useful to convert mouse events into coordinates inside the
7461  * #PangoLayout, e.g. to take some action if some part of the entry text
7462  * is clicked.
7463  * 
7464  * Note that as the user scrolls around in the entry the offsets will
7465  * change; you'll need to connect to the "notify::scroll-offset"
7466  * signal to track this. Remember when using the #PangoLayout
7467  * functions you need to convert to and from pixels using
7468  * PANGO_PIXELS() or #PANGO_SCALE.
7469  *
7470  * Keep in mind that the layout text may contain a preedit string, so
7471  * gtk_entry_layout_index_to_text_index() and
7472  * gtk_entry_text_index_to_layout_index() are needed to convert byte
7473  * indices in the layout to byte indices in the entry contents.
7474  **/
7475 void
7476 gtk_entry_get_layout_offsets (GtkEntry *entry,
7477                               gint     *x,
7478                               gint     *y)
7479 {
7480   gint text_area_x, text_area_y;
7481   
7482   g_return_if_fail (GTK_IS_ENTRY (entry));
7483
7484   /* this gets coords relative to text area */
7485   get_layout_position (entry, x, y);
7486
7487   /* convert to widget coords */
7488   gtk_entry_get_text_area_size (entry, &text_area_x, &text_area_y, NULL, NULL);
7489   
7490   if (x)
7491     *x += text_area_x;
7492
7493   if (y)
7494     *y += text_area_y;
7495 }
7496
7497
7498 /**
7499  * gtk_entry_set_alignment:
7500  * @entry: a #GtkEntry
7501  * @xalign: The horizontal alignment, from 0 (left) to 1 (right).
7502  *          Reversed for RTL layouts
7503  * 
7504  * Sets the alignment for the contents of the entry. This controls
7505  * the horizontal positioning of the contents when the displayed
7506  * text is shorter than the width of the entry.
7507  *
7508  * Since: 2.4
7509  **/
7510 void
7511 gtk_entry_set_alignment (GtkEntry *entry, gfloat xalign)
7512 {
7513   GtkEntryPrivate *priv;
7514
7515   g_return_if_fail (GTK_IS_ENTRY (entry));
7516
7517   priv = entry->priv;
7518
7519   if (xalign < 0.0)
7520     xalign = 0.0;
7521   else if (xalign > 1.0)
7522     xalign = 1.0;
7523
7524   if (xalign != priv->xalign)
7525     {
7526       priv->xalign = xalign;
7527
7528       gtk_entry_recompute (entry);
7529
7530       g_object_notify (G_OBJECT (entry), "xalign");
7531     }
7532 }
7533
7534 /**
7535  * gtk_entry_get_alignment:
7536  * @entry: a #GtkEntry
7537  * 
7538  * Gets the value set by gtk_entry_set_alignment().
7539  * 
7540  * Return value: the alignment
7541  *
7542  * Since: 2.4
7543  **/
7544 gfloat
7545 gtk_entry_get_alignment (GtkEntry *entry)
7546 {
7547   g_return_val_if_fail (GTK_IS_ENTRY (entry), 0.0);
7548
7549   return entry->priv->xalign;
7550 }
7551
7552 /**
7553  * gtk_entry_set_icon_from_pixbuf:
7554  * @entry: a #GtkEntry
7555  * @icon_pos: Icon position
7556  * @pixbuf: (allow-none): A #GdkPixbuf, or %NULL
7557  *
7558  * Sets the icon shown in the specified position using a pixbuf.
7559  *
7560  * If @pixbuf is %NULL, no icon will be shown in the specified position.
7561  *
7562  * Since: 2.16
7563  */
7564 void
7565 gtk_entry_set_icon_from_pixbuf (GtkEntry             *entry,
7566                                 GtkEntryIconPosition  icon_pos,
7567                                 GdkPixbuf            *pixbuf)
7568 {
7569   GtkEntryPrivate *priv;
7570   EntryIconInfo *icon_info;
7571
7572   g_return_if_fail (GTK_IS_ENTRY (entry));
7573   g_return_if_fail (IS_VALID_ICON_POSITION (icon_pos));
7574
7575   priv = entry->priv;
7576
7577   if ((icon_info = priv->icons[icon_pos]) == NULL)
7578     icon_info = construct_icon_info (GTK_WIDGET (entry), icon_pos);
7579
7580   g_object_freeze_notify (G_OBJECT (entry));
7581
7582   if (pixbuf)
7583     g_object_ref (pixbuf);
7584
7585   gtk_entry_clear (entry, icon_pos);
7586
7587   if (pixbuf)
7588     {
7589       _gtk_icon_helper_set_pixbuf (icon_info->icon_helper, pixbuf);
7590
7591       if (icon_pos == GTK_ENTRY_ICON_PRIMARY)
7592         {
7593           g_object_notify (G_OBJECT (entry), "primary-icon-pixbuf");
7594           g_object_notify (G_OBJECT (entry), "primary-icon-storage-type");
7595         }
7596       else
7597         {
7598           g_object_notify (G_OBJECT (entry), "secondary-icon-pixbuf");
7599           g_object_notify (G_OBJECT (entry), "secondary-icon-storage-type");
7600         }
7601
7602       if (gtk_widget_get_mapped (GTK_WIDGET (entry)))
7603           gdk_window_show_unraised (icon_info->window);
7604
7605       g_object_unref (pixbuf);
7606     }
7607   
7608   if (gtk_widget_get_visible (GTK_WIDGET (entry)))
7609     gtk_widget_queue_resize (GTK_WIDGET (entry));
7610
7611   g_object_thaw_notify (G_OBJECT (entry));
7612 }
7613
7614 /**
7615  * gtk_entry_set_icon_from_stock:
7616  * @entry: A #GtkEntry
7617  * @icon_pos: Icon position
7618  * @stock_id: (allow-none): The name of the stock item, or %NULL
7619  *
7620  * Sets the icon shown in the entry at the specified position from
7621  * a stock image.
7622  *
7623  * If @stock_id is %NULL, no icon will be shown in the specified position.
7624  *
7625  * Since: 2.16
7626  */
7627 void
7628 gtk_entry_set_icon_from_stock (GtkEntry             *entry,
7629                                GtkEntryIconPosition  icon_pos,
7630                                const gchar          *stock_id)
7631 {
7632   GtkEntryPrivate *priv;
7633   EntryIconInfo *icon_info;
7634   gchar *new_id;
7635
7636   g_return_if_fail (GTK_IS_ENTRY (entry));
7637   g_return_if_fail (IS_VALID_ICON_POSITION (icon_pos));
7638
7639   priv = entry->priv;
7640
7641   if ((icon_info = priv->icons[icon_pos]) == NULL)
7642     icon_info = construct_icon_info (GTK_WIDGET (entry), icon_pos);
7643
7644   g_object_freeze_notify (G_OBJECT (entry));
7645
7646   /* need to dup before clearing */
7647   new_id = g_strdup (stock_id);
7648
7649   gtk_entry_clear (entry, icon_pos);
7650
7651   if (new_id != NULL)
7652     {
7653       _gtk_icon_helper_set_stock_id (icon_info->icon_helper, new_id, GTK_ICON_SIZE_MENU);
7654
7655       if (icon_pos == GTK_ENTRY_ICON_PRIMARY)
7656         {
7657           g_object_notify (G_OBJECT (entry), "primary-icon-stock");
7658           g_object_notify (G_OBJECT (entry), "primary-icon-storage-type");
7659         }
7660       else
7661         {
7662           g_object_notify (G_OBJECT (entry), "secondary-icon-stock");
7663           g_object_notify (G_OBJECT (entry), "secondary-icon-storage-type");
7664         }
7665
7666       if (gtk_widget_get_mapped (GTK_WIDGET (entry)))
7667           gdk_window_show_unraised (icon_info->window);
7668
7669       g_free (new_id);
7670     }
7671
7672   if (gtk_widget_get_visible (GTK_WIDGET (entry)))
7673     gtk_widget_queue_resize (GTK_WIDGET (entry));
7674
7675   g_object_thaw_notify (G_OBJECT (entry));
7676 }
7677
7678 /**
7679  * gtk_entry_set_icon_from_icon_name:
7680  * @entry: A #GtkEntry
7681  * @icon_pos: The position at which to set the icon
7682  * @icon_name: (allow-none): An icon name, or %NULL
7683  *
7684  * Sets the icon shown in the entry at the specified position
7685  * from the current icon theme.
7686  *
7687  * If the icon name isn't known, a "broken image" icon will be displayed
7688  * instead.
7689  *
7690  * If @icon_name is %NULL, no icon will be shown in the specified position.
7691  *
7692  * Since: 2.16
7693  */
7694 void
7695 gtk_entry_set_icon_from_icon_name (GtkEntry             *entry,
7696                                    GtkEntryIconPosition  icon_pos,
7697                                    const gchar          *icon_name)
7698 {
7699   GtkEntryPrivate *priv;
7700   EntryIconInfo *icon_info;
7701   gchar *new_name;
7702
7703   g_return_if_fail (GTK_IS_ENTRY (entry));
7704   g_return_if_fail (IS_VALID_ICON_POSITION (icon_pos));
7705
7706   priv = entry->priv;
7707
7708   if ((icon_info = priv->icons[icon_pos]) == NULL)
7709     icon_info = construct_icon_info (GTK_WIDGET (entry), icon_pos);
7710
7711   g_object_freeze_notify (G_OBJECT (entry));
7712
7713   /* need to dup before clearing */
7714   new_name = g_strdup (icon_name);
7715
7716   gtk_entry_clear (entry, icon_pos);
7717
7718   if (new_name != NULL)
7719     {
7720       _gtk_icon_helper_set_icon_name (icon_info->icon_helper, new_name, GTK_ICON_SIZE_MENU);
7721
7722       if (icon_pos == GTK_ENTRY_ICON_PRIMARY)
7723         {
7724           g_object_notify (G_OBJECT (entry), "primary-icon-name");
7725           g_object_notify (G_OBJECT (entry), "primary-icon-storage-type");
7726         }
7727       else
7728         {
7729           g_object_notify (G_OBJECT (entry), "secondary-icon-name");
7730           g_object_notify (G_OBJECT (entry), "secondary-icon-storage-type");
7731         }
7732
7733       if (gtk_widget_get_mapped (GTK_WIDGET (entry)))
7734           gdk_window_show_unraised (icon_info->window);
7735
7736       g_free (new_name);
7737     }
7738
7739   if (gtk_widget_get_visible (GTK_WIDGET (entry)))
7740     gtk_widget_queue_resize (GTK_WIDGET (entry));
7741
7742   g_object_thaw_notify (G_OBJECT (entry));
7743 }
7744
7745 /**
7746  * gtk_entry_set_icon_from_gicon:
7747  * @entry: A #GtkEntry
7748  * @icon_pos: The position at which to set the icon
7749  * @icon: (allow-none): The icon to set, or %NULL
7750  *
7751  * Sets the icon shown in the entry at the specified position
7752  * from the current icon theme.
7753  * If the icon isn't known, a "broken image" icon will be displayed
7754  * instead.
7755  *
7756  * If @icon is %NULL, no icon will be shown in the specified position.
7757  *
7758  * Since: 2.16
7759  */
7760 void
7761 gtk_entry_set_icon_from_gicon (GtkEntry             *entry,
7762                                GtkEntryIconPosition  icon_pos,
7763                                GIcon                *icon)
7764 {
7765   GtkEntryPrivate *priv;
7766   EntryIconInfo *icon_info;
7767
7768   g_return_if_fail (GTK_IS_ENTRY (entry));
7769   g_return_if_fail (IS_VALID_ICON_POSITION (icon_pos));
7770
7771   priv = entry->priv;
7772
7773   if ((icon_info = priv->icons[icon_pos]) == NULL)
7774     icon_info = construct_icon_info (GTK_WIDGET (entry), icon_pos);
7775
7776   g_object_freeze_notify (G_OBJECT (entry));
7777
7778   /* need to ref before clearing */
7779   if (icon)
7780     g_object_ref (icon);
7781
7782   gtk_entry_clear (entry, icon_pos);
7783
7784   if (icon)
7785     {
7786       _gtk_icon_helper_set_gicon (icon_info->icon_helper, icon, GTK_ICON_SIZE_MENU);
7787
7788       if (icon_pos == GTK_ENTRY_ICON_PRIMARY)
7789         {
7790           g_object_notify (G_OBJECT (entry), "primary-icon-gicon");
7791           g_object_notify (G_OBJECT (entry), "primary-icon-storage-type");
7792         }
7793       else
7794         {
7795           g_object_notify (G_OBJECT (entry), "secondary-icon-gicon");
7796           g_object_notify (G_OBJECT (entry), "secondary-icon-storage-type");
7797         }
7798
7799       if (gtk_widget_get_mapped (GTK_WIDGET (entry)))
7800           gdk_window_show_unraised (icon_info->window);
7801
7802       g_object_unref (icon);
7803     }
7804
7805   if (gtk_widget_get_visible (GTK_WIDGET (entry)))
7806     gtk_widget_queue_resize (GTK_WIDGET (entry));
7807
7808   g_object_thaw_notify (G_OBJECT (entry));
7809 }
7810
7811 /**
7812  * gtk_entry_set_icon_activatable:
7813  * @entry: A #GtkEntry
7814  * @icon_pos: Icon position
7815  * @activatable: %TRUE if the icon should be activatable
7816  *
7817  * Sets whether the icon is activatable.
7818  *
7819  * Since: 2.16
7820  */
7821 void
7822 gtk_entry_set_icon_activatable (GtkEntry             *entry,
7823                                 GtkEntryIconPosition  icon_pos,
7824                                 gboolean              activatable)
7825 {
7826   GtkEntryPrivate *priv;
7827   EntryIconInfo *icon_info;
7828
7829   g_return_if_fail (GTK_IS_ENTRY (entry));
7830   g_return_if_fail (IS_VALID_ICON_POSITION (icon_pos));
7831
7832   priv = entry->priv;
7833
7834   if ((icon_info = priv->icons[icon_pos]) == NULL)
7835     icon_info = construct_icon_info (GTK_WIDGET (entry), icon_pos);
7836
7837   activatable = activatable != FALSE;
7838
7839   if (icon_info->nonactivatable != !activatable)
7840     {
7841       icon_info->nonactivatable = !activatable;
7842
7843       if (gtk_widget_get_realized (GTK_WIDGET (entry)))
7844         update_cursors (GTK_WIDGET (entry));
7845
7846       g_object_notify (G_OBJECT (entry),
7847                        icon_pos == GTK_ENTRY_ICON_PRIMARY ? "primary-icon-activatable" : "secondary-icon-activatable");
7848     }
7849 }
7850
7851 /**
7852  * gtk_entry_get_icon_activatable:
7853  * @entry: a #GtkEntry
7854  * @icon_pos: Icon position
7855  *
7856  * Returns whether the icon is activatable.
7857  *
7858  * Returns: %TRUE if the icon is activatable.
7859  *
7860  * Since: 2.16
7861  */
7862 gboolean
7863 gtk_entry_get_icon_activatable (GtkEntry             *entry,
7864                                 GtkEntryIconPosition  icon_pos)
7865 {
7866   GtkEntryPrivate *priv;
7867   EntryIconInfo *icon_info;
7868
7869   g_return_val_if_fail (GTK_IS_ENTRY (entry), FALSE);
7870   g_return_val_if_fail (IS_VALID_ICON_POSITION (icon_pos), FALSE);
7871
7872   priv = entry->priv;
7873   icon_info = priv->icons[icon_pos];
7874
7875   return (!icon_info || !icon_info->nonactivatable);
7876 }
7877
7878 /**
7879  * gtk_entry_get_icon_pixbuf:
7880  * @entry: A #GtkEntry
7881  * @icon_pos: Icon position
7882  *
7883  * Retrieves the image used for the icon.
7884  *
7885  * Unlike the other methods of setting and getting icon data, this
7886  * method will work regardless of whether the icon was set using a
7887  * #GdkPixbuf, a #GIcon, a stock item, or an icon name.
7888  *
7889  * Returns: (transfer none): A #GdkPixbuf, or %NULL if no icon is
7890  *     set for this position.
7891  *
7892  * Since: 2.16
7893  */
7894 GdkPixbuf *
7895 gtk_entry_get_icon_pixbuf (GtkEntry             *entry,
7896                            GtkEntryIconPosition  icon_pos)
7897 {
7898   GtkEntryPrivate *priv;
7899   EntryIconInfo *icon_info;
7900   GdkPixbuf *pixbuf;
7901
7902   g_return_val_if_fail (GTK_IS_ENTRY (entry), NULL);
7903   g_return_val_if_fail (IS_VALID_ICON_POSITION (icon_pos), NULL);
7904
7905   priv = entry->priv;
7906
7907   icon_info = priv->icons[icon_pos];
7908
7909   if (!icon_info)
7910     return NULL;
7911
7912   /* HACK: unfortunately this is transfer none, so we need to return
7913    * the icon helper's cache ref directly.
7914    */
7915   pixbuf = gtk_entry_ensure_pixbuf (entry, icon_pos);
7916   g_object_unref (pixbuf);
7917
7918   return pixbuf;
7919 }
7920
7921 /**
7922  * gtk_entry_get_icon_gicon:
7923  * @entry: A #GtkEntry
7924  * @icon_pos: Icon position
7925  *
7926  * Retrieves the #GIcon used for the icon, or %NULL if there is
7927  * no icon or if the icon was set by some other method (e.g., by
7928  * stock, pixbuf, or icon name).
7929  *
7930  * Returns: (transfer none): A #GIcon, or %NULL if no icon is set
7931  *     or if the icon is not a #GIcon
7932  *
7933  * Since: 2.16
7934  */
7935 GIcon *
7936 gtk_entry_get_icon_gicon (GtkEntry             *entry,
7937                           GtkEntryIconPosition  icon_pos)
7938 {
7939   GtkEntryPrivate *priv;
7940   EntryIconInfo *icon_info;
7941
7942   g_return_val_if_fail (GTK_IS_ENTRY (entry), NULL);
7943   g_return_val_if_fail (IS_VALID_ICON_POSITION (icon_pos), NULL);
7944
7945   priv = entry->priv;
7946   icon_info = priv->icons[icon_pos];
7947
7948   if (!icon_info)
7949     return NULL;
7950
7951   return _gtk_icon_helper_peek_gicon (icon_info->icon_helper);
7952 }
7953
7954 /**
7955  * gtk_entry_get_icon_stock:
7956  * @entry: A #GtkEntry
7957  * @icon_pos: Icon position
7958  *
7959  * Retrieves the stock id used for the icon, or %NULL if there is
7960  * no icon or if the icon was set by some other method (e.g., by
7961  * pixbuf, icon name or gicon).
7962  *
7963  * Returns: A stock id, or %NULL if no icon is set or if the icon
7964  *          wasn't set from a stock id
7965  *
7966  * Since: 2.16
7967  */
7968 const gchar *
7969 gtk_entry_get_icon_stock (GtkEntry             *entry,
7970                           GtkEntryIconPosition  icon_pos)
7971 {
7972   GtkEntryPrivate *priv;
7973   EntryIconInfo *icon_info;
7974
7975   g_return_val_if_fail (GTK_IS_ENTRY (entry), NULL);
7976   g_return_val_if_fail (IS_VALID_ICON_POSITION (icon_pos), NULL);
7977
7978   priv = entry->priv;
7979   icon_info = priv->icons[icon_pos];
7980
7981   if (!icon_info)
7982     return NULL;
7983
7984   return _gtk_icon_helper_get_stock_id (icon_info->icon_helper);
7985 }
7986
7987 /**
7988  * gtk_entry_get_icon_name:
7989  * @entry: A #GtkEntry
7990  * @icon_pos: Icon position
7991  *
7992  * Retrieves the icon name used for the icon, or %NULL if there is
7993  * no icon or if the icon was set by some other method (e.g., by
7994  * pixbuf, stock or gicon).
7995  *
7996  * Returns: An icon name, or %NULL if no icon is set or if the icon
7997  *          wasn't set from an icon name
7998  *
7999  * Since: 2.16
8000  */
8001 const gchar *
8002 gtk_entry_get_icon_name (GtkEntry             *entry,
8003                          GtkEntryIconPosition  icon_pos)
8004 {
8005   GtkEntryPrivate *priv;
8006   EntryIconInfo *icon_info;
8007
8008   g_return_val_if_fail (GTK_IS_ENTRY (entry), NULL);
8009   g_return_val_if_fail (IS_VALID_ICON_POSITION (icon_pos), NULL);
8010
8011   priv = entry->priv;
8012   icon_info = priv->icons[icon_pos];
8013
8014   if (!icon_info)
8015     return NULL;
8016
8017   return _gtk_icon_helper_get_icon_name (icon_info->icon_helper);
8018 }
8019
8020 /**
8021  * gtk_entry_set_icon_sensitive:
8022  * @entry: A #GtkEntry
8023  * @icon_pos: Icon position
8024  * @sensitive: Specifies whether the icon should appear
8025  *             sensitive or insensitive
8026  *
8027  * Sets the sensitivity for the specified icon.
8028  *
8029  * Since: 2.16
8030  */
8031 void
8032 gtk_entry_set_icon_sensitive (GtkEntry             *entry,
8033                               GtkEntryIconPosition  icon_pos,
8034                               gboolean              sensitive)
8035 {
8036   GtkEntryPrivate *priv;
8037   EntryIconInfo *icon_info;
8038
8039   g_return_if_fail (GTK_IS_ENTRY (entry));
8040   g_return_if_fail (IS_VALID_ICON_POSITION (icon_pos));
8041
8042   priv = entry->priv;
8043
8044   if ((icon_info = priv->icons[icon_pos]) == NULL)
8045     icon_info = construct_icon_info (GTK_WIDGET (entry), icon_pos);
8046
8047   if (icon_info->insensitive != !sensitive)
8048     {
8049       icon_info->insensitive = !sensitive;
8050
8051       icon_info->pressed = FALSE;
8052       icon_info->prelight = FALSE;
8053
8054       if (gtk_widget_get_realized (GTK_WIDGET (entry)))
8055         update_cursors (GTK_WIDGET (entry));
8056
8057       gtk_widget_queue_draw (GTK_WIDGET (entry));
8058
8059       g_object_notify (G_OBJECT (entry),
8060                        icon_pos == GTK_ENTRY_ICON_PRIMARY ? "primary-icon-sensitive" : "secondary-icon-sensitive");
8061     }
8062 }
8063
8064 /**
8065  * gtk_entry_get_icon_sensitive:
8066  * @entry: a #GtkEntry
8067  * @icon_pos: Icon position
8068  *
8069  * Returns whether the icon appears sensitive or insensitive.
8070  *
8071  * Returns: %TRUE if the icon is sensitive.
8072  *
8073  * Since: 2.16
8074  */
8075 gboolean
8076 gtk_entry_get_icon_sensitive (GtkEntry             *entry,
8077                               GtkEntryIconPosition  icon_pos)
8078 {
8079   GtkEntryPrivate *priv;
8080   EntryIconInfo *icon_info;
8081
8082   g_return_val_if_fail (GTK_IS_ENTRY (entry), TRUE);
8083   g_return_val_if_fail (IS_VALID_ICON_POSITION (icon_pos), TRUE);
8084
8085   priv = entry->priv;
8086
8087   icon_info = priv->icons[icon_pos];
8088
8089   return (!icon_info || !icon_info->insensitive);
8090
8091 }
8092
8093 /**
8094  * gtk_entry_get_icon_storage_type:
8095  * @entry: a #GtkEntry
8096  * @icon_pos: Icon position
8097  *
8098  * Gets the type of representation being used by the icon
8099  * to store image data. If the icon has no image data,
8100  * the return value will be %GTK_IMAGE_EMPTY.
8101  *
8102  * Return value: image representation being used
8103  *
8104  * Since: 2.16
8105  **/
8106 GtkImageType
8107 gtk_entry_get_icon_storage_type (GtkEntry             *entry,
8108                                  GtkEntryIconPosition  icon_pos)
8109 {
8110   GtkEntryPrivate *priv;
8111   EntryIconInfo *icon_info;
8112
8113   g_return_val_if_fail (GTK_IS_ENTRY (entry), GTK_IMAGE_EMPTY);
8114   g_return_val_if_fail (IS_VALID_ICON_POSITION (icon_pos), GTK_IMAGE_EMPTY);
8115
8116   priv = entry->priv;
8117
8118   icon_info = priv->icons[icon_pos];
8119
8120   if (!icon_info)
8121     return GTK_IMAGE_EMPTY;
8122
8123   return _gtk_icon_helper_get_storage_type (icon_info->icon_helper);
8124 }
8125
8126 /**
8127  * gtk_entry_get_icon_at_pos:
8128  * @entry: a #GtkEntry
8129  * @x: the x coordinate of the position to find
8130  * @y: the y coordinate of the position to find
8131  *
8132  * Finds the icon at the given position and return its index. The
8133  * position's coordinates are relative to the @entry's top left corner.
8134  * If @x, @y doesn't lie inside an icon, -1 is returned.
8135  * This function is intended for use in a #GtkWidget::query-tooltip
8136  * signal handler.
8137  *
8138  * Returns: the index of the icon at the given position, or -1
8139  *
8140  * Since: 2.16
8141  */
8142 gint
8143 gtk_entry_get_icon_at_pos (GtkEntry *entry,
8144                            gint      x,
8145                            gint      y)
8146 {
8147   GtkAllocation primary;
8148   GtkAllocation secondary;
8149   gint frame_x, frame_y;
8150
8151   g_return_val_if_fail (GTK_IS_ENTRY (entry), -1);
8152
8153   get_frame_size (entry, FALSE, &frame_x, &frame_y, NULL, NULL);
8154   x -= frame_x;
8155   y -= frame_y;
8156
8157   get_icon_allocations (entry, &primary, &secondary);
8158
8159   if (primary.x <= x && x < primary.x + primary.width &&
8160       primary.y <= y && y < primary.y + primary.height)
8161     return GTK_ENTRY_ICON_PRIMARY;
8162
8163   if (secondary.x <= x && x < secondary.x + secondary.width &&
8164       secondary.y <= y && y < secondary.y + secondary.height)
8165     return GTK_ENTRY_ICON_SECONDARY;
8166
8167   return -1;
8168 }
8169
8170 /**
8171  * gtk_entry_set_icon_drag_source:
8172  * @entry: a #GtkIconEntry
8173  * @icon_pos: icon position
8174  * @target_list: the targets (data formats) in which the data can be provided
8175  * @actions: a bitmask of the allowed drag actions
8176  *
8177  * Sets up the icon at the given position so that GTK+ will start a drag
8178  * operation when the user clicks and drags the icon.
8179  *
8180  * To handle the drag operation, you need to connect to the usual
8181  * #GtkWidget::drag-data-get (or possibly #GtkWidget::drag-data-delete)
8182  * signal, and use gtk_entry_get_current_icon_drag_source() in
8183  * your signal handler to find out if the drag was started from
8184  * an icon.
8185  *
8186  * By default, GTK+ uses the icon as the drag icon. You can use the 
8187  * #GtkWidget::drag-begin signal to set a different icon. Note that you 
8188  * have to use g_signal_connect_after() to ensure that your signal handler
8189  * gets executed after the default handler.
8190  *
8191  * Since: 2.16
8192  */
8193 void
8194 gtk_entry_set_icon_drag_source (GtkEntry             *entry,
8195                                 GtkEntryIconPosition  icon_pos,
8196                                 GtkTargetList        *target_list,
8197                                 GdkDragAction         actions)
8198 {
8199   GtkEntryPrivate *priv;
8200   EntryIconInfo *icon_info;
8201
8202   g_return_if_fail (GTK_IS_ENTRY (entry));
8203   g_return_if_fail (IS_VALID_ICON_POSITION (icon_pos));
8204
8205   priv = entry->priv;
8206
8207   if ((icon_info = priv->icons[icon_pos]) == NULL)
8208     icon_info = construct_icon_info (GTK_WIDGET (entry), icon_pos);
8209
8210   if (icon_info->target_list)
8211     gtk_target_list_unref (icon_info->target_list);
8212   icon_info->target_list = target_list;
8213   if (icon_info->target_list)
8214     gtk_target_list_ref (icon_info->target_list);
8215
8216   icon_info->actions = actions;
8217 }
8218
8219 /**
8220  * gtk_entry_get_current_icon_drag_source:
8221  * @entry: a #GtkIconEntry
8222  *
8223  * Returns the index of the icon which is the source of the current
8224  * DND operation, or -1.
8225  *
8226  * This function is meant to be used in a #GtkWidget::drag-data-get
8227  * callback.
8228  *
8229  * Returns: index of the icon which is the source of the current
8230  *          DND operation, or -1.
8231  *
8232  * Since: 2.16
8233  */
8234 gint
8235 gtk_entry_get_current_icon_drag_source (GtkEntry *entry)
8236 {
8237   GtkEntryPrivate *priv;
8238   EntryIconInfo *icon_info = NULL;
8239   gint i;
8240
8241   g_return_val_if_fail (GTK_IS_ENTRY (entry), -1);
8242
8243   priv = entry->priv;
8244
8245   for (i = 0; i < MAX_ICONS; i++)
8246     {
8247       if ((icon_info = priv->icons[i]))
8248         {
8249           if (icon_info->in_drag)
8250             return i;
8251         }
8252     }
8253
8254   return -1;
8255 }
8256
8257 /**
8258  * gtk_entry_get_icon_area:
8259  * @entry: A #GtkEntry
8260  * @icon_pos: Icon position
8261  * @icon_area: (out): Return location for the icon's area
8262  *
8263  * Gets the area where entry's icon at @icon_pos is drawn.
8264  * This function is useful when drawing something to the
8265  * entry in a draw callback.
8266  *
8267  * If the entry is not realized or has no icon at the given position,
8268  * @icon_area is filled with zeros.
8269  *
8270  * See also gtk_entry_get_text_area()
8271  *
8272  * Since: 3.0
8273  */
8274 void
8275 gtk_entry_get_icon_area (GtkEntry             *entry,
8276                          GtkEntryIconPosition  icon_pos,
8277                          GdkRectangle         *icon_area)
8278 {
8279   GtkEntryPrivate *priv;
8280   EntryIconInfo *icon_info;
8281
8282   g_return_if_fail (GTK_IS_ENTRY (entry));
8283   g_return_if_fail (icon_area != NULL);
8284
8285   priv = entry->priv;
8286
8287   icon_info = priv->icons[icon_pos];
8288
8289   if (icon_info)
8290     {
8291       GtkAllocation primary;
8292       GtkAllocation secondary;
8293
8294       get_icon_allocations (entry, &primary, &secondary);
8295
8296       if (icon_pos == GTK_ENTRY_ICON_PRIMARY)
8297         *icon_area = primary;
8298       else
8299         *icon_area = secondary;
8300     }
8301   else
8302     {
8303       icon_area->x = 0;
8304       icon_area->y = 0;
8305       icon_area->width = 0;
8306       icon_area->height = 0;
8307     }
8308 }
8309
8310 static void
8311 ensure_has_tooltip (GtkEntry *entry)
8312 {
8313   GtkEntryPrivate *priv;
8314   EntryIconInfo *icon_info;
8315   int i;
8316   gboolean has_tooltip = FALSE;
8317
8318   priv = entry->priv;
8319
8320   for (i = 0; i < MAX_ICONS; i++)
8321     {
8322       if ((icon_info = priv->icons[i]) != NULL)
8323         {
8324           if (icon_info->tooltip != NULL)
8325             {
8326               has_tooltip = TRUE;
8327               break;
8328             }
8329         }
8330     }
8331
8332   gtk_widget_set_has_tooltip (GTK_WIDGET (entry), has_tooltip);
8333 }
8334
8335 /**
8336  * gtk_entry_get_icon_tooltip_text:
8337  * @entry: a #GtkEntry
8338  * @icon_pos: the icon position
8339  *
8340  * Gets the contents of the tooltip on the icon at the specified 
8341  * position in @entry.
8342  * 
8343  * Returns: the tooltip text, or %NULL. Free the returned string
8344  *     with g_free() when done.
8345  * 
8346  * Since: 2.16
8347  */
8348 gchar *
8349 gtk_entry_get_icon_tooltip_text (GtkEntry             *entry,
8350                                  GtkEntryIconPosition  icon_pos)
8351 {
8352   GtkEntryPrivate *priv;
8353   EntryIconInfo *icon_info;
8354   gchar *text = NULL;
8355
8356   g_return_val_if_fail (GTK_IS_ENTRY (entry), NULL);
8357   g_return_val_if_fail (IS_VALID_ICON_POSITION (icon_pos), NULL);
8358
8359   priv = entry->priv;
8360
8361   icon_info = priv->icons[icon_pos];
8362
8363   if (!icon_info)
8364     return NULL;
8365  
8366   if (icon_info->tooltip && 
8367       !pango_parse_markup (icon_info->tooltip, -1, 0, NULL, &text, NULL, NULL))
8368     g_assert (NULL == text); /* text should still be NULL in case of markup errors */
8369
8370   return text;
8371 }
8372
8373 /**
8374  * gtk_entry_set_icon_tooltip_text:
8375  * @entry: a #GtkEntry
8376  * @icon_pos: the icon position
8377  * @tooltip: (allow-none): the contents of the tooltip for the icon, or %NULL
8378  *
8379  * Sets @tooltip as the contents of the tooltip for the icon
8380  * at the specified position.
8381  *
8382  * Use %NULL for @tooltip to remove an existing tooltip.
8383  *
8384  * See also gtk_widget_set_tooltip_text() and 
8385  * gtk_entry_set_icon_tooltip_markup().
8386  *
8387  * Since: 2.16
8388  */
8389 void
8390 gtk_entry_set_icon_tooltip_text (GtkEntry             *entry,
8391                                  GtkEntryIconPosition  icon_pos,
8392                                  const gchar          *tooltip)
8393 {
8394   GtkEntryPrivate *priv;
8395   EntryIconInfo *icon_info;
8396
8397   g_return_if_fail (GTK_IS_ENTRY (entry));
8398   g_return_if_fail (IS_VALID_ICON_POSITION (icon_pos));
8399
8400   priv = entry->priv;
8401
8402   if ((icon_info = priv->icons[icon_pos]) == NULL)
8403     icon_info = construct_icon_info (GTK_WIDGET (entry), icon_pos);
8404
8405   if (icon_info->tooltip)
8406     g_free (icon_info->tooltip);
8407
8408   /* Treat an empty string as a NULL string,
8409    * because an empty string would be useless for a tooltip:
8410    */
8411   if (tooltip && tooltip[0] == '\0')
8412     tooltip = NULL;
8413
8414   icon_info->tooltip = tooltip ? g_markup_escape_text (tooltip, -1) : NULL;
8415
8416   ensure_has_tooltip (entry);
8417 }
8418
8419 /**
8420  * gtk_entry_get_icon_tooltip_markup:
8421  * @entry: a #GtkEntry
8422  * @icon_pos: the icon position
8423  *
8424  * Gets the contents of the tooltip on the icon at the specified 
8425  * position in @entry.
8426  * 
8427  * Returns: the tooltip text, or %NULL. Free the returned string
8428  *     with g_free() when done.
8429  * 
8430  * Since: 2.16
8431  */
8432 gchar *
8433 gtk_entry_get_icon_tooltip_markup (GtkEntry             *entry,
8434                                    GtkEntryIconPosition  icon_pos)
8435 {
8436   GtkEntryPrivate *priv;
8437   EntryIconInfo *icon_info;
8438
8439   g_return_val_if_fail (GTK_IS_ENTRY (entry), NULL);
8440   g_return_val_if_fail (IS_VALID_ICON_POSITION (icon_pos), NULL);
8441
8442   priv = entry->priv;
8443
8444   icon_info = priv->icons[icon_pos];
8445
8446   if (!icon_info)
8447     return NULL;
8448  
8449   return g_strdup (icon_info->tooltip);
8450 }
8451
8452 /**
8453  * gtk_entry_set_icon_tooltip_markup:
8454  * @entry: a #GtkEntry
8455  * @icon_pos: the icon position
8456  * @tooltip: (allow-none): the contents of the tooltip for the icon, or %NULL
8457  *
8458  * Sets @tooltip as the contents of the tooltip for the icon at
8459  * the specified position. @tooltip is assumed to be marked up with
8460  * the <link linkend="PangoMarkupFormat">Pango text markup language</link>.
8461  *
8462  * Use %NULL for @tooltip to remove an existing tooltip.
8463  *
8464  * See also gtk_widget_set_tooltip_markup() and 
8465  * gtk_enty_set_icon_tooltip_text().
8466  *
8467  * Since: 2.16
8468  */
8469 void
8470 gtk_entry_set_icon_tooltip_markup (GtkEntry             *entry,
8471                                    GtkEntryIconPosition  icon_pos,
8472                                    const gchar          *tooltip)
8473 {
8474   GtkEntryPrivate *priv;
8475   EntryIconInfo *icon_info;
8476
8477   g_return_if_fail (GTK_IS_ENTRY (entry));
8478   g_return_if_fail (IS_VALID_ICON_POSITION (icon_pos));
8479
8480   priv = entry->priv;
8481
8482   if ((icon_info = priv->icons[icon_pos]) == NULL)
8483     icon_info = construct_icon_info (GTK_WIDGET (entry), icon_pos);
8484
8485   if (icon_info->tooltip)
8486     g_free (icon_info->tooltip);
8487
8488   /* Treat an empty string as a NULL string,
8489    * because an empty string would be useless for a tooltip:
8490    */
8491   if (tooltip && tooltip[0] == '\0')
8492     tooltip = NULL;
8493
8494   icon_info->tooltip = g_strdup (tooltip);
8495
8496   ensure_has_tooltip (entry);
8497 }
8498
8499 static gboolean
8500 gtk_entry_query_tooltip (GtkWidget  *widget,
8501                          gint        x,
8502                          gint        y,
8503                          gboolean    keyboard_tip,
8504                          GtkTooltip *tooltip)
8505 {
8506   GtkEntry *entry;
8507   GtkEntryPrivate *priv;
8508   EntryIconInfo *icon_info;
8509   gint icon_pos;
8510
8511   entry = GTK_ENTRY (widget);
8512   priv = entry->priv;
8513
8514   if (!keyboard_tip)
8515     {
8516       icon_pos = gtk_entry_get_icon_at_pos (entry, x, y);
8517       if (icon_pos != -1)
8518         {
8519           if ((icon_info = priv->icons[icon_pos]) != NULL)
8520             {
8521               if (icon_info->tooltip)
8522                 {
8523                   gtk_tooltip_set_markup (tooltip, icon_info->tooltip);
8524                   return TRUE;
8525                 }
8526
8527               return FALSE;
8528             }
8529         }
8530     }
8531
8532   return GTK_WIDGET_CLASS (gtk_entry_parent_class)->query_tooltip (widget,
8533                                                                    x, y,
8534                                                                    keyboard_tip,
8535                                                                    tooltip);
8536 }
8537
8538
8539 /* Quick hack of a popup menu
8540  */
8541 static void
8542 activate_cb (GtkWidget *menuitem,
8543              GtkEntry  *entry)
8544 {
8545   const gchar *signal = g_object_get_data (G_OBJECT (menuitem), "gtk-signal");
8546   g_signal_emit_by_name (entry, signal);
8547 }
8548
8549
8550 static gboolean
8551 gtk_entry_mnemonic_activate (GtkWidget *widget,
8552                              gboolean   group_cycling)
8553 {
8554   gtk_widget_grab_focus (widget);
8555   return TRUE;
8556 }
8557
8558 static void
8559 append_action_signal (GtkEntry     *entry,
8560                       GtkWidget    *menu,
8561                       const gchar  *stock_id,
8562                       const gchar  *signal,
8563                       gboolean      sensitive)
8564 {
8565   GtkWidget *menuitem = gtk_image_menu_item_new_from_stock (stock_id, NULL);
8566
8567   g_object_set_data (G_OBJECT (menuitem), I_("gtk-signal"), (char *)signal);
8568   g_signal_connect (menuitem, "activate",
8569                     G_CALLBACK (activate_cb), entry);
8570
8571   gtk_widget_set_sensitive (menuitem, sensitive);
8572   
8573   gtk_widget_show (menuitem);
8574   gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
8575 }
8576         
8577 static void
8578 popup_menu_detach (GtkWidget *attach_widget,
8579                    GtkMenu   *menu)
8580 {
8581   GtkEntry *entry_attach = GTK_ENTRY (attach_widget);
8582   GtkEntryPrivate *priv_attach = entry_attach->priv;
8583
8584   priv_attach->popup_menu = NULL;
8585 }
8586
8587 static void
8588 popup_position_func (GtkMenu   *menu,
8589                      gint      *x,
8590                      gint      *y,
8591                      gboolean  *push_in,
8592                      gpointer   user_data)
8593 {
8594   GtkEntry *entry = GTK_ENTRY (user_data);
8595   GtkEntryPrivate *priv = entry->priv;
8596   GtkWidget *widget = GTK_WIDGET (entry);
8597   GdkScreen *screen;
8598   GtkRequisition menu_req;
8599   GdkRectangle monitor;
8600   GtkBorder borders;
8601   gint monitor_num, strong_x, height;
8602  
8603   g_return_if_fail (gtk_widget_get_realized (widget));
8604
8605   gdk_window_get_origin (priv->text_area, x, y);
8606
8607   screen = gtk_widget_get_screen (widget);
8608   monitor_num = gdk_screen_get_monitor_at_window (screen, priv->text_area);
8609   if (monitor_num < 0)
8610     monitor_num = 0;
8611   gtk_menu_set_monitor (menu, monitor_num);
8612
8613   gdk_screen_get_monitor_workarea (screen, monitor_num, &monitor);
8614   gtk_widget_get_preferred_size (priv->popup_menu,
8615                                  &menu_req, NULL);
8616   height = gdk_window_get_height (priv->text_area);
8617   gtk_entry_get_cursor_locations (entry, CURSOR_STANDARD, &strong_x, NULL);
8618   _gtk_entry_get_borders (entry, &borders);
8619
8620   *x += borders.left + strong_x - priv->scroll_offset;
8621   if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)
8622     *x -= menu_req.width;
8623
8624   if ((*y + height + menu_req.height) <= monitor.y + monitor.height)
8625     *y += height;
8626   else if ((*y - menu_req.height) >= monitor.y)
8627     *y -= menu_req.height;
8628   else if (monitor.y + monitor.height - (*y + height) > *y)
8629     *y += height;
8630   else
8631     *y -= menu_req.height;
8632
8633   *push_in = FALSE;
8634 }
8635
8636 static void
8637 unichar_chosen_func (const char *text,
8638                      gpointer    data)
8639 {
8640   GtkEntry *entry = GTK_ENTRY (data);
8641   GtkEntryPrivate *priv = entry->priv;
8642
8643   if (priv->editable)
8644     gtk_entry_enter_text (entry, text);
8645 }
8646
8647 typedef struct
8648 {
8649   GtkEntry *entry;
8650   gint button;
8651   guint time;
8652   GdkDevice *device;
8653 } PopupInfo;
8654
8655 static void
8656 popup_targets_received (GtkClipboard     *clipboard,
8657                         GtkSelectionData *data,
8658                         gpointer          user_data)
8659 {
8660   PopupInfo *info = user_data;
8661   GtkEntry *entry = info->entry;
8662   GtkEntryPrivate *info_entry_priv = entry->priv;
8663
8664   if (gtk_widget_get_realized (GTK_WIDGET (entry)))
8665     {
8666       DisplayMode mode;
8667       gboolean clipboard_contains_text;
8668       GtkWidget *menuitem;
8669       GtkWidget *submenu;
8670       gboolean show_input_method_menu;
8671       gboolean show_unicode_menu;
8672       
8673       clipboard_contains_text = gtk_selection_data_targets_include_text (data);
8674       if (info_entry_priv->popup_menu)
8675         gtk_widget_destroy (info_entry_priv->popup_menu);
8676
8677       info_entry_priv->popup_menu = gtk_menu_new ();
8678
8679       gtk_menu_attach_to_widget (GTK_MENU (info_entry_priv->popup_menu),
8680                                  GTK_WIDGET (entry),
8681                                  popup_menu_detach);
8682       
8683       mode = gtk_entry_get_display_mode (entry);
8684       append_action_signal (entry, info_entry_priv->popup_menu, GTK_STOCK_CUT, "cut-clipboard",
8685                             info_entry_priv->editable && mode == DISPLAY_NORMAL &&
8686                             info_entry_priv->current_pos != info_entry_priv->selection_bound);
8687
8688       append_action_signal (entry, info_entry_priv->popup_menu, GTK_STOCK_COPY, "copy-clipboard",
8689                             mode == DISPLAY_NORMAL &&
8690                             info_entry_priv->current_pos != info_entry_priv->selection_bound);
8691
8692       append_action_signal (entry, info_entry_priv->popup_menu, GTK_STOCK_PASTE, "paste-clipboard",
8693                             info_entry_priv->editable && clipboard_contains_text);
8694
8695       menuitem = gtk_image_menu_item_new_from_stock (GTK_STOCK_DELETE, NULL);
8696       gtk_widget_set_sensitive (menuitem, info_entry_priv->editable && info_entry_priv->current_pos != info_entry_priv->selection_bound);
8697       g_signal_connect_swapped (menuitem, "activate",
8698                                 G_CALLBACK (gtk_entry_delete_cb), entry);
8699       gtk_widget_show (menuitem);
8700       gtk_menu_shell_append (GTK_MENU_SHELL (info_entry_priv->popup_menu), menuitem);
8701
8702       menuitem = gtk_separator_menu_item_new ();
8703       gtk_widget_show (menuitem);
8704       gtk_menu_shell_append (GTK_MENU_SHELL (info_entry_priv->popup_menu), menuitem);
8705       
8706       menuitem = gtk_image_menu_item_new_from_stock (GTK_STOCK_SELECT_ALL, NULL);
8707       gtk_widget_set_sensitive (menuitem, gtk_entry_buffer_get_length (info_entry_priv->buffer) > 0);
8708       g_signal_connect_swapped (menuitem, "activate",
8709                                 G_CALLBACK (gtk_entry_select_all), entry);
8710       gtk_widget_show (menuitem);
8711       gtk_menu_shell_append (GTK_MENU_SHELL (info_entry_priv->popup_menu), menuitem);
8712       
8713       g_object_get (gtk_widget_get_settings (GTK_WIDGET (entry)),
8714                     "gtk-show-input-method-menu", &show_input_method_menu,
8715                     "gtk-show-unicode-menu", &show_unicode_menu,
8716                     NULL);
8717
8718       if (show_input_method_menu || show_unicode_menu)
8719         {
8720           menuitem = gtk_separator_menu_item_new ();
8721           gtk_widget_show (menuitem);
8722           gtk_menu_shell_append (GTK_MENU_SHELL (info_entry_priv->popup_menu), menuitem);
8723         }
8724       
8725       if (show_input_method_menu)
8726         {
8727           menuitem = gtk_menu_item_new_with_mnemonic (_("Input _Methods"));
8728           gtk_widget_set_sensitive (menuitem, info_entry_priv->editable);
8729           gtk_widget_show (menuitem);
8730           submenu = gtk_menu_new ();
8731           gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
8732
8733           gtk_menu_shell_append (GTK_MENU_SHELL (info_entry_priv->popup_menu), menuitem);
8734
8735           gtk_im_multicontext_append_menuitems (GTK_IM_MULTICONTEXT (info_entry_priv->im_context),
8736                                                 GTK_MENU_SHELL (submenu));
8737         }
8738       
8739       if (show_unicode_menu)
8740         {
8741           menuitem = gtk_menu_item_new_with_mnemonic (_("_Insert Unicode Control Character"));
8742           gtk_widget_set_sensitive (menuitem, info_entry_priv->editable);
8743           gtk_widget_show (menuitem);
8744           
8745           submenu = gtk_menu_new ();
8746           gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu);
8747           gtk_menu_shell_append (GTK_MENU_SHELL (info_entry_priv->popup_menu), menuitem);
8748
8749           _gtk_text_util_append_special_char_menuitems (GTK_MENU_SHELL (submenu),
8750                                                         unichar_chosen_func,
8751                                                         entry);
8752         }
8753       
8754       g_signal_emit (entry,
8755                      signals[POPULATE_POPUP],
8756                      0,
8757                      info_entry_priv->popup_menu);
8758
8759
8760       if (info->device)
8761         gtk_menu_popup_for_device (GTK_MENU (info_entry_priv->popup_menu),
8762                         info->device, NULL, NULL, NULL, NULL, NULL,
8763                         info->button, info->time);
8764       else
8765         {
8766           gtk_menu_popup (GTK_MENU (info_entry_priv->popup_menu), NULL, NULL,
8767                           popup_position_func, entry,
8768                           0, gtk_get_current_event_time ());
8769           gtk_menu_shell_select_first (GTK_MENU_SHELL (info_entry_priv->popup_menu), FALSE);
8770         }
8771     }
8772
8773   g_object_unref (entry);
8774   g_slice_free (PopupInfo, info);
8775 }
8776                         
8777 static void
8778 gtk_entry_do_popup (GtkEntry       *entry,
8779                     GdkEventButton *event)
8780 {
8781   PopupInfo *info = g_slice_new (PopupInfo);
8782
8783   /* In order to know what entries we should make sensitive, we
8784    * ask for the current targets of the clipboard, and when
8785    * we get them, then we actually pop up the menu.
8786    */
8787   info->entry = g_object_ref (entry);
8788   
8789   if (event)
8790     {
8791       info->button = event->button;
8792       info->time = event->time;
8793       info->device = event->device;
8794     }
8795   else
8796     {
8797       info->button = 0;
8798       info->time = gtk_get_current_event_time ();
8799       info->device = NULL;
8800     }
8801
8802   gtk_clipboard_request_contents (gtk_widget_get_clipboard (GTK_WIDGET (entry), GDK_SELECTION_CLIPBOARD),
8803                                   gdk_atom_intern_static_string ("TARGETS"),
8804                                   popup_targets_received,
8805                                   info);
8806 }
8807
8808 static gboolean
8809 gtk_entry_popup_menu (GtkWidget *widget)
8810 {
8811   gtk_entry_do_popup (GTK_ENTRY (widget), NULL);
8812   return TRUE;
8813 }
8814
8815 static void
8816 gtk_entry_drag_begin (GtkWidget      *widget,
8817                       GdkDragContext *context)
8818 {
8819   GtkEntry *entry = GTK_ENTRY (widget);
8820   GtkEntryPrivate *priv = entry->priv;
8821   gint i;
8822
8823   for (i = 0; i < MAX_ICONS; i++)
8824     {
8825       EntryIconInfo *icon_info = priv->icons[i];
8826       
8827       if (icon_info != NULL)
8828         {
8829           if (icon_info->in_drag) 
8830             {
8831               GdkPixbuf *pix;
8832
8833               pix = _gtk_icon_helper_ensure_pixbuf
8834                 (icon_info->icon_helper,
8835                  gtk_widget_get_style_context (GTK_WIDGET (entry)));
8836               gtk_drag_set_icon_pixbuf (context, pix, -2, -2);
8837
8838               g_object_unref (pix);
8839             }
8840         }
8841     }
8842 }
8843
8844 static void
8845 gtk_entry_drag_end (GtkWidget      *widget,
8846                     GdkDragContext *context)
8847 {
8848   GtkEntry *entry = GTK_ENTRY (widget);
8849   GtkEntryPrivate *priv = entry->priv;
8850   gint i;
8851
8852   for (i = 0; i < MAX_ICONS; i++)
8853     {
8854       EntryIconInfo *icon_info = priv->icons[i];
8855
8856       if (icon_info != NULL)
8857         icon_info->in_drag = 0;
8858     }
8859 }
8860
8861 static void
8862 gtk_entry_drag_leave (GtkWidget        *widget,
8863                       GdkDragContext   *context,
8864                       guint             time)
8865 {
8866   GtkEntry *entry = GTK_ENTRY (widget);
8867   GtkEntryPrivate *priv = entry->priv;
8868
8869   priv->dnd_position = -1;
8870   gtk_widget_queue_draw (widget);
8871 }
8872
8873 static gboolean
8874 gtk_entry_drag_drop  (GtkWidget        *widget,
8875                       GdkDragContext   *context,
8876                       gint              x,
8877                       gint              y,
8878                       guint             time)
8879 {
8880   GtkEntry *entry = GTK_ENTRY (widget);
8881   GtkEntryPrivate *priv = entry->priv;
8882   GdkAtom target = GDK_NONE;
8883
8884   if (priv->editable)
8885     target = gtk_drag_dest_find_target (widget, context, NULL);
8886
8887   if (target != GDK_NONE)
8888     gtk_drag_get_data (widget, context, target, time);
8889   else
8890     gtk_drag_finish (context, FALSE, FALSE, time);
8891   
8892   return TRUE;
8893 }
8894
8895 static gboolean
8896 gtk_entry_drag_motion (GtkWidget        *widget,
8897                        GdkDragContext   *context,
8898                        gint              x,
8899                        gint              y,
8900                        guint             time)
8901 {
8902   GtkEntry *entry = GTK_ENTRY (widget);
8903   GtkEntryPrivate *priv = entry->priv;
8904   GtkStyleContext *style_context;
8905   GtkWidget *source_widget;
8906   GdkDragAction suggested_action;
8907   gint new_position, old_position;
8908   gint sel1, sel2;
8909   GtkBorder padding;
8910
8911   style_context = gtk_widget_get_style_context (widget);
8912   gtk_style_context_get_padding (style_context, 0, &padding);
8913   x -= padding.left;
8914   y -= padding.top;
8915
8916   old_position = priv->dnd_position;
8917   new_position = gtk_entry_find_position (entry, x + priv->scroll_offset);
8918
8919   if (priv->editable &&
8920       gtk_drag_dest_find_target (widget, context, NULL) != GDK_NONE)
8921     {
8922       source_widget = gtk_drag_get_source_widget (context);
8923       suggested_action = gdk_drag_context_get_suggested_action (context);
8924
8925       if (!gtk_editable_get_selection_bounds (GTK_EDITABLE (entry), &sel1, &sel2) ||
8926           new_position < sel1 || new_position > sel2)
8927         {
8928           if (source_widget == widget)
8929             {
8930               /* Default to MOVE, unless the user has
8931                * pressed ctrl or alt to affect available actions
8932                */
8933               if ((gdk_drag_context_get_actions (context) & GDK_ACTION_MOVE) != 0)
8934                 suggested_action = GDK_ACTION_MOVE;
8935             }
8936
8937           priv->dnd_position = new_position;
8938         }
8939       else
8940         {
8941           if (source_widget == widget)
8942             suggested_action = 0;       /* Can't drop in selection where drag started */
8943
8944           priv->dnd_position = -1;
8945         }
8946     }
8947   else
8948     {
8949       /* Entry not editable, or no text */
8950       suggested_action = 0;
8951       priv->dnd_position = -1;
8952     }
8953   
8954   gdk_drag_status (context, suggested_action, time);
8955
8956   if (priv->dnd_position != old_position)
8957     gtk_widget_queue_draw (widget);
8958
8959   return TRUE;
8960 }
8961
8962 static void
8963 gtk_entry_drag_data_received (GtkWidget        *widget,
8964                               GdkDragContext   *context,
8965                               gint              x,
8966                               gint              y,
8967                               GtkSelectionData *selection_data,
8968                               guint             info,
8969                               guint             time)
8970 {
8971   GtkEntry *entry = GTK_ENTRY (widget);
8972   GtkEntryPrivate *priv = entry->priv;
8973   GtkEditable *editable = GTK_EDITABLE (widget);
8974   GtkStyleContext *style_context;
8975   GtkBorder padding;
8976   gchar *str;
8977
8978   str = (gchar *) gtk_selection_data_get_text (selection_data);
8979
8980   style_context = gtk_widget_get_style_context (widget);
8981   gtk_style_context_get_padding (style_context, 0, &padding);
8982   x -= padding.left;
8983   y -= padding.top;
8984
8985   if (str && priv->editable)
8986     {
8987       gint new_position;
8988       gint sel1, sel2;
8989       gint length = -1;
8990
8991       if (priv->truncate_multiline)
8992         length = truncate_multiline (str);
8993
8994       new_position = gtk_entry_find_position (entry, x + priv->scroll_offset);
8995
8996       if (!gtk_editable_get_selection_bounds (editable, &sel1, &sel2) ||
8997           new_position < sel1 || new_position > sel2)
8998         {
8999           gtk_editable_insert_text (editable, str, length, &new_position);
9000         }
9001       else
9002         {
9003           /* Replacing selection */
9004           begin_change (entry);
9005           gtk_editable_delete_text (editable, sel1, sel2);
9006           gtk_editable_insert_text (editable, str, length, &sel1);
9007           end_change (entry);
9008         }
9009       
9010       gtk_drag_finish (context, TRUE, gdk_drag_context_get_selected_action (context) == GDK_ACTION_MOVE, time);
9011     }
9012   else
9013     {
9014       /* Drag and drop didn't happen! */
9015       gtk_drag_finish (context, FALSE, FALSE, time);
9016     }
9017
9018   g_free (str);
9019 }
9020
9021 static void
9022 gtk_entry_drag_data_get (GtkWidget        *widget,
9023                          GdkDragContext   *context,
9024                          GtkSelectionData *selection_data,
9025                          guint             info,
9026                          guint             time)
9027 {
9028   GtkEntry *entry = GTK_ENTRY (widget);
9029   GtkEntryPrivate *priv = entry->priv;
9030   GtkEditable *editable = GTK_EDITABLE (widget);
9031   gint sel_start, sel_end;
9032   gint i;
9033
9034   /* If there is an icon drag going on, exit early. */
9035   for (i = 0; i < MAX_ICONS; i++)
9036     {
9037       EntryIconInfo *icon_info = priv->icons[i];
9038
9039       if (icon_info != NULL)
9040         {
9041           if (icon_info->in_drag)
9042             return;
9043         }
9044     }
9045
9046   if (gtk_editable_get_selection_bounds (editable, &sel_start, &sel_end))
9047     {
9048       gchar *str = gtk_entry_get_display_text (GTK_ENTRY (widget), sel_start, sel_end);
9049
9050       gtk_selection_data_set_text (selection_data, str, -1);
9051       
9052       g_free (str);
9053     }
9054
9055 }
9056
9057 static void
9058 gtk_entry_drag_data_delete (GtkWidget      *widget,
9059                             GdkDragContext *context)
9060 {
9061   GtkEntry *entry = GTK_ENTRY (widget);
9062   GtkEntryPrivate *priv = entry->priv;
9063   GtkEditable *editable = GTK_EDITABLE (widget);
9064   gint sel_start, sel_end;
9065   gint i;
9066
9067   /* If there is an icon drag going on, exit early. */
9068   for (i = 0; i < MAX_ICONS; i++)
9069     {
9070       EntryIconInfo *icon_info = priv->icons[i];
9071
9072       if (icon_info != NULL)
9073         {
9074           if (icon_info->in_drag)
9075             return;
9076         }
9077     }
9078
9079   if (priv->editable &&
9080       gtk_editable_get_selection_bounds (editable, &sel_start, &sel_end))
9081     gtk_editable_delete_text (editable, sel_start, sel_end);
9082 }
9083
9084 /* We display the cursor when
9085  *
9086  *  - the selection is empty, AND
9087  *  - the widget has focus
9088  */
9089
9090 #define CURSOR_ON_MULTIPLIER 2
9091 #define CURSOR_OFF_MULTIPLIER 1
9092 #define CURSOR_PEND_MULTIPLIER 3
9093 #define CURSOR_DIVIDER 3
9094
9095 static gboolean
9096 cursor_blinks (GtkEntry *entry)
9097 {
9098   GtkEntryPrivate *priv = entry->priv;
9099
9100   if (gtk_widget_has_focus (GTK_WIDGET (entry)) &&
9101       priv->editable &&
9102       priv->selection_bound == priv->current_pos)
9103     {
9104       GtkSettings *settings;
9105       gboolean blink;
9106
9107       settings = gtk_widget_get_settings (GTK_WIDGET (entry));
9108       g_object_get (settings, "gtk-cursor-blink", &blink, NULL);
9109
9110       return blink;
9111     }
9112   else
9113     return FALSE;
9114 }
9115
9116 static gint
9117 get_cursor_time (GtkEntry *entry)
9118 {
9119   GtkSettings *settings = gtk_widget_get_settings (GTK_WIDGET (entry));
9120   gint time;
9121
9122   g_object_get (settings, "gtk-cursor-blink-time", &time, NULL);
9123
9124   return time;
9125 }
9126
9127 static gint
9128 get_cursor_blink_timeout (GtkEntry *entry)
9129 {
9130   GtkSettings *settings = gtk_widget_get_settings (GTK_WIDGET (entry));
9131   gint timeout;
9132
9133   g_object_get (settings, "gtk-cursor-blink-timeout", &timeout, NULL);
9134
9135   return timeout;
9136 }
9137
9138 static void
9139 show_cursor (GtkEntry *entry)
9140 {
9141   GtkEntryPrivate *priv = entry->priv;
9142   GtkWidget *widget;
9143
9144   if (!priv->cursor_visible)
9145     {
9146       priv->cursor_visible = TRUE;
9147
9148       widget = GTK_WIDGET (entry);
9149       if (gtk_widget_has_focus (widget) && priv->selection_bound == priv->current_pos)
9150         gtk_widget_queue_draw (widget);
9151     }
9152 }
9153
9154 static void
9155 hide_cursor (GtkEntry *entry)
9156 {
9157   GtkEntryPrivate *priv = entry->priv;
9158   GtkWidget *widget;
9159
9160   if (priv->cursor_visible)
9161     {
9162       priv->cursor_visible = FALSE;
9163
9164       widget = GTK_WIDGET (entry);
9165       if (gtk_widget_has_focus (widget) && priv->selection_bound == priv->current_pos)
9166         gtk_widget_queue_draw (widget);
9167     }
9168 }
9169
9170 /*
9171  * Blink!
9172  */
9173 static gint
9174 blink_cb (gpointer data)
9175 {
9176   GtkEntry *entry;
9177   GtkEntryPrivate *priv; 
9178   gint blink_timeout;
9179
9180   entry = GTK_ENTRY (data);
9181   priv = entry->priv;
9182  
9183   if (!gtk_widget_has_focus (GTK_WIDGET (entry)))
9184     {
9185       g_warning ("GtkEntry - did not receive focus-out-event. If you\n"
9186                  "connect a handler to this signal, it must return\n"
9187                  "FALSE so the entry gets the event as well");
9188
9189       gtk_entry_check_cursor_blink (entry);
9190
9191       return FALSE;
9192     }
9193   
9194   g_assert (priv->selection_bound == priv->current_pos);
9195   
9196   blink_timeout = get_cursor_blink_timeout (entry);
9197   if (priv->blink_time > 1000 * blink_timeout && 
9198       blink_timeout < G_MAXINT/1000) 
9199     {
9200       /* we've blinked enough without the user doing anything, stop blinking */
9201       show_cursor (entry);
9202       priv->blink_timeout = 0;
9203     } 
9204   else if (priv->cursor_visible)
9205     {
9206       hide_cursor (entry);
9207       priv->blink_timeout = gdk_threads_add_timeout (get_cursor_time (entry) * CURSOR_OFF_MULTIPLIER / CURSOR_DIVIDER,
9208                                             blink_cb,
9209                                             entry);
9210     }
9211   else
9212     {
9213       show_cursor (entry);
9214       priv->blink_time += get_cursor_time (entry);
9215       priv->blink_timeout = gdk_threads_add_timeout (get_cursor_time (entry) * CURSOR_ON_MULTIPLIER / CURSOR_DIVIDER,
9216                                             blink_cb,
9217                                             entry);
9218     }
9219
9220   /* Remove ourselves */
9221   return FALSE;
9222 }
9223
9224 static void
9225 gtk_entry_check_cursor_blink (GtkEntry *entry)
9226 {
9227   GtkEntryPrivate *priv = entry->priv;
9228
9229   if (cursor_blinks (entry))
9230     {
9231       if (!priv->blink_timeout)
9232         {
9233           show_cursor (entry);
9234           priv->blink_timeout = gdk_threads_add_timeout (get_cursor_time (entry) * CURSOR_ON_MULTIPLIER / CURSOR_DIVIDER,
9235                                                 blink_cb,
9236                                                 entry);
9237         }
9238     }
9239   else
9240     {
9241       if (priv->blink_timeout)
9242         {
9243           g_source_remove (priv->blink_timeout);
9244           priv->blink_timeout = 0;
9245         }
9246
9247       priv->cursor_visible = TRUE;
9248     }
9249 }
9250
9251 static void
9252 gtk_entry_pend_cursor_blink (GtkEntry *entry)
9253 {
9254   GtkEntryPrivate *priv = entry->priv;
9255
9256   if (cursor_blinks (entry))
9257     {
9258       if (priv->blink_timeout != 0)
9259         g_source_remove (priv->blink_timeout);
9260
9261       priv->blink_timeout = gdk_threads_add_timeout (get_cursor_time (entry) * CURSOR_PEND_MULTIPLIER / CURSOR_DIVIDER,
9262                                                      blink_cb,
9263                                                      entry);
9264       show_cursor (entry);
9265     }
9266 }
9267
9268 static void
9269 gtk_entry_reset_blink_time (GtkEntry *entry)
9270 {
9271   GtkEntryPrivate *priv = entry->priv;
9272
9273   priv->blink_time = 0;
9274 }
9275
9276
9277 /* completion */
9278 static gint
9279 gtk_entry_completion_timeout (gpointer data)
9280 {
9281   GtkEntryCompletion *completion = GTK_ENTRY_COMPLETION (data);
9282   GtkEntryPrivate *completion_entry_priv = GTK_ENTRY (completion->priv->entry)->priv;
9283
9284   completion->priv->completion_timeout = 0;
9285
9286   if (completion->priv->filter_model &&
9287       g_utf8_strlen (gtk_entry_get_text (GTK_ENTRY (completion->priv->entry)), -1)
9288       >= completion->priv->minimum_key_length)
9289     {
9290       gint matches;
9291       gint actions;
9292       GtkTreeSelection *s;
9293       gboolean popup_single;
9294
9295       gtk_entry_completion_complete (completion);
9296       matches = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (completion->priv->filter_model), NULL);
9297
9298       gtk_tree_selection_unselect_all (gtk_tree_view_get_selection (GTK_TREE_VIEW (completion->priv->tree_view)));
9299
9300       s = gtk_tree_view_get_selection (GTK_TREE_VIEW (completion->priv->action_view));
9301
9302       gtk_tree_selection_unselect_all (s);
9303
9304       actions = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (completion->priv->actions), NULL);
9305
9306       g_object_get (completion, "popup-single-match", &popup_single, NULL);
9307       if ((matches > (popup_single ? 0: 1)) || actions > 0)
9308         { 
9309           if (gtk_widget_get_visible (completion->priv->popup_window))
9310             _gtk_entry_completion_resize_popup (completion);
9311           else
9312             _gtk_entry_completion_popup (completion, completion_entry_priv->completion_device);
9313         }
9314       else 
9315         _gtk_entry_completion_popdown (completion);
9316     }
9317   else if (gtk_widget_get_visible (completion->priv->popup_window))
9318     _gtk_entry_completion_popdown (completion);
9319
9320   return FALSE;
9321 }
9322
9323 static inline gboolean
9324 keyval_is_cursor_move (guint keyval)
9325 {
9326   if (keyval == GDK_KEY_Up || keyval == GDK_KEY_KP_Up)
9327     return TRUE;
9328
9329   if (keyval == GDK_KEY_Down || keyval == GDK_KEY_KP_Down)
9330     return TRUE;
9331
9332   if (keyval == GDK_KEY_Page_Up)
9333     return TRUE;
9334
9335   if (keyval == GDK_KEY_Page_Down)
9336     return TRUE;
9337
9338   return FALSE;
9339 }
9340
9341 static gboolean
9342 gtk_entry_completion_key_press (GtkWidget   *widget,
9343                                 GdkEventKey *event,
9344                                 gpointer     user_data)
9345 {
9346   gint matches, actions = 0;
9347   GtkEntryCompletion *completion = GTK_ENTRY_COMPLETION (user_data);
9348
9349   if (!gtk_widget_get_mapped (completion->priv->popup_window))
9350     return FALSE;
9351
9352   matches = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (completion->priv->filter_model), NULL);
9353
9354   if (completion->priv->actions)
9355     actions = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (completion->priv->actions), NULL);
9356
9357   if (keyval_is_cursor_move (event->keyval))
9358     {
9359       GtkTreePath *path = NULL;
9360       
9361       if (event->keyval == GDK_KEY_Up || event->keyval == GDK_KEY_KP_Up)
9362         {
9363           if (completion->priv->current_selected < 0)
9364             completion->priv->current_selected = matches + actions - 1;
9365           else
9366             completion->priv->current_selected--;
9367         }
9368       else if (event->keyval == GDK_KEY_Down || event->keyval == GDK_KEY_KP_Down)
9369         {
9370           if (completion->priv->current_selected < matches + actions - 1)
9371             completion->priv->current_selected++;
9372           else
9373             completion->priv->current_selected = -1;
9374         }
9375       else if (event->keyval == GDK_KEY_Page_Up)
9376         {
9377           if (completion->priv->current_selected < 0)
9378             completion->priv->current_selected = matches + actions - 1;
9379           else if (completion->priv->current_selected == 0)
9380             completion->priv->current_selected = -1;
9381           else if (completion->priv->current_selected < matches) 
9382             {
9383               completion->priv->current_selected -= PAGE_STEP;
9384               if (completion->priv->current_selected < 0)
9385                 completion->priv->current_selected = 0;
9386             }
9387           else 
9388             {
9389               completion->priv->current_selected -= PAGE_STEP;
9390               if (completion->priv->current_selected < matches - 1)
9391                 completion->priv->current_selected = matches - 1;
9392             }
9393         }
9394       else if (event->keyval == GDK_KEY_Page_Down)
9395         {
9396           if (completion->priv->current_selected < 0)
9397             completion->priv->current_selected = 0;
9398           else if (completion->priv->current_selected < matches - 1)
9399             {
9400               completion->priv->current_selected += PAGE_STEP;
9401               if (completion->priv->current_selected > matches - 1)
9402                 completion->priv->current_selected = matches - 1;
9403             }
9404           else if (completion->priv->current_selected == matches + actions - 1)
9405             {
9406               completion->priv->current_selected = -1;
9407             }
9408           else
9409             {
9410               completion->priv->current_selected += PAGE_STEP;
9411               if (completion->priv->current_selected > matches + actions - 1)
9412                 completion->priv->current_selected = matches + actions - 1;
9413             }
9414         }
9415
9416       if (completion->priv->current_selected < 0)
9417         {
9418           gtk_tree_selection_unselect_all (gtk_tree_view_get_selection (GTK_TREE_VIEW (completion->priv->tree_view)));
9419           gtk_tree_selection_unselect_all (gtk_tree_view_get_selection (GTK_TREE_VIEW (completion->priv->action_view)));
9420
9421           if (completion->priv->inline_selection &&
9422               completion->priv->completion_prefix)
9423             {
9424               gtk_entry_set_text (GTK_ENTRY (completion->priv->entry), 
9425                                   completion->priv->completion_prefix);
9426               gtk_editable_set_position (GTK_EDITABLE (widget), -1);
9427             }
9428         }
9429       else if (completion->priv->current_selected < matches)
9430         {
9431           gtk_tree_selection_unselect_all (gtk_tree_view_get_selection (GTK_TREE_VIEW (completion->priv->action_view)));
9432
9433           path = gtk_tree_path_new_from_indices (completion->priv->current_selected, -1);
9434           gtk_tree_view_set_cursor (GTK_TREE_VIEW (completion->priv->tree_view),
9435                                     path, NULL, FALSE);
9436
9437           if (completion->priv->inline_selection)
9438             {
9439
9440               GtkTreeIter iter;
9441               GtkTreeIter child_iter;
9442               GtkTreeModel *model = NULL;
9443               GtkTreeSelection *sel;
9444               gboolean entry_set;
9445
9446               sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (completion->priv->tree_view));
9447               if (!gtk_tree_selection_get_selected (sel, &model, &iter))
9448                 return FALSE;
9449
9450               gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (model), &child_iter, &iter);
9451               model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (model));
9452               
9453               if (completion->priv->completion_prefix == NULL)
9454                 completion->priv->completion_prefix = g_strdup (gtk_entry_get_text (GTK_ENTRY (completion->priv->entry)));
9455
9456               g_signal_emit_by_name (completion, "cursor-on-match", model,
9457                                      &child_iter, &entry_set);
9458             }
9459         }
9460       else if (completion->priv->current_selected - matches >= 0)
9461         {
9462           gtk_tree_selection_unselect_all (gtk_tree_view_get_selection (GTK_TREE_VIEW (completion->priv->tree_view)));
9463
9464           path = gtk_tree_path_new_from_indices (completion->priv->current_selected - matches, -1);
9465           gtk_tree_view_set_cursor (GTK_TREE_VIEW (completion->priv->action_view),
9466                                     path, NULL, FALSE);
9467
9468           if (completion->priv->inline_selection &&
9469               completion->priv->completion_prefix)
9470             {
9471               gtk_entry_set_text (GTK_ENTRY (completion->priv->entry), 
9472                                   completion->priv->completion_prefix);
9473               gtk_editable_set_position (GTK_EDITABLE (widget), -1);
9474             }
9475         }
9476
9477       gtk_tree_path_free (path);
9478
9479       return TRUE;
9480     }
9481   else if (event->keyval == GDK_KEY_Escape ||
9482            event->keyval == GDK_KEY_Left ||
9483            event->keyval == GDK_KEY_KP_Left ||
9484            event->keyval == GDK_KEY_Right ||
9485            event->keyval == GDK_KEY_KP_Right) 
9486     {
9487       gboolean retval = TRUE;
9488
9489       _gtk_entry_reset_im_context (GTK_ENTRY (widget));
9490       _gtk_entry_completion_popdown (completion);
9491
9492       if (completion->priv->current_selected < 0)
9493         {
9494           retval = FALSE;
9495           goto keypress_completion_out;
9496         }
9497       else if (completion->priv->inline_selection)
9498         {
9499           /* Escape rejects the tentative completion */
9500           if (event->keyval == GDK_KEY_Escape)
9501             {
9502               if (completion->priv->completion_prefix)
9503                 gtk_entry_set_text (GTK_ENTRY (completion->priv->entry), 
9504                                     completion->priv->completion_prefix);
9505               else 
9506                 gtk_entry_set_text (GTK_ENTRY (completion->priv->entry), "");
9507             }
9508
9509           /* Move the cursor to the end for Right/Esc, to the
9510              beginning for Left */
9511           if (event->keyval == GDK_KEY_Right ||
9512               event->keyval == GDK_KEY_KP_Right ||
9513               event->keyval == GDK_KEY_Escape)
9514             gtk_editable_set_position (GTK_EDITABLE (widget), -1);
9515           else
9516             gtk_editable_set_position (GTK_EDITABLE (widget), 0);
9517         }
9518
9519 keypress_completion_out:
9520       if (completion->priv->inline_selection)
9521         {
9522           g_free (completion->priv->completion_prefix);
9523           completion->priv->completion_prefix = NULL;
9524         }
9525
9526       return retval;
9527     }
9528   else if (event->keyval == GDK_KEY_Tab || 
9529            event->keyval == GDK_KEY_KP_Tab ||
9530            event->keyval == GDK_KEY_ISO_Left_Tab) 
9531     {
9532       _gtk_entry_reset_im_context (GTK_ENTRY (widget));
9533       _gtk_entry_completion_popdown (completion);
9534
9535       g_free (completion->priv->completion_prefix);
9536       completion->priv->completion_prefix = NULL;
9537
9538       return FALSE;
9539     }
9540   else if (event->keyval == GDK_KEY_ISO_Enter ||
9541            event->keyval == GDK_KEY_KP_Enter ||
9542            event->keyval == GDK_KEY_Return)
9543     {
9544       GtkTreeIter iter;
9545       GtkTreeModel *model = NULL;
9546       GtkTreeModel *child_model;
9547       GtkTreeIter child_iter;
9548       GtkTreeSelection *sel;
9549       gboolean retval = TRUE;
9550
9551       _gtk_entry_reset_im_context (GTK_ENTRY (widget));
9552       _gtk_entry_completion_popdown (completion);
9553
9554       if (completion->priv->current_selected < matches)
9555         {
9556           gboolean entry_set;
9557
9558           sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (completion->priv->tree_view));
9559           if (gtk_tree_selection_get_selected (sel, &model, &iter))
9560             {
9561               gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (model), &child_iter, &iter);
9562               child_model = gtk_tree_model_filter_get_model (GTK_TREE_MODEL_FILTER (model));
9563               g_signal_handler_block (widget, completion->priv->changed_id);
9564               g_signal_emit_by_name (completion, "match-selected",
9565                                      child_model, &child_iter, &entry_set);
9566               g_signal_handler_unblock (widget, completion->priv->changed_id);
9567
9568               if (!entry_set)
9569                 {
9570                   gchar *str = NULL;
9571
9572                   gtk_tree_model_get (model, &iter,
9573                                       completion->priv->text_column, &str,
9574                                       -1);
9575
9576                   gtk_entry_set_text (GTK_ENTRY (widget), str);
9577
9578                   /* move the cursor to the end */
9579                   gtk_editable_set_position (GTK_EDITABLE (widget), -1);
9580
9581                   g_free (str);
9582                 }
9583             }
9584           else
9585             retval = FALSE;
9586         }
9587       else if (completion->priv->current_selected - matches >= 0)
9588         {
9589           sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (completion->priv->action_view));
9590           if (gtk_tree_selection_get_selected (sel, &model, &iter))
9591             {
9592               GtkTreePath *path;
9593
9594               path = gtk_tree_path_new_from_indices (completion->priv->current_selected - matches, -1);
9595               g_signal_emit_by_name (completion, "action-activated",
9596                                      gtk_tree_path_get_indices (path)[0]);
9597               gtk_tree_path_free (path);
9598             }
9599           else
9600             retval = FALSE;
9601         }
9602
9603       g_free (completion->priv->completion_prefix);
9604       completion->priv->completion_prefix = NULL;
9605
9606       return retval;
9607     }
9608
9609   return FALSE;
9610 }
9611
9612 static void
9613 gtk_entry_completion_changed (GtkWidget *widget,
9614                               gpointer   user_data)
9615 {
9616   GtkEntryCompletion *completion = GTK_ENTRY_COMPLETION (user_data);
9617   GtkEntry *entry = GTK_ENTRY (widget);
9618   GtkEntryPrivate *priv = entry->priv;
9619   GdkDevice *device;
9620
9621   /* (re)install completion timeout */
9622   if (completion->priv->completion_timeout)
9623     g_source_remove (completion->priv->completion_timeout);
9624
9625   if (!gtk_entry_get_text (entry))
9626     return;
9627
9628   /* no need to normalize for this test */
9629   if (completion->priv->minimum_key_length > 0 &&
9630       strcmp ("", gtk_entry_get_text (entry)) == 0)
9631     {
9632       if (gtk_widget_get_visible (completion->priv->popup_window))
9633         _gtk_entry_completion_popdown (completion);
9634       return;
9635     }
9636
9637   device = gtk_get_current_event_device ();
9638
9639   if (device && gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
9640     device = gdk_device_get_associated_device (device);
9641
9642   if (device)
9643     priv->completion_device = device;
9644
9645   completion->priv->completion_timeout =
9646     gdk_threads_add_timeout (COMPLETION_TIMEOUT,
9647                    gtk_entry_completion_timeout,
9648                    completion);
9649 }
9650
9651 static gboolean
9652 check_completion_callback (GtkEntryCompletion *completion)
9653 {
9654   completion->priv->check_completion_idle = NULL;
9655   
9656   gtk_entry_completion_complete (completion);
9657   gtk_entry_completion_insert_prefix (completion);
9658
9659   return FALSE;
9660 }
9661
9662 static void
9663 clear_completion_callback (GtkEntry   *entry,
9664                            GParamSpec *pspec)
9665 {
9666   if (pspec->name == I_("cursor-position") ||
9667       pspec->name == I_("selection-bound"))
9668     {
9669       GtkEntryCompletion *completion = gtk_entry_get_completion (entry);
9670       
9671       completion->priv->has_completion = FALSE;
9672     }
9673 }
9674
9675 static gboolean
9676 accept_completion_callback (GtkEntry *entry)
9677 {
9678   GtkEntryCompletion *completion = gtk_entry_get_completion (entry);
9679
9680   if (completion->priv->has_completion)
9681     gtk_editable_set_position (GTK_EDITABLE (entry),
9682                                gtk_entry_buffer_get_length (get_buffer (entry)));
9683
9684   return FALSE;
9685 }
9686
9687 static void
9688 completion_insert_text_callback (GtkEntry           *entry,
9689                                  const gchar        *text,
9690                                  gint                length,
9691                                  gint                position,
9692                                  GtkEntryCompletion *completion)
9693 {
9694   /* idle to update the selection based on the file list */
9695   if (completion->priv->check_completion_idle == NULL)
9696     {
9697       completion->priv->check_completion_idle = g_idle_source_new ();
9698       g_source_set_priority (completion->priv->check_completion_idle, G_PRIORITY_HIGH);
9699       g_source_set_closure (completion->priv->check_completion_idle,
9700                             g_cclosure_new_object (G_CALLBACK (check_completion_callback),
9701                                                    G_OBJECT (completion)));
9702       g_source_attach (completion->priv->check_completion_idle, NULL);
9703     }
9704 }
9705
9706 static void
9707 completion_changed (GtkEntryCompletion *completion,
9708                     GParamSpec         *pspec,
9709                     gpointer            data)
9710 {
9711   GtkEntry *entry = GTK_ENTRY (data);
9712
9713   if (pspec->name == I_("popup-completion") ||
9714       pspec->name == I_("inline-completion"))
9715     {
9716       disconnect_completion_signals (entry, completion);
9717       connect_completion_signals (entry, completion);
9718     }
9719 }
9720
9721 static void
9722 disconnect_completion_signals (GtkEntry           *entry,
9723                                GtkEntryCompletion *completion)
9724 {
9725   g_signal_handlers_disconnect_by_func (completion, 
9726                                        G_CALLBACK (completion_changed), entry);
9727   if (completion->priv->changed_id > 0 &&
9728       g_signal_handler_is_connected (entry, completion->priv->changed_id))
9729     {
9730       g_signal_handler_disconnect (entry, completion->priv->changed_id);
9731       completion->priv->changed_id = 0;
9732     }
9733   g_signal_handlers_disconnect_by_func (entry, 
9734                                         G_CALLBACK (gtk_entry_completion_key_press), completion);
9735   if (completion->priv->insert_text_id > 0 &&
9736       g_signal_handler_is_connected (entry, completion->priv->insert_text_id))
9737     {
9738       g_signal_handler_disconnect (entry, completion->priv->insert_text_id);
9739       completion->priv->insert_text_id = 0;
9740     }
9741   g_signal_handlers_disconnect_by_func (entry, 
9742                                         G_CALLBACK (completion_insert_text_callback), completion);
9743   g_signal_handlers_disconnect_by_func (entry, 
9744                                         G_CALLBACK (clear_completion_callback), completion);
9745   g_signal_handlers_disconnect_by_func (entry, 
9746                                         G_CALLBACK (accept_completion_callback), completion);
9747 }
9748
9749 static void
9750 connect_completion_signals (GtkEntry           *entry,
9751                             GtkEntryCompletion *completion)
9752 {
9753   if (completion->priv->popup_completion)
9754     {
9755       completion->priv->changed_id =
9756         g_signal_connect (entry, "changed",
9757                           G_CALLBACK (gtk_entry_completion_changed), completion);
9758       g_signal_connect (entry, "key-press-event",
9759                         G_CALLBACK (gtk_entry_completion_key_press), completion);
9760     }
9761  
9762   if (completion->priv->inline_completion)
9763     {
9764       completion->priv->insert_text_id =
9765         g_signal_connect (entry, "insert-text",
9766                           G_CALLBACK (completion_insert_text_callback), completion);
9767       g_signal_connect (entry, "notify",
9768                         G_CALLBACK (clear_completion_callback), completion);
9769       g_signal_connect (entry, "activate",
9770                         G_CALLBACK (accept_completion_callback), completion);
9771       g_signal_connect (entry, "focus-out-event",
9772                         G_CALLBACK (accept_completion_callback), completion);
9773     }
9774
9775   g_signal_connect (completion, "notify",
9776                     G_CALLBACK (completion_changed), entry);
9777 }
9778
9779 /**
9780  * gtk_entry_set_completion:
9781  * @entry: A #GtkEntry
9782  * @completion: (allow-none): The #GtkEntryCompletion or %NULL
9783  *
9784  * Sets @completion to be the auxiliary completion object to use with @entry.
9785  * All further configuration of the completion mechanism is done on
9786  * @completion using the #GtkEntryCompletion API. Completion is disabled if
9787  * @completion is set to %NULL.
9788  *
9789  * Since: 2.4
9790  */
9791 void
9792 gtk_entry_set_completion (GtkEntry           *entry,
9793                           GtkEntryCompletion *completion)
9794 {
9795   GtkEntryCompletion *old;
9796
9797   g_return_if_fail (GTK_IS_ENTRY (entry));
9798   g_return_if_fail (!completion || GTK_IS_ENTRY_COMPLETION (completion));
9799
9800   old = gtk_entry_get_completion (entry);
9801
9802   if (old == completion)
9803     return;
9804   
9805   if (old)
9806     {
9807       if (old->priv->completion_timeout)
9808         {
9809           g_source_remove (old->priv->completion_timeout);
9810           old->priv->completion_timeout = 0;
9811         }
9812
9813       if (old->priv->check_completion_idle)
9814         {
9815           g_source_destroy (old->priv->check_completion_idle);
9816           old->priv->check_completion_idle = NULL;
9817         }
9818
9819       if (gtk_widget_get_mapped (old->priv->popup_window))
9820         _gtk_entry_completion_popdown (old);
9821
9822       disconnect_completion_signals (entry, old);
9823       old->priv->entry = NULL;
9824
9825       g_object_unref (old);
9826     }
9827
9828   if (!completion)
9829     {
9830       g_object_set_data (G_OBJECT (entry), I_(GTK_ENTRY_COMPLETION_KEY), NULL);
9831       return;
9832     }
9833
9834   /* hook into the entry */
9835   g_object_ref (completion);
9836
9837   connect_completion_signals (entry, completion);    
9838   completion->priv->entry = GTK_WIDGET (entry);
9839   g_object_set_data (G_OBJECT (entry), I_(GTK_ENTRY_COMPLETION_KEY), completion);
9840
9841   g_object_notify (G_OBJECT (entry), "completion");
9842 }
9843
9844 /**
9845  * gtk_entry_get_completion:
9846  * @entry: A #GtkEntry
9847  *
9848  * Returns the auxiliary completion object currently in use by @entry.
9849  *
9850  * Return value: (transfer none): The auxiliary completion object currently
9851  *     in use by @entry.
9852  *
9853  * Since: 2.4
9854  */
9855 GtkEntryCompletion *
9856 gtk_entry_get_completion (GtkEntry *entry)
9857 {
9858   GtkEntryCompletion *completion;
9859
9860   g_return_val_if_fail (GTK_IS_ENTRY (entry), NULL);
9861
9862   completion = GTK_ENTRY_COMPLETION (g_object_get_data (G_OBJECT (entry),
9863                                      GTK_ENTRY_COMPLETION_KEY));
9864
9865   return completion;
9866 }
9867
9868 /**
9869  * gtk_entry_set_cursor_hadjustment:
9870  * @entry: a #GtkEntry
9871  * @adjustment: an adjustment which should be adjusted when the cursor 
9872  *              is moved, or %NULL
9873  *
9874  * Hooks up an adjustment to the cursor position in an entry, so that when 
9875  * the cursor is moved, the adjustment is scrolled to show that position. 
9876  * See gtk_scrolled_window_get_hadjustment() for a typical way of obtaining 
9877  * the adjustment.
9878  *
9879  * The adjustment has to be in pixel units and in the same coordinate system 
9880  * as the entry. 
9881  * 
9882  * Since: 2.12
9883  */
9884 void
9885 gtk_entry_set_cursor_hadjustment (GtkEntry      *entry,
9886                                   GtkAdjustment *adjustment)
9887 {
9888   g_return_if_fail (GTK_IS_ENTRY (entry));
9889   if (adjustment)
9890     g_return_if_fail (GTK_IS_ADJUSTMENT (adjustment));
9891
9892   if (adjustment)
9893     g_object_ref (adjustment);
9894
9895   g_object_set_qdata_full (G_OBJECT (entry), 
9896                            quark_cursor_hadjustment,
9897                            adjustment, 
9898                            g_object_unref);
9899 }
9900
9901 /**
9902  * gtk_entry_get_cursor_hadjustment:
9903  * @entry: a #GtkEntry
9904  *
9905  * Retrieves the horizontal cursor adjustment for the entry. 
9906  * See gtk_entry_set_cursor_hadjustment().
9907  *
9908  * Return value: (transfer none): the horizontal cursor adjustment, or %NULL
9909  *   if none has been set.
9910  *
9911  * Since: 2.12
9912  */
9913 GtkAdjustment*
9914 gtk_entry_get_cursor_hadjustment (GtkEntry *entry)
9915 {
9916   g_return_val_if_fail (GTK_IS_ENTRY (entry), NULL);
9917
9918   return g_object_get_qdata (G_OBJECT (entry), quark_cursor_hadjustment);
9919 }
9920
9921 /**
9922  * gtk_entry_set_progress_fraction:
9923  * @entry: a #GtkEntry
9924  * @fraction: fraction of the task that's been completed
9925  *
9926  * Causes the entry's progress indicator to "fill in" the given
9927  * fraction of the bar. The fraction should be between 0.0 and 1.0,
9928  * inclusive.
9929  *
9930  * Since: 2.16
9931  */
9932 void
9933 gtk_entry_set_progress_fraction (GtkEntry *entry,
9934                                  gdouble   fraction)
9935 {
9936   GtkWidget       *widget;
9937   GtkEntryPrivate *private;
9938   gdouble          old_fraction;
9939   gint x, y, width, height;
9940   gint old_x, old_y, old_width, old_height;
9941
9942   g_return_if_fail (GTK_IS_ENTRY (entry));
9943
9944   widget = GTK_WIDGET (entry);
9945   private = entry->priv;
9946
9947   if (private->progress_pulse_mode)
9948     old_fraction = -1;
9949   else
9950     old_fraction = private->progress_fraction;
9951
9952   if (gtk_widget_is_drawable (widget))
9953     get_progress_area (widget, &old_x, &old_y, &old_width, &old_height);
9954
9955   fraction = CLAMP (fraction, 0.0, 1.0);
9956
9957   private->progress_fraction = fraction;
9958   private->progress_pulse_mode = FALSE;
9959   private->progress_pulse_current = 0.0;
9960
9961   if (gtk_widget_is_drawable (widget))
9962     {
9963       get_progress_area (widget, &x, &y, &width, &height);
9964
9965       if ((x != old_x) || (y != old_y) || (width != old_width) || (height != old_height))
9966         gtk_widget_queue_draw (widget);
9967     }
9968
9969   if (fraction != old_fraction)
9970     g_object_notify (G_OBJECT (entry), "progress-fraction");
9971 }
9972
9973 /**
9974  * gtk_entry_get_progress_fraction:
9975  * @entry: a #GtkEntry
9976  *
9977  * Returns the current fraction of the task that's been completed.
9978  * See gtk_entry_set_progress_fraction().
9979  *
9980  * Return value: a fraction from 0.0 to 1.0
9981  *
9982  * Since: 2.16
9983  */
9984 gdouble
9985 gtk_entry_get_progress_fraction (GtkEntry *entry)
9986 {
9987   g_return_val_if_fail (GTK_IS_ENTRY (entry), 0.0);
9988
9989   return entry->priv->progress_fraction;
9990 }
9991
9992 /**
9993  * gtk_entry_set_progress_pulse_step:
9994  * @entry: a #GtkEntry
9995  * @fraction: fraction between 0.0 and 1.0
9996  *
9997  * Sets the fraction of total entry width to move the progress
9998  * bouncing block for each call to gtk_entry_progress_pulse().
9999  *
10000  * Since: 2.16
10001  */
10002 void
10003 gtk_entry_set_progress_pulse_step (GtkEntry *entry,
10004                                    gdouble   fraction)
10005 {
10006   GtkEntryPrivate *private;
10007
10008   g_return_if_fail (GTK_IS_ENTRY (entry));
10009
10010   private = entry->priv;
10011
10012   fraction = CLAMP (fraction, 0.0, 1.0);
10013
10014   if (fraction != private->progress_pulse_fraction)
10015     {
10016       private->progress_pulse_fraction = fraction;
10017
10018       gtk_widget_queue_draw (GTK_WIDGET (entry));
10019
10020       g_object_notify (G_OBJECT (entry), "progress-pulse-step");
10021     }
10022 }
10023
10024 /**
10025  * gtk_entry_get_progress_pulse_step:
10026  * @entry: a #GtkEntry
10027  *
10028  * Retrieves the pulse step set with gtk_entry_set_progress_pulse_step().
10029  *
10030  * Return value: a fraction from 0.0 to 1.0
10031  *
10032  * Since: 2.16
10033  */
10034 gdouble
10035 gtk_entry_get_progress_pulse_step (GtkEntry *entry)
10036 {
10037   g_return_val_if_fail (GTK_IS_ENTRY (entry), 0.0);
10038
10039   return entry->priv->progress_pulse_fraction;
10040 }
10041
10042 /**
10043  * gtk_entry_progress_pulse:
10044  * @entry: a #GtkEntry
10045  *
10046  * Indicates that some progress is made, but you don't know how much.
10047  * Causes the entry's progress indicator to enter "activity mode,"
10048  * where a block bounces back and forth. Each call to
10049  * gtk_entry_progress_pulse() causes the block to move by a little bit
10050  * (the amount of movement per pulse is determined by
10051  * gtk_entry_set_progress_pulse_step()).
10052  *
10053  * Since: 2.16
10054  */
10055 void
10056 gtk_entry_progress_pulse (GtkEntry *entry)
10057 {
10058   GtkEntryPrivate *private;
10059
10060   g_return_if_fail (GTK_IS_ENTRY (entry));
10061
10062   private = entry->priv;
10063
10064   if (private->progress_pulse_mode)
10065     {
10066       if (private->progress_pulse_way_back)
10067         {
10068           private->progress_pulse_current -= private->progress_pulse_fraction;
10069
10070           if (private->progress_pulse_current < 0.0)
10071             {
10072               private->progress_pulse_current = 0.0;
10073               private->progress_pulse_way_back = FALSE;
10074             }
10075         }
10076       else
10077         {
10078           private->progress_pulse_current += private->progress_pulse_fraction;
10079
10080           if (private->progress_pulse_current > 1.0 - private->progress_pulse_fraction)
10081             {
10082               private->progress_pulse_current = 1.0 - private->progress_pulse_fraction;
10083               private->progress_pulse_way_back = TRUE;
10084             }
10085         }
10086     }
10087   else
10088     {
10089       private->progress_fraction = 0.0;
10090       private->progress_pulse_mode = TRUE;
10091       private->progress_pulse_way_back = FALSE;
10092       private->progress_pulse_current = 0.0;
10093     }
10094
10095   gtk_widget_queue_draw (GTK_WIDGET (entry));
10096 }
10097
10098 /**
10099  * gtk_entry_set_placeholder_text:
10100  * @entry: a #GtkEntry
10101  * @text: a string to be displayed when @entry is empty an unfocused, or %NULL
10102  *
10103  * Sets text to be displayed in @entry when it is empty and unfocused.
10104  * This can be used to give a visual hint of the expected contents of
10105  * the #GtkEntry.
10106  *
10107  * Note that since the placeholder text gets removed when the entry
10108  * received focus, using this feature is a bit problematic if the entry
10109  * is given the initial focus in a window. Sometimes this can be
10110  * worked around by delaying the initial focus setting until the
10111  * first key event arrives.
10112  *
10113  * Since: 3.2
10114  **/
10115 void
10116 gtk_entry_set_placeholder_text (GtkEntry    *entry,
10117                                 const gchar *text)
10118 {
10119   GtkEntryPrivate *priv;
10120
10121   g_return_if_fail (GTK_IS_ENTRY (entry));
10122
10123   priv = entry->priv;
10124
10125   if (g_strcmp0 (priv->placeholder_text, text) == 0)
10126     return;
10127
10128   g_free (priv->placeholder_text);
10129   priv->placeholder_text = g_strdup (text);
10130
10131   gtk_entry_recompute (entry);
10132
10133   g_object_notify (G_OBJECT (entry), "placeholder-text");
10134 }
10135
10136 /**
10137  * gtk_entry_get_placeholder_text:
10138  * @entry: a #GtkEntry
10139  *
10140  * Retrieves the text that will be displayed when @entry is empty and unfocused
10141  *
10142  * Returns: a pointer to the placeholder text as a string. This string points to internally allocated
10143  * storage in the widget and must not be freed, modified or stored.
10144  *
10145  * Since: 3.2
10146  **/
10147 const gchar *
10148 gtk_entry_get_placeholder_text (GtkEntry *entry)
10149 {
10150   GtkEntryPrivate *priv;
10151
10152   g_return_val_if_fail (GTK_IS_ENTRY (entry), NULL);
10153
10154   priv = entry->priv;
10155
10156   return priv->placeholder_text;
10157 }
10158
10159 /* Caps Lock warning for password entries */
10160
10161 static void
10162 show_capslock_feedback (GtkEntry    *entry,
10163                         const gchar *text)
10164 {
10165   GtkEntryPrivate *priv = entry->priv;
10166
10167   if (gtk_entry_get_icon_storage_type (entry, GTK_ENTRY_ICON_SECONDARY) == GTK_IMAGE_EMPTY)
10168     {
10169       gtk_entry_set_icon_from_stock (entry, GTK_ENTRY_ICON_SECONDARY, GTK_STOCK_CAPS_LOCK_WARNING);
10170       gtk_entry_set_icon_activatable (entry, GTK_ENTRY_ICON_SECONDARY, FALSE);
10171       priv->caps_lock_warning_shown = TRUE;
10172     }
10173
10174   if (priv->caps_lock_warning_shown)
10175     gtk_entry_set_icon_tooltip_text (entry, GTK_ENTRY_ICON_SECONDARY, text);
10176   else
10177     g_warning ("Can't show Caps Lock warning, since secondary icon is set");
10178 }
10179
10180 static void
10181 remove_capslock_feedback (GtkEntry *entry)
10182 {
10183   GtkEntryPrivate *priv = entry->priv;
10184
10185   if (priv->caps_lock_warning_shown)
10186     {
10187       gtk_entry_set_icon_from_stock (entry, GTK_ENTRY_ICON_SECONDARY, NULL);
10188       priv->caps_lock_warning_shown = FALSE;
10189     } 
10190 }
10191
10192 static void
10193 keymap_state_changed (GdkKeymap *keymap, 
10194                       GtkEntry  *entry)
10195 {
10196   GtkEntryPrivate *priv = entry->priv;
10197   char *text = NULL;
10198
10199   if (gtk_entry_get_display_mode (entry) != DISPLAY_NORMAL && priv->caps_lock_warning)
10200     { 
10201       if (gdk_keymap_get_num_lock_state (keymap)
10202           && gdk_keymap_get_caps_lock_state (keymap))
10203         text = _("Caps Lock and Num Lock are on");
10204       else if (gdk_keymap_get_num_lock_state (keymap))
10205         text = _("Num Lock is on");
10206       else if (gdk_keymap_get_caps_lock_state (keymap))
10207         text = _("Caps Lock is on");
10208     }
10209
10210   if (text)
10211     show_capslock_feedback (entry, text);
10212   else
10213     remove_capslock_feedback (entry);
10214 }
10215
10216 /*
10217  * _gtk_entry_set_is_cell_renderer:
10218  * @entry: a #GtkEntry
10219  * @is_cell_renderer: new value
10220  *
10221  * This is a helper function for GtkComboBox. A GtkEntry in a GtkComboBox
10222  * is supposed to behave like a GtkCellEditable when placed in a combo box.
10223  *
10224  * I.e take up its allocation and get GtkEntry->is_cell_renderer = TRUE.
10225  *
10226  */
10227 void
10228 _gtk_entry_set_is_cell_renderer (GtkEntry *entry,
10229                                  gboolean  is_cell_renderer)
10230 {
10231   entry->priv->is_cell_renderer = is_cell_renderer;
10232 }