/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

/* GTK - The GIMP Toolkit

 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald

 * Copyright (C) 2004-2006 Christian Hammond

 * Copyright (C) 2008 Cody Russell

 * Copyright (C) 2008 Red Hat, Inc.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 */

/*

 * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS

 * file for a list of people on the GTK+ Team.  See the ChangeLog

 * files for a list of changes.  These files are distributed with

 * GTK+ at ftp://ftp.gtk.org/pub/gtk/.

 */

#include "config.h"

#include <math.h>

#include <string.h>

#include "gdk/gdkkeysyms.h"

#include "gtkalignment.h"

#include "gtkbindings.h"

#include "gtkcelleditable.h"

#include "gtkclipboard.h"

#include "gtkdnd.h"

#include "gtkentry.h"

#include "gtkentrybuffer.h"

#include "gtkimagemenuitem.h"

#include "gtkimcontextsimple.h"

#include "gtkimmulticontext.h"

#include "gtkintl.h"

#include "gtklabel.h"

#include "gtkmain.h"

#include "gtkmarshalers.h"

#include "gtkmenu.h"

#include "gtkmenuitem.h"

#include "gtkseparatormenuitem.h"

#include "gtkselection.h"

#include "gtksettings.h"

#include "gtkspinbutton.h"

#include "gtkstock.h"

#include "gtktextutil.h"

#include "gtkwindow.h"

#include "gtktreeview.h"

#include "gtktreeselection.h"

#include "gtkprivate.h"

#include "gtkentryprivate.h"

#include "gtkcelllayout.h"

#include "gtktooltip.h"

#include "gtkiconfactory.h"

#include "gtkicontheme.h"

#include "gtkalias.h"

#define GTK_ENTRY_COMPLETION_KEY "gtk-entry-completion-key"

#define MIN_ENTRY_WIDTH  150

#define DRAW_TIMEOUT     20

#define COMPLETION_TIMEOUT 300

#define PASSWORD_HINT_MAX 8

#define MAX_ICONS 2

#define IS_VALID_ICON_POSITION(pos)               \

  ((pos) == GTK_ENTRY_ICON_PRIMARY ||                   \

   (pos) == GTK_ENTRY_ICON_SECONDARY)

static const GtkBorder default_inner_border = { 2, 2, 2, 2 };

static GQuark          quark_inner_border   = 0;

static GQuark          quark_password_hint  = 0;

static GQuark          quark_cursor_hadjustment = 0;

static GQuark          quark_capslock_feedback = 0;

typedef struct _GtkEntryPrivate GtkEntryPrivate;

#define GTK_ENTRY_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_ENTRY, GtkEntryPrivate))

typedef struct

{

  GdkWindow *window;

  gchar *tooltip;

  guint insensitive    : 1;

  guint nonactivatable : 1;

  guint prelight       : 1;

  guint in_drag        : 1;

  guint pressed        : 1;

  GtkImageType  storage_type;

  GdkPixbuf    *pixbuf;

  gchar        *stock_id;

  gchar        *icon_name;

  GIcon        *gicon;

  GtkTargetList *target_list;

  GdkDragAction actions;

} EntryIconInfo;

struct _GtkEntryPrivate 

{

  GtkEntryBuffer* buffer;

  gfloat xalign;

  gint insert_pos;

  guint blink_time;  /* time in msec the cursor has blinked since last user event */

  guint interior_focus          : 1;

  guint real_changed            : 1;

  guint invisible_char_set      : 1;

  guint caps_lock_warning       : 1;

  guint caps_lock_warning_shown : 1;

  guint change_count            : 8;

  guint progress_pulse_mode     : 1;

  guint progress_pulse_way_back : 1;

  gint focus_width;

  GtkShadowType shadow_type;

  gdouble progress_fraction;

  gdouble progress_pulse_fraction;

  gdouble progress_pulse_current;

  EntryIconInfo *icons[MAX_ICONS];

  gint icon_margin;

  gint start_x;

  gint start_y;

  gchar *im_module;

};

typedef struct _GtkEntryPasswordHint GtkEntryPasswordHint;

struct _GtkEntryPasswordHint

{

  gint position;      /* Position (in text) of the last password hint */

  guint source_id;    /* Timeout source id */

};

