Pileus Git - ~andy/gtk/blob - gtk/gtkentry.c

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 /*
  21  * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS
  22  * file for a list of people on the GTK+ Team.  See the ChangeLog
  23  * files for a list of changes.  These files are distributed with
  24  * GTK+ at ftp://ftp.gtk.org/pub/gtk/.
  25  */
  26
  27 #include <string.h>
  28
  29 #include <pango/pango.h>
  30
  31 #include "gdk/gdkkeysyms.h"
  32 #include "gtkbindings.h"
  33 #include "gtkclipboard.h"
  34 #include "gtkentry.h"
  35 #include "gtkimmulticontext.h"
  36 #include "gtkintl.h"
  37 #include "gtkmain.h"
  38 #include "gtkmenu.h"
  39 #include "gtkmenuitem.h"
  40 #include "gtkselection.h"
  41 #include "gtksignal.h"
  42
  43 #define MIN_ENTRY_WIDTH  150
  44 #define DRAW_TIMEOUT     20
  45 #define INNER_BORDER     2
  46
  47 /* Initial size of buffer, in bytes */
  48 #define MIN_SIZE 16
  49
  50 /* Maximum size of text buffer, in bytes */
  51 #define MAX_SIZE G_MAXUSHORT
  52
  53 enum {
  54   INSERT_TEXT,
  55   DELETE_TEXT,
  56   CHANGED,
  57   ACTIVATE,
  58   MOVE_CURSOR,
  59   INSERT_AT_CURSOR,
  60   DELETE_FROM_CURSOR,
  61   CUT_CLIPBOARD,
  62   COPY_CLIPBOARD,
  63   PASTE_CLIPBOARD,
  64   TOGGLE_OVERWRITE,
  65   LAST_SIGNAL
  66 };
  67
  68 enum {
  69   ARG_0,
  70   ARG_TEXT_POSITION,
  71   ARG_EDITABLE,
  72   ARG_MAX_LENGTH,
  73   ARG_VISIBILITY,
  74   ARG_INVISIBLE_CHAR
  75 };
  76
  77 static guint signals[LAST_SIGNAL] = { 0 };
  78
  79 /* GObject, GtkObject methods
  80  */
  81 static void   gtk_entry_class_init           (GtkEntryClass    *klass);
  82 static void   gtk_entry_editable_init        (GtkEditableClass *iface);
  83 static void   gtk_entry_init                 (GtkEntry         *entry);
  84 static void   gtk_entry_set_arg              (GtkObject        *object,
  85                                               GtkArg           *arg,
  86                                               guint             arg_id);
  87 static void   gtk_entry_get_arg              (GtkObject        *object,
  88                                               GtkArg           *arg,
  89                                               guint             arg_id);
  90 static void   gtk_entry_finalize             (GObject          *object);
  91
  92 /* GtkWidget methods
  93  */
  94 static void   gtk_entry_realize              (GtkWidget        *widget);
  95 static void   gtk_entry_unrealize            (GtkWidget        *widget);
  96 static void   gtk_entry_size_request         (GtkWidget        *widget,
  97                                               GtkRequisition   *requisition);
  98 static void   gtk_entry_size_allocate        (GtkWidget        *widget,
  99                                               GtkAllocation    *allocation);
 100 static void   gtk_entry_draw_focus           (GtkWidget        *widget);
 101 static gint   gtk_entry_expose               (GtkWidget        *widget,
 102                                               GdkEventExpose   *event);
 103 static gint   gtk_entry_button_press         (GtkWidget        *widget,
 104                                               GdkEventButton   *event);
 105 static gint   gtk_entry_button_release       (GtkWidget        *widget,
 106                                               GdkEventButton   *event);
 107 static gint   gtk_entry_motion_notify        (GtkWidget        *widget,
 108                                               GdkEventMotion   *event);
 109 static gint   gtk_entry_key_press            (GtkWidget        *widget,
 110                                               GdkEventKey      *event);
 111 static gint   gtk_entry_focus_in             (GtkWidget        *widget,
 112                                               GdkEventFocus    *event);
 113 static gint   gtk_entry_focus_out            (GtkWidget        *widget,
 114                                               GdkEventFocus    *event);
 115 static void   gtk_entry_style_set            (GtkWidget        *widget,
 116                                               GtkStyle         *previous_style);
 117 static void   gtk_entry_direction_changed    (GtkWidget        *widget,
 118                                               GtkTextDirection  previous_dir);
 119 static void   gtk_entry_state_changed        (GtkWidget        *widget,
 120                                               GtkStateType      previous_state);
 121
 122 /* GtkEditable method implementations
 123  */
 124 static void     gtk_entry_insert_text          (GtkEditable *editable,
 125                                                 const gchar *new_text,
 126                                                 gint         new_text_length,
 127                                                 gint        *position);
 128 static void     gtk_entry_delete_text          (GtkEditable *editable,
 129                                                 gint         start_pos,
 130                                                 gint         end_pos);
 131 static gchar *  gtk_entry_get_chars            (GtkEditable *editable,
 132                                                 gint         start_pos,
 133                                                 gint         end_pos);
 134 static void     gtk_entry_real_set_position    (GtkEditable *editable,
 135                                                 gint         position);
 136 static gint     gtk_entry_get_position         (GtkEditable *editable);
 137 static void     gtk_entry_set_selection_bounds (GtkEditable *editable,
 138                                                 gint         start,
 139                                                 gint         end);
 140 static gboolean gtk_entry_get_selection_bounds (GtkEditable *editable,
 141                                                 gint        *start,
 142                                                 gint        *end);
 143
 144 /* Default signal handlers
 145  */
 146 static void gtk_entry_real_insert_text   (GtkEntry        *entry,
 147                                           const gchar     *new_text,
 148                                           gint             new_text_length,
 149                                           gint            *position);
 150 static void gtk_entry_real_delete_text   (GtkEntry        *entry,
 151                                           gint             start_pos,
 152                                           gint             end_pos);
 153 static void gtk_entry_move_cursor        (GtkEntry        *entry,
 154                                           GtkMovementStep  step,
 155                                           gint             count,
 156                                           gboolean         extend_selection);
 157 static void gtk_entry_insert_at_cursor   (GtkEntry        *entry,
 158                                           const gchar     *str);
 159 static void gtk_entry_delete_from_cursor (GtkEntry        *entry,
 160                                           GtkDeleteType    type,
 161                                           gint             count);
 162 static void gtk_entry_cut_clipboard      (GtkEntry        *entry);
 163 static void gtk_entry_copy_clipboard     (GtkEntry        *entry);
 164 static void gtk_entry_paste_clipboard    (GtkEntry        *entry);
 165 static void gtk_entry_toggle_overwrite   (GtkEntry        *entry);
 166
 167 /* IM Context Callbacks
 168  */
 169 static void gtk_entry_commit_cb           (GtkIMContext      *context,
 170                                            const gchar       *str,
 171                                            GtkEntry          *entry);
 172 static void gtk_entry_preedit_changed_cb  (GtkIMContext      *context,
 173                                            GtkEntry          *entry);
 174 /* Internal routines
 175  */
 176 static void         gtk_entry_draw_text                (GtkEntry       *entry);
 177 static void         gtk_entry_draw_cursor              (GtkEntry       *entry);
 178 static PangoLayout *gtk_entry_get_layout               (GtkEntry       *entry,
 179                                                         gboolean        include_preedit);
 180 static void         gtk_entry_queue_draw               (GtkEntry       *entry);
 181 static void         gtk_entry_reset_im_context         (GtkEntry       *entry);
 182 static void         gtk_entry_recompute                (GtkEntry       *entry);
 183 static gint         gtk_entry_find_position            (GtkEntry       *entry,
 184                                                         gint            x);
 185 static void         gtk_entry_get_cursor_locations     (GtkEntry       *entry,
 186                                                         gint           *strong_x,
 187                                                         gint           *weak_x);
 188 static void         gtk_entry_adjust_scroll            (GtkEntry       *entry);
 189 static gint         gtk_entry_move_visually            (GtkEntry       *editable,
 190                                                         gint            start,
 191                                                         gint            count);
 192 static gint         gtk_entry_move_forward_word        (GtkEntry       *entry,
 193                                                         gint            start);
 194 static gint         gtk_entry_move_backward_word       (GtkEntry       *entry,
 195                                                         gint            start);
 196 static void         gtk_entry_delete_whitespace        (GtkEntry       *entry);
 197 static void         gtk_entry_select_word              (GtkEntry       *entry);
 198 static void         gtk_entry_select_line              (GtkEntry       *entry);
 199 static char *       gtk_entry_get_public_chars         (GtkEntry       *entry,
 200                                                         gint            start,
 201                                                         gint            end);
 202 static void         gtk_entry_paste                    (GtkEntry       *entry,
 203                                                         GdkAtom         selection);
 204 static void         gtk_entry_update_primary_selection (GtkEntry       *entry);
 205 static void         gtk_entry_popup_menu               (GtkEntry       *entry,
 206                                                         GdkEventButton *event);
 207
 208 static GtkWidgetClass *parent_class = NULL;
 209
 210 GtkType
 211 gtk_entry_get_type (void)
 212 {
 213   static GtkType entry_type = 0;
 214
 215   if (!entry_type)
 216     {
 217       static const GtkTypeInfo entry_info =
 218       {
 219         "GtkEntry",
 220         sizeof (GtkEntry),
 221         sizeof (GtkEntryClass),
 222         (GtkClassInitFunc) gtk_entry_class_init,
 223         (GtkObjectInitFunc) gtk_entry_init,
 224         /* reserved_1 */ NULL,
 225         /* reserved_2 */ NULL,
 226         (GtkClassInitFunc) NULL,
 227       };
 228
 229       static const GInterfaceInfo editable_info =
 230       {
 231         (GInterfaceInitFunc) gtk_entry_editable_init,    /* interface_init */
 232         NULL,                                            /* interface_finalize */
 233         NULL                                             /* interface_data */
 234       };
 235
 236       entry_type = gtk_type_unique (GTK_TYPE_WIDGET, &entry_info);
 237       g_type_add_interface_static (entry_type,
 238                                    GTK_TYPE_EDITABLE,
 239                                    &editable_info);
 240     }
 241
 242   return entry_type;
 243 }
 244
 245 static void
 246 add_move_binding (GtkBindingSet  *binding_set,
 247                   guint           keyval,
 248                   guint           modmask,
 249                   GtkMovementStep step,
 250                   gint            count)
 251 {
 252   g_return_if_fail ((modmask & GDK_SHIFT_MASK) == 0);
 253
 254   gtk_binding_entry_add_signal (binding_set, keyval, modmask,
 255                                 "move_cursor", 3,
 256                                 GTK_TYPE_ENUM, step,
 257                                 G_TYPE_INT, count,
 258                                 G_TYPE_BOOLEAN, FALSE);
 259
 260   /* Selection-extending version */
 261   gtk_binding_entry_add_signal (binding_set, keyval, modmask | GDK_SHIFT_MASK,
 262                                 "move_cursor", 3,
 263                                 GTK_TYPE_ENUM, step,
 264                                 G_TYPE_INT, count,
 265                                 G_TYPE_BOOLEAN, TRUE);
 266 }
 267
 268 static void
 269 gtk_entry_class_init (GtkEntryClass *class)
 270 {
 271   GObjectClass *gobject_class = G_OBJECT_CLASS (class);
 272   GtkObjectClass *object_class;
 273   GtkWidgetClass *widget_class;
 274   GtkBindingSet *binding_set;
 275
 276   object_class = (GtkObjectClass*) class;
 277   widget_class = (GtkWidgetClass*) class;
 278   parent_class = gtk_type_class (GTK_TYPE_WIDGET);
 279
 280   gobject_class->finalize = gtk_entry_finalize;
 281
 282   object_class->set_arg = gtk_entry_set_arg;
 283   object_class->get_arg = gtk_entry_get_arg;
 284
 285   widget_class->realize = gtk_entry_realize;
 286   widget_class->unrealize = gtk_entry_unrealize;
 287   widget_class->draw_focus = gtk_entry_draw_focus;
 288   widget_class->size_request = gtk_entry_size_request;
 289   widget_class->size_allocate = gtk_entry_size_allocate;
 290   widget_class->expose_event = gtk_entry_expose;
 291   widget_class->button_press_event = gtk_entry_button_press;
 292   widget_class->button_release_event = gtk_entry_button_release;
 293   widget_class->motion_notify_event = gtk_entry_motion_notify;
 294   widget_class->key_press_event = gtk_entry_key_press;
 295   widget_class->focus_in_event = gtk_entry_focus_in;
 296   widget_class->focus_out_event = gtk_entry_focus_out;
 297   widget_class->style_set = gtk_entry_style_set;
 298   widget_class->direction_changed = gtk_entry_direction_changed;
 299   widget_class->state_changed = gtk_entry_state_changed;
 300
 301   class->insert_text = gtk_entry_real_insert_text;
 302   class->delete_text = gtk_entry_real_delete_text;
 303   class->move_cursor = gtk_entry_move_cursor;
 304   class->insert_at_cursor = gtk_entry_insert_at_cursor;
 305   class->delete_from_cursor = gtk_entry_delete_from_cursor;
 306   class->cut_clipboard = gtk_entry_cut_clipboard;
 307   class->copy_clipboard = gtk_entry_copy_clipboard;
 308   class->paste_clipboard = gtk_entry_paste_clipboard;
 309   class->toggle_overwrite = gtk_entry_toggle_overwrite;
 310
 311   gtk_object_add_arg_type ("GtkEntry::text_position", GTK_TYPE_INT,  GTK_ARG_READWRITE, ARG_TEXT_POSITION);
 312   gtk_object_add_arg_type ("GtkEntry::editable",      GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_EDITABLE);
 313   gtk_object_add_arg_type ("GtkEntry::max_length",    GTK_TYPE_UINT, GTK_ARG_READWRITE, ARG_MAX_LENGTH);
 314   gtk_object_add_arg_type ("GtkEntry::visibility",    GTK_TYPE_BOOL, GTK_ARG_READWRITE, ARG_VISIBILITY);
 315   gtk_object_add_arg_type ("GtkEntry::invisible_char", GTK_TYPE_INT, GTK_ARG_READWRITE, ARG_INVISIBLE_CHAR);
 316
 317   signals[INSERT_TEXT] =
 318     gtk_signal_new ("insert_text",
 319                     GTK_RUN_LAST,
 320                     GTK_CLASS_TYPE (object_class),
 321                     GTK_SIGNAL_OFFSET (GtkEntryClass, insert_text),
 322                     gtk_marshal_VOID__STRING_INT_POINTER,
 323                     GTK_TYPE_NONE,
 324                     3,
 325                     GTK_TYPE_STRING,
 326                     GTK_TYPE_INT,
 327                     GTK_TYPE_POINTER);
 328
 329   signals[DELETE_TEXT] =
 330     gtk_signal_new ("delete_text",
 331                     GTK_RUN_LAST,
 332                     GTK_CLASS_TYPE (object_class),
 333                     GTK_SIGNAL_OFFSET (GtkEntryClass, delete_text),
 334                     gtk_marshal_VOID__INT_INT,
 335                     GTK_TYPE_NONE,
 336                     2,
 337                     GTK_TYPE_INT,
 338                     GTK_TYPE_INT);
 339
 340   signals[CHANGED] =
 341     gtk_signal_new ("changed",
 342                     GTK_RUN_LAST,
 343                     GTK_CLASS_TYPE (object_class),
 344                     GTK_SIGNAL_OFFSET (GtkEntryClass, changed),
 345                     gtk_marshal_VOID__VOID,
 346                     GTK_TYPE_NONE, 0);
 347
 348  /* Action signals */
 349
 350   signals[ACTIVATE] =
 351     gtk_signal_new ("activate",
 352                     GTK_RUN_LAST | GTK_RUN_ACTION,
 353                     GTK_CLASS_TYPE (object_class),
 354                     GTK_SIGNAL_OFFSET (GtkEntryClass, activate),
 355                     gtk_marshal_VOID__VOID,
 356                     GTK_TYPE_NONE, 0);
 357   widget_class->activate_signal = signals[ACTIVATE];
 358
 359   signals[MOVE_CURSOR] =
 360       gtk_signal_new ("move_cursor",
 361                       GTK_RUN_LAST | GTK_RUN_ACTION,
 362                       GTK_CLASS_TYPE (object_class),
 363                       GTK_SIGNAL_OFFSET (GtkEntryClass, move_cursor),
 364                       gtk_marshal_VOID__ENUM_INT_BOOLEAN,
 365                       GTK_TYPE_NONE, 3, GTK_TYPE_MOVEMENT_STEP, GTK_TYPE_INT, GTK_TYPE_BOOL);
 366
 367   signals[INSERT_AT_CURSOR] =
 368       gtk_signal_new ("insert_at_cursor",
 369                       GTK_RUN_LAST | GTK_RUN_ACTION,
 370                       GTK_CLASS_TYPE (object_class),
 371                       GTK_SIGNAL_OFFSET (GtkEntryClass, insert_at_cursor),
 372                       gtk_marshal_VOID__STRING,
 373                       GTK_TYPE_NONE, 1, GTK_TYPE_STRING);
 374
 375   signals[DELETE_FROM_CURSOR] =
 376       gtk_signal_new ("delete_from_cursor",
 377                       GTK_RUN_LAST | GTK_RUN_ACTION,
 378                       GTK_CLASS_TYPE (object_class),
 379                       GTK_SIGNAL_OFFSET (GtkEntryClass, delete_from_cursor),
 380                       gtk_marshal_VOID__ENUM_INT,
 381                       GTK_TYPE_NONE, 2, GTK_TYPE_DELETE_TYPE, GTK_TYPE_INT);
 382
 383   signals[CUT_CLIPBOARD] =
 384     gtk_signal_new ("cut_clipboard",
 385                     GTK_RUN_LAST | GTK_RUN_ACTION,
 386                     GTK_CLASS_TYPE (object_class),
 387                     GTK_SIGNAL_OFFSET (GtkEntryClass, cut_clipboard),
 388                     gtk_marshal_VOID__VOID,
 389                     GTK_TYPE_NONE, 0);
 390
 391   signals[COPY_CLIPBOARD] =
 392     gtk_signal_new ("copy_clipboard",
 393                     GTK_RUN_LAST | GTK_RUN_ACTION,
 394                     GTK_CLASS_TYPE (object_class),
 395                     GTK_SIGNAL_OFFSET (GtkEntryClass, copy_clipboard),
 396                     gtk_marshal_VOID__VOID,
 397                     GTK_TYPE_NONE, 0);
 398
 399   signals[PASTE_CLIPBOARD] =
 400     gtk_signal_new ("paste_clipboard",
 401                     GTK_RUN_LAST | GTK_RUN_ACTION,
 402                     GTK_CLASS_TYPE (object_class),
 403                     GTK_SIGNAL_OFFSET (GtkEntryClass, paste_clipboard),
 404                     gtk_marshal_VOID__VOID,
 405                     GTK_TYPE_NONE, 0);
 406
 407   signals[TOGGLE_OVERWRITE] =
 408     gtk_signal_new ("toggle_overwrite",
 409                     GTK_RUN_LAST | GTK_RUN_ACTION,
 410                     GTK_CLASS_TYPE (object_class),
 411                     GTK_SIGNAL_OFFSET (GtkEntryClass, toggle_overwrite),
 412                     gtk_marshal_VOID__VOID,
 413                     GTK_TYPE_NONE, 0);
 414
 415   /*
 416    * Key bindings
 417    */
 418
 419   binding_set = gtk_binding_set_by_class (class);
 420
 421   /* Moving the insertion point */
 422   add_move_binding (binding_set, GDK_Right, 0,
 423                     GTK_MOVEMENT_VISUAL_POSITIONS, 1);
 424
 425   add_move_binding (binding_set, GDK_Left, 0,
 426                     GTK_MOVEMENT_VISUAL_POSITIONS, -1);
 427
 428   add_move_binding (binding_set, GDK_f, GDK_CONTROL_MASK,
 429                     GTK_MOVEMENT_LOGICAL_POSITIONS, 1);
 430
 431   add_move_binding (binding_set, GDK_b, GDK_CONTROL_MASK,
 432                     GTK_MOVEMENT_LOGICAL_POSITIONS, -1);
 433
 434   add_move_binding (binding_set, GDK_Right, GDK_CONTROL_MASK,
 435                     GTK_MOVEMENT_WORDS, 1);
 436
 437   add_move_binding (binding_set, GDK_Left, GDK_CONTROL_MASK,
 438                     GTK_MOVEMENT_WORDS, -1);
 439
 440   add_move_binding (binding_set, GDK_a, GDK_CONTROL_MASK,
 441                     GTK_MOVEMENT_PARAGRAPH_ENDS, -1);
 442
 443   add_move_binding (binding_set, GDK_e, GDK_CONTROL_MASK,
 444                     GTK_MOVEMENT_PARAGRAPH_ENDS, 1);
 445
 446   add_move_binding (binding_set, GDK_f, GDK_MOD1_MASK,
 447                     GTK_MOVEMENT_WORDS, 1);
 448
 449   add_move_binding (binding_set, GDK_b, GDK_MOD1_MASK,
 450                     GTK_MOVEMENT_WORDS, -1);
 451
 452   add_move_binding (binding_set, GDK_Home, 0,
 453                     GTK_MOVEMENT_DISPLAY_LINE_ENDS, -1);
 454
 455   add_move_binding (binding_set, GDK_End, 0,
 456                     GTK_MOVEMENT_DISPLAY_LINE_ENDS, 1);
 457
 458   add_move_binding (binding_set, GDK_Home, GDK_CONTROL_MASK,
 459                     GTK_MOVEMENT_BUFFER_ENDS, -1);
 460
 461   add_move_binding (binding_set, GDK_End, GDK_CONTROL_MASK,
 462                     GTK_MOVEMENT_BUFFER_ENDS, 1);
 463
 464   /* Deleting text */
 465   gtk_binding_entry_add_signal (binding_set, GDK_Delete, 0,
 466                                 "delete_from_cursor", 2,
 467                                 GTK_TYPE_ENUM, GTK_DELETE_CHARS,
 468                                 GTK_TYPE_INT, 1);
 469
 470   gtk_binding_entry_add_signal (binding_set, GDK_d, GDK_CONTROL_MASK,
 471                                 "delete_from_cursor", 2,
 472                                 GTK_TYPE_ENUM, GTK_DELETE_CHARS,
 473                                 GTK_TYPE_INT, 1);
 474
 475   gtk_binding_entry_add_signal (binding_set, GDK_BackSpace, 0,
 476                                 "delete_from_cursor", 2,
 477                                 GTK_TYPE_ENUM, GTK_DELETE_CHARS,
 478                                 GTK_TYPE_INT, -1);
 479
 480   gtk_binding_entry_add_signal (binding_set, GDK_Delete, GDK_CONTROL_MASK,
 481                                 "delete_from_cursor", 2,
 482                                 GTK_TYPE_ENUM, GTK_DELETE_WORD_ENDS,
 483                                 GTK_TYPE_INT, 1);
 484
 485   gtk_binding_entry_add_signal (binding_set, GDK_d, GDK_MOD1_MASK,
 486                                 "delete_from_cursor", 2,
 487                                 GTK_TYPE_ENUM, GTK_DELETE_WORD_ENDS,
 488                                 GTK_TYPE_INT, 1);
 489
 490   gtk_binding_entry_add_signal (binding_set, GDK_BackSpace, GDK_CONTROL_MASK,
 491                                 "delete_from_cursor", 2,
 492                                 GTK_TYPE_ENUM, GTK_DELETE_WORD_ENDS,
 493                                 GTK_TYPE_INT, -1);
 494
 495   gtk_binding_entry_add_signal (binding_set, GDK_k, GDK_CONTROL_MASK,
 496                                 "delete_from_cursor", 2,
 497                                 GTK_TYPE_ENUM, GTK_DELETE_PARAGRAPH_ENDS,
 498                                 GTK_TYPE_INT, 1);
 499
 500   gtk_binding_entry_add_signal (binding_set, GDK_u, GDK_CONTROL_MASK,
 501                                 "delete_from_cursor", 2,
 502                                 GTK_TYPE_ENUM, GTK_DELETE_PARAGRAPHS,
 503                                 GTK_TYPE_INT, 1);
 504
 505   gtk_binding_entry_add_signal (binding_set, GDK_space, GDK_MOD1_MASK,
 506                                 "delete_from_cursor", 2,
 507                                 GTK_TYPE_ENUM, GTK_DELETE_WHITESPACE,
 508                                 GTK_TYPE_INT, 1);
 509   gtk_binding_entry_add_signal (binding_set, GDK_space, GDK_MOD1_MASK,
 510                                 "insert_at_cursor", 1,
 511                                 GTK_TYPE_STRING, " ");
 512
 513   gtk_binding_entry_add_signal (binding_set, GDK_backslash, GDK_MOD1_MASK,
 514                                 "delete_from_cursor", 2,
 515                                 GTK_TYPE_ENUM, GTK_DELETE_WHITESPACE,
 516                                 GTK_TYPE_INT, 1);
 517
 518   /* Cut/copy/paste */
 519
 520   gtk_binding_entry_add_signal (binding_set, GDK_x, GDK_CONTROL_MASK,
 521                                 "cut_clipboard", 0);
 522
 523   gtk_binding_entry_add_signal (binding_set, GDK_w, GDK_CONTROL_MASK,
 524                                 "cut_clipboard", 0);
 525
 526   gtk_binding_entry_add_signal (binding_set, GDK_c, GDK_CONTROL_MASK,
 527                                 "copy_clipboard", 0);
 528
 529   gtk_binding_entry_add_signal (binding_set, GDK_v, GDK_CONTROL_MASK,
 530                                 "paste_clipboard", 0);
 531
 532   gtk_binding_entry_add_signal (binding_set, GDK_y, GDK_CONTROL_MASK,
 533                                 "paste_clipboard", 0);
 534
 535   /* Overwrite */
 536   gtk_binding_entry_add_signal (binding_set, GDK_Insert, 0,
 537                                 "toggle_overwrite", 0);
 538 }
 539
 540 static void
 541 gtk_entry_editable_init (GtkEditableClass *iface)
 542 {
 543   iface->insert_text = gtk_entry_insert_text;
 544   iface->delete_text = gtk_entry_delete_text;
 545   iface->get_chars = gtk_entry_get_chars;
 546   iface->set_selection_bounds = gtk_entry_set_selection_bounds;
 547   iface->get_selection_bounds = gtk_entry_get_selection_bounds;
 548   iface->set_position = gtk_entry_real_set_position;
 549   iface->get_position = gtk_entry_get_position;
 550 }
 551
 552 static void
 553 gtk_entry_set_arg (GtkObject      *object,
 554                    GtkArg         *arg,
 555                    guint           arg_id)
 556 {
 557   GtkEntry *entry = GTK_ENTRY (object);
 558
 559   switch (arg_id)
 560     {
 561     case ARG_TEXT_POSITION:
 562       gtk_editable_set_position (GTK_EDITABLE (object), GTK_VALUE_INT (*arg));
 563       break;
 564     case ARG_EDITABLE:
 565       {
 566         gboolean new_value = GTK_VALUE_BOOL (*arg) != 0;
 567         if (new_value != entry->editable)
 568           {
 569             entry->editable = new_value;
 570             gtk_entry_queue_draw (entry);
 571           }
 572       }
 573       break;
 574     case ARG_MAX_LENGTH:
 575       gtk_entry_set_max_length (entry, GTK_VALUE_UINT (*arg));
 576       break;
 577     case ARG_VISIBILITY:
 578       gtk_entry_set_visibility (entry, GTK_VALUE_BOOL (*arg));
 579       break;
 580     case ARG_INVISIBLE_CHAR:
 581       gtk_entry_set_invisible_char (entry, GTK_VALUE_INT (*arg));
 582       break;
 583     default:
 584       break;
 585     }
 586 }
 587
 588 static void
 589 gtk_entry_get_arg (GtkObject      *object,
 590                    GtkArg         *arg,
 591                    guint           arg_id)
 592 {
 593   GtkEntry *entry;
 594
 595   entry = GTK_ENTRY (object);
 596
 597   switch (arg_id)
 598     {
 599     case ARG_TEXT_POSITION:
 600       GTK_VALUE_INT (*arg) = entry->current_pos;
 601       break;
 602     case ARG_EDITABLE:
 603       GTK_VALUE_BOOL (*arg) = entry->editable;
 604       break;
 605     case ARG_MAX_LENGTH:
 606       GTK_VALUE_UINT (*arg) = entry->text_max_length;
 607       break;
 608     case ARG_VISIBILITY:
 609       GTK_VALUE_BOOL (*arg) = entry->visible;
 610       break;
 611     case ARG_INVISIBLE_CHAR:
 612       GTK_VALUE_INT (*arg) = entry->invisible_char;
 613       break;
 614     default:
 615       arg->type = GTK_TYPE_INVALID;
 616       break;
 617     }
 618 }
 619
 620 static void
 621 gtk_entry_init (GtkEntry *entry)
 622 {
 623   GTK_WIDGET_SET_FLAGS (entry, GTK_CAN_FOCUS);
 624
 625   entry->text_size = MIN_SIZE;
 626   entry->text = g_malloc (entry->text_size);
 627   entry->text[0] = '\0';
 628
 629   entry->editable = TRUE;
 630   entry->visible = TRUE;
 631   entry->invisible_char = '*';
 632
 633   /* This object is completely private. No external entity can gain a reference
 634    * to it; so we create it here and destroy it in finalize().
 635    */
 636   entry->im_context = gtk_im_multicontext_new ();
 637
 638   gtk_signal_connect (GTK_OBJECT (entry->im_context), "commit",
 639                       GTK_SIGNAL_FUNC (gtk_entry_commit_cb), entry);
 640   gtk_signal_connect (GTK_OBJECT (entry->im_context), "preedit_changed",
 641                       GTK_SIGNAL_FUNC (gtk_entry_preedit_changed_cb), entry);
 642 }
 643
 644 static void
 645 gtk_entry_finalize (GObject *object)
 646 {
 647   GtkEntry *entry;
 648
 649   g_return_if_fail (GTK_IS_ENTRY (object));
 650
 651   entry = GTK_ENTRY (object);
 652
 653   if (entry->cached_layout)
 654     g_object_unref (G_OBJECT (entry->cached_layout));
 655
 656   gtk_object_unref (GTK_OBJECT (entry->im_context));
 657
 658   if (entry->timer)
 659     g_source_remove (entry->timer);
 660
 661   if (entry->recompute_idle)
 662     g_source_remove (entry->recompute_idle);
 663
 664   entry->text_size = 0;
 665
 666   if (entry->text)
 667     g_free (entry->text);
 668   entry->text = NULL;
 669
 670   G_OBJECT_CLASS (parent_class)->finalize (object);
 671 }
 672
 673 static void
 674 gtk_entry_realize (GtkWidget *widget)
 675 {
 676   GtkEntry *entry;
 677   GtkEditable *editable;
 678   GtkRequisition requisition;
 679   GdkWindowAttr attributes;
 680   gint attributes_mask;
 681
 682   g_return_if_fail (widget != NULL);
 683   g_return_if_fail (GTK_IS_ENTRY (widget));
 684
 685   GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);
 686   entry = GTK_ENTRY (widget);
 687   editable = GTK_EDITABLE (widget);
 688
 689   gtk_widget_get_child_requisition (widget, &requisition);
 690
 691   attributes.window_type = GDK_WINDOW_CHILD;
 692   attributes.x = widget->allocation.x;
 693   attributes.y = widget->allocation.y + (widget->allocation.height -
 694                                          requisition.height) / 2;
 695   attributes.width = widget->allocation.width;
 696   attributes.height = requisition.height;
 697   attributes.wclass = GDK_INPUT_OUTPUT;
 698   attributes.visual = gtk_widget_get_visual (widget);
 699   attributes.colormap = gtk_widget_get_colormap (widget);
 700   attributes.event_mask = gtk_widget_get_events (widget);
 701   attributes.event_mask |= (GDK_EXPOSURE_MASK |
 702                             GDK_BUTTON_PRESS_MASK |
 703                             GDK_BUTTON_RELEASE_MASK |
 704                             GDK_BUTTON1_MOTION_MASK |
 705                             GDK_BUTTON3_MOTION_MASK |
 706                             GDK_POINTER_MOTION_HINT_MASK);
 707   attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
 708
 709   widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
 710   gdk_window_set_user_data (widget->window, entry);
 711
 712   attributes.x = widget->style->xthickness;
 713   attributes.y = widget->style->ythickness;
 714   attributes.width = widget->allocation.width - attributes.x * 2;
 715   attributes.height = requisition.height - attributes.y * 2;
 716   attributes.cursor = gdk_cursor_new (GDK_XTERM);
 717   attributes_mask |= GDK_WA_CURSOR;
 718
 719   entry->text_area = gdk_window_new (widget->window, &attributes, attributes_mask);
 720   gdk_window_set_user_data (entry->text_area, entry);
 721
 722   widget->style = gtk_style_attach (widget->style, widget->window);
 723
 724   gdk_window_set_background (widget->window, &widget->style->base[GTK_WIDGET_STATE (widget)]);
 725   gdk_window_set_background (entry->text_area, &widget->style->base[GTK_WIDGET_STATE (widget)]);
 726
 727   gdk_window_show (entry->text_area);
 728
 729   gtk_im_context_set_client_window (entry->im_context, entry->text_area);
 730
 731   gtk_entry_adjust_scroll (entry);
 732 }
 733
 734 static void
 735 gtk_entry_unrealize (GtkWidget *widget)
 736 {
 737   GtkEntry *entry;
 738
 739   g_return_if_fail (widget != NULL);
 740   g_return_if_fail (GTK_IS_ENTRY (widget));
 741
 742   entry = GTK_ENTRY (widget);
 743
 744   gtk_im_context_set_client_window (entry->im_context, entry->text_area);
 745
 746   if (entry->text_area)
 747     {
 748       gdk_window_set_user_data (entry->text_area, NULL);
 749       gdk_window_destroy (entry->text_area);
 750       entry->text_area = NULL;
 751     }
 752
 753   if (entry->popup_menu)
 754     gtk_widget_destroy (entry->popup_menu);
 755
 756   if (GTK_WIDGET_CLASS (parent_class)->unrealize)
 757     (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget);
 758 }
 759
 760 static void
 761 gtk_entry_size_request (GtkWidget      *widget,
 762                         GtkRequisition *requisition)
 763 {
 764   GtkEntry *entry;
 765   PangoFontMetrics metrics;
 766   PangoFont *font;
 767   gchar *lang;
 768
 769   g_return_if_fail (widget != NULL);
 770   g_return_if_fail (GTK_IS_ENTRY (widget));
 771   g_return_if_fail (requisition != NULL);
 772
 773   entry = GTK_ENTRY (widget);
 774
 775   /* hackish for now, get metrics
 776    */
 777   font = pango_context_load_font (gtk_widget_get_pango_context (widget),
 778                                   widget->style->font_desc);
 779   lang = pango_context_get_lang (gtk_widget_get_pango_context (widget));
 780   pango_font_get_metrics (font, lang, &metrics);
 781   g_free (lang);
 782
 783   g_object_unref (G_OBJECT (font));
 784
 785   entry->ascent = metrics.ascent;
 786   entry->descent = metrics.descent;
 787
 788   requisition->width = MIN_ENTRY_WIDTH + (widget->style->xthickness + INNER_BORDER) * 2;
 789   requisition->height = ((metrics.ascent + metrics.descent) / PANGO_SCALE +
 790                          (widget->style->ythickness + INNER_BORDER) * 2);
 791 }
 792
 793 static void
 794 gtk_entry_size_allocate (GtkWidget     *widget,
 795                          GtkAllocation *allocation)
 796 {
 797   GtkEntry *entry;
 798   GtkEditable *editable;
 799
 800   g_return_if_fail (widget != NULL);
 801   g_return_if_fail (GTK_IS_ENTRY (widget));
 802   g_return_if_fail (allocation != NULL);
 803
 804   widget->allocation = *allocation;
 805   entry = GTK_ENTRY (widget);
 806   editable = GTK_EDITABLE (widget);
 807
 808   if (GTK_WIDGET_REALIZED (widget))
 809     {
 810       /* We call gtk_widget_get_child_requisition, since we want (for
 811        * backwards compatibility reasons) the realization here to
 812        * be affected by the usize of the entry, if set
 813        */
 814       GtkRequisition requisition;
 815       gtk_widget_get_child_requisition (widget, &requisition);
 816
 817       gdk_window_move_resize (widget->window,
 818                               allocation->x,
 819                               allocation->y + (allocation->height - requisition.height) / 2,
 820                               allocation->width, requisition.height);
 821       gdk_window_move_resize (entry->text_area,
 822                               widget->style->xthickness,
 823                               widget->style->ythickness,
 824                               allocation->width - widget->style->xthickness * 2,
 825                               requisition.height - widget->style->ythickness * 2);
 826
 827       gtk_entry_recompute (entry);
 828     }
 829 }
 830
 831 static void
 832 gtk_entry_draw_focus (GtkWidget *widget)
 833 {
 834   gint width, height;
 835   gint x, y;
 836
 837   g_return_if_fail (widget != NULL);
 838   g_return_if_fail (GTK_IS_ENTRY (widget));
 839
 840   if (GTK_WIDGET_DRAWABLE (widget))
 841     {
 842       x = 0;
 843       y = 0;
 844       gdk_window_get_size (widget->window, &width, &height);
 845
 846       if (GTK_WIDGET_HAS_FOCUS (widget))
 847         {
 848           x += 1;
 849           y += 1;
 850           width -= 2;
 851           height -= 2;
 852         }
 853
 854       gtk_paint_shadow (widget->style, widget->window,
 855                         GTK_STATE_NORMAL, GTK_SHADOW_IN,
 856                         NULL, widget, "entry",
 857                         x, y, width, height);
 858
 859       if (GTK_WIDGET_HAS_FOCUS (widget))
 860         {
 861            gdk_window_get_size (widget->window, &width, &height);
 862            gtk_paint_focus (widget->style, widget->window,
 863                             NULL, widget, "entry",
 864                             0, 0, width - 1, height - 1);
 865         }
 866     }
 867 }
 868
 869 static gint
 870 gtk_entry_expose (GtkWidget      *widget,
 871                   GdkEventExpose *event)
 872 {
 873   GtkEntry *entry;
 874
 875   g_return_val_if_fail (widget != NULL, FALSE);
 876   g_return_val_if_fail (GTK_IS_ENTRY (widget), FALSE);
 877   g_return_val_if_fail (event != NULL, FALSE);
 878
 879   entry = GTK_ENTRY (widget);
 880
 881   if (widget->window == event->window)
 882     gtk_widget_draw_focus (widget);
 883   else if (entry->text_area == event->window)
 884     {
 885       gtk_entry_draw_text (GTK_ENTRY (widget));
 886       gtk_entry_draw_cursor (GTK_ENTRY (widget));
 887     }
 888
 889   return FALSE;
 890 }
 891
 892 static gint
 893 gtk_entry_button_press (GtkWidget      *widget,
 894                         GdkEventButton *event)
 895 {
 896   GtkEntry *entry = GTK_ENTRY (widget);
 897   GtkEditable *editable = GTK_EDITABLE (widget);
 898   gint tmp_pos;
 899
 900   entry = GTK_ENTRY (widget);
 901   editable = GTK_EDITABLE (widget);
 902
 903   if (event->window != entry->text_area ||
 904       (entry->button && event->button != entry->button))
 905     return FALSE;
 906
 907   entry->button = event->button;
 908
 909   if (!GTK_WIDGET_HAS_FOCUS (widget))
 910     gtk_widget_grab_focus (widget);
 911
 912   tmp_pos = gtk_entry_find_position (entry, event->x + entry->scroll_offset);
 913
 914   if (event->button == 1)
 915     {
 916       switch (event->type)
 917         {
 918         case GDK_BUTTON_PRESS:
 919           gtk_entry_reset_im_context (entry);
 920
 921           entry->current_pos = tmp_pos;
 922           entry->selection_bound = tmp_pos;
 923
 924           gtk_entry_recompute (entry);
 925
 926           break;
 927
 928         case GDK_2BUTTON_PRESS:
 929           gtk_entry_select_word (entry);
 930           break;
 931
 932         case GDK_3BUTTON_PRESS:
 933           gtk_entry_select_line (entry);
 934           break;
 935
 936         default:
 937           break;
 938         }
 939
 940       return TRUE;
 941     }
 942   else if (event->button == 2 && event->type == GDK_BUTTON_PRESS && entry->editable)
 943     {
 944       gtk_editable_select_region (editable, tmp_pos, tmp_pos);
 945       gtk_entry_paste (entry, GDK_SELECTION_PRIMARY);
 946
 947       return TRUE;
 948     }
 949   else if (event->button == 3 && event->type == GDK_BUTTON_PRESS)
 950     {
 951       gtk_entry_popup_menu (entry, event);
 952       entry->button = 0;        /* Don't wait for release, since the menu will gtk_grab_add */
 953
 954       return TRUE;
 955     }
 956
 957   return FALSE;
 958 }
 959
 960 static gint
 961 gtk_entry_button_release (GtkWidget      *widget,
 962                           GdkEventButton *event)
 963 {
 964   GtkEntry *entry = GTK_ENTRY (widget);
 965   GtkEditable *editable = GTK_EDITABLE (widget);
 966
 967   if (event->window != entry->text_area || entry->button != event->button)
 968     return FALSE;
 969
 970   entry->button = 0;
 971
 972   return FALSE;
 973 }
 974
 975 static gint
 976 gtk_entry_motion_notify (GtkWidget      *widget,
 977                          GdkEventMotion *event)
 978 {
 979   GtkEntry *entry = GTK_ENTRY (widget);
 980   gint tmp_pos;
 981
 982   if (event->window != entry->text_area || entry->button != 1)
 983     return FALSE;
 984
 985   if (event->is_hint || (entry->text_area != event->window))
 986     gdk_window_get_pointer (entry->text_area, NULL, NULL, NULL);
 987
 988   tmp_pos = gtk_entry_find_position (entry, event->x + entry->scroll_offset);
 989
 990   if (tmp_pos != entry->current_pos)
 991     {
 992       entry->current_pos = tmp_pos;
 993       gtk_entry_recompute (entry);
 994     }
 995
 996   return TRUE;
 997 }
 998
 999 static gint
