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