typedef struct _GtkEntryCapslockFeedback GtkEntryCapslockFeedback;

struct _GtkEntryCapslockFeedback

{

  GtkWidget *entry;

  GtkWidget *window;

  GtkWidget *label;

};

enum {

  ACTIVATE,

  POPULATE_POPUP,

  MOVE_CURSOR,

  INSERT_AT_CURSOR,

  DELETE_FROM_CURSOR,

  BACKSPACE,

  CUT_CLIPBOARD,

  COPY_CLIPBOARD,

  PASTE_CLIPBOARD,

  TOGGLE_OVERWRITE,

  ICON_PRESS,

  ICON_RELEASE,

  PREEDIT_CHANGED,

  LAST_SIGNAL

};

enum {

  PROP_0,

  PROP_BUFFER,

  PROP_CURSOR_POSITION,

  PROP_SELECTION_BOUND,

  PROP_EDITABLE,

  PROP_MAX_LENGTH,

  PROP_VISIBILITY,

  PROP_HAS_FRAME,

  PROP_INNER_BORDER,

  PROP_INVISIBLE_CHAR,

  PROP_ACTIVATES_DEFAULT,

  PROP_WIDTH_CHARS,

  PROP_SCROLL_OFFSET,

  PROP_TEXT,

  PROP_XALIGN,

  PROP_TRUNCATE_MULTILINE,

  PROP_SHADOW_TYPE,

  PROP_OVERWRITE_MODE,

  PROP_TEXT_LENGTH,

  PROP_INVISIBLE_CHAR_SET,

  PROP_CAPS_LOCK_WARNING,

  PROP_PROGRESS_FRACTION,

  PROP_PROGRESS_PULSE_STEP,

  PROP_PIXBUF_PRIMARY,

  PROP_PIXBUF_SECONDARY,

  PROP_STOCK_PRIMARY,

  PROP_STOCK_SECONDARY,

  PROP_ICON_NAME_PRIMARY,

  PROP_ICON_NAME_SECONDARY,

  PROP_GICON_PRIMARY,

  PROP_GICON_SECONDARY,

  PROP_STORAGE_TYPE_PRIMARY,

  PROP_STORAGE_TYPE_SECONDARY,

  PROP_ACTIVATABLE_PRIMARY,

  PROP_ACTIVATABLE_SECONDARY,

  PROP_SENSITIVE_PRIMARY,

  PROP_SENSITIVE_SECONDARY,

  PROP_TOOLTIP_TEXT_PRIMARY,

  PROP_TOOLTIP_TEXT_SECONDARY,

  PROP_TOOLTIP_MARKUP_PRIMARY,

  PROP_TOOLTIP_MARKUP_SECONDARY,

  PROP_IM_MODULE,

  PROP_EDITING_CANCELED

};

static guint signals[LAST_SIGNAL] = { 0 };

typedef enum {

  CURSOR_STANDARD,

  CURSOR_DND

} CursorType;

typedef enum

{

  DISPLAY_NORMAL,       /* The entry text is being shown */

  DISPLAY_INVISIBLE,    /* In invisible mode, text replaced by (eg) bullets */

  DISPLAY_BLANK         /* In invisible mode, nothing shown at all */

} DisplayMode;

/* GObject, GtkObject methods

 */

static void   gtk_entry_editable_init        (GtkEditableClass     *iface);

static void   gtk_entry_cell_editable_init   (GtkCellEditableIface *iface);

static void   gtk_entry_set_property         (GObject          *object,

                                              guint             prop_id,

                                              const GValue     *value,

                                              GParamSpec       *pspec);

static void   gtk_entry_get_property         (GObject          *object,

                                              guint             prop_id,

                                              GValue           *value,

                                              GParamSpec       *pspec);

static void   gtk_entry_finalize             (GObject          *object);

static void   gtk_entry_destroy              (GtkObject        *object);

static void   gtk_entry_dispose              (GObject          *object);

/* GtkWidget methods

 */

static void   gtk_entry_realize              (GtkWidget        *widget);

static void   gtk_entry_unrealize            (GtkWidget        *widget);

static void   gtk_entry_map                  (GtkWidget        *widget);

static void   gtk_entry_unmap                (GtkWidget        *widget);