1000 gtk_entry_key_press (GtkWidget   *widget,
1001                      GdkEventKey *event)
1002 {
1003   GtkEntry *entry = GTK_ENTRY (widget);
1004
1005   if (!entry->editable)
1006     return FALSE;
1007
1008   if (gtk_im_context_filter_keypress (entry->im_context, event))
1009     {
1010       entry->need_im_reset = TRUE;
1011       return TRUE;
1012     }
1013   else if (GTK_WIDGET_CLASS (parent_class)->key_press_event (widget, event))
1014     /* Activate key bindings
1015      */
1016     return TRUE;
1017   else if (event->keyval == GDK_Return)
1018     {
1019       gtk_widget_activate (widget);
1020       return TRUE;
1021     }
1022
1023   return FALSE;
1024 }
1025
1026 static gint
1027 gtk_entry_focus_in (GtkWidget     *widget,
1028                     GdkEventFocus *event)
1029 {
1030   g_return_val_if_fail (widget != NULL, FALSE);
1031   g_return_val_if_fail (GTK_IS_ENTRY (widget), FALSE);
1032   g_return_val_if_fail (event != NULL, FALSE);
1033
1034   GTK_WIDGET_SET_FLAGS (widget, GTK_HAS_FOCUS);
1035   gtk_widget_draw_focus (widget);
1036   gtk_entry_queue_draw (GTK_ENTRY (widget));
1037
1038   GTK_ENTRY (widget)->need_im_reset = TRUE;
1039   gtk_im_context_focus_in (GTK_ENTRY (widget)->im_context);
1040
1041   return FALSE;
1042 }
1043
1044 static gint
1045 gtk_entry_focus_out (GtkWidget     *widget,
1046                      GdkEventFocus *event)
1047 {
1048   g_return_val_if_fail (widget != NULL, FALSE);
1049   g_return_val_if_fail (GTK_IS_ENTRY (widget), FALSE);
1050   g_return_val_if_fail (event != NULL, FALSE);
1051
1052   GTK_WIDGET_UNSET_FLAGS (widget, GTK_HAS_FOCUS);
1053   gtk_widget_draw_focus (widget);
1054   gtk_entry_queue_draw (GTK_ENTRY (widget));
1055
1056   GTK_ENTRY (widget)->need_im_reset = TRUE;
1057   gtk_im_context_focus_out (GTK_ENTRY (widget)->im_context);
1058
1059   return FALSE;
1060 }
1061
1062 static void
1063 gtk_entry_direction_changed (GtkWidget        *widget,
1064                              GtkTextDirection  previous_dir)
1065 {
1066   GtkEntry *entry = GTK_ENTRY (widget);
1067
1068   gtk_entry_recompute (entry);
1069
1070   GTK_WIDGET_CLASS (parent_class)->direction_changed (widget, previous_dir);
1071 }
1072
1073 static void
1074 gtk_entry_state_changed (GtkWidget      *widget,
1075                          GtkStateType    previous_state)
1076 {
1077   g_return_if_fail (widget != NULL);
1078   g_return_if_fail (GTK_IS_ENTRY (widget));
1079
1080   if (GTK_WIDGET_REALIZED (widget))
1081     {
1082       gdk_window_set_background (widget->window, &widget->style->base[GTK_WIDGET_STATE (widget)]);
1083       gdk_window_set_background (GTK_ENTRY (widget)->text_area, &widget->style->base[GTK_WIDGET_STATE (widget)]);
1084     }
1085
1086   gtk_widget_queue_clear (widget);
1087 }
1088
1089 /* GtkEditable method implementations
1090  */
1091 static void
1092 gtk_entry_insert_text (GtkEditable *editable,
1093                        const gchar *new_text,
1094                        gint         new_text_length,
1095                        gint        *position)
1096 {
1097   GtkEntry *entry = GTK_ENTRY (editable);
1098   gchar buf[64];
1099   gchar *text;
1100
1101   if (*position < 0 || *position > entry->text_length)
1102     *position = entry->text_length;
1103
1104   g_object_ref (G_OBJECT (editable));
1105
1106   if (new_text_length <= 63)
1107     text = buf;
1108   else
1109     text = g_new (gchar, new_text_length + 1);
1110
1111   text[new_text_length] = '\0';
1112   strncpy (text, new_text, new_text_length);
1113
1114   gtk_signal_emit (GTK_OBJECT (editable), signals[INSERT_TEXT], text, new_text_length, position);
1115   gtk_signal_emit (GTK_OBJECT (editable), signals[CHANGED]);
1116
1117   if (new_text_length > 63)
1118     g_free (text);
1119
1120   g_object_unref (G_OBJECT (editable));
1121 }
1122
1123 static void
1124 gtk_entry_delete_text (GtkEditable *editable,
1125                        gint         start_pos,
1126                        gint         end_pos)
1127 {
1128   GtkEntry *entry = GTK_ENTRY (editable);
1129
1130   if (end_pos < 0 || end_pos > entry->text_length)
1131     end_pos = entry->text_length;
1132   if (start_pos < 0)
1133     start_pos = 0;
1134   if (start_pos > end_pos)
1135     start_pos = end_pos;
1136
1137   g_object_ref (G_OBJECT (editable));
1138
1139   gtk_signal_emit (GTK_OBJECT (editable), signals[DELETE_TEXT], start_pos, end_pos);
1140   gtk_signal_emit (GTK_OBJECT (editable), signals[CHANGED]);
1141
1142   g_object_unref (G_OBJECT (editable));
1143 }
1144
1145 static gchar *
1146 gtk_entry_get_chars      (GtkEditable   *editable,
1147                           gint           start_pos,
1148                           gint           end_pos)
1149 {
1150   GtkEntry *entry;
1151   gint start_index, end_index;
1152
1153   g_return_val_if_fail (editable != NULL, NULL);
1154   g_return_val_if_fail (GTK_IS_ENTRY (editable), NULL);
1155
1156   entry = GTK_ENTRY (editable);
1157
1158   if (end_pos < 0)
1159     end_pos = entry->text_length;
1160
1161   start_pos = MIN (entry->text_length, start_pos);
1162   end_pos = MIN (entry->text_length, end_pos);
1163
1164   start_index = g_utf8_offset_to_pointer (entry->text, start_pos) - entry->text;
1165   end_index = g_utf8_offset_to_pointer (entry->text, end_pos) - entry->text;
1166
1167   return g_strndup (entry->text + start_index, end_index - start_index);
1168 }
1169
1170 static void
1171 gtk_entry_real_set_position (GtkEditable *editable,
1172                              gint         position)
1173 {
1174   GtkEntry *entry = GTK_ENTRY (editable);
1175
1176   if (position < 0 || position > entry->text_length)
1177     position = entry->text_length;
1178
1179   if (position != entry->current_pos)
1180     {
1181       gtk_entry_reset_im_context (entry);
1182
1183       entry->current_pos = entry->selection_bound = position;
1184       gtk_entry_recompute (entry);
1185     }
1186 }
1187
1188 static gint
1189 gtk_entry_get_position (GtkEditable *editable)
1190 {
1191   return GTK_ENTRY (editable)->current_pos;
1192 }
1193
1194 static void
1195 gtk_entry_set_selection_bounds (GtkEditable *editable,
1196                                 gint         start,
1197                                 gint         end)
1198 {
1199   GtkEntry *entry = GTK_ENTRY (editable);
1200
1201   if (start < 0)
1202     start = entry->text_length;
1203   if (end < 0)
1204     end = entry->text_length;
1205
1206   gtk_entry_reset_im_context (entry);
1207
1208   entry->selection_bound = MIN (start, entry->text_length);
1209   entry->current_pos = MIN (end, entry->text_length);
1210
1211   gtk_entry_update_primary_selection (entry);
1212
1213   gtk_entry_recompute (entry);
1214 }
1215
1216 static gboolean
1217 gtk_entry_get_selection_bounds (GtkEditable *editable,
1218                                 gint        *start,
1219                                 gint        *end)
1220 {
1221   GtkEntry *entry = GTK_ENTRY (editable);
1222
1223   *start = entry->selection_bound;
1224   *end = entry->current_pos;
1225
1226   return (entry->selection_bound != entry->current_pos);
1227 }
1228
1229 static void
1230 gtk_entry_style_set     (GtkWidget      *widget,
1231                          GtkStyle       *previous_style)
1232 {
1233   GtkEntry *entry = GTK_ENTRY (widget);
1234
1235   if (previous_style && GTK_WIDGET_REALIZED (widget))
1236     {
1237       gtk_entry_recompute (entry);
1238
1239       gdk_window_set_background (widget->window, &widget->style->base[GTK_WIDGET_STATE (widget)]);
1240       gdk_window_set_background (entry->text_area, &widget->style->base[GTK_WIDGET_STATE (widget)]);
1241     }
1242 }
1243
1244 /* Default signal handlers
1245  */
1246 static void
1247 gtk_entry_real_insert_text (GtkEntry    *entry,
1248                             const gchar *new_text,
1249                             gint         new_text_length,
1250                             gint        *position)
1251 {
1252   gint index;
1253   gint n_chars;
1254
1255   if (new_text_length < 0)
1256     new_text_length = strlen (new_text);
1257
1258   n_chars = g_utf8_strlen (new_text, new_text_length);
1259   if (entry->text_max_length > 0 && n_chars + entry->text_length > entry->text_max_length)
1260     {
1261       gdk_beep ();
1262       n_chars = entry->text_max_length - entry->text_length;
1263     }
1264
1265   if (new_text_length + entry->n_bytes + 1 > entry->text_size)
1266     {
1267       while (new_text_length + entry->n_bytes + 1 > entry->text_size)
1268         {
1269           if (entry->text_size == 0)
1270             entry->text_size = MIN_SIZE;
1271           else
1272             {
1273               if (2 * (guint)entry->text_size < MAX_SIZE &&
1274                   2 * (guint)entry->text_size > entry->text_size)
1275                 entry->text_size *= 2;
1276               else
1277                 {
1278                   entry->text_size = MAX_SIZE;
1279                   new_text_length = entry->text_size - new_text_length - 1;
1280                   break;
1281                 }
1282             }
1283         }
1284
1285       entry->text = g_realloc (entry->text, entry->text_size);
1286     }
1287
1288   index = g_utf8_offset_to_pointer (entry->text, *position) - entry->text;
1289
1290   g_memmove (entry->text + index + new_text_length, entry->text + index, entry->n_bytes - index);
1291   memcpy (entry->text + index, new_text, new_text_length);
1292
1293   entry->n_bytes += new_text_length;
1294   entry->text_length += n_chars;
1295
1296   /* NUL terminate for safety and convenience */
1297   entry->text[entry->n_bytes] = '\0';
1298
1299   if (entry->current_pos > *position)
1300     entry->current_pos += n_chars;
1301
1302   if (entry->selection_bound > *position)
1303     entry->selection_bound += n_chars;
1304
1305   *position += n_chars;
1306
1307   gtk_entry_recompute (entry);
1308 }
1309
1310 static void
1311 gtk_entry_real_delete_text (GtkEntry *entry,
1312                             gint      start_pos,
1313                             gint      end_pos)
1314 {
1315   if (start_pos < 0)
1316     start_pos = 0;
1317   if (end_pos < 0 || end_pos > entry->text_length)
1318     end_pos = entry->text_length;
1319
1320   if (start_pos < end_pos)
1321     {
1322       gint start_index = g_utf8_offset_to_pointer (entry->text, start_pos) - entry->text;
1323       gint end_index = g_utf8_offset_to_pointer (entry->text, end_pos) - entry->text;
1324
1325       g_memmove (entry->text + start_index, entry->text + end_index, entry->n_bytes - end_index);
1326       entry->text_length -= (end_pos - start_pos);
1327       entry->n_bytes -= (end_index - start_index);
1328
1329       if (entry->current_pos > start_pos)
1330         entry->current_pos -= MIN (entry->current_pos, end_pos) - start_pos;
1331
1332       if (entry->selection_bound > start_pos)
1333         entry->selection_bound -= MIN (entry->selection_bound, end_pos) - start_pos;
1334     }
1335
1336   /* We might have deleted the selection
1337    */
1338   gtk_entry_update_primary_selection (entry);
1339
1340   gtk_entry_recompute (entry);
1341 }
1342
1343
1344 static void
1345 gtk_entry_move_cursor (GtkEntry       *entry,
1346                        GtkMovementStep step,
1347                        gint            count,
1348                        gboolean        extend_selection)
1349 {
1350   gint new_pos = entry->current_pos;
1351
1352   gtk_entry_reset_im_context (entry);
1353
1354   switch (step)
1355     {
1356     case GTK_MOVEMENT_LOGICAL_POSITIONS:
1357       new_pos = CLAMP (new_pos + count, 0, entry->text_length);
1358       break;
1359     case GTK_MOVEMENT_VISUAL_POSITIONS:
1360       new_pos = gtk_entry_move_visually (entry, new_pos, count);
1361       break;
1362     case GTK_MOVEMENT_WORDS:
1363       while (count > 0)
1364         {
1365           new_pos = gtk_entry_move_forward_word (entry, new_pos);
1366           count--;
1367         }
1368       while (count < 0)
1369         {
1370           new_pos = gtk_entry_move_backward_word (entry, new_pos);
1371           count++;
1372         }
1373       break;
1374     case GTK_MOVEMENT_DISPLAY_LINE_ENDS:
1375     case GTK_MOVEMENT_PARAGRAPH_ENDS:
1376     case GTK_MOVEMENT_BUFFER_ENDS:
1377       new_pos = count < 0 ? 0 : entry->text_length;
1378       break;
1379     case GTK_MOVEMENT_DISPLAY_LINES:
1380     case GTK_MOVEMENT_PARAGRAPHS:
1381     case GTK_MOVEMENT_PAGES:
1382       break;
1383     }
1384
1385   if (extend_selection)
1386     gtk_editable_select_region (GTK_EDITABLE (entry), entry->selection_bound, new_pos);
1387   else
1388     gtk_editable_set_position (GTK_EDITABLE (entry), new_pos);
1389 }
1390
1391 static void
1392 gtk_entry_insert_at_cursor (GtkEntry    *entry,
1393                             const gchar *str)
1394 {
1395   GtkEditable *editable = GTK_EDITABLE (entry);
1396   gint pos = entry->current_pos;
1397
1398   gtk_entry_reset_im_context (entry);
1399
1400   gtk_editable_insert_text (editable, str, -1, &pos);
1401   gtk_editable_set_position (editable, pos);
1402 }
1403
1404 static void
1405 gtk_entry_delete_from_cursor (GtkEntry       *entry,
1406                               GtkDeleteType   type,
1407                               gint            count)
1408 {
1409   GtkEditable *editable = GTK_EDITABLE (entry);
1410   gint start_pos = entry->current_pos;
1411   gint end_pos = entry->current_pos;
1412
1413   gtk_entry_reset_im_context (entry);
1414
1415   if (!entry->editable)
1416     return;
1417
1418   if (entry->selection_bound != entry->current_pos)
1419     {
1420       gtk_editable_delete_selection (editable);
1421       return;
1422     }
1423
1424   switch (type)
1425     {
1426     case GTK_DELETE_CHARS:
1427       end_pos = entry->current_pos + count;
1428       gtk_editable_delete_text (editable, MIN (start_pos, end_pos), MAX (start_pos, end_pos));
1429       break;
1430     case GTK_DELETE_WORDS:
1431       if (count < 0)
1432         {
1433           /* Move to end of current word, or if not on a word, end of previous word */
1434           end_pos = gtk_entry_move_backward_word (entry, end_pos);
1435           end_pos = gtk_entry_move_forward_word (entry, end_pos);
1436         }
1437       else if (count > 0)
1438         {
1439           /* Move to beginning of current word, or if not on a word, begining of next word */
1440           start_pos = gtk_entry_move_forward_word (entry, start_pos);
1441           start_pos = gtk_entry_move_backward_word (entry, start_pos);
1442         }
1443
1444       /* Fall through */
1445     case GTK_DELETE_WORD_ENDS:
1446       while (count < 0)
1447         {
1448           start_pos = gtk_entry_move_backward_word (entry, start_pos);
1449           count++;
1450         }
1451       while (count > 0)
1452         {
1453           end_pos = gtk_entry_move_forward_word (entry, end_pos);
1454           count--;
1455         }
1456       gtk_editable_delete_text (editable, start_pos, end_pos);
1457       break;
1458     case GTK_DELETE_DISPLAY_LINE_ENDS:
1459     case GTK_DELETE_PARAGRAPH_ENDS:
1460       if (count < 0)
1461         gtk_editable_delete_text (editable, 0, entry->current_pos);
1462       else
1463         gtk_editable_delete_text (editable, entry->current_pos, -1);
1464       break;
1465     case GTK_DELETE_DISPLAY_LINES:
1466     case GTK_DELETE_PARAGRAPHS:
1467       gtk_editable_delete_text (editable, 0, -1);
1468       break;
1469     case GTK_DELETE_WHITESPACE:
1470       gtk_entry_delete_whitespace (entry);
1471       break;
1472     }
1473 }
1474
1475 static void
1476 gtk_entry_copy_clipboard (GtkEntry *entry)
1477 {
1478   GtkEditable *editable = GTK_EDITABLE (entry);
1479   gint start, end;
1480
1481   if (gtk_editable_get_selection_bounds (editable, &start, &end))
1482     {
1483       gchar *str = gtk_entry_get_public_chars (entry, start, end);
1484       gtk_clipboard_set_text (gtk_clipboard_get (GDK_NONE), str, -1);
1485       g_free (str);
1486     }
1487 }
1488
1489 static void
1490 gtk_entry_cut_clipboard (GtkEntry *entry)
1491 {
1492   GtkEditable *editable = GTK_EDITABLE (entry);
1493   gint start, end;
1494
1495   gtk_entry_copy_clipboard (entry);
1496   if (gtk_editable_get_selection_bounds (editable, &start, &end))
1497     gtk_editable_delete_text (editable, start, end);
1498 }
1499
1500 static void
1501 gtk_entry_paste_clipboard (GtkEntry *entry)
1502 {
1503   gtk_entry_paste (entry, GDK_NONE);
1504 }
1505
1506 static void
1507 gtk_entry_toggle_overwrite (GtkEntry *entry)
1508 {
1509   entry->overwrite_mode = !entry->overwrite_mode;
1510 }
1511
1512 /* IM Context Callbacks
1513  */
1514
1515 static void
1516 gtk_entry_commit_cb (GtkIMContext *context,
1517                      const gchar  *str,
1518                      GtkEntry     *entry)
1519 {
1520   GtkEditable *editable = GTK_EDITABLE (entry);
1521   gint tmp_pos = entry->current_pos;
1522
1523   gtk_editable_insert_text (editable, str, strlen (str), &tmp_pos);
1524   gtk_editable_set_position (editable, tmp_pos);
1525 }
1526
1527 static void
1528 gtk_entry_preedit_changed_cb (GtkIMContext *context,
1529                               GtkEntry     *entry)
1530 {
1531   gchar *preedit_string;
1532   gint cursor_pos;
1533
1534   gtk_im_context_get_preedit_string (entry->im_context,
1535                                      &preedit_string, NULL,
1536                                      &cursor_pos);
1537   entry->preedit_length = strlen (preedit_string);
1538   cursor_pos = CLAMP (cursor_pos, 0, g_utf8_strlen (preedit_string, -1));
1539   entry->preedit_cursor = cursor_pos;
1540   g_free (preedit_string);
1541
1542   gtk_entry_recompute (entry);
1543 }
1544
1545 /* Internal functions
1546  */
1547
1548 static void
1549 gtk_entry_reset_layout (GtkEntry *entry)
1550 {
1551   if (entry->cached_layout)
1552     {
1553       g_object_unref (G_OBJECT (entry->cached_layout));
1554       entry->cached_layout = NULL;
1555     }
1556 }
1557
1558 static gboolean
1559 recompute_idle_func (gpointer data)
1560 {
1561   GtkEntry *entry = GTK_ENTRY (data);
1562
1563   gtk_entry_adjust_scroll (entry);
1564   gtk_entry_queue_draw (entry);
1565
1566   entry->recompute_idle = FALSE;
1567
1568   return FALSE;
1569 }
1570
1571 static void
1572 gtk_entry_recompute (GtkEntry *entry)
1573 {
1574   gtk_entry_reset_layout (entry);
1575
1576   if (!entry->recompute_idle)
1577     {
1578       entry->recompute_idle = g_idle_add_full (G_PRIORITY_HIGH_IDLE + 15, /* between resize and redraw */
1579                                                recompute_idle_func, entry, NULL);
1580     }
1581 }
1582
1583 static void
1584 append_char (GString *str,
1585              gunichar ch,
1586              gint     count)
1587 {
1588   gint i;
1589   gint char_len;
1590   gchar buf[7];
1591
1592   char_len = g_unichar_to_utf8 (ch, buf);
1593
1594   i = 0;
1595   while (i < count)
1596     {
1597       g_string_append_len (str, buf, char_len);
1598       ++i;
1599     }
1600 }
1601
1602 static PangoLayout *
1603 gtk_entry_create_layout (GtkEntry *entry,
1604                          gboolean  include_preedit)
1605 {
1606   PangoLayout *layout = gtk_widget_create_pango_layout (GTK_WIDGET (entry), NULL);
1607   PangoAttrList *tmp_attrs = pango_attr_list_new ();
1608
1609   gchar *preedit_string = NULL;
1610   gint preedit_length = 0;
1611   PangoAttrList *preedit_attrs = NULL;
1612
1613   if (include_preedit)
1614     {
1615       gtk_im_context_get_preedit_string (entry->im_context,
1616                                          &preedit_string, &preedit_attrs, NULL);
1617       preedit_length = entry->preedit_length;
1618     }
1619
1620   if (preedit_length)
1621     {
1622       GString *tmp_string = g_string_new (NULL);
1623
1624       gint cursor_index = g_utf8_offset_to_pointer (entry->text, entry->current_pos) - entry->text;
1625
1626       if (entry->visible)
1627         {
1628           g_string_prepend_len (tmp_string, entry->text, entry->n_bytes);
1629           g_string_insert (tmp_string, cursor_index, preedit_string);
1630         }
1631       else
1632         {
1633           gint ch_len;
1634           gint preedit_len_chars;
1635           gunichar invisible_char;
1636
1637           ch_len = g_utf8_strlen (entry->text, entry->n_bytes);
1638           preedit_len_chars = g_utf8_strlen (preedit_string, -1);
1639           ch_len += preedit_len_chars;
1640
1641           if (entry->invisible_char != 0)
1642             invisible_char = entry->invisible_char;
1643           else
1644             invisible_char = ' '; /* just pick a char */
1645
1646           append_char (tmp_string, invisible_char, ch_len);
1647
1648           /* Fix cursor index to point to invisible char corresponding
1649            * to the preedit, fix preedit_length to be the length of
1650            * the invisible chars representing the preedit
1651            */
1652           cursor_index =
1653             g_utf8_offset_to_pointer (tmp_string->str, entry->current_pos) -
1654             tmp_string->str;
1655           preedit_length =
1656             preedit_len_chars *
1657             g_unichar_to_utf8 (invisible_char, NULL);
1658         }
1659
1660       pango_layout_set_text (layout, tmp_string->str, tmp_string->len);
1661
1662       pango_attr_list_splice (tmp_attrs, preedit_attrs,
1663                               cursor_index, preedit_length);
1664
1665       g_string_free (tmp_string, TRUE);
1666     }
1667   else
1668     {
1669       if (entry->visible)
1670         {
1671           pango_layout_set_text (layout, entry->text, entry->n_bytes);
1672         }
1673       else
1674         {
1675           GString *str = g_string_new (NULL);
1676           gunichar invisible_char;
1677
1678           if (entry->invisible_char != 0)
1679             invisible_char = entry->invisible_char;
1680           else
1681             invisible_char = ' '; /* just pick a char */
1682
1683           append_char (str, invisible_char, entry->text_length);
1684           pango_layout_set_text (layout, str->str, str->len);
1685           g_string_free (str, TRUE);
1686         }
1687     }
1688
1689   pango_layout_set_attributes (layout, tmp_attrs);
1690
1691   if (preedit_string)
1692     g_free (preedit_string);
1693   if (preedit_attrs)
1694     pango_attr_list_unref (preedit_attrs);
1695
1696   pango_attr_list_unref (tmp_attrs);
1697
1698   return layout;
1699 }
1700
1701 static PangoLayout *
1702 gtk_entry_get_layout (GtkEntry *entry,
1703                       gboolean  include_preedit)
1704 {
1705   if (entry->preedit_length > 0 &&
1706       !include_preedit != !entry->cache_includes_preedit)
1707     gtk_entry_reset_layout (entry);
1708
1709   if (!entry->cached_layout)
1710     {
1711       entry->cached_layout = gtk_entry_create_layout (entry, include_preedit);
1712       entry->cache_includes_preedit = include_preedit;
1713     }
1714
1715   g_object_ref (G_OBJECT (entry->cached_layout));
1716   return entry->cached_layout;
1717 }
1718
1719 static void
1720 gtk_entry_draw_text (GtkEntry *entry)
1721 {
1722   GtkWidget *widget;
1723   PangoLayoutLine *line;
1724
1725   g_return_if_fail (entry != NULL);
1726   g_return_if_fail (GTK_IS_ENTRY (entry));
1727
1728   if (!entry->visible && entry->invisible_char == 0)
1729     return;
1730
1731   if (GTK_WIDGET_DRAWABLE (entry))
1732     {
1733       PangoLayout *layout = gtk_entry_get_layout (entry, TRUE);
1734       PangoRectangle logical_rect;
1735       gint area_width, area_height;
1736       gint start_pos, end_pos;
1737       gint y_pos;
1738
1739       gdk_window_get_size (entry->text_area, &area_width, &area_height);
1740       area_height = PANGO_SCALE * (area_height - 2 * INNER_BORDER);
1741
1742       widget = GTK_WIDGET (entry);
1743
1744       gtk_paint_flat_box (widget->style, entry->text_area,
1745                           GTK_WIDGET_STATE(widget), GTK_SHADOW_NONE,
1746                           NULL, widget, "entry_bg",
1747                           0, 0, area_width, area_height);
1748
1749       line = pango_layout_get_lines (layout)->data;
1750       pango_layout_line_get_extents (line, NULL, &logical_rect);
1751
1752       /* Align primarily for locale's ascent/descent */
1753       y_pos = ((area_height - entry->ascent - entry->descent) / 2 +
1754                entry->ascent + logical_rect.y);
1755
1756       /* Now see if we need to adjust to fit in actual drawn string */
1757       if (logical_rect.height > area_height)
1758         y_pos = (area_height - logical_rect.height) / 2;
1759       else if (y_pos < 0)
1760         y_pos = 0;
1761       else if (y_pos + logical_rect.height > area_height)
1762         y_pos = area_height - logical_rect.height;
1763
1764       y_pos = INNER_BORDER + y_pos / PANGO_SCALE;
1765
1766       gdk_draw_layout (entry->text_area, widget->style->text_gc [widget->state],
1767                        INNER_BORDER - entry->scroll_offset, y_pos,
1768                        layout);
1769
1770       if (gtk_editable_get_selection_bounds (GTK_EDITABLE (entry), &start_pos, &end_pos))
1771         {
1772           gint *ranges;
1773           gint n_ranges, i;
1774           gint start_index = g_utf8_offset_to_pointer (entry->text, start_pos) - entry->text;
1775           gint end_index = g_utf8_offset_to_pointer (entry->text, end_pos) - entry->text;
1776           GdkRegion *clip_region = gdk_region_new ();
1777
1778           pango_layout_line_get_x_ranges (line, start_index, end_index, &ranges, &n_ranges);
1779
1780           for (i=0; i < n_ranges; i++)
1781             {
1782               GdkRectangle rect;
1783
1784               rect.x = INNER_BORDER - entry->scroll_offset + ranges[2*i] / PANGO_SCALE;
1785               rect.y = y_pos;
1786               rect.width = (ranges[2*i + 1] - ranges[2*i]) / PANGO_SCALE;
1787               rect.height = logical_rect.height / PANGO_SCALE;
1788
1789               gdk_draw_rectangle (entry->text_area, widget->style->bg_gc [GTK_STATE_SELECTED], TRUE,
1790                                   rect.x, rect.y, rect.width, rect.height);
1791
1792               gdk_region_union_with_rect (clip_region, &rect);
1793             }
1794
1795           gdk_gc_set_clip_region (widget->style->fg_gc [GTK_STATE_SELECTED], clip_region);
1796           gdk_draw_layout (entry->text_area, widget->style->fg_gc [GTK_STATE_SELECTED],
1797                            INNER_BORDER - entry->scroll_offset, y_pos,
1798                            layout);
1799           gdk_gc_set_clip_region (widget->style->fg_gc [GTK_STATE_SELECTED], NULL);
1800
1801           gdk_region_destroy (clip_region);
1802           g_free (ranges);
1803         }
1804
1805       g_object_unref (G_OBJECT (layout));
1806     }
1807 }
1808
1809 static void
1810 gtk_entry_draw_cursor (GtkEntry *entry)
1811 {
1812   g_return_if_fail (entry != NULL);
1813   g_return_if_fail (GTK_IS_ENTRY (entry));
1814
1815   if (!entry->visible && entry->invisible_char == 0)
1816     return;
1817
1818   if (GTK_WIDGET_DRAWABLE (entry))
1819     {
1820       GtkWidget *widget = GTK_WIDGET (entry);
1821
1822       if (GTK_WIDGET_HAS_FOCUS (widget) &&
1823           (entry->selection_bound == entry->current_pos))
1824         {
1825           gint xoffset = INNER_BORDER - entry->scroll_offset;
1826           gint strong_x, weak_x;
1827           gint text_area_height;
1828
1829           gdk_window_get_size (entry->text_area, NULL, &text_area_height);
1830
1831           gtk_entry_get_cursor_locations (entry, &strong_x, &weak_x);
1832
1833           gdk_draw_line (entry->text_area, widget->style->bg_gc[GTK_STATE_SELECTED],
1834                          xoffset + strong_x, INNER_BORDER,
1835                          xoffset + strong_x, text_area_height - INNER_BORDER);
1836
1837           if (weak_x != strong_x)
1838             gdk_draw_line (entry->text_area, widget->style->fg_gc[GTK_STATE_NORMAL],
1839                            xoffset + weak_x, INNER_BORDER,
1840                            xoffset + weak_x, text_area_height - INNER_BORDER);
1841
1842         }
1843     }
1844 }
1845
1846 static void
1847 gtk_entry_queue_draw (GtkEntry *entry)
1848 {
1849   g_return_if_fail (entry != NULL);
1850   g_return_if_fail (GTK_IS_ENTRY (entry));
1851
1852   if (GTK_WIDGET_REALIZED (entry))
1853     {
1854       GdkRectangle rect = { 0 };
1855
1856       gdk_window_get_size (entry->text_area, &rect.width, &rect.height);
1857       gdk_window_invalidate_rect (entry->text_area, &rect, FALSE);
1858     }
1859 }
1860
1861 static void
1862 gtk_entry_reset_im_context (GtkEntry *entry)
1863 {
1864   if (entry->need_im_reset)
1865     {
1866       entry->need_im_reset = 0;
1867       gtk_im_context_reset (entry->im_context);
1868     }
1869 }
1870
1871 static gint
1872 gtk_entry_find_position (GtkEntry *entry,
1873                          gint      x)
1874 {
1875   PangoLayout *layout;
1876   PangoLayoutLine *line;
1877   gint index;
1878   gint pos;
1879   gboolean trailing;
1880   gint cursor_index = g_utf8_offset_to_pointer (entry->text, entry->current_pos) - entry->text;
1881
1882   layout = gtk_entry_get_layout (entry, TRUE);
1883
1884   line = pango_layout_get_lines (layout)->data;
1885   pango_layout_line_x_to_index (line, x * PANGO_SCALE, &index, &trailing);
1886
1887   g_object_unref (G_OBJECT (layout));
1888
1889   if (index >= cursor_index && entry->preedit_length)
1890     {
1891       if (index >= cursor_index + entry->preedit_length)
1892         index -= entry->preedit_length;
1893       else
1894         {
1895           index = cursor_index;
1896           trailing = 0;
1897         }
1898     }
1899
1900   pos = g_utf8_pointer_to_offset (entry->text, entry->text + index);
1901
1902   if (trailing)
1903     pos += 1;
1904
1905   return pos;
1906 }
1907
1908 static void
1909 gtk_entry_get_cursor_locations (GtkEntry *entry,
1910                                 gint     *strong_x,
1911                                 gint     *weak_x)
1912 {
1913   PangoLayout *layout = gtk_entry_get_layout (entry, TRUE);
1914   const gchar *text;
1915   PangoRectangle strong_pos, weak_pos;
1916   gint index;
1917
1918   text = pango_layout_get_text (layout);
1919
1920   index =
1921     g_utf8_offset_to_pointer (text,
1922                               entry->current_pos +
1923                               entry->preedit_cursor) - text;
1924
1925   pango_layout_get_cursor_pos (layout, index, &strong_pos, &weak_pos);
1926   g_object_unref (G_OBJECT (layout));
1927
1928   if (strong_x)
1929     *strong_x = strong_pos.x / PANGO_SCALE;
1930
1931   if (weak_x)
1932     *weak_x = weak_pos.x / PANGO_SCALE;
1933 }
1934
1935 static void
1936 gtk_entry_adjust_scroll (GtkEntry *entry)
1937 {
1938   GtkWidget *widget;
1939   gint min_offset, max_offset;
1940   gint text_area_width;
1941   gint strong_x, weak_x;
1942   gint strong_xoffset, weak_xoffset;
1943   PangoLayout *layout;
1944   PangoLayoutLine *line;
1945   PangoRectangle logical_rect;
1946
1947   g_return_if_fail (entry != NULL);
1948   g_return_if_fail (GTK_IS_ENTRY (entry));
1949
1950   widget = GTK_WIDGET (entry);
1951
1952   if (!GTK_WIDGET_REALIZED (entry))
1953     return;
1954
1955   gdk_window_get_size (entry->text_area, &text_area_width, NULL);
1956   text_area_width -= 2 * INNER_BORDER;
1957
1958   layout = gtk_entry_get_layout (entry, TRUE);
1959   line = pango_layout_get_lines (layout)->data;
1960
1961   pango_layout_line_get_extents (line, NULL, &logical_rect);
1962   g_object_unref (G_OBJECT (layout));
1963
1964   /* Display as much text as we can */
1965
1966   if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_LTR)
1967     {
1968       min_offset = 0;
1969       max_offset = MAX (min_offset, logical_rect.width / PANGO_SCALE - text_area_width);
1970     }
1971   else
1972     {
1973       max_offset = logical_rect.width / PANGO_SCALE - text_area_width;
1974       min_offset = MIN (0, max_offset);
1975     }
1976
1977   entry->scroll_offset = CLAMP (entry->scroll_offset, min_offset, max_offset);
1978
1979   /* And make sure cursors are on screen. Note that the cursor is
1980    * actually drawn one pixel into the INNER_BORDER space on
1981    * the right, when the scroll is at the utmost right. This
1982    * looks better to to me than confining the cursor inside the
1983    * border entirely, though it means that the cursor gets one
1984    * pixel closer to the the edge of the widget on the right than
1985    * on the left. This might need changing if one changed
1986    * INNER_BORDER from 2 to 1, as one would do on a
1987    * small-screen-real-estate display.
1988    *
1989    * We always make sure that the strong cursor is on screen, and
1990    * put the weak cursor on screen if possible.
1991    */
1992
1993   gtk_entry_get_cursor_locations (entry, &strong_x, &weak_x);
1994
1995   strong_xoffset = strong_x - entry->scroll_offset;
1996
1997   if (strong_xoffset < 0)
1998     {
1999       entry->scroll_offset += strong_xoffset;
2000       strong_xoffset = 0;
2001     }
2002   else if (strong_xoffset > text_area_width)
2003     {
2004       entry->scroll_offset += strong_xoffset - text_area_width;
2005       strong_xoffset = text_area_width;
2006     }
2007
2008   weak_xoffset = weak_x - entry->scroll_offset;
2009
2010   if (weak_xoffset < 0 && strong_xoffset - weak_xoffset <= text_area_width)
2011     {
2012       entry->scroll_offset += weak_xoffset;
2013     }
2014   else if (weak_xoffset > text_area_width &&
2015            strong_xoffset - (weak_xoffset - text_area_width) >= 0)
2016     {
2017       entry->scroll_offset += weak_xoffset - text_area_width;
2018     }
2019 }
2020
2021 static gint
2022 gtk_entry_move_visually (GtkEntry *entry,
2023                          gint      start,
2024                          gint      count)
2025 {
2026   gint index;
2027   PangoLayout *layout = gtk_entry_get_layout (entry, FALSE);
2028   const gchar *text;
2029
2030   text = pango_layout_get_text (layout);
2031
2032   index = g_utf8_offset_to_pointer (text, start) - text;
2033
2034   while (count != 0)
2035     {
2036       int new_index, new_trailing;
2037
2038       if (count > 0)
2039         {
2040           pango_layout_move_cursor_visually (layout, index, 0, 1, &new_index, &new_trailing);
2041           count--;
2042         }
2043       else
2044         {
2045           pango_layout_move_cursor_visually (layout, index, 0, -1, &new_index, &new_trailing);
2046           count++;
2047         }
2048
2049       if (new_index < 0 || new_index == G_MAXINT)
2050         break;
2051
2052       if (new_trailing)
2053         index = g_utf8_next_char (entry->text + new_index) - entry->text;
2054       else
2055         index = new_index;
2056     }
2057
2058   g_object_unref (G_OBJECT (layout));
2059
2060   return g_utf8_pointer_to_offset (text, text + index);
2061 }
2062
2063 static gint
2064 gtk_entry_move_forward_word (GtkEntry *entry,
2065                              gint      start)
2066 {
2067   gint new_pos = start;
2068
2069   /* Prevent any leak of information */
2070   if (!entry->visible)
2071     {
2072       new_pos = entry->text_length;
2073     }
2074   else if (entry->text && (new_pos < entry->text_length))
2075     {
2076       PangoLayout *layout = gtk_entry_get_layout (entry, FALSE);
2077       PangoLogAttr *log_attrs;
2078       gint n_attrs;
2079
2080       pango_layout_get_log_attrs (layout, &log_attrs, &n_attrs);
2081
2082       /* Find the next word end */
2083       new_pos++;
2084       while (new_pos < n_attrs && !log_attrs[new_pos].is_word_end)
2085         new_pos++;
2086
2087       g_free (log_attrs);
2088       g_object_unref (G_OBJECT (layout));
2089     }
2090
2091   return new_pos;
2092 }
2093
2094
2095 static gint
2096 gtk_entry_move_backward_word (GtkEntry *entry,
2097                               gint      start)
2098 {
2099   gint new_pos = start;
2100
2101   /* Prevent any leak of information */
2102   if (!entry->visible)
2103     {
2104       new_pos = 0;
2105     }
2106   else if (entry->text && start > 0)
2107     {
2108       PangoLayout *layout = gtk_entry_get_layout (entry, FALSE);
2109       PangoLogAttr *log_attrs;
2110       gint n_attrs;
2111
2112       pango_layout_get_log_attrs (layout, &log_attrs, &n_attrs);
2113
2114       new_pos = start - 1;
2115
2116       /* Find the previous word beginning */
2117       while (new_pos > 0 && !log_attrs[new_pos].is_word_start)
2118         new_pos--;
2119
2120       g_free (log_attrs);
2121       g_object_unref (G_OBJECT (layout));
2122     }
2123
2124   return new_pos;
2125 }
2126
2127 static void
2128 gtk_entry_delete_whitespace (GtkEntry *entry)
2129 {
2130   PangoLayout *layout = gtk_entry_get_layout (entry, FALSE);
2131   PangoLogAttr *log_attrs;
2132   gint n_attrs;
2133   gint start, end;
2134
2135   pango_layout_get_log_attrs (layout, &log_attrs, &n_attrs);
2136
2137   start = end = entry->current_pos;
2138
2139   while (start > 0 && log_attrs[start-1].is_white)
2140     start--;
2141
2142   while (end < n_attrs && log_attrs[start-1].is_white)
2143     end++;
2144
2145   g_free (log_attrs);
2146   g_object_unref (G_OBJECT (layout));
2147
2148   if (start != end)
2149     gtk_editable_delete_text (GTK_EDITABLE (entry), start, end);
2150 }
2151
2152
2153 static void
2154 gtk_entry_select_word (GtkEntry *entry)
2155 {
2156   gint start_pos = gtk_entry_move_backward_word (entry, entry->current_pos);
2157   gint end_pos = gtk_entry_move_forward_word (entry, entry->current_pos);
2158
2159   gtk_editable_select_region (GTK_EDITABLE (entry), start_pos, end_pos);
2160 }
2161
2162 static void
2163 gtk_entry_select_line (GtkEntry *entry)
2164 {
2165   gtk_editable_select_region (GTK_EDITABLE (entry), 0, -1);
2166 }
2167
2168 /*
2169  * Like gtk_editable_get_chars, but if the editable is not
2170  * visible, return asterisks; also convert result to UTF-8.
2171  */
2172 static char *
2173 gtk_entry_get_public_chars (GtkEntry *entry,
2174                             gint      start,
2175                             gint      end)
2176 {
2177   if (end < 0)
2178     end = entry->text_length;
2179
2180   if (entry->visible)
2181     return gtk_editable_get_chars (GTK_EDITABLE (entry), start, end);
2182   else
2183     {
2184       gchar *str;
2185       gint i;
2186       gint n_chars = end - start;
2187
2188       str = g_malloc (n_chars + 1);
2189       for (i = 0; i < n_chars; i++)
2190         str[i] = '*';
2191       str[i] = '\0';
2192
2193       return str;
2194     }
2195
2196 }
2197
2198 static void
2199 paste_received (GtkClipboard *clipboard,
2200                 const gchar  *text,
2201                 gpointer      data)
2202 {
2203   GtkEntry *entry = GTK_ENTRY (data);
2204   GtkEditable *editable = GTK_EDITABLE (entry);
2205
2206   if (text)
2207     {
2208       gint pos = entry->current_pos;
2209
2210       gtk_editable_insert_text (editable, text, -1, &pos);
2211       gtk_editable_set_position (editable, pos);
2212     }
2213
2214   g_object_unref (G_OBJECT (entry));
2215 }
2216
2217 static void
2218 gtk_entry_paste (GtkEntry *entry,
2219                  GdkAtom   selection)
2220 {
2221   g_object_ref (G_OBJECT (entry));
2222   gtk_clipboard_request_text (gtk_clipboard_get (selection),
2223                               paste_received, entry);
2224 }
2225
2226 static void
2227 primary_get_cb (GtkClipboard     *clipboard,
2228                 GtkSelectionData *selection_data,
2229                 guint             info,
2230                 gpointer          data)
2231 {
2232   GtkEntry *entry = GTK_ENTRY (data);
2233   gint start, end;
2234
2235   if (gtk_editable_get_selection_bounds (GTK_EDITABLE (entry), &start, &end))
2236     {
2237       gchar *str = gtk_entry_get_public_chars (entry, start, end);
2238       gtk_selection_data_set_text (selection_data, str);
2239       g_free (str);
2240     }
2241 }
2242
2243 static void
2244 primary_clear_cb (GtkClipboard *clipboard,
2245                   gpointer      data)
2246 {
2247   GtkEntry *entry = GTK_ENTRY (data);
2248
2249   gtk_editable_select_region (GTK_EDITABLE (entry), entry->current_pos, entry->current_pos);
2250 }
2251
2252 static void
2253 gtk_entry_update_primary_selection (GtkEntry *entry)
2254 {
2255   static const GtkTargetEntry targets[] = {
2256     { "UTF8_STRING", 0, 0 },
2257     { "STRING", 0, 0 },
2258     { "TEXT",   0, 0 },
2259     { "COMPOUND_TEXT", 0, 0 }
2260   };
2261
2262   GtkClipboard *clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
2263   gint start, end;
2264
2265   if (gtk_editable_get_selection_bounds (GTK_EDITABLE (entry), &start, &end))
2266     {
2267       if (!gtk_clipboard_set_with_owner (clipboard, targets, G_N_ELEMENTS (targets),
2268                                          primary_get_cb, primary_clear_cb, G_OBJECT (entry)))
2269         primary_clear_cb (clipboard, entry);
2270     }
2271   else
2272     {
2273       if (gtk_clipboard_get_owner (clipboard) == G_OBJECT (entry))
2274         gtk_clipboard_clear (clipboard);
2275     }
2276 }
2277
2278 /* Public API
2279  */
2280
2281 GtkWidget*
2282 gtk_entry_new (void)
2283 {
2284   return GTK_WIDGET (gtk_type_new (GTK_TYPE_ENTRY));
2285 }
2286
2287 GtkWidget*
2288 gtk_entry_new_with_max_length (guint16 max)
2289 {
2290   GtkEntry *entry;
2291
2292   entry = gtk_type_new (GTK_TYPE_ENTRY);
2293   entry->text_max_length = max;
2294
2295   return GTK_WIDGET (entry);
2296 }
2297
2298 void
2299 gtk_entry_set_text (GtkEntry *entry,
2300                     const gchar *text)
2301 {
2302   gint tmp_pos;
2303
2304   GtkEditable *editable;
2305
2306   g_return_if_fail (entry != NULL);
2307   g_return_if_fail (GTK_IS_ENTRY (entry));
2308   g_return_if_fail (text != NULL);
2309
2310   editable = GTK_EDITABLE (entry);
2311
2312   gtk_editable_delete_text (GTK_EDITABLE(entry), 0, -1);
2313
2314   tmp_pos = 0;
2315   gtk_editable_insert_text (editable, text, strlen (text), &tmp_pos);
2316 }
2317
2318 void
2319 gtk_entry_append_text (GtkEntry *entry,
2320                        const gchar *text)
2321 {
2322   gint tmp_pos;
2323
2324   g_return_if_fail (entry != NULL);
2325   g_return_if_fail (GTK_IS_ENTRY (entry));
2326   g_return_if_fail (text != NULL);
2327
2328   tmp_pos = entry->text_length;
2329   gtk_editable_insert_text (GTK_EDITABLE(entry), text, -1, &tmp_pos);
2330 }
2331
2332 void
2333 gtk_entry_prepend_text (GtkEntry *entry,
2334                         const gchar *text)
2335 {
2336   gint tmp_pos;
2337
2338   g_return_if_fail (entry != NULL);
2339   g_return_if_fail (GTK_IS_ENTRY (entry));
2340   g_return_if_fail (text != NULL);
2341
2342   tmp_pos = 0;
2343   gtk_editable_insert_text (GTK_EDITABLE(entry), text, -1, &tmp_pos);
2344 }
2345
2346 void
2347 gtk_entry_set_position (GtkEntry *entry,
2348                         gint       position)
2349 {
2350   g_return_if_fail (entry != NULL);
2351   g_return_if_fail (GTK_IS_ENTRY (entry));
2352
2353   gtk_editable_set_position (GTK_EDITABLE (entry), position);
2354 }
2355
2356 void
2357 gtk_entry_set_visibility (GtkEntry *entry,
2358                           gboolean visible)
2359 {
2360   g_return_if_fail (entry != NULL);
2361   g_return_if_fail (GTK_IS_ENTRY (entry));
2362
2363   entry->visible = visible ? TRUE : FALSE;
2364
2365   gtk_entry_recompute (entry);
2366 }
2367
2368 void
2369 gtk_entry_set_invisible_char (GtkEntry *entry,
2370                               gunichar  ch)
2371 {
2372   g_return_if_fail (GTK_IS_ENTRY (entry));
2373
2374   if (ch == entry->invisible_char)
2375     return;
2376
2377   entry->invisible_char = ch;
2378
2379   gtk_entry_recompute (entry);
2380 }
2381
2382 void
2383 gtk_entry_set_editable(GtkEntry *entry,
2384                        gboolean  editable)
2385 {
2386   g_return_if_fail (entry != NULL);
2387   g_return_if_fail (GTK_IS_ENTRY (entry));
2388
2389   gtk_editable_set_editable (GTK_EDITABLE (entry), editable);
2390 }
2391
2392 gchar*
2393 gtk_entry_get_text (GtkEntry *entry)
2394 {
2395   g_return_val_if_fail (entry != NULL, NULL);
2396   g_return_val_if_fail (GTK_IS_ENTRY (entry), NULL);
2397
2398   return entry->text;
2399 }
2400
2401 void
2402 gtk_entry_select_region  (GtkEntry       *entry,
2403                           gint            start,
2404                           gint            end)
2405 {
2406   gtk_editable_select_region (GTK_EDITABLE (entry), start, end);
2407 }
2408
2409 void
2410 gtk_entry_set_max_length (GtkEntry     *entry,
2411                           guint16       max)
2412 {
2413   g_return_if_fail (entry != NULL);
2414   g_return_if_fail (GTK_IS_ENTRY (entry));
2415
2416   if (max && entry->text_length > max)
2417     gtk_editable_delete_text (GTK_EDITABLE(entry), max, -1);
2418
2419   entry->text_max_length = max;
2420 }
2421
2422 /* Quick hack of a popup menu
2423  */
2424 static void
2425 activate_cb (GtkWidget *menuitem,
2426              GtkEntry  *entry)
2427 {
2428   const gchar *signal = gtk_object_get_data (GTK_OBJECT (menuitem), "gtk-signal");
2429   gtk_signal_emit_by_name (GTK_OBJECT (entry), signal);
2430 }
2431
2432 static void
2433 append_action_signal (GtkEntry     *entry,
2434                       GtkWidget    *menu,
2435                       const gchar  *label,
2436                       const gchar  *signal)
2437 {
2438   GtkWidget *menuitem = gtk_menu_item_new_with_label (label);
2439
2440   gtk_object_set_data (GTK_OBJECT (menuitem), "gtk-signal", (char *)signal);
2441   gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
2442                       activate_cb, entry);
2443
2444   gtk_widget_show (menuitem);
2445   gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
2446 }
2447
2448 static void
2449 popup_menu_detach (GtkWidget *attach_widget,
2450                    GtkMenu   *menu)
2451 {
2452   GTK_ENTRY (attach_widget)->popup_menu = NULL;
2453 }
2454
2455 static void
2456 gtk_entry_popup_menu (GtkEntry       *entry,
2457                       GdkEventButton *event)
2458 {
2459   if (!entry->popup_menu)
2460     {
2461       GtkWidget *menuitem;
2462
2463       entry->popup_menu = gtk_menu_new ();
2464
2465       gtk_menu_attach_to_widget (GTK_MENU (entry->popup_menu),
2466                                  GTK_WIDGET (entry),
2467                                  popup_menu_detach);
2468
2469       append_action_signal (entry, entry->popup_menu, _("Cut"), "cut_clipboard");
2470       append_action_signal (entry, entry->popup_menu, _("Copy"), "copy_clipboard");
2471       append_action_signal (entry, entry->popup_menu, _("Paste"), "paste_clipboard");
2472
2473       menuitem = gtk_menu_item_new (); /* Separator */
2474       gtk_widget_show (menuitem);
2475       gtk_menu_shell_append (GTK_MENU_SHELL (entry->popup_menu), menuitem);
2476
2477       gtk_im_multicontext_append_menuitems (GTK_IM_MULTICONTEXT (entry->im_context),
2478                                             GTK_MENU_SHELL (entry->popup_menu));
2479     }
2480
2481   gtk_menu_popup (GTK_MENU (entry->popup_menu), NULL, NULL,
2482                   NULL, NULL,
2483                   event->button, event->time);
2484 }