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