static void   gtk_entry_size_request         (GtkWidget        *widget,

					      GtkRequisition   *requisition);

static void   gtk_entry_size_allocate        (GtkWidget        *widget,

					      GtkAllocation    *allocation);

static void   gtk_entry_draw_frame           (GtkWidget        *widget,

                                              GdkEventExpose   *event);

static void   gtk_entry_draw_progress        (GtkWidget        *widget,

                                              GdkEventExpose   *event);

static gint   gtk_entry_expose               (GtkWidget        *widget,

					      GdkEventExpose   *event);

static gint   gtk_entry_button_press         (GtkWidget        *widget,

					      GdkEventButton   *event);

static gint   gtk_entry_button_release       (GtkWidget        *widget,

					      GdkEventButton   *event);

static gint   gtk_entry_enter_notify         (GtkWidget        *widget,

                                              GdkEventCrossing *event);

static gint   gtk_entry_leave_notify         (GtkWidget        *widget,

                                              GdkEventCrossing *event);

static gint   gtk_entry_motion_notify        (GtkWidget        *widget,

					      GdkEventMotion   *event);

static gint   gtk_entry_key_press            (GtkWidget        *widget,

					      GdkEventKey      *event);

static gint   gtk_entry_key_release          (GtkWidget        *widget,

					      GdkEventKey      *event);

static gint   gtk_entry_focus_in             (GtkWidget        *widget,

					      GdkEventFocus    *event);

static gint   gtk_entry_focus_out            (GtkWidget        *widget,

					      GdkEventFocus    *event);

static void   gtk_entry_grab_focus           (GtkWidget        *widget);

static void   gtk_entry_style_set            (GtkWidget        *widget,

					      GtkStyle         *previous_style);

static gboolean gtk_entry_query_tooltip      (GtkWidget        *widget,

                                              gint              x,

                                              gint              y,

                                              gboolean          keyboard_tip,

                                              GtkTooltip       *tooltip);

static void   gtk_entry_direction_changed    (GtkWidget        *widget,

					      GtkTextDirection  previous_dir);

static void   gtk_entry_state_changed        (GtkWidget        *widget,

					      GtkStateType      previous_state);

static void   gtk_entry_screen_changed       (GtkWidget        *widget,

					      GdkScreen        *old_screen);

static gboolean gtk_entry_drag_drop          (GtkWidget        *widget,

                                              GdkDragContext   *context,

                                              gint              x,

                                              gint              y,

                                              guint             time);

static gboolean gtk_entry_drag_motion        (GtkWidget        *widget,

					      GdkDragContext   *context,

					      gint              x,

					      gint              y,

					      guint             time);

static void     gtk_entry_drag_leave         (GtkWidget        *widget,

					      GdkDragContext   *context,

					      guint             time);

static void     gtk_entry_drag_data_received (GtkWidget        *widget,

					      GdkDragContext   *context,

					      gint              x,

					      gint              y,

					      GtkSelectionData *selection_data,

					      guint             info,

					      guint             time);

static void     gtk_entry_drag_data_get      (GtkWidget        *widget,

					      GdkDragContext   *context,

					      GtkSelectionData *selection_data,

					      guint             info,

					      guint             time);

static void     gtk_entry_drag_data_delete   (GtkWidget        *widget,

					      GdkDragContext   *context);

static void     gtk_entry_drag_begin         (GtkWidget        *widget,

                                              GdkDragContext   *context);

static void     gtk_entry_drag_end           (GtkWidget        *widget,

                                              GdkDragContext   *context);

/* GtkEditable method implementations

 */

static void     gtk_entry_insert_text          (GtkEditable *editable,

						const gchar *new_text,

						gint         new_text_length,

						gint        *position);

static void     gtk_entry_delete_text          (GtkEditable *editable,

						gint         start_pos,

						gint         end_pos);

static gchar *  gtk_entry_get_chars            (GtkEditable *editable,

						gint         start_pos,

						gint         end_pos);

static void     gtk_entry_real_set_position    (GtkEditable *editable,

						gint         position);

static gint     gtk_entry_get_position         (GtkEditable *editable);

static void     gtk_entry_set_selection_bounds (GtkEditable *editable,

						gint         start,

						gint         end);

static gboolean gtk_entry_get_selection_bounds (GtkEditable *editable,

						gint        *start,

						gint        *end);

