X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Fgtktextview.c;h=50efb41bdb4989514a7128532b75cac743662eb4;hb=2f49fbd6cd8749aa6c13370cc6fa83aaae958018;hp=771bdcb42c9327936c0cae8c4c3fc2f3f61b2cc7;hpb=049771c5f6eb927d5a65b4461bdd8e3b29aff163;p=~andy%2Fgtk diff --git a/gtk/gtktextview.c b/gtk/gtktextview.c index 771bdcb42..50efb41bd 100644 --- a/gtk/gtktextview.c +++ b/gtk/gtktextview.c @@ -24,6 +24,7 @@ * GTK+ at ftp://ftp.gtk.org/pub/gtk/. */ +#include #include #define GTK_TEXT_USE_INTERNAL_UNSUPPORTED_API @@ -37,16 +38,15 @@ #include "gtkmenuitem.h" #include "gtkseparatormenuitem.h" #include "gtksettings.h" -#include "gtksignal.h" #include "gtkstock.h" #include "gtktextdisplay.h" #include "gtktextview.h" #include "gtkimmulticontext.h" #include "gdk/gdkkeysyms.h" +#include "gtkprivate.h" #include "gtksizegroup.h" /* FIXME http://bugzilla.gnome.org/show_bug.cgi?id=72258 */ #include "gtktextutil.h" #include "gtkwindow.h" -#include /* How scrolling, validation, exposes, etc. work. * @@ -96,6 +96,8 @@ #define SCREEN_WIDTH(widget) text_window_get_width (GTK_TEXT_VIEW (widget)->text_window) #define SCREEN_HEIGHT(widget) text_window_get_height (GTK_TEXT_VIEW (widget)->text_window) +#define SPACE_FOR_CURSOR 1 + struct _GtkTextPendingScroll { GtkTextMark *mark; @@ -119,6 +121,8 @@ enum PASTE_CLIPBOARD, TOGGLE_OVERWRITE, MOVE_FOCUS, + MOVE_VIEWPORT, + SELECT_ALL, LAST_SIGNAL }; @@ -136,6 +140,9 @@ enum PROP_INDENT, PROP_TABS, PROP_CURSOR_VISIBLE, + PROP_BUFFER, + PROP_OVERWRITE, + PROP_ACCEPTS_TAB, LAST_PROP }; @@ -161,6 +168,11 @@ static void gtk_text_view_style_set (GtkWidget *widget, GtkStyle *previous_style); static void gtk_text_view_direction_changed (GtkWidget *widget, GtkTextDirection previous_direction); +static void gtk_text_view_grab_notify (GtkWidget *widget, + gboolean was_grabbed); +static void gtk_text_view_state_changed (GtkWidget *widget, + GtkStateType previous_state); + static gint gtk_text_view_event (GtkWidget *widget, GdkEvent *event); static gint gtk_text_view_key_press_event (GtkWidget *widget, @@ -180,9 +192,10 @@ static gint gtk_text_view_motion_event (GtkWidget *widget, static gint gtk_text_view_expose_event (GtkWidget *widget, GdkEventExpose *expose); static void gtk_text_view_draw_focus (GtkWidget *widget); -static void gtk_text_view_grab_focus (GtkWidget *widget); static gboolean gtk_text_view_focus (GtkWidget *widget, GtkDirectionType direction); +static void gtk_text_view_select_all (GtkWidget *widget, + gboolean select); /* Source side drag signals */ @@ -232,11 +245,16 @@ static void gtk_text_view_move_cursor (GtkTextView *text_view, static void gtk_text_view_page_horizontally (GtkTextView *text_view, gint count, gboolean extend_selection); +static void gtk_text_view_move_viewport (GtkTextView *text_view, + GtkScrollStep step, + gint count); static void gtk_text_view_set_anchor (GtkTextView *text_view); static void gtk_text_view_scroll_pages (GtkTextView *text_view, - gint count); + gint count, + gboolean extend_selection); static void gtk_text_view_scroll_hpages (GtkTextView *text_view, - gint count); + gint count, + gboolean extend_selection); static void gtk_text_view_insert_at_cursor (GtkTextView *text_view, const gchar *str); static void gtk_text_view_delete_from_cursor (GtkTextView *text_view, @@ -293,6 +311,8 @@ static void gtk_text_view_mark_set_handler (GtkTextBuffer *buffer, const GtkTextIter *location, GtkTextMark *mark, gpointer data); +static void gtk_text_view_get_cursor_location (GtkTextView *text_view, + GdkRectangle *pos); static void gtk_text_view_get_virtual_cursor_pos (GtkTextView *text_view, gint *x, gint *y); @@ -327,7 +347,7 @@ static void gtk_text_view_remove (GtkContainer *container, GtkWidget *child); static void gtk_text_view_forall (GtkContainer *container, gboolean include_internals, - GtkCallback callback, + GtkCallback callback, gpointer callback_data); /* FIXME probably need the focus methods. */ @@ -388,8 +408,6 @@ static void text_window_invalidate_rect (GtkTextWindow *win, static gint text_window_get_width (GtkTextWindow *win); static gint text_window_get_height (GtkTextWindow *win); -static void text_window_get_allocation (GtkTextWindow *win, - GdkRectangle *rect); enum @@ -401,7 +419,7 @@ enum TARGET_TEXT_BUFFER_CONTENTS }; -static GtkTargetEntry target_table[] = { +static const GtkTargetEntry target_table[] = { { "GTK_TEXT_BUFFER_CONTENTS", GTK_TARGET_SAME_APP, TARGET_TEXT_BUFFER_CONTENTS }, { "UTF8_STRING", 0, TARGET_UTF8_STRING }, @@ -413,26 +431,28 @@ static GtkTargetEntry target_table[] = { static GtkContainerClass *parent_class = NULL; static guint signals[LAST_SIGNAL] = { 0 }; -GtkType +GType gtk_text_view_get_type (void) { - static GtkType our_type = 0; + static GType our_type = 0; if (our_type == 0) { - static const GtkTypeInfo our_info = + static const GTypeInfo our_info = { - "GtkTextView", - sizeof (GtkTextView), - sizeof (GtkTextViewClass), - (GtkClassInitFunc) gtk_text_view_class_init, - (GtkObjectInitFunc) gtk_text_view_init, - /* reserved_1 */ NULL, - /* reserved_2 */ NULL, - (GtkClassInitFunc) NULL + sizeof (GtkTextViewClass), + NULL, /* base_init */ + NULL, /* base_finalize */ + (GClassInitFunc) gtk_text_view_class_init, + NULL, /* class_finalize */ + NULL, /* class_data */ + sizeof (GtkTextView), + 0, /* n_preallocs */ + (GInstanceInitFunc) gtk_text_view_init, }; - our_type = gtk_type_unique (GTK_TYPE_CONTAINER, &our_info); + our_type = g_type_register_static (GTK_TYPE_CONTAINER, "GtkTextView", + &our_info, 0); } return our_type; @@ -449,16 +469,16 @@ add_move_binding (GtkBindingSet *binding_set, gtk_binding_entry_add_signal (binding_set, keyval, modmask, "move_cursor", 3, - GTK_TYPE_ENUM, step, - GTK_TYPE_INT, count, - GTK_TYPE_BOOL, FALSE); + 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, - GTK_TYPE_ENUM, step, - GTK_TYPE_INT, count, - GTK_TYPE_BOOL, TRUE); + G_TYPE_ENUM, step, + G_TYPE_INT, count, + G_TYPE_BOOLEAN, TRUE); } static void @@ -470,7 +490,7 @@ gtk_text_view_class_init (GtkTextViewClass *klass) GtkContainerClass *container_class = GTK_CONTAINER_CLASS (klass); GtkBindingSet *binding_set; - parent_class = gtk_type_class (GTK_TYPE_CONTAINER); + parent_class = g_type_class_peek_parent (klass); /* Default handlers and virtual methods */ @@ -484,6 +504,8 @@ gtk_text_view_class_init (GtkTextViewClass *klass) widget_class->unrealize = gtk_text_view_unrealize; widget_class->style_set = gtk_text_view_style_set; widget_class->direction_changed = gtk_text_view_direction_changed; + widget_class->grab_notify = gtk_text_view_grab_notify; + widget_class->state_changed = gtk_text_view_state_changed; widget_class->size_request = gtk_text_view_size_request; widget_class->size_allocate = gtk_text_view_size_allocate; widget_class->event = gtk_text_view_event; @@ -495,7 +517,6 @@ gtk_text_view_class_init (GtkTextViewClass *klass) widget_class->focus_out_event = gtk_text_view_focus_out_event; widget_class->motion_notify_event = gtk_text_view_motion_event; widget_class->expose_event = gtk_text_view_expose_event; - widget_class->grab_focus = gtk_text_view_grab_focus; widget_class->focus = gtk_text_view_focus; widget_class->drag_begin = gtk_text_view_drag_begin; @@ -533,8 +554,8 @@ gtk_text_view_class_init (GtkTextViewClass *klass) g_object_class_install_property (gobject_class, PROP_PIXELS_ABOVE_LINES, g_param_spec_int ("pixels_above_lines", - _("Pixels Above Lines"), - _("Pixels of blank space above paragraphs"), + P_("Pixels Above Lines"), + P_("Pixels of blank space above paragraphs"), 0, G_MAXINT, 0, @@ -543,8 +564,8 @@ gtk_text_view_class_init (GtkTextViewClass *klass) g_object_class_install_property (gobject_class, PROP_PIXELS_BELOW_LINES, g_param_spec_int ("pixels_below_lines", - _("Pixels Below Lines"), - _("Pixels of blank space below paragraphs"), + P_("Pixels Below Lines"), + P_("Pixels of blank space below paragraphs"), 0, G_MAXINT, 0, @@ -553,8 +574,8 @@ gtk_text_view_class_init (GtkTextViewClass *klass) g_object_class_install_property (gobject_class, PROP_PIXELS_INSIDE_WRAP, g_param_spec_int ("pixels_inside_wrap", - _("Pixels Inside Wrap"), - _("Pixels of blank space between wrapped lines in a paragraph"), + P_("Pixels Inside Wrap"), + P_("Pixels of blank space between wrapped lines in a paragraph"), 0, G_MAXINT, 0, @@ -563,16 +584,16 @@ gtk_text_view_class_init (GtkTextViewClass *klass) g_object_class_install_property (gobject_class, PROP_EDITABLE, g_param_spec_boolean ("editable", - _("Editable"), - _("Whether the text can be modified by the user"), + P_("Editable"), + P_("Whether the text can be modified by the user"), TRUE, G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, PROP_WRAP_MODE, g_param_spec_enum ("wrap_mode", - _("Wrap Mode"), - _("Whether to wrap lines never, at word boundaries, or at character boundaries"), + P_("Wrap Mode"), + P_("Whether to wrap lines never, at word boundaries, or at character boundaries"), GTK_TYPE_WRAP_MODE, GTK_WRAP_NONE, G_PARAM_READWRITE)); @@ -580,8 +601,8 @@ gtk_text_view_class_init (GtkTextViewClass *klass) g_object_class_install_property (gobject_class, PROP_JUSTIFICATION, g_param_spec_enum ("justification", - _("Justification"), - _("Left, right, or center justification"), + P_("Justification"), + P_("Left, right, or center justification"), GTK_TYPE_JUSTIFICATION, GTK_JUSTIFY_LEFT, G_PARAM_READWRITE)); @@ -589,8 +610,8 @@ gtk_text_view_class_init (GtkTextViewClass *klass) g_object_class_install_property (gobject_class, PROP_LEFT_MARGIN, g_param_spec_int ("left_margin", - _("Left Margin"), - _("Width of the left margin in pixels"), + P_("Left Margin"), + P_("Width of the left margin in pixels"), 0, G_MAXINT, 0, @@ -599,8 +620,8 @@ gtk_text_view_class_init (GtkTextViewClass *klass) g_object_class_install_property (gobject_class, PROP_RIGHT_MARGIN, g_param_spec_int ("right_margin", - _("Right Margin"), - _("Width of the right margin in pixels"), + P_("Right Margin"), + P_("Width of the right margin in pixels"), 0, G_MAXINT, 0, @@ -609,8 +630,8 @@ gtk_text_view_class_init (GtkTextViewClass *klass) g_object_class_install_property (gobject_class, PROP_INDENT, g_param_spec_int ("indent", - _("Indent"), - _("Amount to indent the paragraph, in pixels"), + P_("Indent"), + P_("Amount to indent the paragraph, in pixels"), 0, G_MAXINT, 0, @@ -619,120 +640,199 @@ gtk_text_view_class_init (GtkTextViewClass *klass) g_object_class_install_property (gobject_class, PROP_TABS, g_param_spec_boxed ("tabs", - _("Tabs"), - _("Custom tabs for this text"), + P_("Tabs"), + P_("Custom tabs for this text"), PANGO_TYPE_TAB_ARRAY, G_PARAM_READWRITE)); g_object_class_install_property (gobject_class, PROP_CURSOR_VISIBLE, g_param_spec_boolean ("cursor_visible", - _("Cursor Visible"), - _("If the insertion cursor is shown"), + P_("Cursor Visible"), + P_("If the insertion cursor is shown"), + TRUE, + G_PARAM_READWRITE)); + + g_object_class_install_property (gobject_class, + PROP_BUFFER, + g_param_spec_object ("buffer", + P_("Buffer"), + P_("The buffer which is displayed"), + GTK_TYPE_TEXT_BUFFER, + G_PARAM_READWRITE)); + + g_object_class_install_property (gobject_class, + PROP_OVERWRITE, + g_param_spec_boolean ("overwrite", + P_("Overwrite mode"), + P_("Whether entered text overwrites existing contents"), + FALSE, + G_PARAM_READWRITE)); + + g_object_class_install_property (gobject_class, + PROP_ACCEPTS_TAB, + g_param_spec_boolean ("accepts_tab", + P_("Accepts tab"), + P_("Whether Tab will result in a tab character being entered"), TRUE, G_PARAM_READWRITE)); + /* + * Style properties + */ + gtk_widget_class_install_style_property (widget_class, + g_param_spec_boxed ("error-underline-color", + P_("Error underline color"), + P_("Color with which to draw error-indication underlines"), + GDK_TYPE_COLOR, + G_PARAM_READABLE)); /* * Signals */ signals[MOVE_CURSOR] = - gtk_signal_new ("move_cursor", - GTK_RUN_LAST | GTK_RUN_ACTION, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkTextViewClass, move_cursor), - _gtk_marshal_VOID__ENUM_INT_BOOLEAN, - GTK_TYPE_NONE, 3, GTK_TYPE_MOVEMENT_STEP, GTK_TYPE_INT, GTK_TYPE_BOOL); + g_signal_new ("move_cursor", + G_OBJECT_CLASS_TYPE (gobject_class), + G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, + G_STRUCT_OFFSET (GtkTextViewClass, move_cursor), + NULL, NULL, + _gtk_marshal_VOID__ENUM_INT_BOOLEAN, + G_TYPE_NONE, 3, + GTK_TYPE_MOVEMENT_STEP, + G_TYPE_INT, + G_TYPE_BOOLEAN); signals[PAGE_HORIZONTALLY] = - gtk_signal_new ("page_horizontally", - GTK_RUN_LAST | GTK_RUN_ACTION, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkTextViewClass, page_horizontally), - _gtk_marshal_VOID__INT_BOOLEAN, - GTK_TYPE_NONE, 2, GTK_TYPE_INT, GTK_TYPE_BOOL); - + g_signal_new ("page_horizontally", + G_OBJECT_CLASS_TYPE (gobject_class), + G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, + G_STRUCT_OFFSET (GtkTextViewClass, page_horizontally), + NULL, NULL, + _gtk_marshal_VOID__INT_BOOLEAN, + G_TYPE_NONE, 2, + G_TYPE_INT, + G_TYPE_BOOLEAN); + + signals[MOVE_VIEWPORT] = + _gtk_binding_signal_new ("move_viewport", + G_OBJECT_CLASS_TYPE (gobject_class), + G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, + G_CALLBACK (gtk_text_view_move_viewport), + NULL, NULL, + _gtk_marshal_VOID__ENUM_INT, + G_TYPE_NONE, 2, + GTK_TYPE_SCROLL_STEP, + G_TYPE_INT); + signals[SET_ANCHOR] = - gtk_signal_new ("set_anchor", - GTK_RUN_LAST | GTK_RUN_ACTION, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkTextViewClass, set_anchor), - _gtk_marshal_VOID__VOID, - GTK_TYPE_NONE, 0); + g_signal_new ("set_anchor", + G_OBJECT_CLASS_TYPE (gobject_class), + G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, + G_STRUCT_OFFSET (GtkTextViewClass, set_anchor), + NULL, NULL, + _gtk_marshal_VOID__VOID, + G_TYPE_NONE, 0); signals[INSERT_AT_CURSOR] = - gtk_signal_new ("insert_at_cursor", - GTK_RUN_LAST | GTK_RUN_ACTION, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkTextViewClass, insert_at_cursor), - _gtk_marshal_VOID__STRING, - GTK_TYPE_NONE, 1, GTK_TYPE_STRING); + g_signal_new ("insert_at_cursor", + G_OBJECT_CLASS_TYPE (gobject_class), + G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, + G_STRUCT_OFFSET (GtkTextViewClass, insert_at_cursor), + NULL, NULL, + _gtk_marshal_VOID__STRING, + G_TYPE_NONE, 1, + G_TYPE_STRING); signals[DELETE_FROM_CURSOR] = - gtk_signal_new ("delete_from_cursor", - GTK_RUN_LAST | GTK_RUN_ACTION, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkTextViewClass, delete_from_cursor), - _gtk_marshal_VOID__ENUM_INT, - GTK_TYPE_NONE, 2, GTK_TYPE_DELETE_TYPE, GTK_TYPE_INT); + g_signal_new ("delete_from_cursor", + G_OBJECT_CLASS_TYPE (gobject_class), + G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, + G_STRUCT_OFFSET (GtkTextViewClass, delete_from_cursor), + NULL, NULL, + _gtk_marshal_VOID__ENUM_INT, + G_TYPE_NONE, 2, + GTK_TYPE_DELETE_TYPE, + G_TYPE_INT); signals[CUT_CLIPBOARD] = - gtk_signal_new ("cut_clipboard", - GTK_RUN_LAST | GTK_RUN_ACTION, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkTextViewClass, cut_clipboard), - _gtk_marshal_VOID__VOID, - GTK_TYPE_NONE, 0); + g_signal_new ("cut_clipboard", + G_OBJECT_CLASS_TYPE (gobject_class), + G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, + G_STRUCT_OFFSET (GtkTextViewClass, cut_clipboard), + NULL, NULL, + _gtk_marshal_VOID__VOID, + G_TYPE_NONE, 0); signals[COPY_CLIPBOARD] = - gtk_signal_new ("copy_clipboard", - GTK_RUN_LAST | GTK_RUN_ACTION, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkTextViewClass, copy_clipboard), - _gtk_marshal_VOID__VOID, - GTK_TYPE_NONE, 0); + g_signal_new ("copy_clipboard", + G_OBJECT_CLASS_TYPE (gobject_class), + G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, + G_STRUCT_OFFSET (GtkTextViewClass, copy_clipboard), + NULL, NULL, + _gtk_marshal_VOID__VOID, + G_TYPE_NONE, 0); signals[PASTE_CLIPBOARD] = - gtk_signal_new ("paste_clipboard", - GTK_RUN_LAST | GTK_RUN_ACTION, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkTextViewClass, paste_clipboard), - _gtk_marshal_VOID__VOID, - GTK_TYPE_NONE, 0); + g_signal_new ("paste_clipboard", + G_OBJECT_CLASS_TYPE (gobject_class), + G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, + G_STRUCT_OFFSET (GtkTextViewClass, paste_clipboard), + NULL, NULL, + _gtk_marshal_VOID__VOID, + G_TYPE_NONE, 0); signals[TOGGLE_OVERWRITE] = - gtk_signal_new ("toggle_overwrite", - GTK_RUN_LAST | GTK_RUN_ACTION, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkTextViewClass, toggle_overwrite), - _gtk_marshal_VOID__VOID, - GTK_TYPE_NONE, 0); + g_signal_new ("toggle_overwrite", + G_OBJECT_CLASS_TYPE (gobject_class), + G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, + G_STRUCT_OFFSET (GtkTextViewClass, toggle_overwrite), + NULL, NULL, + _gtk_marshal_VOID__VOID, + G_TYPE_NONE, 0); signals[MOVE_FOCUS] = - gtk_signal_new ("move_focus", - GTK_RUN_LAST | GTK_RUN_ACTION, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkTextViewClass, move_focus), - _gtk_marshal_VOID__ENUM, - GTK_TYPE_NONE, 1, GTK_TYPE_DIRECTION_TYPE); + g_signal_new ("move_focus", + G_OBJECT_CLASS_TYPE (gobject_class), + G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, + G_STRUCT_OFFSET (GtkTextViewClass, move_focus), + NULL, NULL, + _gtk_marshal_VOID__ENUM, + G_TYPE_NONE, 1, + GTK_TYPE_DIRECTION_TYPE); signals[SET_SCROLL_ADJUSTMENTS] = - gtk_signal_new ("set_scroll_adjustments", - GTK_RUN_LAST, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkTextViewClass, set_scroll_adjustments), - _gtk_marshal_VOID__OBJECT_OBJECT, - GTK_TYPE_NONE, 2, GTK_TYPE_ADJUSTMENT, GTK_TYPE_ADJUSTMENT); + g_signal_new ("set_scroll_adjustments", + G_OBJECT_CLASS_TYPE (gobject_class), + G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, + G_STRUCT_OFFSET (GtkTextViewClass, set_scroll_adjustments), + NULL, NULL, + _gtk_marshal_VOID__OBJECT_OBJECT, + G_TYPE_NONE, 2, + GTK_TYPE_ADJUSTMENT, + GTK_TYPE_ADJUSTMENT); widget_class->set_scroll_adjustments_signal = signals[SET_SCROLL_ADJUSTMENTS]; signals[POPULATE_POPUP] = - gtk_signal_new ("populate_popup", - GTK_RUN_LAST, - GTK_CLASS_TYPE (object_class), - GTK_SIGNAL_OFFSET (GtkTextViewClass, populate_popup), - _gtk_marshal_VOID__OBJECT, - GTK_TYPE_NONE, 1, GTK_TYPE_MENU); + g_signal_new ("populate_popup", + G_OBJECT_CLASS_TYPE (gobject_class), + G_SIGNAL_RUN_LAST, + G_STRUCT_OFFSET (GtkTextViewClass, populate_popup), + NULL, NULL, + _gtk_marshal_VOID__OBJECT, + G_TYPE_NONE, 1, + GTK_TYPE_MENU); + + signals[SELECT_ALL] = + _gtk_binding_signal_new ("select_all", + G_OBJECT_CLASS_TYPE (object_class), + G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, + G_CALLBACK (gtk_text_view_select_all), + NULL, NULL, + _gtk_marshal_VOID__BOOLEAN, + G_TYPE_NONE, 1, + G_TYPE_BOOLEAN, TRUE); + /* * Key bindings @@ -825,122 +925,105 @@ gtk_text_view_class_init (GtkTextViewClass *klass) add_move_binding (binding_set, GDK_KP_Page_Down, 0, GTK_MOVEMENT_PAGES, 1); - /* Select all - */ - gtk_binding_entry_add_signal (binding_set, GDK_a, GDK_CONTROL_MASK, - "move_cursor", 3, - GTK_TYPE_MOVEMENT_STEP, GTK_MOVEMENT_BUFFER_ENDS, - GTK_TYPE_INT, -1, - GTK_TYPE_BOOL, FALSE); + add_move_binding (binding_set, GDK_Page_Up, GDK_CONTROL_MASK, + GTK_MOVEMENT_HORIZONTAL_PAGES, -1); + + add_move_binding (binding_set, GDK_KP_Page_Up, GDK_CONTROL_MASK, + GTK_MOVEMENT_HORIZONTAL_PAGES, -1); + + add_move_binding (binding_set, GDK_Page_Down, GDK_CONTROL_MASK, + GTK_MOVEMENT_HORIZONTAL_PAGES, 1); + + add_move_binding (binding_set, GDK_KP_Page_Down, GDK_CONTROL_MASK, + GTK_MOVEMENT_HORIZONTAL_PAGES, 1); + + /* Select all */ gtk_binding_entry_add_signal (binding_set, GDK_a, GDK_CONTROL_MASK, - "move_cursor", 3, - GTK_TYPE_MOVEMENT_STEP, GTK_MOVEMENT_BUFFER_ENDS, - GTK_TYPE_INT, 1, - GTK_TYPE_BOOL, TRUE); - - - gtk_binding_entry_add_signal (binding_set, GDK_Page_Up, GDK_CONTROL_MASK, - "page_horizontally", 2, - GTK_TYPE_INT, -1, - GTK_TYPE_BOOL, FALSE); - - gtk_binding_entry_add_signal (binding_set, GDK_Page_Up, GDK_CONTROL_MASK | GDK_SHIFT_MASK, - "page_horizontally", 2, - GTK_TYPE_INT, -1, - GTK_TYPE_BOOL, TRUE); - - gtk_binding_entry_add_signal (binding_set, GDK_KP_Page_Up, GDK_CONTROL_MASK, - "page_horizontally", 2, - GTK_TYPE_INT, -1, - GTK_TYPE_BOOL, FALSE); - - gtk_binding_entry_add_signal (binding_set, GDK_KP_Page_Up, GDK_CONTROL_MASK | GDK_SHIFT_MASK, - "page_horizontally", 2, - GTK_TYPE_INT, -1, - GTK_TYPE_BOOL, TRUE); - - gtk_binding_entry_add_signal (binding_set, GDK_Page_Down, GDK_CONTROL_MASK, - "page_horizontally", 2, - GTK_TYPE_INT, 1, - GTK_TYPE_BOOL, FALSE); - - gtk_binding_entry_add_signal (binding_set, GDK_Page_Down, GDK_CONTROL_MASK | GDK_SHIFT_MASK, - "page_horizontally", 2, - GTK_TYPE_INT, 1, - GTK_TYPE_BOOL, TRUE); - - gtk_binding_entry_add_signal (binding_set, GDK_KP_Page_Down, GDK_CONTROL_MASK, - "page_horizontally", 2, - GTK_TYPE_INT, 1, - GTK_TYPE_BOOL, FALSE); - - gtk_binding_entry_add_signal (binding_set, GDK_KP_Page_Down, GDK_CONTROL_MASK | GDK_SHIFT_MASK, - "page_horizontally", 2, - GTK_TYPE_INT, 1, - GTK_TYPE_BOOL, TRUE); + "select_all", 1, + G_TYPE_BOOLEAN, TRUE); + + gtk_binding_entry_add_signal (binding_set, GDK_slash, GDK_CONTROL_MASK, + "select_all", 1, + G_TYPE_BOOLEAN, TRUE); + /* Unselect all */ + gtk_binding_entry_add_signal (binding_set, GDK_backslash, GDK_CONTROL_MASK, + "select_all", 1, + G_TYPE_BOOLEAN, FALSE); + /* Deleting text */ gtk_binding_entry_add_signal (binding_set, GDK_Delete, 0, - "delete_from_cursor", 2, - GTK_TYPE_ENUM, GTK_DELETE_CHARS, - GTK_TYPE_INT, 1); + "delete_from_cursor", 2, + G_TYPE_ENUM, GTK_DELETE_CHARS, + G_TYPE_INT, 1); gtk_binding_entry_add_signal (binding_set, GDK_KP_Delete, 0, - "delete_from_cursor", 2, - GTK_TYPE_ENUM, GTK_DELETE_CHARS, - GTK_TYPE_INT, 1); + "delete_from_cursor", 2, + G_TYPE_ENUM, GTK_DELETE_CHARS, + G_TYPE_INT, 1); gtk_binding_entry_add_signal (binding_set, GDK_BackSpace, 0, - "delete_from_cursor", 2, - GTK_TYPE_ENUM, GTK_DELETE_CHARS, - GTK_TYPE_INT, -1); + "delete_from_cursor", 2, + G_TYPE_ENUM, GTK_DELETE_CHARS, + G_TYPE_INT, -1); + + /* Make this do the same as Backspace, to help with mis-typing */ + gtk_binding_entry_add_signal (binding_set, GDK_BackSpace, GDK_SHIFT_MASK, + "delete_from_cursor", 2, + G_TYPE_ENUM, GTK_DELETE_CHARS, + G_TYPE_INT, -1); gtk_binding_entry_add_signal (binding_set, GDK_Delete, GDK_CONTROL_MASK, - "delete_from_cursor", 2, - GTK_TYPE_ENUM, GTK_DELETE_WORD_ENDS, - GTK_TYPE_INT, 1); + "delete_from_cursor", 2, + G_TYPE_ENUM, GTK_DELETE_WORD_ENDS, + G_TYPE_INT, 1); gtk_binding_entry_add_signal (binding_set, GDK_KP_Delete, GDK_CONTROL_MASK, - "delete_from_cursor", 2, - GTK_TYPE_ENUM, GTK_DELETE_WORD_ENDS, - GTK_TYPE_INT, 1); + "delete_from_cursor", 2, + G_TYPE_ENUM, GTK_DELETE_WORD_ENDS, + G_TYPE_INT, 1); gtk_binding_entry_add_signal (binding_set, GDK_BackSpace, GDK_CONTROL_MASK, - "delete_from_cursor", 2, - GTK_TYPE_ENUM, GTK_DELETE_WORD_ENDS, - GTK_TYPE_INT, -1); + "delete_from_cursor", 2, + G_TYPE_ENUM, GTK_DELETE_WORD_ENDS, + G_TYPE_INT, -1); /* Cut/copy/paste */ gtk_binding_entry_add_signal (binding_set, GDK_x, GDK_CONTROL_MASK, - "cut_clipboard", 0); - + "cut_clipboard", 0); gtk_binding_entry_add_signal (binding_set, GDK_c, GDK_CONTROL_MASK, - "copy_clipboard", 0); - + "copy_clipboard", 0); gtk_binding_entry_add_signal (binding_set, GDK_v, GDK_CONTROL_MASK, - "paste_clipboard", 0); + "paste_clipboard", 0); + + gtk_binding_entry_add_signal (binding_set, GDK_Delete, GDK_SHIFT_MASK, + "cut_clipboard", 0); + gtk_binding_entry_add_signal (binding_set, GDK_Insert, GDK_CONTROL_MASK, + "copy_clipboard", 0); + gtk_binding_entry_add_signal (binding_set, GDK_Insert, GDK_SHIFT_MASK, + "paste_clipboard", 0); /* Overwrite */ gtk_binding_entry_add_signal (binding_set, GDK_Insert, 0, - "toggle_overwrite", 0); + "toggle_overwrite", 0); gtk_binding_entry_add_signal (binding_set, GDK_KP_Insert, 0, - "toggle_overwrite", 0); + "toggle_overwrite", 0); /* Control-tab focus motion */ gtk_binding_entry_add_signal (binding_set, GDK_Tab, GDK_CONTROL_MASK, - "move_focus", 1, - GTK_TYPE_DIRECTION_TYPE, GTK_DIR_TAB_FORWARD); + "move_focus", 1, + GTK_TYPE_DIRECTION_TYPE, GTK_DIR_TAB_FORWARD); gtk_binding_entry_add_signal (binding_set, GDK_KP_Tab, GDK_CONTROL_MASK, - "move_focus", 1, - GTK_TYPE_DIRECTION_TYPE, GTK_DIR_TAB_FORWARD); + "move_focus", 1, + GTK_TYPE_DIRECTION_TYPE, GTK_DIR_TAB_FORWARD); gtk_binding_entry_add_signal (binding_set, GDK_Tab, GDK_SHIFT_MASK | GDK_CONTROL_MASK, - "move_focus", 1, - GTK_TYPE_DIRECTION_TYPE, GTK_DIR_TAB_BACKWARD); + "move_focus", 1, + GTK_TYPE_DIRECTION_TYPE, GTK_DIR_TAB_BACKWARD); gtk_binding_entry_add_signal (binding_set, GDK_KP_Tab, GDK_SHIFT_MASK | GDK_CONTROL_MASK, - "move_focus", 1, - GTK_TYPE_DIRECTION_TYPE, GTK_DIR_TAB_BACKWARD); + "move_focus", 1, + GTK_TYPE_DIRECTION_TYPE, GTK_DIR_TAB_BACKWARD); } static void @@ -977,17 +1060,19 @@ gtk_text_view_init (GtkTextView *text_view) */ text_view->im_context = gtk_im_multicontext_new (); - g_signal_connect (G_OBJECT (text_view->im_context), "commit", + g_signal_connect (text_view->im_context, "commit", G_CALLBACK (gtk_text_view_commit_handler), text_view); - g_signal_connect (G_OBJECT (text_view->im_context), "preedit_changed", + g_signal_connect (text_view->im_context, "preedit_changed", G_CALLBACK (gtk_text_view_preedit_changed_handler), text_view); - g_signal_connect (G_OBJECT (text_view->im_context), "retrieve_surrounding", + g_signal_connect (text_view->im_context, "retrieve_surrounding", G_CALLBACK (gtk_text_view_retrieve_surrounding_handler), text_view); - g_signal_connect (G_OBJECT (text_view->im_context), "delete_surrounding", + g_signal_connect (text_view->im_context, "delete_surrounding", G_CALLBACK (gtk_text_view_delete_surrounding_handler), text_view); text_view->cursor_visible = TRUE; + text_view->accepts_tab = TRUE; + text_view->text_window = text_window_new (GTK_TEXT_WINDOW_TEXT, widget, 200, 200); @@ -1013,7 +1098,7 @@ gtk_text_view_init (GtkTextView *text_view) GtkWidget* gtk_text_view_new (void) { - return GTK_WIDGET (gtk_type_new (gtk_text_view_get_type ())); + return g_object_new (GTK_TYPE_TEXT_VIEW, NULL); } /** @@ -1086,14 +1171,18 @@ gtk_text_view_set_buffer (GtkTextView *text_view, g_slist_free (copy); - g_signal_handlers_disconnect_by_func (G_OBJECT (text_view->buffer), - gtk_text_view_mark_set_handler, text_view); - g_object_unref (G_OBJECT (text_view->buffer)); + g_signal_handlers_disconnect_by_func (text_view->buffer, + gtk_text_view_mark_set_handler, + text_view); + g_object_unref (text_view->buffer); text_view->dnd_mark = NULL; if (GTK_WIDGET_REALIZED (text_view)) - gtk_text_buffer_remove_selection_clipboard (text_view->buffer, - gtk_clipboard_get (GDK_SELECTION_PRIMARY)); + { + GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (text_view), + GDK_SELECTION_PRIMARY); + gtk_text_buffer_remove_selection_clipboard (text_view->buffer, clipboard); + } } text_view->buffer = buffer; @@ -1102,7 +1191,7 @@ gtk_text_view_set_buffer (GtkTextView *text_view, { GtkTextIter start; - g_object_ref (G_OBJECT (buffer)); + g_object_ref (buffer); if (text_view->layout) gtk_text_layout_set_buffer (text_view->layout, buffer); @@ -1119,13 +1208,18 @@ gtk_text_view_set_buffer (GtkTextView *text_view, text_view->first_para_pixels = 0; - g_signal_connect (G_OBJECT (text_view->buffer), "mark_set", + g_signal_connect (text_view->buffer, "mark_set", G_CALLBACK (gtk_text_view_mark_set_handler), text_view); if (GTK_WIDGET_REALIZED (text_view)) - gtk_text_buffer_add_selection_clipboard (text_view->buffer, - gtk_clipboard_get (GDK_SELECTION_PRIMARY)); + { + GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (text_view), + GDK_SELECTION_PRIMARY); + gtk_text_buffer_add_selection_clipboard (text_view->buffer, clipboard); + } } + + g_object_notify (G_OBJECT (text_view), "buffer"); if (GTK_WIDGET_VISIBLE (text_view)) gtk_widget_queue_draw (GTK_WIDGET (text_view)); @@ -1142,7 +1236,7 @@ get_buffer (GtkTextView *text_view) GtkTextBuffer *b; b = gtk_text_buffer_new (NULL); gtk_text_view_set_buffer (text_view, b); - g_object_unref (G_OBJECT (b)); + g_object_unref (b); } return text_view->buffer; @@ -1188,8 +1282,9 @@ gtk_text_view_get_iter_at_location (GtkTextView *text_view, { g_return_if_fail (GTK_IS_TEXT_VIEW (text_view)); g_return_if_fail (iter != NULL); - g_return_if_fail (text_view->layout != NULL); + gtk_text_view_ensure_layout (text_view); + gtk_text_layout_get_iter_at_pixel (text_view->layout, iter, x, @@ -1216,6 +1311,8 @@ gtk_text_view_get_iter_location (GtkTextView *text_view, g_return_if_fail (GTK_IS_TEXT_VIEW (text_view)); g_return_if_fail (gtk_text_iter_get_buffer (iter) == get_buffer (text_view)); + gtk_text_view_ensure_layout (text_view); + gtk_text_layout_get_iter_location (text_view->layout, iter, location); } @@ -1240,6 +1337,8 @@ gtk_text_view_get_line_yrange (GtkTextView *text_view, g_return_if_fail (GTK_IS_TEXT_VIEW (text_view)); g_return_if_fail (gtk_text_iter_get_buffer (iter) == get_buffer (text_view)); + gtk_text_view_ensure_layout (text_view); + gtk_text_layout_get_line_yrange (text_view->layout, iter, y, @@ -1267,6 +1366,8 @@ gtk_text_view_get_line_at_y (GtkTextView *text_view, { g_return_if_fail (GTK_IS_TEXT_VIEW (text_view)); + gtk_text_view_ensure_layout (text_view); + gtk_text_layout_get_line_at_y (text_view->layout, target_iter, y, @@ -1383,7 +1484,10 @@ gtk_text_view_scroll_to_iter (GtkTextView *text_view, if (screen.height < 1) screen.height = 1; - screen_right = screen.x + screen.width; + /* The -1 here ensures that we leave enough space to draw the cursor + * when this function is used for horizontal scrolling. + */ + screen_right = screen.x + screen.width - 1; screen_bottom = screen.y + screen.height; /* The alignment affects the point in the target character that we @@ -1482,10 +1586,20 @@ free_pending_scroll (GtkTextPendingScroll *scroll) if (!gtk_text_mark_get_deleted (scroll->mark)) gtk_text_buffer_delete_mark (gtk_text_mark_get_buffer (scroll->mark), scroll->mark); - g_object_unref (G_OBJECT (scroll->mark)); + g_object_unref (scroll->mark); g_free (scroll); } +static void +cancel_pending_scroll (GtkTextView *text_view) +{ + if (text_view->pending_scroll) + { + free_pending_scroll (text_view->pending_scroll); + text_view->pending_scroll = NULL; + } +} + static void gtk_text_view_queue_scroll (GtkTextView *text_view, GtkTextMark *mark, @@ -1513,10 +1627,9 @@ gtk_text_view_queue_scroll (GtkTextView *text_view, &iter, gtk_text_mark_get_left_gravity (mark)); - g_object_ref (G_OBJECT (scroll->mark)); + g_object_ref (scroll->mark); - if (text_view->pending_scroll) - free_pending_scroll (text_view->pending_scroll); + cancel_pending_scroll (text_view); text_view->pending_scroll = scroll; } @@ -1591,13 +1704,13 @@ gtk_text_view_set_adjustment_upper (GtkAdjustment *adj, gdouble upper) value_changed = TRUE; } - gtk_signal_emit_by_name (GTK_OBJECT (adj), "changed"); + gtk_adjustment_changed (adj); DV(g_print(">Changed adj upper to %g ("G_STRLOC")\n", upper)); if (value_changed) { DV(g_print(">Changed adj value because upper decreased ("G_STRLOC")\n")); - gtk_signal_emit_by_name (GTK_OBJECT (adj), "value_changed"); + gtk_adjustment_value_changed (adj); } } } @@ -1612,6 +1725,9 @@ gtk_text_view_update_adjustments (GtkTextView *text_view) if (text_view->layout) gtk_text_layout_get_size (text_view->layout, &width, &height); + /* Make room for the cursor after the last character in the widest line */ + width += SPACE_FOR_CURSOR; + if (text_view->width != width || text_view->height != height) { text_view->width = width; @@ -1637,8 +1753,8 @@ gtk_text_view_update_adjustments (GtkTextView *text_view) text_view->vadjustment->page_increment = SCREEN_HEIGHT (text_view) * 0.9; - gtk_signal_emit_by_name (GTK_OBJECT (get_hadjustment (text_view)), "changed"); - gtk_signal_emit_by_name (GTK_OBJECT (get_hadjustment (text_view)), "changed"); + gtk_adjustment_changed (get_hadjustment (text_view)); + gtk_adjustment_changed (get_vadjustment (text_view)); } } @@ -1650,23 +1766,26 @@ gtk_text_view_update_layout_width (GtkTextView *text_view) gtk_text_view_ensure_layout (text_view); gtk_text_layout_set_screen_width (text_view->layout, - SCREEN_WIDTH (text_view)); + MAX (1, SCREEN_WIDTH (text_view) - SPACE_FOR_CURSOR)); } static void gtk_text_view_update_im_spot_location (GtkTextView *text_view) { GdkRectangle area; - gint cursor_x_pos, cursor_y_pos; if (text_view->layout == NULL) return; - gtk_text_view_get_virtual_cursor_pos (text_view, &cursor_x_pos, &cursor_y_pos); + gtk_text_view_get_cursor_location (text_view, &area); - area.x = cursor_x_pos; - area.y = cursor_y_pos; - area.width = area.height = 0; + area.x -= text_view->xoffset; + area.y -= text_view->yoffset; + + /* Width returned by Pango indicates direction of cursor, + * by it's sign more than the size of cursor. + */ + area.width = 0; gtk_im_context_set_cursor_location (text_view->im_context, &area); } @@ -2402,19 +2521,15 @@ gtk_text_view_finalize (GObject *object) gtk_text_view_destroy_layout (text_view); gtk_text_view_set_buffer (text_view, NULL); - if (text_view->pending_scroll) - { - free_pending_scroll (text_view->pending_scroll); - text_view->pending_scroll = NULL; - } + cancel_pending_scroll (text_view); if (text_view->tabs) pango_tab_array_free (text_view->tabs); if (text_view->hadjustment) - g_object_unref (G_OBJECT (text_view->hadjustment)); + g_object_unref (text_view->hadjustment); if (text_view->vadjustment) - g_object_unref (G_OBJECT (text_view->vadjustment)); + g_object_unref (text_view->vadjustment); text_window_free (text_view->text_window); @@ -2430,8 +2545,8 @@ gtk_text_view_finalize (GObject *object) if (text_view->bottom_window) text_window_free (text_view->bottom_window); - g_object_unref (G_OBJECT (text_view->im_context)); - + g_object_unref (text_view->im_context); + (* G_OBJECT_CLASS (parent_class)->finalize) (object); } @@ -2491,6 +2606,18 @@ gtk_text_view_set_property (GObject *object, gtk_text_view_set_cursor_visible (text_view, g_value_get_boolean (value)); break; + case PROP_OVERWRITE: + gtk_text_view_set_overwrite (text_view, g_value_get_boolean (value)); + break; + + case PROP_BUFFER: + gtk_text_view_set_buffer (text_view, GTK_TEXT_BUFFER (g_value_get_object (value))); + break; + + case PROP_ACCEPTS_TAB: + gtk_text_view_set_accepts_tab (text_view, g_value_get_boolean (value)); + break; + default: g_assert_not_reached (); break; @@ -2553,6 +2680,18 @@ gtk_text_view_get_property (GObject *object, g_value_set_boolean (value, text_view->cursor_visible); break; + case PROP_BUFFER: + g_value_set_object (value, get_buffer (text_view)); + break; + + case PROP_OVERWRITE: + g_value_set_boolean (value, text_view->overwrite_mode); + break; + + case PROP_ACCEPTS_TAB: + g_value_set_boolean (value, text_view->accepts_tab); + break; + default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; @@ -2739,6 +2878,19 @@ gtk_text_view_allocate_children (GtkTextView *text_view) &child_loc, child->anchor); + /* Since anchored children are only ever allocated from + * gtk_text_layout_get_line_display() we have to make sure + * that the display line caching in the layout doesn't + * get in the way. Invalidating the layout around the anchor + * achieves this. + */ + if (GTK_WIDGET_ALLOC_NEEDED (child->widget)) + { + GtkTextIter end = child_loc; + gtk_text_iter_forward_char (&end); + gtk_text_layout_invalidate (text_view->layout, &child_loc, &end); + } + gtk_text_layout_validate_yrange (text_view->layout, &child_loc, 0, 1); @@ -2772,8 +2924,6 @@ gtk_text_view_size_allocate (GtkWidget *widget, GtkTextView *text_view; GtkTextIter first_para; gint y; - GtkAdjustment *vadj; - gboolean yoffset_changed = FALSE; gint width, height; GdkRectangle text_rect; GdkRectangle left_rect; @@ -2899,35 +3049,21 @@ gtk_text_view_size_allocate (GtkWidget *widget, /* Note that this will do some layout validation */ gtk_text_view_allocate_children (text_view); - /* Now adjust the value of the adjustment to keep the cursor at the - * same place in the buffer - */ - gtk_text_view_get_first_para_iter (text_view, &first_para); - gtk_text_layout_get_line_yrange (text_view->layout, &first_para, &y, NULL); - - y += text_view->first_para_pixels; - /* Ensure h/v adj exist */ get_hadjustment (text_view); get_vadjustment (text_view); - vadj = text_view->vadjustment; - if (y > vadj->upper - vadj->page_size) - y = MAX (0, vadj->upper - vadj->page_size); - - if (y != text_view->yoffset) - { - vadj->value = y; - yoffset_changed = TRUE; - } - text_view->hadjustment->page_size = SCREEN_WIDTH (text_view); text_view->hadjustment->page_increment = SCREEN_WIDTH (text_view) * 0.9; text_view->hadjustment->step_increment = SCREEN_WIDTH (text_view) * 0.1; text_view->hadjustment->lower = 0; text_view->hadjustment->upper = MAX (SCREEN_WIDTH (text_view), text_view->width); - gtk_signal_emit_by_name (GTK_OBJECT (text_view->hadjustment), "changed"); + + if (text_view->hadjustment->value > text_view->hadjustment->upper - text_view->hadjustment->page_size) + gtk_adjustment_set_value (text_view->hadjustment, MAX (0, text_view->hadjustment->upper - text_view->hadjustment->page_size)); + + gtk_adjustment_changed (text_view->hadjustment); text_view->vadjustment->page_size = SCREEN_HEIGHT (text_view); text_view->vadjustment->page_increment = SCREEN_HEIGHT (text_view) * 0.9; @@ -2935,10 +3071,22 @@ gtk_text_view_size_allocate (GtkWidget *widget, text_view->vadjustment->lower = 0; text_view->vadjustment->upper = MAX (SCREEN_HEIGHT (text_view), text_view->height); - gtk_signal_emit_by_name (GTK_OBJECT (text_view->vadjustment), "changed"); - if (yoffset_changed) - gtk_adjustment_value_changed (vadj); + /* Now adjust the value of the adjustment to keep the cursor at the + * same place in the buffer + */ + gtk_text_view_get_first_para_iter (text_view, &first_para); + gtk_text_layout_get_line_yrange (text_view->layout, &first_para, &y, NULL); + + y += text_view->first_para_pixels; + + if (y > text_view->vadjustment->upper - text_view->vadjustment->page_size) + y = MAX (0, text_view->vadjustment->upper - text_view->vadjustment->page_size); + + if (y != text_view->yoffset) + gtk_adjustment_set_value (text_view->vadjustment, y); + + gtk_adjustment_changed (text_view->vadjustment); /* The GTK resize loop processes all the pending exposes right * after doing the resize stuff, so the idle sizer won't have a @@ -3026,11 +3174,14 @@ gtk_text_view_flush_first_validate (GtkTextView *text_view) } else { - /* scroll to any marks, if that's pending. This can - * jump us to the validation codepath used for scrolling - * onscreen, if so we bail out. + /* scroll to any marks, if that's pending. This can jump us to + * the validation codepath used for scrolling onscreen, if so we + * bail out. It won't jump if already in that codepath since + * value_changed is not recursive, so also validate if + * necessary. */ - if (!gtk_text_view_flush_scroll (text_view)) + if (!gtk_text_view_flush_scroll (text_view) || + !text_view->onscreen_validated) gtk_text_view_validate_onscreen (text_view); DV(g_print(">Leaving first validate idle ("G_STRLOC")\n")); @@ -3091,6 +3242,10 @@ gtk_text_view_invalidate (GtkTextView *text_view) text_view->onscreen_validated)); text_view->onscreen_validated = FALSE; + + /* We'll invalidate when the layout is created */ + if (text_view->layout == NULL) + return; if (!text_view->first_validate_idle) { @@ -3146,9 +3301,11 @@ changed_handler (GtkTextLayout *layout, if (old_height == new_height) redraw_rect.height = old_height; - else + else if (start_y + old_height > visible_rect.y) redraw_rect.height = MAX (0, visible_rect.y + visible_rect.height - start_y); - + else + redraw_rect.height = 0; + if (gdk_rectangle_intersect (&redraw_rect, &visible_rect, &redraw_rect)) { /* text_window_invalidate_rect() takes buffer coordinates */ @@ -3245,8 +3402,7 @@ changed_handler (GtkTextLayout *layout, if (old_req.width != new_req.width || old_req.height != new_req.height) { - /* FIXME http://bugzilla.gnome.org/show_bug.cgi?id=72258 */ - _gtk_size_group_queue_resize (widget); + gtk_widget_queue_resize_no_redraw (widget); } } } @@ -3305,8 +3461,11 @@ gtk_text_view_realize (GtkWidget *widget) gtk_text_view_ensure_layout (text_view); if (text_view->buffer) - gtk_text_buffer_add_selection_clipboard (text_view->buffer, - gtk_clipboard_get (GDK_SELECTION_PRIMARY)); + { + GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (text_view), + GDK_SELECTION_PRIMARY); + gtk_text_buffer_add_selection_clipboard (text_view->buffer, clipboard); + } tmp_list = text_view->children; while (tmp_list != NULL) @@ -3327,8 +3486,11 @@ gtk_text_view_unrealize (GtkWidget *widget) text_view = GTK_TEXT_VIEW (widget); if (text_view->buffer) - gtk_text_buffer_remove_selection_clipboard (text_view->buffer, - gtk_clipboard_get (GDK_SELECTION_PRIMARY)); + { + GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (text_view), + GDK_SELECTION_PRIMARY); + gtk_text_buffer_remove_selection_clipboard (text_view->buffer, clipboard); + } gtk_text_view_remove_validate_idles (text_view); @@ -3357,6 +3519,33 @@ gtk_text_view_unrealize (GtkWidget *widget) (* GTK_WIDGET_CLASS (parent_class)->unrealize) (widget); } +static void +gtk_text_view_set_background (GtkTextView *text_view) +{ + GtkWidget *widget = GTK_WIDGET (text_view); + + gdk_window_set_background (widget->window, + &widget->style->bg[GTK_WIDGET_STATE (widget)]); + + gdk_window_set_background (text_view->text_window->bin_window, + &widget->style->base[GTK_WIDGET_STATE (widget)]); + + if (text_view->left_window) + gdk_window_set_background (text_view->left_window->bin_window, + &widget->style->bg[GTK_WIDGET_STATE (widget)]); + if (text_view->right_window) + gdk_window_set_background (text_view->right_window->bin_window, + &widget->style->bg[GTK_WIDGET_STATE (widget)]); + + if (text_view->top_window) + gdk_window_set_background (text_view->top_window->bin_window, + &widget->style->bg[GTK_WIDGET_STATE (widget)]); + + if (text_view->bottom_window) + gdk_window_set_background (text_view->bottom_window->bin_window, + &widget->style->bg[GTK_WIDGET_STATE (widget)]); +} + static void gtk_text_view_style_set (GtkWidget *widget, GtkStyle *previous_style) @@ -3365,26 +3554,7 @@ gtk_text_view_style_set (GtkWidget *widget, if (GTK_WIDGET_REALIZED (widget)) { - gdk_window_set_background (widget->window, - &widget->style->bg[GTK_WIDGET_STATE (widget)]); - - gdk_window_set_background (text_view->text_window->bin_window, - &widget->style->base[GTK_WIDGET_STATE (widget)]); - - if (text_view->left_window) - gdk_window_set_background (text_view->left_window->bin_window, - &widget->style->bg[GTK_WIDGET_STATE (widget)]); - if (text_view->right_window) - gdk_window_set_background (text_view->right_window->bin_window, - &widget->style->bg[GTK_WIDGET_STATE (widget)]); - - if (text_view->top_window) - gdk_window_set_background (text_view->top_window->bin_window, - &widget->style->bg[GTK_WIDGET_STATE (widget)]); - - if (text_view->bottom_window) - gdk_window_set_background (text_view->bottom_window->bin_window, - &widget->style->bg[GTK_WIDGET_STATE (widget)]); + gtk_text_view_set_background (text_view); } if (text_view->layout && previous_style) @@ -3409,6 +3579,25 @@ gtk_text_view_direction_changed (GtkWidget *widget, } } +static void +gtk_text_view_state_changed (GtkWidget *widget, + GtkStateType previous_state) +{ + GtkTextView *text_view = GTK_TEXT_VIEW (widget); + + if (GTK_WIDGET_REALIZED (widget)) + { + gtk_text_view_set_background (text_view); + } + + if (!GTK_WIDGET_IS_SENSITIVE (widget)) + { + /* Clear any selection */ + gtk_text_view_unselect (text_view); + } + + gtk_widget_queue_draw (widget); +} static void set_invisible_cursor (GdkWindow *window) @@ -3448,6 +3637,30 @@ gtk_text_view_obscure_mouse_cursor (GtkTextView *text_view) text_view->mouse_cursor_obscured = TRUE; } +static void +gtk_text_view_unobscure_mouse_cursor (GtkTextView *text_view) +{ + if (text_view->mouse_cursor_obscured) + { + GdkCursor *cursor; + + cursor = gdk_cursor_new_for_display (gtk_widget_get_display (GTK_WIDGET (text_view)), + GDK_XTERM); + gdk_window_set_cursor (text_view->text_window->bin_window, cursor); + gdk_cursor_unref (cursor); + text_view->mouse_cursor_obscured = FALSE; + } +} + +static void +gtk_text_view_grab_notify (GtkWidget *widget, + gboolean was_grabbed) +{ + if (!was_grabbed) + gtk_text_view_unobscure_mouse_cursor (GTK_TEXT_VIEW (widget)); +} + + /* * Events */ @@ -3587,6 +3800,7 @@ gtk_text_view_key_press_event (GtkWidget *widget, GdkEventKey *event) GtkTextView *text_view = GTK_TEXT_VIEW (widget); GtkTextMark *insert; GtkTextIter iter; + gboolean can_insert; if (text_view->layout == NULL || get_buffer (text_view) == NULL) @@ -3594,19 +3808,26 @@ gtk_text_view_key_press_event (GtkWidget *widget, GdkEventKey *event) insert = gtk_text_buffer_get_insert (get_buffer (text_view)); gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &iter, insert); - if (gtk_text_iter_can_insert (&iter, text_view->editable) && + can_insert = gtk_text_iter_can_insert (&iter, text_view->editable); + if (can_insert && gtk_im_context_filter_keypress (text_view->im_context, event)) { text_view->need_im_reset = TRUE; obscure = TRUE; retval = TRUE; } + /* Binding set */ else if (GTK_WIDGET_CLASS (parent_class)->key_press_event && GTK_WIDGET_CLASS (parent_class)->key_press_event (widget, event)) retval = TRUE; - else if (event->keyval == GDK_Return || - event->keyval == GDK_KP_Enter) + /* use overall editability not can_insert, more predictable for users */ + else if (text_view->editable && + (event->keyval == GDK_Return || + event->keyval == GDK_KP_Enter)) { + /* this won't actually insert the newline if the cursor isn't + * editable + */ gtk_text_view_commit_text (text_view, "\n"); obscure = TRUE; @@ -3617,8 +3838,10 @@ gtk_text_view_key_press_event (GtkWidget *widget, GdkEventKey *event) event->keyval == GDK_KP_Tab) && !(event->state & GDK_CONTROL_MASK)) { - /* If the text isn't editable, move the focus instead */ - if (text_view->editable) + /* If the text widget isn't editable overall, or if the application + * has turned off "accepts_tab", move the focus instead + */ + if (text_view->accepts_tab && text_view->editable) { gtk_text_view_commit_text (text_view, "\t"); obscure = TRUE; @@ -3670,9 +3893,7 @@ gtk_text_view_button_press_event (GtkWidget *widget, GdkEventButton *event) text_view = GTK_TEXT_VIEW (widget); - text_view->disable_scroll_on_focus = TRUE; gtk_widget_grab_focus (widget); - text_view->disable_scroll_on_focus = FALSE; if (event->window != text_view->text_window->bin_window) { @@ -3731,7 +3952,7 @@ gtk_text_view_button_press_event (GtkWidget *widget, GdkEventButton *event) event->y + text_view->yoffset); gtk_text_buffer_paste_clipboard (get_buffer (text_view), - gtk_clipboard_get (GDK_SELECTION_PRIMARY), + gtk_widget_get_clipboard (widget, GDK_SELECTION_PRIMARY), &iter, text_view->editable); return TRUE; @@ -3739,84 +3960,23 @@ gtk_text_view_button_press_event (GtkWidget *widget, GdkEventButton *event) else if (event->button == 3) { gtk_text_view_do_popup (text_view, event); + return TRUE; } } else if ((event->type == GDK_2BUTTON_PRESS || - event->type == GDK_3BUTTON_PRESS) && - event->button == 1) + event->type == GDK_3BUTTON_PRESS) && + event->button == 1) { - GtkTextIter start, end; - - /* End the selection drag, otherwise we'd clear the new - * word/line selection on button release - */ - gtk_text_view_end_selection_drag (text_view, event); - - gtk_text_layout_get_iter_at_pixel (text_view->layout, - &start, - event->x + text_view->xoffset, - event->y + text_view->yoffset); - - end = start; - - if (event->type == GDK_2BUTTON_PRESS) - { - if (gtk_text_iter_inside_word (&start)) - { - if (!gtk_text_iter_starts_word (&start)) - gtk_text_iter_backward_word_start (&start); - - if (!gtk_text_iter_ends_word (&end)) - gtk_text_iter_forward_word_end (&end); - } - } - else if (event->type == GDK_3BUTTON_PRESS) - { - if (gtk_text_view_starts_display_line (text_view, &start)) - { - /* If on a display line boundary, we assume the user - * clicked off the end of a line and we therefore select - * the line before the boundary. - */ - gtk_text_view_backward_display_line_start (text_view, &start); - } - else - { - /* start isn't on the start of a line, so we move it to the - * start, and move end to the end unless it's already there. - */ - gtk_text_view_backward_display_line_start (text_view, &start); - - if (!gtk_text_view_starts_display_line (text_view, &end)) - gtk_text_view_forward_display_line_end (text_view, &end); - } - } - - if (event->state & GDK_SHIFT_MASK) - { - /* Take union of old and new selection */ - GtkTextIter old_start, old_end; - - gtk_text_buffer_get_selection_bounds (get_buffer (text_view), - &old_start, &old_end); + GtkTextIter iter; - gtk_text_iter_order (&start, &old_start); - gtk_text_iter_order (&old_end, &end); + gtk_text_view_end_selection_drag (text_view, event); - /* Now start is the first of the starts, and end is the - * last of the ends - */ - } - - gtk_text_buffer_move_mark_by_name (get_buffer (text_view), - "selection_bound", - &start); - gtk_text_buffer_move_mark_by_name (get_buffer (text_view), - "insert", - &end); - - text_view->just_selected_element = TRUE; + gtk_text_layout_get_iter_at_pixel (text_view->layout, + &iter, + event->x + text_view->xoffset, + event->y + text_view->yoffset); + gtk_text_view_start_selection_drag (text_view, &iter, event); return TRUE; } @@ -3843,11 +4003,6 @@ gtk_text_view_button_release_event (GtkWidget *widget, GdkEventButton *event) if (gtk_text_view_end_selection_drag (GTK_TEXT_VIEW (widget), event)) return TRUE; - else if (text_view->just_selected_element) - { - text_view->just_selected_element = FALSE; - return FALSE; - } else if (text_view->pending_place_cursor_button == event->button) { GtkTextIter iter; @@ -3894,7 +4049,7 @@ gtk_text_view_focus_in_event (GtkWidget *widget, GdkEventFocus *event) gtk_text_view_check_cursor_blink (text_view); } - g_signal_connect (gdk_keymap_get_default (), + g_signal_connect (gdk_keymap_get_for_display (gtk_widget_get_display (widget)), "direction_changed", G_CALLBACK (keymap_direction_changed), text_view); gtk_text_view_check_keymap_direction (text_view); @@ -3920,9 +4075,9 @@ gtk_text_view_focus_out_event (GtkWidget *widget, GdkEventFocus *event) gtk_text_view_check_cursor_blink (text_view); } - g_signal_handlers_disconnect_by_func (gdk_keymap_get_default (), - keymap_direction_changed, - text_view); + g_signal_handlers_disconnect_by_func (gdk_keymap_get_for_display (gtk_widget_get_display (widget)), + keymap_direction_changed, + text_view); text_view->need_im_reset = TRUE; gtk_im_context_focus_out (GTK_TEXT_VIEW (widget)->im_context); @@ -3935,15 +4090,7 @@ gtk_text_view_motion_event (GtkWidget *widget, GdkEventMotion *event) { GtkTextView *text_view = GTK_TEXT_VIEW (widget); - if (text_view->mouse_cursor_obscured) - { - GdkCursor *cursor; - - cursor = gdk_cursor_new (GDK_XTERM); - gdk_window_set_cursor (text_view->text_window->bin_window, cursor); - gdk_cursor_unref (cursor); - text_view->mouse_cursor_obscured = FALSE; - } + gtk_text_view_unobscure_mouse_cursor (text_view); if (event->window == text_view->text_window->bin_window && text_view->drag_start_x >= 0) @@ -4019,7 +4166,7 @@ gtk_text_view_paint (GtkWidget *widget, if (!text_view->onscreen_validated) { g_warning (G_STRLOC ": somehow some text lines were modified or scrolling occurred since the last validation of lines on the screen - may be a text widget bug."); - G_BREAKPOINT (); + g_assert_not_reached (); } #if 0 @@ -4043,12 +4190,12 @@ gtk_text_view_paint (GtkWidget *widget, while (tmp_list != NULL) { GtkWidget *child = tmp_list->data; - + gtk_container_propagate_expose (GTK_CONTAINER (text_view), child, event); - g_object_unref (G_OBJECT (child)); + g_object_unref (child); tmp_list = tmp_list->next; } @@ -4118,32 +4265,35 @@ gtk_text_view_draw_focus (GtkWidget *widget) } } -static void -gtk_text_view_grab_focus (GtkWidget *widget) -{ - GtkTextView *text_view; - - text_view = GTK_TEXT_VIEW (widget); - - GTK_WIDGET_CLASS (parent_class)->grab_focus (widget); - - if (!text_view->disable_scroll_on_focus) - gtk_text_view_scroll_mark_onscreen (text_view, - gtk_text_buffer_get_mark (get_buffer (text_view), - "insert")); -} - static gboolean gtk_text_view_focus (GtkWidget *widget, GtkDirectionType direction) { GtkTextView *text_view; GtkContainer *container; + gboolean result; text_view = GTK_TEXT_VIEW (widget); container = GTK_CONTAINER (widget); - - return GTK_WIDGET_CLASS (parent_class)->focus (widget, direction); + + if (!gtk_widget_is_focus (widget) && + container->focus_child == NULL) + { + gtk_widget_grab_focus (widget); + return TRUE; + } + else + { + /* + * Unset CAN_FOCUS flag so that gtk_container_focus() allows + * children to get the focus + */ + GTK_WIDGET_UNSET_FLAGS (widget, GTK_CAN_FOCUS); + result = GTK_WIDGET_CLASS (parent_class)->focus (widget, direction); + GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_FOCUS); + + return result; + } } /* @@ -4246,7 +4396,7 @@ cursor_blinks (GtkTextView *text_view) if (gtk_debug_flags & GTK_DEBUG_UPDATES) return FALSE; - g_object_get (G_OBJECT (settings), "gtk-cursor-blink", &blink, NULL); + g_object_get (settings, "gtk-cursor-blink", &blink, NULL); return blink; } @@ -4256,7 +4406,7 @@ get_cursor_time (GtkTextView *text_view) GtkSettings *settings = gtk_widget_get_settings (GTK_WIDGET (text_view)); gint time; - g_object_get (G_OBJECT (settings), "gtk-cursor-blink-time", &time, NULL); + g_object_get (settings, "gtk-cursor-blink-time", &time, NULL); return time; } @@ -4282,13 +4432,13 @@ blink_cb (gpointer data) visible = gtk_text_layout_get_cursor_visible (text_view->layout); if (visible) - text_view->blink_timeout = gtk_timeout_add (get_cursor_time (text_view) * CURSOR_OFF_MULTIPLIER, - blink_cb, - text_view); + text_view->blink_timeout = g_timeout_add (get_cursor_time (text_view) * CURSOR_OFF_MULTIPLIER, + blink_cb, + text_view); else - text_view->blink_timeout = gtk_timeout_add (get_cursor_time (text_view) * CURSOR_ON_MULTIPLIER, - blink_cb, - text_view); + text_view->blink_timeout = g_timeout_add (get_cursor_time (text_view) * CURSOR_ON_MULTIPLIER, + blink_cb, + text_view); gtk_text_layout_set_cursor_visible (text_view->layout, !visible); @@ -4305,7 +4455,7 @@ gtk_text_view_stop_cursor_blink (GtkTextView *text_view) { if (text_view->blink_timeout) { - gtk_timeout_remove (text_view->blink_timeout); + g_source_remove (text_view->blink_timeout); text_view->blink_timeout = 0; } } @@ -4323,9 +4473,9 @@ gtk_text_view_check_cursor_blink (GtkTextView *text_view) { gtk_text_layout_set_cursor_visible (text_view->layout, TRUE); - text_view->blink_timeout = gtk_timeout_add (get_cursor_time (text_view) * CURSOR_OFF_MULTIPLIER, - blink_cb, - text_view); + text_view->blink_timeout = g_timeout_add (get_cursor_time (text_view) * CURSOR_OFF_MULTIPLIER, + blink_cb, + text_view); } } else @@ -4347,15 +4497,15 @@ gtk_text_view_pend_cursor_blink(GtkTextView *text_view) { if (text_view->blink_timeout != 0) { - gtk_timeout_remove (text_view->blink_timeout); + g_source_remove (text_view->blink_timeout); text_view->blink_timeout = 0; } gtk_text_layout_set_cursor_visible (text_view->layout, TRUE); - text_view->blink_timeout = gtk_timeout_add (get_cursor_time (text_view) * CURSOR_PEND_MULTIPLIER, - blink_cb, - text_view); + text_view->blink_timeout = g_timeout_add (get_cursor_time (text_view) * CURSOR_PEND_MULTIPLIER, + blink_cb, + text_view); } } @@ -4382,10 +4532,19 @@ gtk_text_view_move_iter_by_lines (GtkTextView *text_view, } } -/* FIXME when we are unfrozen and can change GtkMovementStep, - * fix this - */ -#define PAGE_HORIZONTALLY_HACK_VALUE 57 +static void +move_cursor (GtkTextView *text_view, + const GtkTextIter *new_location, + gboolean extend_selection) +{ + if (extend_selection) + gtk_text_buffer_move_mark_by_name (get_buffer (text_view), + "insert", + new_location); + else + gtk_text_buffer_place_cursor (get_buffer (text_view), + new_location); +} static void gtk_text_view_move_cursor_internal (GtkTextView *text_view, @@ -4398,17 +4557,55 @@ gtk_text_view_move_cursor_internal (GtkTextView *text_view, gint cursor_x_pos = 0; + if (!text_view->cursor_visible) + { + GtkScrollStep scroll_step; + + switch (step) + { + case GTK_MOVEMENT_LOGICAL_POSITIONS: + case GTK_MOVEMENT_VISUAL_POSITIONS: + case GTK_MOVEMENT_WORDS: + scroll_step = GTK_SCROLL_HORIZONTAL_STEPS; + break; + case GTK_MOVEMENT_DISPLAY_LINE_ENDS: + scroll_step = GTK_SCROLL_HORIZONTAL_ENDS; + break; + case GTK_MOVEMENT_DISPLAY_LINES: + case GTK_MOVEMENT_PARAGRAPHS: + case GTK_MOVEMENT_PARAGRAPH_ENDS: + scroll_step = GTK_SCROLL_STEPS; + break; + case GTK_MOVEMENT_PAGES: + scroll_step = GTK_SCROLL_PAGES; + break; + case GTK_MOVEMENT_HORIZONTAL_PAGES: + scroll_step = GTK_SCROLL_HORIZONTAL_PAGES; + break; + case GTK_MOVEMENT_BUFFER_ENDS: + scroll_step = GTK_SCROLL_ENDS; + break; + default: + scroll_step = GTK_SCROLL_PAGES; + break; + } + + gtk_text_view_move_viewport (text_view, scroll_step, count); + + return; + } + gtk_text_view_reset_im_context (text_view); if (step == GTK_MOVEMENT_PAGES) { - gtk_text_view_scroll_pages (text_view, count); + gtk_text_view_scroll_pages (text_view, count, extend_selection); gtk_text_view_pend_cursor_blink (text_view); return; } - else if (step == PAGE_HORIZONTALLY_HACK_VALUE) + else if (step == GTK_MOVEMENT_HORIZONTAL_PAGES) { - gtk_text_view_scroll_hpages (text_view, count); + gtk_text_view_scroll_hpages (text_view, count, extend_selection); gtk_text_view_pend_cursor_blink (text_view); return; } @@ -4424,7 +4621,7 @@ gtk_text_view_move_cursor_internal (GtkTextView *text_view, switch (step) { case GTK_MOVEMENT_LOGICAL_POSITIONS: - gtk_text_iter_forward_cursor_positions (&newplace, count); + gtk_text_iter_forward_visible_cursor_positions (&newplace, count); break; case GTK_MOVEMENT_VISUAL_POSITIONS: @@ -4434,9 +4631,12 @@ gtk_text_view_move_cursor_internal (GtkTextView *text_view, case GTK_MOVEMENT_WORDS: if (count < 0) - gtk_text_iter_backward_word_starts (&newplace, -count); - else if (count > 0) - gtk_text_iter_forward_word_ends (&newplace, count); + gtk_text_iter_backward_visible_word_starts (&newplace, -count); + else if (count > 0) + { + if (!gtk_text_iter_forward_visible_word_ends (&newplace, count)) + gtk_text_iter_forward_to_end (&newplace); + } break; case GTK_MOVEMENT_DISPLAY_LINES: @@ -4462,6 +4662,8 @@ gtk_text_view_move_cursor_internal (GtkTextView *text_view, gtk_text_iter_forward_to_line_end (&newplace); --count; } + gtk_text_iter_forward_lines (&newplace, count); + gtk_text_iter_forward_to_line_end (&newplace); } else if (count < 0) { @@ -4470,10 +4672,6 @@ gtk_text_view_move_cursor_internal (GtkTextView *text_view, gtk_text_iter_set_line_offset (&newplace, 0); ++count; } - } - - if (count != 0) - { gtk_text_iter_forward_lines (&newplace, count); gtk_text_iter_set_line_offset (&newplace, 0); } @@ -4496,22 +4694,19 @@ gtk_text_view_move_cursor_internal (GtkTextView *text_view, gtk_text_buffer_get_end_iter (get_buffer (text_view), &newplace); else if (count < 0) gtk_text_buffer_get_iter_at_offset (get_buffer (text_view), &newplace, 0); - break; + break; default: break; } + /* call move_cursor() even if the cursor hasn't moved, since it + cancels the selection + */ + move_cursor (text_view, &newplace, extend_selection); + if (!gtk_text_iter_equal (&insert, &newplace)) { - if (extend_selection) - gtk_text_buffer_move_mark (get_buffer (text_view), - gtk_text_buffer_get_mark (get_buffer (text_view), - "insert"), - &newplace); - else - gtk_text_buffer_place_cursor (get_buffer (text_view), &newplace); - DV(g_print (G_STRLOC": scrolling onscreen\n")); gtk_text_view_scroll_mark_onscreen (text_view, gtk_text_buffer_get_mark (get_buffer (text_view), @@ -4540,10 +4735,58 @@ gtk_text_view_page_horizontally (GtkTextView *text_view, gint count, gboolean extend_selection) { - gtk_text_view_move_cursor_internal (text_view, PAGE_HORIZONTALLY_HACK_VALUE, + gtk_text_view_move_cursor_internal (text_view, GTK_MOVEMENT_HORIZONTAL_PAGES, count, extend_selection); } + +static void +gtk_text_view_move_viewport (GtkTextView *text_view, + GtkScrollStep step, + gint count) +{ + GtkAdjustment *adjustment; + gdouble increment; + + switch (step) + { + case GTK_SCROLL_STEPS: + case GTK_SCROLL_PAGES: + case GTK_SCROLL_ENDS: + adjustment = get_vadjustment (text_view); + break; + case GTK_SCROLL_HORIZONTAL_STEPS: + case GTK_SCROLL_HORIZONTAL_PAGES: + case GTK_SCROLL_HORIZONTAL_ENDS: + adjustment = get_hadjustment (text_view); + break; + default: + adjustment = get_vadjustment (text_view); + break; + } + + switch (step) + { + case GTK_SCROLL_STEPS: + case GTK_SCROLL_HORIZONTAL_STEPS: + increment = adjustment->step_increment; + break; + case GTK_SCROLL_PAGES: + case GTK_SCROLL_HORIZONTAL_PAGES: + increment = adjustment->page_increment; + break; + case GTK_SCROLL_ENDS: + case GTK_SCROLL_HORIZONTAL_ENDS: + increment = adjustment->upper - adjustment->lower; + break; + default: + increment = 0.0; + break; + } + + set_adjustment_clamped (adjustment, adjustment->value + count * increment); +} + static void gtk_text_view_set_anchor (GtkTextView *text_view) { @@ -4558,7 +4801,8 @@ gtk_text_view_set_anchor (GtkTextView *text_view) static void gtk_text_view_scroll_pages (GtkTextView *text_view, - gint count) + gint count, + gboolean extend_selection) { gdouble newval; gdouble oldval; @@ -4570,9 +4814,18 @@ gtk_text_view_scroll_pages (GtkTextView *text_view, g_return_if_fail (text_view->vadjustment != NULL); + cancel_pending_scroll (text_view); + adj = text_view->vadjustment; - /* Validate the region that will be brought into view by the cursor motion + /* Make sure we start from the current cursor position, even + * if it was offscreen. + */ + gtk_text_view_scroll_mark_onscreen (text_view, + gtk_text_buffer_get_mark (get_buffer (text_view), + "insert")); + +/* Validate the region that will be brought into view by the cursor motion */ if (count < 0) { @@ -4594,13 +4847,13 @@ gtk_text_view_scroll_pages (GtkTextView *text_view, { /* already at top, just be sure we are at offset 0 */ gtk_text_buffer_get_start_iter (get_buffer (text_view), &new_insert); - gtk_text_buffer_place_cursor (get_buffer (text_view), &new_insert); + move_cursor (text_view, &new_insert, extend_selection); } else if (count > 0 && adj->value >= (adj->upper - adj->page_size - 1e-12)) { /* already at bottom, just be sure we are at the end */ gtk_text_buffer_get_end_iter (get_buffer (text_view), &new_insert); - gtk_text_buffer_place_cursor (get_buffer (text_view), &new_insert); + move_cursor (text_view, &new_insert, extend_selection); } else { @@ -4616,7 +4869,7 @@ gtk_text_view_scroll_pages (GtkTextView *text_view, gtk_text_layout_get_iter_at_pixel (text_view->layout, &new_insert, cursor_x_pos, cursor_y_pos); clamp_iter_onscreen (text_view, &new_insert); - gtk_text_buffer_place_cursor (get_buffer (text_view), &new_insert); + move_cursor (text_view, &new_insert, extend_selection); gtk_text_view_set_virtual_cursor_pos (text_view, cursor_x_pos, cursor_y_pos); } @@ -4632,7 +4885,8 @@ gtk_text_view_scroll_pages (GtkTextView *text_view, static void gtk_text_view_scroll_hpages (GtkTextView *text_view, - gint count) + gint count, + gboolean extend_selection) { gdouble newval; gdouble oldval; @@ -4643,8 +4897,17 @@ gtk_text_view_scroll_hpages (GtkTextView *text_view, g_return_if_fail (text_view->hadjustment != NULL); + cancel_pending_scroll (text_view); + adj = text_view->hadjustment; + /* Make sure we start from the current cursor position, even + * if it was offscreen. + */ + gtk_text_view_scroll_mark_onscreen (text_view, + gtk_text_buffer_get_mark (get_buffer (text_view), + "insert")); + /* Validate the line that we're moving within. */ gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), @@ -4658,13 +4921,13 @@ gtk_text_view_scroll_hpages (GtkTextView *text_view, { /* already at far left, just be sure we are at offset 0 */ gtk_text_iter_set_line_offset (&new_insert, 0); - gtk_text_buffer_place_cursor (get_buffer (text_view), &new_insert); + move_cursor (text_view, &new_insert, extend_selection); } else if (count > 0 && adj->value >= (adj->upper - adj->page_size - 1e-12)) { /* already at far right, just be sure we are at the end */ gtk_text_iter_forward_to_line_end (&new_insert); - gtk_text_buffer_place_cursor (get_buffer (text_view), &new_insert); + move_cursor (text_view, &new_insert, extend_selection); } else { @@ -4680,7 +4943,7 @@ gtk_text_view_scroll_hpages (GtkTextView *text_view, gtk_text_layout_get_iter_at_pixel (text_view->layout, &new_insert, cursor_x_pos, cursor_y_pos); clamp_iter_onscreen (text_view, &new_insert); - gtk_text_buffer_place_cursor (get_buffer (text_view), &new_insert); + move_cursor (text_view, &new_insert, extend_selection); gtk_text_view_set_virtual_cursor_pos (text_view, cursor_x_pos, cursor_y_pos); } @@ -4861,8 +5124,11 @@ gtk_text_view_delete_from_cursor (GtkTextView *text_view, static void gtk_text_view_cut_clipboard (GtkTextView *text_view) { + GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (text_view), + GDK_SELECTION_CLIPBOARD); + gtk_text_buffer_cut_clipboard (get_buffer (text_view), - gtk_clipboard_get (GDK_SELECTION_CLIPBOARD), + clipboard, text_view->editable); DV(g_print (G_STRLOC": scrolling onscreen\n")); gtk_text_view_scroll_mark_onscreen (text_view, @@ -4873,8 +5139,11 @@ gtk_text_view_cut_clipboard (GtkTextView *text_view) static void gtk_text_view_copy_clipboard (GtkTextView *text_view) { + GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (text_view), + GDK_SELECTION_CLIPBOARD); + gtk_text_buffer_copy_clipboard (get_buffer (text_view), - gtk_clipboard_get (GDK_SELECTION_CLIPBOARD)); + clipboard); DV(g_print (G_STRLOC": scrolling onscreen\n")); gtk_text_view_scroll_mark_onscreen (text_view, gtk_text_buffer_get_mark (get_buffer (text_view), @@ -4884,8 +5153,11 @@ gtk_text_view_copy_clipboard (GtkTextView *text_view) static void gtk_text_view_paste_clipboard (GtkTextView *text_view) { + GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (text_view), + GDK_SELECTION_CLIPBOARD); + gtk_text_buffer_paste_clipboard (get_buffer (text_view), - gtk_clipboard_get (GDK_SELECTION_CLIPBOARD), + clipboard, NULL, text_view->editable); DV(g_print (G_STRLOC": scrolling onscreen\n")); @@ -4898,6 +5170,95 @@ static void gtk_text_view_toggle_overwrite (GtkTextView *text_view) { text_view->overwrite_mode = !text_view->overwrite_mode; + g_object_notify (G_OBJECT (text_view), "overwrite"); +} + +/** + * gtk_text_view_get_overwrite: + * @text_view: a #GtkTextView + * + * Returns whether the #GtkTextView is in overwrite mode or not. + * + * Return value: whether @text_view is in overwrite mode or not. + * + * Since: 2.4 + **/ +gboolean +gtk_text_view_get_overwrite (GtkTextView *text_view) +{ + g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), FALSE); + + return text_view->overwrite_mode; +} + +/** + * gtk_text_view_set_overwrite: + * @text_view: a #GtkTextView + * @overwrite: %TRUE to turn on overwrite mode, %FALSE to turn it off + * + * Changes the #GtkTextView overwrite mode. + * + * Since: 2.4 + **/ +void +gtk_text_view_set_overwrite (GtkTextView *text_view, + gboolean overwrite) +{ + g_return_if_fail (GTK_IS_TEXT_VIEW (text_view)); + overwrite = overwrite != FALSE; + + if (text_view->overwrite_mode != overwrite) + { + text_view->overwrite_mode = overwrite; + + g_object_notify (G_OBJECT (text_view), "overwrite"); + } +} + +/** + * gtk_text_view_set_accepts_tab: + * @text_view: A #GtkTextView + * @accepts_tab: %TRUE if pressing the Tab key should insert a tab character, %FALSE, if pressing the Tab key should move the keyboard focus. + * + * Sets the behavior of the text widget when the Tab key is pressed. If @accepts_tab + * is %TRUE a tab character is inserted. If @accepts_tab is %FALSE the keyboard focus + * is moved to the next widget in the focus chain. + * + * Since: 2.4 + **/ +void +gtk_text_view_set_accepts_tab (GtkTextView *text_view, + gboolean accepts_tab) +{ + g_return_if_fail (GTK_IS_TEXT_VIEW (text_view)); + + accepts_tab = accepts_tab != FALSE; + + if (text_view->accepts_tab != accepts_tab) + { + text_view->accepts_tab = accepts_tab; + + g_object_notify (G_OBJECT (text_view), "accepts_tab"); + } +} + +/** + * gtk_text_view_get_accepts_tab: + * @text_view: A #GtkTextView + * + * Returns whether pressing the Tab key inserts a tab characters. + * gtk_text_view_set_accepts_tab(). + * + * Return value: %TRUE if pressing the Tab key inserts a tab character, %FALSE if pressing the Tab key moves the keyboard focus. + * + * Since: 2.4 + **/ +gboolean +gtk_text_view_get_accepts_tab (GtkTextView *text_view) +{ + g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), FALSE); + + return text_view->accepts_tab; } static void @@ -4910,7 +5271,7 @@ gtk_text_view_move_focus (GtkTextView *text_view, return; /* Propagate to toplevel */ - g_signal_emit_by_name (G_OBJECT (toplevel), "move_focus", direction_type); + g_signal_emit_by_name (toplevel, "move_focus", direction_type); } /* @@ -4980,7 +5341,9 @@ selection_scan_timeout (gpointer data) text_view = GTK_TEXT_VIEW (data); DV(g_print (G_STRLOC": calling move_mark_to_pointer_and_scroll\n")); - move_mark_to_pointer_and_scroll (text_view, "insert"); + gtk_text_view_scroll_mark_onscreen (text_view, + gtk_text_buffer_get_mark (get_buffer (text_view), + "insert")); GDK_THREADS_LEAVE (); @@ -5023,22 +5386,164 @@ drag_scan_timeout (gpointer data) return TRUE; } +typedef enum +{ + SELECT_CHARACTERS, + SELECT_WORDS, + SELECT_LINES +} SelectionGranularity; + +/* + * Move @start and @end to the boundaries of the selection unit (indicated by + * @granularity) which contained @start initially. Return wether @start was + * contained in a selection unit at all (which may not be the case for words). + */ +static gboolean +extend_selection (GtkTextView *text_view, + SelectionGranularity granularity, + GtkTextIter *start, + GtkTextIter *end) +{ + gboolean extend = TRUE; + + *end = *start; + + if (granularity == SELECT_WORDS) + { + if (gtk_text_iter_inside_word (start)) + { + if (!gtk_text_iter_starts_word (start)) + gtk_text_iter_backward_visible_word_start (start); + + if (!gtk_text_iter_ends_word (end)) + { + if (!gtk_text_iter_forward_visible_word_end (end)) + gtk_text_iter_forward_to_end (end); + } + } + else + extend = FALSE; + } + else if (granularity == SELECT_LINES) + { + if (gtk_text_view_starts_display_line (text_view, start)) + { + /* If on a display line boundary, we assume the user + * clicked off the end of a line and we therefore select + * the line before the boundary. + */ + gtk_text_view_backward_display_line_start (text_view, start); + } + else + { + /* start isn't on the start of a line, so we move it to the + * start, and move end to the end unless it's already there. + */ + gtk_text_view_backward_display_line_start (text_view, start); + + if (!gtk_text_view_starts_display_line (text_view, end)) + gtk_text_view_forward_display_line_end (text_view, end); + } + } + + return extend; +} + static gint selection_motion_event_handler (GtkTextView *text_view, GdkEventMotion *event, gpointer data) { - DV(g_print (G_STRLOC": calling move_mark_to_pointer_and_scroll\n")); - move_mark_to_pointer_and_scroll (text_view, "insert"); + SelectionGranularity granularity = GPOINTER_TO_INT (data); + if (granularity == SELECT_CHARACTERS) + { + move_mark_to_pointer_and_scroll (text_view, "insert"); + } + else + { + gint x, y; + GdkModifierType state; + GtkTextIter start, end; + GtkTextIter old_start, old_end; + GtkTextIter ins, bound; + GtkTextBuffer *buffer; + + buffer = get_buffer (text_view); + + gdk_window_get_pointer (text_view->text_window->bin_window, + &x, &y, &state); + + gtk_text_layout_get_iter_at_pixel (text_view->layout, + &start, + event->x + text_view->xoffset, + event->y + text_view->yoffset); + + if (extend_selection (text_view, granularity, &start, &end)) + { + /* Extend selection */ + gtk_text_buffer_get_iter_at_mark (buffer, + &ins, + gtk_text_buffer_get_insert (buffer)); + gtk_text_buffer_get_iter_at_mark (buffer, + &bound, + gtk_text_buffer_get_selection_bound (buffer)); + + if (gtk_text_iter_compare (&ins, &bound) < 0) + { + old_start = ins; + old_end = bound; + } + else + { + old_start = bound; + old_end = ins; + } + + if (gtk_text_iter_compare (&start, &old_start) < 0) + { + /* newly selected unit before the current selection */ + ins = start; + bound = old_end; + } + else if (gtk_text_iter_compare (&old_end, &end) < 0) + { + /* newly selected unit after the current selection */ + ins = end; + bound = old_start; + } + else if (gtk_text_iter_equal (&ins, &old_start)) + { + /* newly selected unit inside the current selection + at the start */ + if (!gtk_text_iter_equal (&ins, &start)) + ins = end; + } + else + { + /* newly selected unit inside the current selection + at the end */ + if (!gtk_text_iter_equal (&ins, &end)) + ins = start; + } + + gtk_text_buffer_select_range (buffer, &ins, &bound); + } + + gtk_text_view_scroll_mark_onscreen (text_view, + gtk_text_buffer_get_mark (buffer, + "insert")); + } + + /* If we had to scroll offscreen, insert a timeout to do so * again. Note that in the timeout, even if the mouse doesn't * move, due to this scroll xoffset/yoffset will have changed * and we'll need to scroll again. */ if (text_view->scroll_timeout != 0) /* reset on every motion event */ - gtk_timeout_remove (text_view->scroll_timeout); + g_source_remove (text_view->scroll_timeout); text_view->scroll_timeout = - gtk_timeout_add (50, selection_scan_timeout, text_view); + g_timeout_add (50, selection_scan_timeout, text_view); return TRUE; } @@ -5048,51 +5553,48 @@ gtk_text_view_start_selection_drag (GtkTextView *text_view, const GtkTextIter *iter, GdkEventButton *button) { - GtkTextIter newplace; + GtkTextIter start, end; GtkTextBuffer *buffer; - + SelectionGranularity granularity; + g_return_if_fail (text_view->selection_drag_handler == 0); + if (button->type == GDK_2BUTTON_PRESS) + granularity = SELECT_WORDS; + else if (button->type == GDK_3BUTTON_PRESS) + granularity = SELECT_LINES; + else + granularity = SELECT_CHARACTERS; + gtk_grab_add (GTK_WIDGET (text_view)); buffer = get_buffer (text_view); - newplace = *iter; + start = *iter; + + extend_selection (text_view, granularity, &start, &end); if (button->state & GDK_SHIFT_MASK) { /* Extend selection */ - GtkTextIter start, end; - - gtk_text_buffer_get_selection_bounds (buffer, &start, &end); + GtkTextIter old_start, old_end; - if (gtk_text_iter_compare (&newplace, &start) <= 0) - { - gtk_text_buffer_move_mark_by_name (buffer, "insert", - &newplace); - - gtk_text_buffer_move_mark_by_name (buffer, "selection_bound", - &end); - } - else if (gtk_text_iter_compare (&newplace, &end) >= 0) - { - gtk_text_buffer_move_mark_by_name (buffer, "insert", - &newplace); - - gtk_text_buffer_move_mark_by_name (buffer, "selection_bound", - &start); - } - } - else - { - /* Replace selection */ - gtk_text_buffer_place_cursor (buffer, &newplace); + gtk_text_buffer_get_selection_bounds (buffer, &old_start, &old_end); + + gtk_text_iter_order (&start, &old_start); + gtk_text_iter_order (&old_end, &end); + + /* Now start is the first of the starts, and end is the + * last of the ends + */ } - text_view->selection_drag_handler = gtk_signal_connect (GTK_OBJECT (text_view), - "motion_notify_event", - GTK_SIGNAL_FUNC (selection_motion_event_handler), - NULL); + gtk_text_buffer_select_range (buffer, &end, &start); + + text_view->selection_drag_handler = g_signal_connect (text_view, + "motion_notify_event", + G_CALLBACK (selection_motion_event_handler), + GINT_TO_POINTER (granularity)); } /* returns whether we were really dragging */ @@ -5102,19 +5604,15 @@ gtk_text_view_end_selection_drag (GtkTextView *text_view, GdkEventButton *event) if (text_view->selection_drag_handler == 0) return FALSE; - gtk_signal_disconnect (GTK_OBJECT (text_view), text_view->selection_drag_handler); + g_signal_handler_disconnect (text_view, text_view->selection_drag_handler); text_view->selection_drag_handler = 0; if (text_view->scroll_timeout != 0) { - gtk_timeout_remove (text_view->scroll_timeout); + g_source_remove (text_view->scroll_timeout); text_view->scroll_timeout = 0; } - /* one last update to current position */ - DV(g_print (G_STRLOC": calling move_mark_to_pointer_and_scroll\n")); - move_mark_to_pointer_and_scroll (text_view, "insert"); - gtk_grab_remove (GTK_WIDGET (text_view)); return TRUE; @@ -5143,21 +5641,28 @@ gtk_text_view_check_keymap_direction (GtkTextView *text_view) { if (text_view->layout) { - gboolean split_cursor; - GtkTextDirection new_dir; GtkSettings *settings = gtk_widget_get_settings (GTK_WIDGET (text_view)); - - g_object_get (G_OBJECT (settings), + GdkKeymap *keymap = gdk_keymap_get_for_display (gtk_widget_get_display (GTK_WIDGET (text_view))); + GtkTextDirection new_cursor_dir; + GtkTextDirection new_keyboard_dir; + gboolean split_cursor; + + g_object_get (settings, "gtk-split-cursor", &split_cursor, NULL); + + if (gdk_keymap_get_direction (keymap) == PANGO_DIRECTION_LTR) + new_keyboard_dir = GTK_TEXT_DIR_LTR; + else + new_keyboard_dir = GTK_TEXT_DIR_RTL; + if (split_cursor) - new_dir = GTK_TEXT_DIR_NONE; + new_cursor_dir = GTK_TEXT_DIR_NONE; else - new_dir = (gdk_keymap_get_direction (gdk_keymap_get_default ()) == PANGO_DIRECTION_LTR) ? - GTK_TEXT_DIR_LTR : GTK_TEXT_DIR_RTL; + new_cursor_dir = new_keyboard_dir; - if (text_view->layout->cursor_direction != new_dir) - gtk_text_layout_set_cursor_direction (text_view->layout, new_dir); + gtk_text_layout_set_cursor_direction (text_view->layout, new_cursor_dir); + gtk_text_layout_set_keyboard_direction (text_view->layout, new_keyboard_dir); } } @@ -5178,17 +5683,17 @@ gtk_text_view_ensure_layout (GtkTextView *text_view) text_view->layout = gtk_text_layout_new (); - g_signal_connect (G_OBJECT (text_view->layout), + g_signal_connect (text_view->layout, "invalidated", G_CALLBACK (invalidated_handler), text_view); - g_signal_connect (G_OBJECT (text_view->layout), + g_signal_connect (text_view->layout, "changed", G_CALLBACK (changed_handler), text_view); - g_signal_connect (G_OBJECT (text_view->layout), + g_signal_connect (text_view->layout, "allocate_child", G_CALLBACK (gtk_text_view_child_allocated), text_view); @@ -5208,8 +5713,8 @@ gtk_text_view_ensure_layout (GtkTextView *text_view) gtk_text_layout_set_contexts (text_view->layout, ltr_context, rtl_context); - g_object_unref (G_OBJECT (ltr_context)); - g_object_unref (G_OBJECT (rtl_context)); + g_object_unref (ltr_context); + g_object_unref (rtl_context); gtk_text_view_check_keymap_direction (text_view); @@ -5251,6 +5756,8 @@ gtk_text_view_ensure_layout (GtkTextView *text_view) tmp_list = g_slist_next (tmp_list); } + + gtk_text_view_invalidate (text_view); } } @@ -5287,6 +5794,13 @@ gtk_text_view_destroy_layout (GtkTextView *text_view) GSList *tmp_list; gtk_text_view_remove_validate_idles (text_view); + + g_signal_handlers_disconnect_by_func (text_view->layout, + invalidated_handler, + text_view); + g_signal_handlers_disconnect_by_func (text_view->layout, + changed_handler, + text_view); /* Remove layout from all anchored children */ tmp_list = text_view->children; @@ -5306,11 +5820,7 @@ gtk_text_view_destroy_layout (GtkTextView *text_view) gtk_text_view_stop_cursor_blink (text_view); gtk_text_view_end_selection_drag (text_view, NULL); - g_signal_handlers_disconnect_by_func (G_OBJECT (text_view->layout), - invalidated_handler, text_view); - g_signal_handlers_disconnect_by_func (G_OBJECT (text_view->layout), - changed_handler, text_view); - g_object_unref (G_OBJECT (text_view->layout)); + g_object_unref (text_view->layout); text_view->layout = NULL; } } @@ -5437,7 +5947,7 @@ gtk_text_view_drag_leave (GtkWidget *widget, gtk_text_mark_set_visible (text_view->dnd_mark, FALSE); if (text_view->scroll_timeout != 0) - gtk_timeout_remove (text_view->scroll_timeout); + g_source_remove (text_view->scroll_timeout); text_view->scroll_timeout = 0; } @@ -5483,7 +5993,8 @@ gtk_text_view_drag_motion (GtkWidget *widget, } else if (gtk_text_buffer_get_selection_bounds (get_buffer (text_view), &start, &end) && - gtk_text_iter_in_range (&newplace, &start, &end)) + gtk_text_iter_compare (&newplace, &start) >= 0 && + gtk_text_iter_compare (&newplace, &end) <= 0) { /* We're inside the selection. */ } @@ -5535,10 +6046,10 @@ gtk_text_view_drag_motion (GtkWidget *widget, DND_SCROLL_MARGIN, FALSE, 0.0, 0.0); if (text_view->scroll_timeout != 0) /* reset on every motion event */ - gtk_timeout_remove (text_view->scroll_timeout); + g_source_remove (text_view->scroll_timeout); text_view->scroll_timeout = - gtk_timeout_add (50, drag_scan_timeout, text_view); + g_timeout_add (50, drag_scan_timeout, text_view); /* TRUE return means don't propagate the drag motion to parent * widgets that may also be drop sites. @@ -5560,7 +6071,7 @@ gtk_text_view_drag_drop (GtkWidget *widget, text_view = GTK_TEXT_VIEW (widget); if (text_view->scroll_timeout != 0) - gtk_timeout_remove (text_view->scroll_timeout); + g_source_remove (text_view->scroll_timeout); text_view->scroll_timeout = 0; @@ -5611,19 +6122,26 @@ gtk_text_view_drag_data_received (GtkWidget *widget, GtkTextIter drop_point; GtkTextView *text_view; gboolean success = FALSE; + GtkTextBuffer *buffer = NULL; text_view = GTK_TEXT_VIEW (widget); if (!text_view->dnd_mark) goto done; - gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), + buffer = get_buffer (text_view); + + gtk_text_buffer_get_iter_at_mark (buffer, &drop_point, text_view->dnd_mark); if (!gtk_text_iter_can_insert (&drop_point, text_view->editable)) goto done; + success = TRUE; + + gtk_text_buffer_begin_user_action (buffer); + if (selection_data->target == gdk_atom_intern ("GTK_TEXT_BUFFER_CONTENTS", FALSE)) { GtkTextBuffer *src_buffer = NULL; @@ -5641,7 +6159,7 @@ gtk_text_view_drag_data_received (GtkWidget *widget, g_return_if_fail (GTK_IS_TEXT_BUFFER (src_buffer)); if (gtk_text_buffer_get_tag_table (src_buffer) != - gtk_text_buffer_get_tag_table (get_buffer (text_view))) + gtk_text_buffer_get_tag_table (buffer)) copy_tags = FALSE; if (gtk_text_buffer_get_selection_bounds (src_buffer, @@ -5649,7 +6167,7 @@ gtk_text_view_drag_data_received (GtkWidget *widget, &end)) { if (copy_tags) - gtk_text_buffer_insert_range_interactive (get_buffer (text_view), + gtk_text_buffer_insert_range_interactive (buffer, &drop_point, &start, &end, @@ -5659,7 +6177,7 @@ gtk_text_view_drag_data_received (GtkWidget *widget, gchar *str; str = gtk_text_iter_get_visible_text (&start, &end); - gtk_text_buffer_insert_interactive (get_buffer (text_view), + gtk_text_buffer_insert_interactive (buffer, &drop_point, str, -1, text_view->editable); g_free (str); @@ -5668,13 +6186,21 @@ gtk_text_view_drag_data_received (GtkWidget *widget, } else insert_text_data (text_view, &drop_point, selection_data); - - success = TRUE; - + done: gtk_drag_finish (context, success, success && context->action == GDK_ACTION_MOVE, time); + + if (success) + { + gtk_text_buffer_get_iter_at_mark (buffer, + &drop_point, + text_view->dnd_mark); + gtk_text_buffer_place_cursor (buffer, &drop_point); + + gtk_text_buffer_end_user_action (buffer); + } } static GtkAdjustment* @@ -5719,37 +6245,41 @@ gtk_text_view_set_scroll_adjustments (GtkTextView *text_view, if (text_view->hadjustment && (text_view->hadjustment != hadj)) { - gtk_signal_disconnect_by_data (GTK_OBJECT (text_view->hadjustment), text_view); - g_object_unref (G_OBJECT (text_view->hadjustment)); + g_signal_handlers_disconnect_by_func (text_view->hadjustment, + gtk_text_view_value_changed, + text_view); + g_object_unref (text_view->hadjustment); } if (text_view->vadjustment && (text_view->vadjustment != vadj)) { - gtk_signal_disconnect_by_data (GTK_OBJECT (text_view->vadjustment), text_view); - g_object_unref (G_OBJECT (text_view->vadjustment)); + g_signal_handlers_disconnect_by_func (text_view->vadjustment, + gtk_text_view_value_changed, + text_view); + g_object_unref (text_view->vadjustment); } if (text_view->hadjustment != hadj) { text_view->hadjustment = hadj; - g_object_ref (G_OBJECT (text_view->hadjustment)); + g_object_ref (text_view->hadjustment); gtk_object_sink (GTK_OBJECT (text_view->hadjustment)); - gtk_signal_connect (GTK_OBJECT (text_view->hadjustment), "value_changed", - (GtkSignalFunc) gtk_text_view_value_changed, - text_view); + g_signal_connect (text_view->hadjustment, "value_changed", + G_CALLBACK (gtk_text_view_value_changed), + text_view); need_adjust = TRUE; } if (text_view->vadjustment != vadj) { text_view->vadjustment = vadj; - g_object_ref (G_OBJECT (text_view->vadjustment)); + g_object_ref (text_view->vadjustment); gtk_object_sink (GTK_OBJECT (text_view->vadjustment)); - gtk_signal_connect (GTK_OBJECT (text_view->vadjustment), "value_changed", - (GtkSignalFunc) gtk_text_view_value_changed, - text_view); + g_signal_connect (text_view->vadjustment, "value_changed", + G_CALLBACK (gtk_text_view_value_changed), + text_view); need_adjust = TRUE; } @@ -6020,9 +6550,12 @@ gtk_text_view_preedit_changed_handler (GtkIMContext *context, gtk_im_context_get_preedit_string (context, &str, &attrs, &cursor_pos); gtk_text_layout_set_preedit_string (text_view->layout, str, attrs, cursor_pos); - pango_attr_list_unref (attrs); g_free (str); + + gtk_text_view_scroll_mark_onscreen (text_view, + gtk_text_buffer_get_mark (get_buffer (text_view), + "insert")); } static gboolean @@ -6096,27 +6629,35 @@ gtk_text_view_mark_set_handler (GtkTextBuffer *buffer, } static void -gtk_text_view_get_virtual_cursor_pos (GtkTextView *text_view, - gint *x, - gint *y) +gtk_text_view_get_cursor_location (GtkTextView *text_view, + GdkRectangle *pos) { - GdkRectangle strong_pos; GtkTextIter insert; - + gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &insert, gtk_text_buffer_get_mark (get_buffer (text_view), "insert")); + gtk_text_layout_get_cursor_locations (text_view->layout, &insert, pos, NULL); +} + +static void +gtk_text_view_get_virtual_cursor_pos (GtkTextView *text_view, + gint *x, + gint *y) +{ + GdkRectangle pos; + if ((x && text_view->virtual_cursor_x == -1) || (y && text_view->virtual_cursor_y == -1)) - gtk_text_layout_get_cursor_locations (text_view->layout, &insert, &strong_pos, NULL); + gtk_text_view_get_cursor_location (text_view, &pos); if (x) { if (text_view->virtual_cursor_x != -1) *x = text_view->virtual_cursor_x; else - *x = strong_pos.x; + *x = pos.x; } if (y) @@ -6124,7 +6665,7 @@ gtk_text_view_get_virtual_cursor_pos (GtkTextView *text_view, if (text_view->virtual_cursor_x != -1) *y = text_view->virtual_cursor_y; else - *y = strong_pos.y + strong_pos.height / 2; + *y = pos.y + pos.height / 2; } } @@ -6133,18 +6674,13 @@ gtk_text_view_set_virtual_cursor_pos (GtkTextView *text_view, gint x, gint y) { - GdkRectangle strong_pos; - GtkTextIter insert; - - gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &insert, - gtk_text_buffer_get_mark (get_buffer (text_view), - "insert")); + GdkRectangle pos; if (x == -1 || y == -1) - gtk_text_layout_get_cursor_locations (text_view->layout, &insert, &strong_pos, NULL); + gtk_text_view_get_cursor_location (text_view, &pos); - text_view->virtual_cursor_x = (x == -1) ? strong_pos.x : x; - text_view->virtual_cursor_y = (y == -1) ? strong_pos.y + strong_pos.height / 2 : y; + text_view->virtual_cursor_x = (x == -1) ? pos.x : x; + text_view->virtual_cursor_y = (y == -1) ? pos.y + pos.height / 2 : y; } /* Quick hack of a popup menu @@ -6154,7 +6690,7 @@ activate_cb (GtkWidget *menuitem, GtkTextView *text_view) { const gchar *signal = g_object_get_data (G_OBJECT (menuitem), "gtk-signal"); - gtk_signal_emit_by_name (GTK_OBJECT (text_view), signal); + g_signal_emit_by_name (text_view, signal); } static void @@ -6167,8 +6703,8 @@ append_action_signal (GtkTextView *text_view, GtkWidget *menuitem = gtk_image_menu_item_new_from_stock (stock_id, NULL); g_object_set_data (G_OBJECT (menuitem), "gtk-signal", (char *)signal); - gtk_signal_connect (GTK_OBJECT (menuitem), "activate", - GTK_SIGNAL_FUNC (activate_cb), text_view); + g_signal_connect (menuitem, "activate", + G_CALLBACK (activate_cb), text_view); gtk_widget_set_sensitive (menuitem, sensitive); @@ -6176,6 +6712,43 @@ append_action_signal (GtkTextView *text_view, gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem); } +static void +gtk_text_view_select_all (GtkWidget *widget, + gboolean select) +{ + GtkTextView *text_view = GTK_TEXT_VIEW (widget); + GtkTextBuffer *buffer; + GtkTextIter start_iter, end_iter, insert; + + buffer = text_view->buffer; + if (select) + { + gtk_text_buffer_get_bounds (buffer, &start_iter, &end_iter); + gtk_text_buffer_move_mark_by_name (buffer, "insert", &start_iter); + gtk_text_buffer_move_mark_by_name (buffer, "selection_bound", &end_iter); + } + else + { + gtk_text_buffer_get_iter_at_mark (buffer, &insert, + gtk_text_buffer_get_insert (buffer)); + gtk_text_buffer_move_mark_by_name (buffer, "selection_bound", &insert); + } +} + +static void +select_all_cb (GtkWidget *menuitem, + GtkTextView *text_view) +{ + gtk_text_view_select_all (GTK_WIDGET (text_view), TRUE); +} + +static void +delete_cb (GtkTextView *text_view) +{ + gtk_text_buffer_delete_selection (get_buffer (text_view), TRUE, + text_view->editable); +} + static void popup_menu_detach (GtkWidget *attach_widget, GtkMenu *menu) @@ -6197,11 +6770,14 @@ popup_position_func (GtkMenu *menu, gint root_x, root_y; GtkTextIter iter; GtkRequisition req; + GdkScreen *screen; text_view = GTK_TEXT_VIEW (user_data); widget = GTK_WIDGET (text_view); g_return_if_fail (GTK_WIDGET_REALIZED (text_view)); + + screen = gtk_widget_get_screen (widget); gdk_window_get_origin (widget->window, &root_x, &root_y); @@ -6242,8 +6818,8 @@ popup_position_func (GtkMenu *menu, *x = CLAMP (*x, root_x, (root_x + widget->allocation.width)); *y = CLAMP (*y, root_y, (root_y + widget->allocation.height)); - *x = CLAMP (*x, 0, MAX (0, gdk_screen_width () - req.width)); - *y = CLAMP (*y, 0, MAX (0, gdk_screen_height () - req.height)); + *x = CLAMP (*x, 0, MAX (0, gdk_screen_get_width (screen) - req.width)); + *y = CLAMP (*y, 0, MAX (0, gdk_screen_get_height (screen) - req.height)); } typedef struct @@ -6328,12 +6904,34 @@ popup_targets_received (GtkClipboard *clipboard, append_action_signal (text_view, text_view->popup_menu, GTK_STOCK_PASTE, "paste_clipboard", can_insert && clipboard_contains_text); + menuitem = gtk_image_menu_item_new_from_stock (GTK_STOCK_DELETE, NULL); + gtk_widget_set_sensitive (menuitem, + have_selection && + range_contains_editable_text (&sel_start, &sel_end, + text_view->editable)); + g_signal_connect_swapped (menuitem, "activate", + G_CALLBACK (delete_cb), text_view); + gtk_widget_show (menuitem); + gtk_menu_shell_append (GTK_MENU_SHELL (text_view->popup_menu), menuitem); + + menuitem = gtk_separator_menu_item_new (); + gtk_widget_show (menuitem); + gtk_menu_shell_append (GTK_MENU_SHELL (text_view->popup_menu), menuitem); + + menuitem = gtk_menu_item_new_with_mnemonic (_("Select _All")); + g_signal_connect (menuitem, "activate", + G_CALLBACK (select_all_cb), text_view); + gtk_widget_show (menuitem); + gtk_menu_shell_append (GTK_MENU_SHELL (text_view->popup_menu), menuitem); + menuitem = gtk_separator_menu_item_new (); gtk_widget_show (menuitem); gtk_menu_shell_append (GTK_MENU_SHELL (text_view->popup_menu), menuitem); menuitem = gtk_menu_item_new_with_mnemonic (_("Input _Methods")); gtk_widget_show (menuitem); + gtk_widget_set_sensitive (menuitem, can_insert); + submenu = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), submenu); gtk_menu_shell_append (GTK_MENU_SHELL (text_view->popup_menu), menuitem); @@ -6341,7 +6939,7 @@ popup_targets_received (GtkClipboard *clipboard, gtk_im_multicontext_append_menuitems (GTK_IM_MULTICONTEXT (text_view->im_context), GTK_MENU_SHELL (submenu)); - menuitem = gtk_menu_item_new_with_mnemonic (_("_Insert Unicode control character")); + menuitem = gtk_menu_item_new_with_mnemonic (_("_Insert Unicode Control Character")); gtk_widget_show (menuitem); gtk_widget_set_sensitive (menuitem, can_insert); @@ -6353,9 +6951,10 @@ popup_targets_received (GtkClipboard *clipboard, unichar_chosen_func, text_view); - gtk_signal_emit (GTK_OBJECT (text_view), - signals[POPULATE_POPUP], - text_view->popup_menu); + g_signal_emit (text_view, + signals[POPULATE_POPUP], + 0, + text_view->popup_menu); if (info->button) gtk_menu_popup (GTK_MENU (text_view->popup_menu), NULL, NULL, @@ -6366,7 +6965,7 @@ popup_targets_received (GtkClipboard *clipboard, gtk_menu_popup (GTK_MENU (text_view->popup_menu), NULL, NULL, popup_position_func, text_view, 0, gtk_get_current_event_time ()); - _gtk_menu_shell_select_first (GTK_MENU_SHELL (text_view->popup_menu)); + gtk_menu_shell_select_first (GTK_MENU_SHELL (text_view->popup_menu), FALSE); } } @@ -6380,6 +6979,9 @@ gtk_text_view_do_popup (GtkTextView *text_view, { PopupInfo *info = g_new (PopupInfo, 1); + /* should not need this, see http://bugzilla.gnome.org/show_bug.cgi?id=74620 */ + gtk_text_view_end_selection_drag (text_view, event); + /* In order to know what entries we should make sensitive, we * ask for the current targets of the clipboard, and when * we get them, then we actually pop up the menu. @@ -6397,7 +6999,8 @@ gtk_text_view_do_popup (GtkTextView *text_view, info->time = gtk_get_current_event_time (); } - gtk_clipboard_request_contents (gtk_clipboard_get (GDK_SELECTION_CLIPBOARD), + gtk_clipboard_request_contents (gtk_widget_get_clipboard (GTK_WIDGET (text_view), + GDK_SELECTION_CLIPBOARD), gdk_atom_intern ("TARGETS", FALSE), popup_targets_received, info); @@ -6496,7 +7099,8 @@ text_window_realize (GtkTextWindow *win, if (win->type == GTK_TEXT_WINDOW_TEXT) { /* I-beam cursor */ - cursor = gdk_cursor_new (GDK_XTERM); + cursor = gdk_cursor_new_for_display (gdk_drawable_get_display (parent), + GDK_XTERM); gdk_window_set_cursor (win->bin_window, cursor); gdk_cursor_unref (cursor); @@ -6618,7 +7222,7 @@ text_window_invalidate_rect (GtkTextWindow *win, gdk_draw_rectangle (win->bin_window, gc, TRUE, window_rect.x, window_rect.y, window_rect.width, window_rect.height); - gdk_gc_unref (gc); + g_object_unref (gc); } #endif } @@ -6635,13 +7239,6 @@ text_window_get_height (GtkTextWindow *win) return win->allocation.height; } -static void -text_window_get_allocation (GtkTextWindow *win, - GdkRectangle *rect) -{ - *rect = win->allocation; -} - /* Windows */ @@ -6811,14 +7408,17 @@ buffer_to_text_window (GtkTextView *text_view, /** * gtk_text_view_buffer_to_window_coords: * @text_view: a #GtkTextView - * @win: a #GtkTextWindowType + * @win: a #GtkTextWindowType except #GTK_TEXT_WINDOW_PRIVATE * @buffer_x: buffer x coordinate * @buffer_y: buffer y coordinate * @window_x: window x coordinate return location * @window_y: window y coordinate return location * * Converts coordinate (@buffer_x, @buffer_y) to coordinates for the window - * @win, and stores the result in (@window_x, @window_y). + * @win, and stores the result in (@window_x, @window_y). + * + * Note that you can't convert coordinates for a nonexisting window (see + * gtk_text_view_set_border_window_size()). **/ void gtk_text_view_buffer_to_window_coords (GtkTextView *text_view, @@ -6948,7 +7548,7 @@ text_window_to_buffer (GtkTextView *text_view, /** * gtk_text_view_window_to_buffer_coords: * @text_view: a #GtkTextView - * @win: a #GtkTextWindowType + * @win: a #GtkTextWindowType except #GTK_TEXT_WINDOW_PRIVATE * @window_x: window x coordinate * @window_y: window y coordinate * @buffer_x: buffer x coordinate return location @@ -6956,6 +7556,9 @@ text_window_to_buffer (GtkTextView *text_view, * * Converts coordinates on the window identified by @win to buffer * coordinates, storing the result in (@buffer_x,@buffer_y). + * + * Note that you can't convert coordinates for a nonexisting window (see + * gtk_text_view_set_border_window_size()). **/ void gtk_text_view_window_to_buffer_coords (GtkTextView *text_view, @@ -7204,14 +7807,15 @@ text_view_child_new_anchored (GtkWidget *child, vc = g_new (GtkTextViewChild, 1); + vc->type = GTK_TEXT_WINDOW_PRIVATE; vc->widget = child; vc->anchor = anchor; vc->from_top_of_line = 0; vc->from_left_of_buffer = 0; - g_object_ref (G_OBJECT (vc->widget)); - g_object_ref (G_OBJECT (vc->anchor)); + g_object_ref (vc->widget); + g_object_ref (vc->anchor); g_object_set_data (G_OBJECT (child), "gtk-text-view-child", @@ -7237,8 +7841,8 @@ text_view_child_new_window (GtkWidget *child, vc->from_top_of_line = 0; vc->from_left_of_buffer = 0; - - g_object_ref (G_OBJECT (vc->widget)); + + g_object_ref (vc->widget); vc->type = type; vc->x = x; @@ -7261,10 +7865,10 @@ text_view_child_free (GtkTextViewChild *child) { gtk_text_child_anchor_unregister_child (child->anchor, child->widget); - g_object_unref (G_OBJECT (child->anchor)); + g_object_unref (child->anchor); } - g_object_unref (G_OBJECT (child->widget)); + g_object_unref (child->widget); g_free (child); } @@ -7558,11 +8162,19 @@ gtk_text_view_starts_display_line (GtkTextView *text_view, * gtk_text_view_move_visually: * @text_view: a #GtkTextView * @iter: a #GtkTextIter - * @count: number of lines to move - * - * Moves @iter up or down by @count display (wrapped) lines. - * See gtk_text_view_forward_display_line() for an explanation of - * display lines vs. paragraphs. + * @count: number of characters to move (negative moves left, positive moves right) + * + * Move the iterator a given number of characters visually, treating + * it as the strong cursor position. If @count is positive, then the + * new strong cursor position will be @count positions to the right of + * the old cursor position. If @count is negative then the new strong + * cursor position will be @count positions to the left of the old + * cursor position. + * + * In the presence of bidirection text, the correspondence + * between logical and visual order will depend on the direction + * of the current run, and there may be jumps when the cursor + * is moved off of the end of a run. * * Return value: %TRUE if @iter moved and is not on the end iterator **/