/* GtkCellEditable method implementations

 */

static void gtk_entry_start_editing (GtkCellEditable *cell_editable,

				     GdkEvent        *event);

/* Default signal handlers

 */

static void gtk_entry_real_insert_text   (GtkEditable     *editable,

					  const gchar     *new_text,

					  gint             new_text_length,

					  gint            *position);

static void gtk_entry_real_delete_text   (GtkEditable     *editable,

					  gint             start_pos,

					  gint             end_pos);

static void gtk_entry_move_cursor        (GtkEntry        *entry,

					  GtkMovementStep  step,

					  gint             count,

					  gboolean         extend_selection);

static void gtk_entry_insert_at_cursor   (GtkEntry        *entry,

					  const gchar     *str);

static void gtk_entry_delete_from_cursor (GtkEntry        *entry,

					  GtkDeleteType    type,

					  gint             count);

static void gtk_entry_backspace          (GtkEntry        *entry);

static void gtk_entry_cut_clipboard      (GtkEntry        *entry);

static void gtk_entry_copy_clipboard     (GtkEntry        *entry);

static void gtk_entry_paste_clipboard    (GtkEntry        *entry);

static void gtk_entry_toggle_overwrite   (GtkEntry        *entry);

static void gtk_entry_select_all         (GtkEntry        *entry);

static void gtk_entry_real_activate      (GtkEntry        *entry);

static gboolean gtk_entry_popup_menu     (GtkWidget       *widget);

static void keymap_direction_changed     (GdkKeymap       *keymap,

					  GtkEntry        *entry);

static void keymap_state_changed         (GdkKeymap       *keymap,

					  GtkEntry        *entry);

static void remove_capslock_feedback     (GtkEntry        *entry);

/* IM Context Callbacks

 */

static void     gtk_entry_commit_cb               (GtkIMContext *context,

						   const gchar  *str,

						   GtkEntry     *entry);

static void     gtk_entry_preedit_changed_cb      (GtkIMContext *context,

						   GtkEntry     *entry);

static gboolean gtk_entry_retrieve_surrounding_cb (GtkIMContext *context,

						   GtkEntry     *entry);

static gboolean gtk_entry_delete_surrounding_cb   (GtkIMContext *context,

						   gint          offset,

						   gint          n_chars,

						   GtkEntry     *entry);

/* Internal routines

 */

static void         gtk_entry_enter_text               (GtkEntry       *entry,

                                                        const gchar    *str);

static void         gtk_entry_set_positions            (GtkEntry       *entry,

							gint            current_pos,

							gint            selection_bound);

static void         gtk_entry_draw_text                (GtkEntry       *entry);

static void         gtk_entry_draw_cursor              (GtkEntry       *entry,

							CursorType      type);

static PangoLayout *gtk_entry_ensure_layout            (GtkEntry       *entry,

                                                        gboolean        include_preedit);

static void         gtk_entry_reset_layout             (GtkEntry       *entry);

static void         gtk_entry_queue_draw               (GtkEntry       *entry);

static void         gtk_entry_recompute                (GtkEntry       *entry);

static gint         gtk_entry_find_position            (GtkEntry       *entry,

							gint            x);

static void         gtk_entry_get_cursor_locations     (GtkEntry       *entry,

							CursorType      type,

							gint           *strong_x,

							gint           *weak_x);

static void         gtk_entry_adjust_scroll            (GtkEntry       *entry);

static gint         gtk_entry_move_visually            (GtkEntry       *editable,

							gint            start,

							gint            count);

static gint         gtk_entry_move_logically           (GtkEntry       *entry,

							gint            start,

							gint            count);

static gint         gtk_entry_move_forward_word        (GtkEntry       *entry,

							gint            start,

                                                        gboolean        allow_whitespace);

static gint         gtk_entry_move_backward_word       (GtkEntry       *entry,

							gint            start,

                                                        gboolean        allow_whitespace);

static void         gtk_entry_delete_whitespace        (GtkEntry       *entry);

static void         gtk_entry_select_word              (GtkEntry       *entry);

static void         gtk_entry_select_line              (GtkEntry       *entry);

static void         gtk_entry_paste                    (GtkEntry       *entry,

							GdkAtom         selection);

static void         gtk_entry_update_primary_selection (GtkEntry       *entry);

static void         gtk_entry_do_popup                 (GtkEntry       *entry,

							GdkEventButton *event);

static gboolean     gtk_entry_mnemonic_activate        (GtkWidget      *widget,

							gboolean        group_cycling);

static void         gtk_entry_check_cursor_blink       (GtkEntry       *entry);

static void         gtk_entry_pend_cursor_blink        (GtkEntry       *entry);

static void         gtk_entry_reset_blink_time         (GtkEntry       *entry);

static void         gtk_entry_get_text_area_size       (GtkEntry       *entry,

							gint           *x,

							gint           *y,

							gint           *width,

							gint           *height);

static void         get_text_area_size                 (GtkEntry       *entry,

							gint           *x,

							gint           *y,

							gint           *width,

							gint           *height);

static void         get_widget_window_size             (GtkEntry       *entry,

							gint           *x,

							gint           *y,

							gint           *width,

							gint           *height);

static void         gtk_entry_move_adjustments         (GtkEntry             *entry);

static void         gtk_entry_ensure_pixbuf            (GtkEntry             *entry,

                                                        GtkEntryIconPosition  icon_pos);

/* Completion */

static gint         gtk_entry_completion_timeout       (gpointer            data);

static gboolean     gtk_entry_completion_key_press     (GtkWidget          *widget,

							GdkEventKey        *event,

							gpointer            user_data);

static void         gtk_entry_completion_changed       (GtkWidget          *entry,

							gpointer            user_data);

static gboolean     check_completion_callback          (GtkEntryCompletion *completion);

static void         clear_completion_callback          (GtkEntry           *entry,

							GParamSpec         *pspec);

static gboolean     accept_completion_callback         (GtkEntry           *entry);

static void         completion_insert_text_callback    (GtkEntry           *entry,

							const gchar        *text,

							gint                length,

							gint                position,

							GtkEntryCompletion *completion);

static void         disconnect_completion_signals      (GtkEntry           *entry,

							GtkEntryCompletion *completion);

static void         connect_completion_signals         (GtkEntry           *entry,

							GtkEntryCompletion *completion);

static void         begin_change                       (GtkEntry *entry);

static void         end_change                         (GtkEntry *entry);

static void         emit_changed                       (GtkEntry *entry);

static void         buffer_inserted_text               (GtkEntryBuffer *buffer, 

                                                        guint           position,

                                                        const gchar    *chars,

                                                        guint           n_chars,

                                                        GtkEntry       *entry);

static void         buffer_deleted_text                (GtkEntryBuffer *buffer, 

                                                        guint           position,

                                                        guint           n_chars,

                                                        GtkEntry       *entry);

static void         buffer_notify_text                 (GtkEntryBuffer *buffer, 

                                                        GParamSpec     *spec,

                                                        GtkEntry       *entry);

static void         buffer_notify_length               (GtkEntryBuffer *buffer, 

                                                        GParamSpec     *spec,

                                                        GtkEntry       *entry);

static void         buffer_notify_max_length           (GtkEntryBuffer *buffer, 

                                                        GParamSpec     *spec,

                                                        GtkEntry       *entry);

static void         buffer_connect_signals             (GtkEntry       *entry);

static void         buffer_disconnect_signals          (GtkEntry       *entry);

static GtkEntryBuffer *get_buffer                      (GtkEntry       *entry);

G_DEFINE_TYPE_WITH_CODE (GtkEntry, gtk_entry, GTK_TYPE_WIDGET,

                         G_IMPLEMENT_INTERFACE (GTK_TYPE_EDITABLE,

                                                gtk_entry_editable_init)

                         G_IMPLEMENT_INTERFACE (GTK_TYPE_CELL_EDITABLE,

                                                gtk_entry_cell_editable_init))

static void

add_move_binding (GtkBindingSet  *binding_set,

		  guint           keyval,

		  guint           modmask,

		  GtkMovementStep step,

		  gint            count)

{

  g_return_if_fail ((modmask & GDK_SHIFT_MASK) == 0);

  gtk_binding_entry_add_signal (binding_set, keyval, modmask,

				"move-cursor", 3,

				G_TYPE_ENUM, step,

				G_TYPE_INT, count,

				G_TYPE_BOOLEAN, FALSE);

  /* Selection-extending version */

  gtk_binding_entry_add_signal (binding_set, keyval, modmask | GDK_SHIFT_MASK,

				"move-cursor", 3,

				G_TYPE_ENUM, step,

				G_TYPE_INT, count,

				G_TYPE_BOOLEAN, TRUE);

}

static void

gtk_entry_class_init (GtkEntryClass *class)

{

  GObjectClass *gobject_class = G_OBJECT_CLASS (class);

  GtkWidgetClass *widget_class;

  GtkObjectClass *gtk_object_class;

  GtkBindingSet *binding_set;

  widget_class = (GtkWidgetClass*) class;

  gtk_object_class = (GtkObjectClass *)class;

  gobject_class->dispose = gtk_entry_dispose;

  gobject_class->finalize = gtk_entry_finalize;

  gobject_class->set_property = gtk_entry_set_property;

  gobject_class->get_property = gtk_entry_get_property;

  widget_class->map = gtk_entry_map;

  widget_class->unmap = gtk_entry_unmap;

  widget_class->realize = gtk_entry_realize;

  widget_class->unrealize = gtk_entry_unrealize;

  widget_class->size_request = gtk_entry_size_request;

  widget_class->size_allocate = gtk_entry_size_allocate;

  widget_class->expose_event = gtk_entry_expose;

  widget_class->enter_notify_event = gtk_entry_enter_notify;

  widget_class->leave_notify_event = gtk_entry_leave_notify;

  widget_class->button_press_event = gtk_entry_button_press;

  widget_class->button_release_event = gtk_entry_button_release;

  widget_class->motion_notify_event = gtk_entry_motion_notify;

  widget_class->key_press_event = gtk_entry_key_press;

  widget_class->key_release_event = gtk_entry_key_release;

  widget_class->focus_in_event = gtk_entry_focus_in;

  widget_class->focus_out_event = gtk_entry_focus_out;

  widget_class->grab_focus = gtk_entry_grab_focus;

  widget_class->style_set = gtk_entry_style_set;

  widget_class->query_tooltip = gtk_entry_query_tooltip;

  widget_class->drag_begin = gtk_entry_drag_begin;

  widget_class->drag_end = gtk_entry_drag_end;

  widget_class->direction_changed = gtk_entry_direction_changed;

  widget_class->state_changed = gtk_entry_state_changed;

  widget_class->screen_changed = gtk_entry_screen_changed;

  widget_class->mnemonic_activate = gtk_entry_mnemonic_activate;

  widget_class->drag_drop = gtk_entry_drag_drop;

  widget_class->drag_motion = gtk_entry_drag_motion;

  widget_class->drag_leave = gtk_entry_drag_leave;

  widget_class->drag_data_received = gtk_entry_drag_data_received;

  widget_class->drag_data_get = gtk_entry_drag_data_get;

  widget_class->drag_data_delete = gtk_entry_drag_data_delete;

  widget_class->popup_menu = gtk_entry_popup_menu;

  gtk_object_class->destroy = gtk_entry_destroy;

  class->move_cursor = gtk_entry_move_cursor;

  class->insert_at_cursor = gtk_entry_insert_at_cursor;

  class->delete_from_cursor = gtk_entry_delete_from_cursor;

  class->backspace = gtk_entry_backspace;

  class->cut_clipboard = gtk_entry_cut_clipboard;

  class->copy_clipboard = gtk_entry_copy_clipboard;

  class->paste_clipboard = gtk_entry_paste_clipboard;

  class->toggle_overwrite = gtk_entry_toggle_overwrite;

  class->activate = gtk_entry_real_activate;

  class->get_text_area_size = gtk_entry_get_text_area_size;

  quark_inner_border = g_quark_from_static_string ("gtk-entry-inner-border");

  quark_password_hint = g_quark_from_static_string ("gtk-entry-password-hint");

  quark_cursor_hadjustment = g_quark_from_static_string ("gtk-hadjustment");

  quark_capslock_feedback = g_quark_from_static_string ("gtk-entry-capslock-feedback");

  g_object_class_override_property (gobject_class,

                                    PROP_EDITING_CANCELED,

                                    "editing-canceled");

  g_object_class_install_property (gobject_class,

                                   PROP_BUFFER,

                                   g_param_spec_object ("buffer",

                                                        P_("Text Buffer"),

                                                        P_("Text buffer object which actually stores entry text"),

                                                        GTK_TYPE_ENTRY_BUFFER,

                                                        GTK_PARAM_READWRITE | G_PARAM_CONSTRUCT));

  g_object_class_install_property (gobject_class,

                                   PROP_CURSOR_POSITION,

                                   g_param_spec_int ("cursor-position",

                                                     P_("Cursor Position"),

                                                     P_("The current position of the insertion cursor in chars"),

                                                     0,

                                                     GTK_ENTRY_BUFFER_MAX_SIZE,

                                                     0,

                                                     GTK_PARAM_READABLE));

  g_object_class_install_property (gobject_class,

                                   PROP_SELECTION_BOUND,

                                   g_param_spec_int ("selection-bound",

                                                     P_("Selection Bound"),

                                                     P_("The position of the opposite end of the selection from the cursor in chars"),

                                                     0,

                                                     GTK_ENTRY_BUFFER_MAX_SIZE,

                                                     0,

                                                     GTK_PARAM_READABLE));

  g_object_class_install_property (gobject_class,

                                   PROP_EDITABLE,

                                   g_param_spec_boolean ("editable",

							 P_("Editable"),

							 P_("Whether the entry contents can be edited"),

                                                         TRUE,

							 GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

                                   PROP_MAX_LENGTH,

                                   g_param_spec_int ("max-length",

                                                     P_("Maximum length"),

                                                     P_("Maximum number of characters for this entry. Zero if no maximum"),

                                                     0,

                                                     GTK_ENTRY_BUFFER_MAX_SIZE,

                                                     0,

                                                     GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

                                   PROP_VISIBILITY,

                                   g_param_spec_boolean ("visibility",

							 P_("Visibility"),

							 P_("FALSE displays the \"invisible char\" instead of the actual text (password mode)"),

                                                         TRUE,

							 GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

                                   PROP_HAS_FRAME,

                                   g_param_spec_boolean ("has-frame",

							 P_("Has Frame"),

							 P_("FALSE removes outside bevel from entry"),

                                                         TRUE,

							 GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

                                   PROP_INNER_BORDER,

                                   g_param_spec_boxed ("inner-border",

                                                       P_("Inner Border"),

                                                       P_("Border between text and frame. Overrides the inner-border style property"),

                                                       GTK_TYPE_BORDER,

                                                       GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

                                   PROP_INVISIBLE_CHAR,

                                   g_param_spec_unichar ("invisible-char",

							 P_("Invisible character"),

							 P_("The character to use when masking entry contents (in \"password mode\")"),

							 '*',

							 GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

                                   PROP_ACTIVATES_DEFAULT,

                                   g_param_spec_boolean ("activates-default",

							 P_("Activates default"),

							 P_("Whether to activate the default widget (such as the default button in a dialog) when Enter is pressed"),

                                                         FALSE,

							 GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

                                   PROP_WIDTH_CHARS,

                                   g_param_spec_int ("width-chars",

                                                     P_("Width in chars"),

                                                     P_("Number of characters to leave space for in the entry"),

                                                     -1,

                                                     G_MAXINT,

                                                     -1,

                                                     GTK_PARAM_READWRITE));

  g_object_class_install_property (gobject_class,

                                   PROP_SCROLL_OFFSET,

                                   g_param_spec_int ("scroll-offset",

                                                     P_("Scroll offset"),

                                                     P_("Number of pixels of the entry scrolled off the screen to the left"),

                                                     0,

                                                     G_MAXINT,

                                                     0,

                                                     GTK_PARAM_READABLE));

  g_object_class_install_property (gobject_class,

                                   PROP_TEXT,

                                   g_param_spec_string ("text",

							P_("Text"),

							P_("The contents of the entry"),

							"",

							GTK_PARAM_READWRITE));

  /**

   * GtkEntry:xalign:

   *

   * The horizontal alignment, from 0 (left) to 1 (right). 

   * Reversed for RTL layouts.

   * 

   * Since: 2.4

   */

  g_object_class_install_property (gobject_class,

                                   PROP_XALIGN,

                                   g_param_spec_float ("xalign",

						       P_("X align"),

						       P_("The horizontal alignment, from 0 (left) to 1 (right). Reversed for RTL layouts."),

						       0.0,

						       1.0,

						       0.0,

						       GTK_PARAM_READWRITE));

  /**

   * GtkEntry:truncate-multiline:

   *

   * When %TRUE, pasted multi-line text is truncated to the first line.

   *

   * Since: 2.10

   */

  g_object_class_install_property (gobject_class,

                                   PROP_TRUNCATE_MULTILINE,

                                   g_param_spec_boolean ("truncate-multiline",

                                                         P_("Truncate multiline"),

                                                         P_("Whether to truncate multiline pastes to one line."),

                                                         FALSE,

                                                         GTK_PARAM_READWRITE));

  /**

   * GtkEntry:shadow-type:

   *

   * Which kind of shadow to draw around the entry when 

   * #GtkEntry:has-frame is set to %TRUE.

   *

   * Since: 2.12

   */

  g_object_class_install_property (gobject_class,

                                   PROP_SHADOW_TYPE,

                                   g_param_spec_enum ("shadow-type",

                                                      P_("Shadow type"),

                                                      P_("Which kind of shadow to draw around the entry when has-frame is set"),

                                                      GTK_TYPE_SHADOW_TYPE,

                                                      GTK_SHADOW_IN,

                                                      GTK_PARAM_READWRITE));

  /**

   * GtkEntry:overwrite-mode:

   *

   * If text is overwritten when typing in the #GtkEntry.

   *

   * Since: 2.14

   */

  g_object_class_install_property (gobject_class,

                                   PROP_OVERWRITE_MODE,

                                   g_param_spec_boolean ("overwrite-mode",

                                                         P_("Overwrite mode"),

                                                         P_("Whether new text overwrites existing text"),

                                                         FALSE,

                                                         GTK_PARAM_READWRITE));

  /**

   * GtkEntry:text-length:

   *

   * The length of the text in the #GtkEntry.

   *

   * Since: 2.14

   */

  g_object_class_install_property (gobject_class,

                                   PROP_TEXT_LENGTH,

                                   g_param_spec_uint ("text-length",

                                                      P_("Text length"),

                                                      P_("Length of the text currently in the entry"),

                                                      0, 

                                                      G_MAXUINT16,

                                                      0,

                                                      GTK_PARAM_READABLE));

  /**

   * GtkEntry:invisible-char-set:

   *

   * Whether the invisible char has been set for the #GtkEntry.

   *

   * Since: 2.16

   */

  g_object_class_install_property (gobject_class,

                                   PROP_INVISIBLE_CHAR_SET,

                                   g_param_spec_boolean ("invisible-char-set",

                                                         P_("Invisible char set"),

                                                         P_("Whether the invisible char has been set"),

                                                         FALSE,

                                                         GTK_PARAM_READWRITE));

  /**

   * GtkEntry:caps-lock-warning

   *

   * Whether password entries will show a warning when Caps Lock is on.

   *

   * Note that the warning is shown using a secondary icon, and thus

   * does not work if you are using the secondary icon position for some 

   * other purpose.

   *

   * Since: 2.16

   */

  g_object_class_install_property (gobject_class,

                                   PROP_CAPS_LOCK_WARNING,

                                   g_param_spec_boolean ("caps-lock-warning",

                                                         P_("Caps Lock warning"),

                                                         P_("Whether password entries will show a warning when Caps Lock is on"),

                                                         TRUE,

                                                         GTK_PARAM_READWRITE));

  /**

   * GtkEntry:progress-fraction:

   *

   * The current fraction of the task that's been completed.

   *

   * Since: 2.16

   */

  g_object_class_install_property (gobject_class,

                                   PROP_PROGRESS_FRACTION,

                                   g_param_spec_double ("progress-fraction",

                                                        P_("Progress Fraction"),

                                                        P_("The current fraction of the task that's been completed"),

                                                        0.0,

                                                        1.0,

                                                        0.0,

                                                        GTK_PARAM_READWRITE));

  /**

   * GtkEntry:progress-pulse-step:

   *

   * The fraction of total entry width to move the progress

   * bouncing block for each call to gtk_entry_progress_pulse().

   *

   * Since: 2.16

   */

  g_object_class_install_property (gobject_class,