* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
-#include <config.h>
+#include "config.h"
#include <string.h>
#define GTK_TEXT_USE_INTERNAL_UNSUPPORTED_API
struct _GtkTextViewPrivate
{
guint blink_time; /* time in msec the cursor has blinked since last user event */
+ guint im_spot_idle;
+ gchar *im_module;
};
MOVE_VIEWPORT,
SELECT_ALL,
TOGGLE_CURSOR_VISIBLE,
+ PREEDIT_CHANGED,
LAST_SIGNAL
};
PROP_BUFFER,
PROP_OVERWRITE,
PROP_ACCEPTS_TAB,
- LAST_PROP
+ PROP_IM_MODULE
};
static void gtk_text_view_destroy (GtkObject *object);
static void gtk_text_view_target_list_notify (GtkTextBuffer *buffer,
const GParamSpec *pspec,
gpointer data);
+static void gtk_text_view_paste_done_handler (GtkTextBuffer *buffer,
+ GtkClipboard *clipboard,
+ 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,
+ GtkTextIter *cursor,
gint *x,
gint *y);
static void gtk_text_view_set_virtual_cursor_pos (GtkTextView *text_view,
static void gtk_text_view_do_popup (GtkTextView *text_view,
GdkEventButton *event);
+static void cancel_pending_scroll (GtkTextView *text_view);
static void gtk_text_view_queue_scroll (GtkTextView *text_view,
GtkTextMark *mark,
gdouble within_margin,
g_assert ((modmask & GDK_SHIFT_MASK) == 0);
gtk_binding_entry_add_signal (binding_set, keyval, modmask,
- "move_cursor", 3,
+ "move-cursor", 3,
G_TYPE_ENUM, step,
G_TYPE_INT, count,
G_TYPE_BOOLEAN, FALSE);
/* Selection-extending version */
gtk_binding_entry_add_signal (binding_set, keyval, modmask | GDK_SHIFT_MASK,
- "move_cursor", 3,
+ "move-cursor", 3,
G_TYPE_ENUM, step,
G_TYPE_INT, count,
G_TYPE_BOOLEAN, TRUE);
widget_class->expose_event = gtk_text_view_expose_event;
widget_class->focus = gtk_text_view_focus;
- /* need to override the base class function via override_class_closure,
+ /* need to override the base class function via override_class_handler,
* because the signal slot is not available in GtkWidgetCLass
*/
- g_signal_override_class_closure (g_signal_lookup ("move-focus",
- GTK_TYPE_WIDGET),
+ g_signal_override_class_handler ("move-focus",
GTK_TYPE_TEXT_VIEW,
- g_cclosure_new (G_CALLBACK (gtk_text_view_move_focus),
- NULL, NULL));
+ G_CALLBACK (gtk_text_view_move_focus));
widget_class->drag_begin = gtk_text_view_drag_begin;
widget_class->drag_end = gtk_text_view_drag_end;
TRUE,
GTK_PARAM_READWRITE));
+ /**
+ * GtkTextView:im-module:
+ *
+ * Which IM (input method) module should be used for this entry.
+ * See #GtkIMContext.
+ *
+ * Setting this to a non-%NULL value overrides the
+ * system-wide IM module setting. See the GtkSettings
+ * #GtkSettings:gtk-im-module property.
+ *
+ * Since: 2.16
+ */
+ g_object_class_install_property (gobject_class,
+ PROP_IM_MODULE,
+ g_param_spec_string ("im-module",
+ P_("IM module"),
+ P_("Which IM module should be used"),
+ NULL,
+ GTK_PARAM_READWRITE));
+
/*
* Style properties
*/
* the viewport to be moved instead.
*
* Applications should not connect to it, but may emit it with
- * g_signal_emit_by_name() if they need to control scrolling
+ * g_signal_emit_by_name() if they need to control the cursor
* programmatically.
*
* The default bindings for this signal come in two variants,
* </itemizedlist>
*/
signals[MOVE_CURSOR] =
- g_signal_new (I_("move_cursor"),
+ g_signal_new (I_("move-cursor"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkTextViewClass, move_cursor),
* granularity.
*/
signals[PAGE_HORIZONTALLY] =
- g_signal_new (I_("page_horizontally"),
+ g_signal_new (I_("page-horizontally"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkTextViewClass, page_horizontally),
* There are no default bindings for this signal.
*/
signals[MOVE_VIEWPORT] =
- _gtk_binding_signal_new (I_("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);
+ g_signal_new_class_handler (I_("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);
+ /**
+ * GtkTextView::set-anchor:
+ * @text_view: the object which received the signal
+ *
+ * The ::set-anchor signal is a
+ * <link linkend="keybinding-signals">keybinding signal</link>
+ * which gets emitted when the user initiates setting the "anchor"
+ * mark. The "anchor" mark gets placed at the same position as the
+ * "insert" mark.
+ *
+ * This signal has no default bindings.
+ */
signals[SET_ANCHOR] =
- g_signal_new (I_("set_anchor"),
+ g_signal_new (I_("set-anchor"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkTextViewClass, set_anchor),
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
+ /**
+ * GtkTextView::insert-at-cursor:
+ * @text_view: the object which received the signal
+ * @string: the string to insert
+ *
+ * The ::insert-at-cursor signal is a
+ * <link linkend="keybinding-signals">keybinding signal</link>
+ * which gets emitted when the user initiates the insertion of a
+ * fixed string at the cursor.
+ *
+ * This signal has no default bindings.
+ */
signals[INSERT_AT_CURSOR] =
- g_signal_new (I_("insert_at_cursor"),
+ g_signal_new (I_("insert-at-cursor"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkTextViewClass, insert_at_cursor),
* backwords.
*/
signals[DELETE_FROM_CURSOR] =
- g_signal_new (I_("delete_from_cursor"),
+ g_signal_new (I_("delete-from-cursor"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkTextViewClass, delete_from_cursor),
* Ctrl-x and Shift-Delete.
*/
signals[CUT_CLIPBOARD] =
- g_signal_new (I_("cut_clipboard"),
+ g_signal_new (I_("cut-clipboard"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkTextViewClass, cut_clipboard),
* Ctrl-c and Ctrl-Insert.
*/
signals[COPY_CLIPBOARD] =
- g_signal_new (I_("copy_clipboard"),
+ g_signal_new (I_("copy-clipboard"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkTextViewClass, copy_clipboard),
* Ctrl-v and Shift-Insert.
*/
signals[PASTE_CLIPBOARD] =
- g_signal_new (I_("paste_clipboard"),
+ g_signal_new (I_("paste-clipboard"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkTextViewClass, paste_clipboard),
*
* The ::toggle-overwrite signal is a
* <link linkend="keybinding-signals">keybinding signal</link>
- * which gets emitted to change the editability of the text view.
+ * which gets emitted to toggle the overwrite mode of the text view.
*
* The default bindings for this signal is Insert.
*/
signals[TOGGLE_OVERWRITE] =
- g_signal_new (I_("toggle_overwrite"),
+ g_signal_new (I_("toggle-overwrite"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkTextViewClass, toggle_overwrite),
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
+ /**
+ * GtkTextView::set-scroll-adjustments
+ * @horizontal: the horizontal #GtkAdjustment
+ * @vertical: the vertical #GtkAdjustment
+ *
+ * Set the scroll adjustments for the text view. Usually scrolled containers
+ * like #GtkScrolledWindow will emit this signal to connect two instances
+ * of #GtkScrollbar to the scroll directions of the #GtkTextView.
+ */
signals[SET_SCROLL_ADJUSTMENTS] =
- g_signal_new (I_("set_scroll_adjustments"),
+ g_signal_new (I_("set-scroll-adjustments"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkTextViewClass, set_scroll_adjustments),
GTK_TYPE_ADJUSTMENT);
widget_class->set_scroll_adjustments_signal = signals[SET_SCROLL_ADJUSTMENTS];
+ /**
+ * GtkTextView::populate-popup:
+ * @entry: The text view on which the signal is emitted
+ * @menu: the menu that is being populated
+ *
+ * The ::populate-popup signal gets emitted before showing the
+ * context menu of the text view.
+ *
+ * If you need to add items to the context menu, connect
+ * to this signal and append your menuitems to the @menu.
+ */
signals[POPULATE_POPUP] =
- g_signal_new (I_("populate_popup"),
+ g_signal_new (I_("populate-popup"),
G_OBJECT_CLASS_TYPE (gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (GtkTextViewClass, populate_popup),
* for selecting and Shift-Ctrl-a and Ctrl-\ for unselecting.
*/
signals[SELECT_ALL] =
- _gtk_binding_signal_new (I_("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);
+ g_signal_new_class_handler (I_("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);
/**
* GtkTextView::toggle-cursor-visible:
* The default binding for this signal is F7.
*/
signals[TOGGLE_CURSOR_VISIBLE] =
- _gtk_binding_signal_new (I_("toggle_cursor_visible"),
- G_OBJECT_CLASS_TYPE (object_class),
- G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
- G_CALLBACK (gtk_text_view_toggle_cursor_visible),
- NULL, NULL,
- _gtk_marshal_VOID__VOID,
- G_TYPE_NONE, 0);
+ g_signal_new_class_handler (I_("toggle-cursor-visible"),
+ G_OBJECT_CLASS_TYPE (object_class),
+ G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+ G_CALLBACK (gtk_text_view_toggle_cursor_visible),
+ NULL, NULL,
+ _gtk_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+
+ /**
+ * GtkTextView::preedit-changed:
+ * @text_view: the object which received the signal
+ * @preedit: the current preedit string
+ *
+ * If an input method is used, the typed text will not immediately
+ * be committed to the buffer. So if you are interested in the text,
+ * connect to this signal.
+ *
+ * This signal is only emitted if the text at the given position
+ * is actually editable.
+ *
+ * Since: 2.20
+ */
+ signals[PREEDIT_CHANGED] =
+ g_signal_new_class_handler (I_("preedit-changed"),
+ G_OBJECT_CLASS_TYPE (object_class),
+ G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
+ NULL,
+ NULL, NULL,
+ _gtk_marshal_VOID__STRING,
+ G_TYPE_NONE, 1,
+ G_TYPE_STRING);
/*
* Key bindings
/* Select all */
gtk_binding_entry_add_signal (binding_set, GDK_a, GDK_CONTROL_MASK,
- "select_all", 1,
+ "select-all", 1,
G_TYPE_BOOLEAN, TRUE);
gtk_binding_entry_add_signal (binding_set, GDK_slash, GDK_CONTROL_MASK,
- "select_all", 1,
+ "select-all", 1,
G_TYPE_BOOLEAN, TRUE);
/* Unselect all */
gtk_binding_entry_add_signal (binding_set, GDK_backslash, GDK_CONTROL_MASK,
- "select_all", 1,
+ "select-all", 1,
G_TYPE_BOOLEAN, FALSE);
gtk_binding_entry_add_signal (binding_set, GDK_a, GDK_SHIFT_MASK | GDK_CONTROL_MASK,
- "select_all", 1,
+ "select-all", 1,
G_TYPE_BOOLEAN, FALSE);
/* Deleting text */
gtk_binding_entry_add_signal (binding_set, GDK_Delete, 0,
- "delete_from_cursor", 2,
+ "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,
+ "delete-from-cursor", 2,
G_TYPE_ENUM, GTK_DELETE_CHARS,
G_TYPE_INT, 1);
"backspace", 0);
gtk_binding_entry_add_signal (binding_set, GDK_Delete, GDK_CONTROL_MASK,
- "delete_from_cursor", 2,
+ "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,
+ "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,
+ "delete-from-cursor", 2,
G_TYPE_ENUM, GTK_DELETE_WORD_ENDS,
G_TYPE_INT, -1);
+ gtk_binding_entry_add_signal (binding_set, GDK_Delete, GDK_SHIFT_MASK | GDK_CONTROL_MASK,
+ "delete-from-cursor", 2,
+ G_TYPE_ENUM, GTK_DELETE_PARAGRAPH_ENDS,
+ G_TYPE_INT, 1);
+
+ gtk_binding_entry_add_signal (binding_set, GDK_KP_Delete, GDK_SHIFT_MASK | GDK_CONTROL_MASK,
+ "delete-from-cursor", 2,
+ G_TYPE_ENUM, GTK_DELETE_PARAGRAPH_ENDS,
+ G_TYPE_INT, 1);
+
+ gtk_binding_entry_add_signal (binding_set, GDK_BackSpace, GDK_SHIFT_MASK | GDK_CONTROL_MASK,
+ "delete-from-cursor", 2,
+ G_TYPE_ENUM, GTK_DELETE_PARAGRAPH_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);
+ "cut-clipboard", 0);
gtk_binding_entry_add_signal (binding_set, GDK_Insert, GDK_CONTROL_MASK,
- "copy_clipboard", 0);
+ "copy-clipboard", 0);
gtk_binding_entry_add_signal (binding_set, GDK_Insert, GDK_SHIFT_MASK,
- "paste_clipboard", 0);
+ "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);
/* Caret mode */
gtk_binding_entry_add_signal (binding_set, GDK_F7, 0,
- "toggle_cursor_visible", 0);
+ "toggle-cursor-visible", 0);
/* Control-tab focus motion */
gtk_binding_entry_add_signal (binding_set, GDK_Tab, GDK_CONTROL_MASK,
- "move_focus", 1,
+ "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,
+ "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,
+ "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,
+ "move-focus", 1,
GTK_TYPE_DIRECTION_TYPE, GTK_DIR_TAB_BACKWARD);
g_type_class_add_private (gobject_class, sizeof (GtkTextViewPrivate));
g_signal_connect (text_view->im_context, "commit",
G_CALLBACK (gtk_text_view_commit_handler), text_view);
- g_signal_connect (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 (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 (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;
/**
* gtk_text_view_set_buffer:
* @text_view: a #GtkTextView
- * @buffer: a #GtkTextBuffer
+ * @buffer: (allow-none): a #GtkTextBuffer
*
* Sets @buffer as the buffer being displayed by @text_view. The previous
* buffer displayed by the text view is unreferenced, and a reference is
g_signal_handlers_disconnect_by_func (text_view->buffer,
gtk_text_view_target_list_notify,
text_view);
- g_object_unref (text_view->buffer);
- text_view->dnd_mark = NULL;
- text_view->first_para_mark = NULL;
+ g_signal_handlers_disconnect_by_func (text_view->buffer,
+ gtk_text_view_paste_done_handler,
+ text_view);
if (GTK_WIDGET_REALIZED (text_view))
{
GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (text_view),
GDK_SELECTION_PRIMARY);
gtk_text_buffer_remove_selection_clipboard (text_view->buffer, clipboard);
- }
+ }
+
+ if (text_view->layout)
+ gtk_text_layout_set_buffer (text_view->layout, NULL);
+
+ g_object_unref (text_view->buffer);
+ text_view->dnd_mark = NULL;
+ text_view->first_para_mark = NULL;
+ cancel_pending_scroll (text_view);
}
text_view->buffer = buffer;
+ if (text_view->layout)
+ gtk_text_layout_set_buffer (text_view->layout, buffer);
+
if (buffer != NULL)
{
GtkTextIter start;
g_object_ref (buffer);
- if (text_view->layout)
- gtk_text_layout_set_buffer (text_view->layout, buffer);
-
gtk_text_buffer_get_iter_at_offset (text_view->buffer, &start, 0);
text_view->dnd_mark = gtk_text_buffer_create_mark (text_view->buffer,
text_view->first_para_pixels = 0;
- g_signal_connect (text_view->buffer, "mark_set",
+ g_signal_connect (text_view->buffer, "mark-set",
G_CALLBACK (gtk_text_view_mark_set_handler),
text_view);
g_signal_connect (text_view->buffer, "notify::paste-target-list",
G_CALLBACK (gtk_text_view_target_list_notify),
text_view);
+ g_signal_connect (text_view->buffer, "paste-done",
+ G_CALLBACK (gtk_text_view_paste_done_handler),
+ text_view);
gtk_text_view_target_list_notify (text_view->buffer, NULL, text_view);
g_object_notify (G_OBJECT (text_view), "buffer");
- if (GTK_WIDGET_VISIBLE (text_view))
+ if (gtk_widget_get_visible (GTK_WIDGET (text_view)))
gtk_widget_queue_draw (GTK_WIDGET (text_view));
DV(g_print ("Invalidating due to set_buffer\n"));
* The reference count on the buffer is not incremented; the caller
* of this function won't own a new reference.
*
- * Return value: a #GtkTextBuffer
+ * Return value: (transfer none): a #GtkTextBuffer
**/
GtkTextBuffer*
gtk_text_view_get_buffer (GtkTextView *text_view)
* gtk_text_view_get_iter_at_position:
* @text_view: a #GtkTextView
* @iter: a #GtkTextIter
- * @trailing: location to store an integer indicating where
+ * @trailing: if non-%NULL, location to store an integer indicating where
* in the grapheme the user clicked. It will either be
* zero, or the number of characters in the grapheme.
* 0 represents the trailing edge of the grapheme.
}
if (retval)
- DV(g_print (">Actually scrolled ("G_STRLOC")\n"));
+ {
+ DV(g_print (">Actually scrolled ("G_STRLOC")\n"));
+ }
else
- DV(g_print (">Didn't end up scrolling ("G_STRLOC")\n"));
+ {
+ DV(g_print (">Didn't end up scrolling ("G_STRLOC")\n"));
+ }
return retval;
}
gtk_im_context_set_cursor_location (text_view->im_context, &area);
}
+static gboolean
+do_update_im_spot_location (gpointer text_view)
+{
+ GtkTextViewPrivate *priv;
+
+ priv = GTK_TEXT_VIEW_GET_PRIVATE (text_view);
+ priv->im_spot_idle = 0;
+
+ gtk_text_view_update_im_spot_location (text_view);
+ return FALSE;
+}
+
+static void
+queue_update_im_spot_location (GtkTextView *text_view)
+{
+ GtkTextViewPrivate *priv;
+
+ priv = GTK_TEXT_VIEW_GET_PRIVATE (text_view);
+
+ /* Use priority a little higher than GTK_TEXT_VIEW_PRIORITY_VALIDATE,
+ * so we don't wait until the entire buffer has been validated. */
+ if (!priv->im_spot_idle)
+ priv->im_spot_idle = gdk_threads_add_idle_full (GTK_TEXT_VIEW_PRIORITY_VALIDATE - 1,
+ do_update_im_spot_location,
+ text_view,
+ NULL);
+}
+
+static void
+flush_update_im_spot_location (GtkTextView *text_view)
+{
+ GtkTextViewPrivate *priv;
+
+ priv = GTK_TEXT_VIEW_GET_PRIVATE (text_view);
+
+ if (priv->im_spot_idle)
+ {
+ g_source_remove (priv->im_spot_idle);
+ priv->im_spot_idle = 0;
+ gtk_text_view_update_im_spot_location (text_view);
+ }
+}
+
/**
* gtk_text_view_scroll_to_mark:
* @text_view: a #GtkTextView
g_return_if_fail (xalign >= 0.0 && xalign <= 1.0);
g_return_if_fail (yalign >= 0.0 && yalign <= 1.0);
+ /* We need to verify that the buffer contains the mark, otherwise this
+ * can lead to data structure corruption later on.
+ */
+ g_return_if_fail (get_buffer (text_view) == gtk_text_mark_get_buffer (mark));
+
gtk_text_view_queue_scroll (text_view, mark,
within_margin,
use_align,
g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
g_return_if_fail (GTK_IS_TEXT_MARK (mark));
+ /* We need to verify that the buffer contains the mark, otherwise this
+ * can lead to data structure corruption later on.
+ */
+ g_return_if_fail (get_buffer (text_view) == gtk_text_mark_get_buffer (mark));
+
gtk_text_view_scroll_to_mark (text_view, mark, 0.0, FALSE, 0.0, 0.0);
}
if (text_view->editable != setting)
{
+ if (!setting)
+ {
+ gtk_text_view_reset_im_context(text_view);
+ if (gtk_widget_has_focus (GTK_WIDGET (text_view)))
+ gtk_im_context_focus_out (text_view->im_context);
+ }
+
text_view->editable = setting;
+ if (setting && gtk_widget_has_focus (GTK_WIDGET (text_view)))
+ gtk_im_context_focus_in (text_view->im_context);
+
if (text_view->layout)
{
gtk_text_layout_set_overwrite_mode (text_view->layout,
{
text_view->cursor_visible = setting;
- if (GTK_WIDGET_HAS_FOCUS (text_view))
+ if (gtk_widget_has_focus (GTK_WIDGET (text_view)))
{
if (text_view->layout)
{
g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), FALSE);
gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &insert,
- gtk_text_buffer_get_mark (get_buffer (text_view),
- "insert"));
+ gtk_text_buffer_get_insert (get_buffer (text_view)));
if (clamp_iter_onscreen (text_view, &insert))
{
gtk_text_view_destroy (GtkObject *object)
{
GtkTextView *text_view;
-
+ GtkTextViewPrivate *priv;
+
text_view = GTK_TEXT_VIEW (object);
+ priv = GTK_TEXT_VIEW_GET_PRIVATE (text_view);
gtk_text_view_remove_validate_idles (text_view);
gtk_text_view_set_buffer (text_view, NULL);
text_view->scroll_timeout = 0;
}
- (* GTK_OBJECT_CLASS (gtk_text_view_parent_class)->destroy) (object);
+ if (priv->im_spot_idle)
+ {
+ g_source_remove (priv->im_spot_idle);
+ priv->im_spot_idle = 0;
+ }
+
+ GTK_OBJECT_CLASS (gtk_text_view_parent_class)->destroy (object);
}
static void
gtk_text_view_finalize (GObject *object)
{
GtkTextView *text_view;
+ GtkTextViewPrivate *priv;
text_view = GTK_TEXT_VIEW (object);
+ priv = GTK_TEXT_VIEW_GET_PRIVATE (text_view);
g_assert (text_view->buffer == NULL);
text_window_free (text_view->bottom_window);
g_object_unref (text_view->im_context);
-
- (* G_OBJECT_CLASS (gtk_text_view_parent_class)->finalize) (object);
+
+ g_free (priv->im_module);
+
+ G_OBJECT_CLASS (gtk_text_view_parent_class)->finalize (object);
}
static void
GParamSpec *pspec)
{
GtkTextView *text_view;
+ GtkTextViewPrivate *priv;
text_view = GTK_TEXT_VIEW (object);
+ priv = GTK_TEXT_VIEW_GET_PRIVATE (text_view);
switch (prop_id)
{
gtk_text_view_set_accepts_tab (text_view, g_value_get_boolean (value));
break;
+ case PROP_IM_MODULE:
+ g_free (priv->im_module);
+ priv->im_module = g_value_dup_string (value);
+ if (GTK_IS_IM_MULTICONTEXT (text_view->im_context))
+ gtk_im_multicontext_set_context_id (GTK_IM_MULTICONTEXT (text_view->im_context), priv->im_module);
+ break;
+
default:
- g_assert_not_reached ();
+ G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
GParamSpec *pspec)
{
GtkTextView *text_view;
+ GtkTextViewPrivate *priv;
text_view = GTK_TEXT_VIEW (object);
+ priv = GTK_TEXT_VIEW_GET_PRIVATE (text_view);
switch (prop_id)
{
g_value_set_boolean (value, text_view->accepts_tab);
break;
+ case PROP_IM_MODULE:
+ g_value_set_string (value, priv->im_module);
+ break;
+
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
text_window_invalidate_rect (text_view->bottom_window,
&redraw_rect);
- gtk_text_view_update_im_spot_location (text_view);
+ queue_update_im_spot_location (text_view);
}
}
tmp_list = tmp_list->next;
}
+
+ /* Ensure updating the spot location. */
+ gtk_text_view_update_im_spot_location (text_view);
}
static void
text_window_unrealize (text_view->bottom_window);
gtk_text_view_destroy_layout (text_view);
-
- (* GTK_WIDGET_CLASS (gtk_text_view_parent_class)->unrealize) (widget);
+
+ GTK_WIDGET_CLASS (gtk_text_view_parent_class)->unrealize (widget);
}
-static void
+static void
gtk_text_view_set_background (GtkTextView *text_view)
{
GtkWidget *widget = GTK_WIDGET (text_view);
{
gtk_text_view_set_background (text_view);
- if (GTK_WIDGET_IS_SENSITIVE (widget))
+ if (gtk_widget_is_sensitive (widget))
cursor = gdk_cursor_new_for_display (gtk_widget_get_display (widget), GDK_XTERM);
else
cursor = NULL;
text_view->mouse_cursor_obscured = FALSE;
}
- if (!GTK_WIDGET_IS_SENSITIVE (widget))
+ if (!gtk_widget_is_sensitive (widget))
{
/* Clear any selection */
gtk_text_view_unselect (text_view);
static void
set_invisible_cursor (GdkWindow *window)
{
- GdkBitmap *empty_bitmap;
+ GdkDisplay *display;
GdkCursor *cursor;
- GdkColor useless;
- char invisible_cursor_bits[] = { 0x0 };
-
- useless.red = useless.green = useless.blue = 0;
- useless.pixel = 0;
-
- empty_bitmap = gdk_bitmap_create_from_data (window,
- invisible_cursor_bits,
- 1, 1);
-
- cursor = gdk_cursor_new_from_pixmap (empty_bitmap,
- empty_bitmap,
- &useless,
- &useless, 0, 0);
-
+
+ display = gdk_drawable_get_display (window);
+ cursor = gdk_cursor_new_for_display (display, GDK_BLANK_CURSOR);
+
gdk_window_set_cursor (window, cursor);
gdk_cursor_unref (cursor);
-
- g_object_unref (empty_bitmap);
}
static void
else if (event->type == GDK_KEY_PRESS ||
event->type == GDK_KEY_RELEASE)
{
- GtkTextMark *insert;
GtkTextIter iter;
- insert = gtk_text_buffer_get_mark (get_buffer (text_view),
- "insert");
-
- gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &iter, insert);
+ gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &iter,
+ gtk_text_buffer_get_insert (get_buffer (text_view)));
return emit_event_on_tags (widget, event, &iter);
}
get_buffer (text_view) == NULL)
return FALSE;
+ /* Make sure input method knows where it is */
+ flush_update_im_spot_location (text_view);
+
insert = gtk_text_buffer_get_insert (get_buffer (text_view));
gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &iter, insert);
can_insert = gtk_text_iter_can_insert (&iter, text_view->editable);
retval = TRUE;
}
/* Binding set */
- else if (GTK_WIDGET_CLASS (gtk_text_view_parent_class)->key_press_event &&
- GTK_WIDGET_CLASS (gtk_text_view_parent_class)->key_press_event (widget, event))
- retval = TRUE;
+ else if (GTK_WIDGET_CLASS (gtk_text_view_parent_class)->key_press_event (widget, event))
+ {
+ retval = TRUE;
+ }
/* use overall editability not can_insert, more predictable for users */
else if (text_view->editable &&
(event->keyval == GDK_Return ||
+ event->keyval == GDK_ISO_Enter ||
event->keyval == GDK_KP_Enter))
{
/* this won't actually insert the newline if the cursor isn't
if (gtk_text_buffer_get_selection_bounds (get_buffer (text_view),
&start, &end) &&
- gtk_text_iter_in_range (&iter, &start, &end))
+ gtk_text_iter_in_range (&iter, &start, &end) &&
+ !(event->state & GDK_SHIFT_MASK))
{
text_view->drag_start_x = event->x;
text_view->drag_start_y = event->y;
}
g_signal_connect (gdk_keymap_get_for_display (gtk_widget_get_display (widget)),
- "direction_changed",
+ "direction-changed",
G_CALLBACK (keymap_direction_changed), text_view);
gtk_text_view_check_keymap_direction (text_view);
-
- text_view->need_im_reset = TRUE;
- gtk_im_context_focus_in (GTK_TEXT_VIEW (widget)->im_context);
+
+ if (text_view->editable)
+ {
+ text_view->need_im_reset = TRUE;
+ gtk_im_context_focus_in (GTK_TEXT_VIEW (widget)->im_context);
+ }
return FALSE;
}
keymap_direction_changed,
text_view);
- text_view->need_im_reset = TRUE;
- gtk_im_context_focus_out (GTK_TEXT_VIEW (widget)->im_context);
+ if (text_view->editable)
+ {
+ text_view->need_im_reset = TRUE;
+ gtk_im_context_focus_out (GTK_TEXT_VIEW (widget)->im_context);
+ }
return FALSE;
}
GtkTextView *text_view;
GList *child_exposes;
GList *tmp_list;
- GdkRegion *updates;
text_view = GTK_TEXT_VIEW (widget);
gtk_text_view_flush_first_validate (text_view);
}
- /* More regions could have become invalid in the above loop */
- updates = gdk_window_get_update_area (text_view->text_window->bin_window);
- if (updates)
- {
- GdkRectangle rect;
-
- gdk_region_get_clipbox (updates, &rect);
-
- gdk_rectangle_union (area, &rect, area);
-
- gdk_region_destroy (updates);
- }
-
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.");
"interior-focus", &interior_focus,
NULL);
- if (GTK_WIDGET_DRAWABLE (widget))
+ if (gtk_widget_is_drawable (widget))
{
- if (GTK_WIDGET_HAS_FOCUS (widget) && !interior_focus)
+ if (gtk_widget_has_focus (widget) && !interior_focus)
{
gtk_paint_focus (widget->style, widget->window, GTK_WIDGET_STATE (widget),
NULL, widget, "textview",
text_view = GTK_TEXT_VIEW (data);
priv = GTK_TEXT_VIEW_GET_PRIVATE (text_view);
- if (!GTK_WIDGET_HAS_FOCUS (text_view))
+ if (!gtk_widget_has_focus (GTK_WIDGET (text_view)))
{
g_warning ("GtkTextView - did not receive focus-out-event. If you\n"
"connect a handler to this signal, it must return\n"
{
if (text_view->layout != NULL &&
text_view->cursor_visible &&
- GTK_WIDGET_HAS_FOCUS (text_view))
+ gtk_widget_has_focus (GTK_WIDGET (text_view)))
{
if (cursor_blinks (text_view))
{
{
if (text_view->layout != NULL &&
text_view->cursor_visible &&
- GTK_WIDGET_HAS_FOCUS (text_view) &&
+ gtk_widget_has_focus (GTK_WIDGET (text_view)) &&
cursor_blinks (text_view))
{
gtk_text_view_stop_cursor_blink (text_view);
{
GtkTextIter insert;
GtkTextIter newplace;
+ gboolean cancel_selection = FALSE;
gint cursor_x_pos = 0;
GtkDirectionType leave_direction = -1;
}
gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &insert,
- gtk_text_buffer_get_mark (get_buffer (text_view),
- "insert"));
+ gtk_text_buffer_get_insert (get_buffer (text_view)));
+
+ if (! extend_selection)
+ {
+ GtkTextIter sel_bound;
+
+ gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &sel_bound,
+ gtk_text_buffer_get_selection_bound (get_buffer (text_view)));
+
+ /* if we move forward, assume the cursor is at the end of the selection;
+ * if we move backward, assume the cursor is at the start
+ */
+ if (count > 0)
+ gtk_text_iter_order (&sel_bound, &insert);
+ else
+ gtk_text_iter_order (&insert, &sel_bound);
+
+ /* if we actually have a selection, just move *to* the beginning/end
+ * of the selection and not *from* there on LOGICAL_POSITIONS
+ * and VISUAL_POSITIONS movement
+ */
+ if (! gtk_text_iter_equal (&sel_bound, &insert))
+ cancel_selection = TRUE;
+ }
+
newplace = insert;
if (step == GTK_MOVEMENT_DISPLAY_LINES)
- gtk_text_view_get_virtual_cursor_pos (text_view, &cursor_x_pos, NULL);
+ gtk_text_view_get_virtual_cursor_pos (text_view, &insert, &cursor_x_pos, NULL);
switch (step)
{
case GTK_MOVEMENT_LOGICAL_POSITIONS:
- gtk_text_iter_forward_visible_cursor_positions (&newplace, count);
+ if (! cancel_selection)
+ gtk_text_iter_forward_visible_cursor_positions (&newplace, count);
break;
case GTK_MOVEMENT_VISUAL_POSITIONS:
- gtk_text_layout_move_iter_visually (text_view->layout,
- &newplace, count);
+ if (! cancel_selection)
+ gtk_text_layout_move_iter_visually (text_view->layout,
+ &newplace, count);
break;
case GTK_MOVEMENT_WORDS:
{
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),
- "insert"));
+ gtk_text_buffer_get_insert (get_buffer (text_view)));
if (step == GTK_MOVEMENT_DISPLAY_LINES)
gtk_text_view_set_virtual_cursor_pos (text_view, cursor_x_pos, -1);
g_signal_emit_by_name (text_view, "move-focus", leave_direction);
}
}
- else
+ else if (! cancel_selection)
{
gtk_widget_error_bell (GTK_WIDGET (text_view));
}
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_buffer_get_insert (get_buffer (text_view)));
gtk_text_buffer_create_mark (get_buffer (text_view), "anchor", &insert, TRUE);
}
gdouble oldval;
GtkAdjustment *adj;
gint cursor_x_pos, cursor_y_pos;
+ GtkTextMark *insert_mark;
GtkTextIter old_insert;
GtkTextIter new_insert;
GtkTextIter anchor;
adj = text_view->vadjustment;
+ insert_mark = gtk_text_buffer_get_insert (get_buffer (text_view));
+
/* Make sure we start from the current cursor position, even
* if it was offscreen, but don't queue more scrolls if we're
* already behind.
if (text_view->pending_scroll)
cancel_pending_scroll (text_view);
else
- gtk_text_view_scroll_mark_onscreen (text_view,
- gtk_text_buffer_get_mark (get_buffer (text_view),
- "insert"));
+ gtk_text_view_scroll_mark_onscreen (text_view, insert_mark);
/* Validate the region that will be brought into view by the cursor motion
*/
gtk_text_buffer_get_iter_at_mark (get_buffer (text_view),
- &old_insert,
- gtk_text_buffer_get_mark (get_buffer (text_view), "insert"));
+ &old_insert, insert_mark);
if (count < 0)
{
}
else
{
- gtk_text_view_get_virtual_cursor_pos (text_view, &cursor_x_pos, &cursor_y_pos);
+ gtk_text_view_get_virtual_cursor_pos (text_view, NULL, &cursor_x_pos, &cursor_y_pos);
oldval = adj->value;
newval = adj->value;
* only guarantees 1 pixel onscreen.
*/
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),
- "insert"));
+ gtk_text_view_scroll_mark_onscreen (text_view, insert_mark);
return !gtk_text_iter_equal (&old_insert, &new_insert);
}
gdouble oldval;
GtkAdjustment *adj;
gint cursor_x_pos, cursor_y_pos;
+ GtkTextMark *insert_mark;
GtkTextIter old_insert;
GtkTextIter new_insert;
gint y, height;
adj = text_view->hadjustment;
+ insert_mark = gtk_text_buffer_get_insert (get_buffer (text_view));
+
/* Make sure we start from the current cursor position, even
* if it was offscreen, but don't queue more scrolls if we're
* already behind.
if (text_view->pending_scroll)
cancel_pending_scroll (text_view);
else
- gtk_text_view_scroll_mark_onscreen (text_view,
- gtk_text_buffer_get_mark (get_buffer (text_view),
- "insert"));
+ gtk_text_view_scroll_mark_onscreen (text_view, insert_mark);
/* Validate the line that we're moving within.
*/
gtk_text_buffer_get_iter_at_mark (get_buffer (text_view),
- &old_insert,
- gtk_text_buffer_get_mark (get_buffer (text_view), "insert"));
+ &old_insert, insert_mark);
+
gtk_text_layout_get_line_yrange (text_view->layout, &old_insert, &y, &height);
gtk_text_layout_validate_yrange (text_view->layout, &old_insert, y, y + height);
/* FIXME do we need to update the adjustment ranges here? */
}
else
{
- gtk_text_view_get_virtual_cursor_pos (text_view, &cursor_x_pos, &cursor_y_pos);
+ gtk_text_view_get_virtual_cursor_pos (text_view, NULL, &cursor_x_pos, &cursor_y_pos);
oldval = adj->value;
newval = adj->value;
* only guarantees 1 pixel onscreen.
*/
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),
- "insert"));
+ gtk_text_view_scroll_mark_onscreen (text_view, insert_mark);
return !gtk_text_iter_equal (&old_insert, &new_insert);
}
return;
}
- gtk_text_buffer_get_iter_at_mark (get_buffer (text_view),
- &insert,
- gtk_text_buffer_get_mark (get_buffer (text_view),
- "insert"));
+ gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &insert,
+ gtk_text_buffer_get_insert (get_buffer (text_view)));
start = insert;
end = insert;
break;
case GTK_DELETE_PARAGRAPH_ENDS:
- /* If we're already at a newline, we need to
- * simply delete that newline, instead of
- * moving to the next one.
- */
- if (gtk_text_iter_ends_line (&end))
+ if (count > 0)
{
- gtk_text_iter_forward_line (&end);
- --count;
- }
+ /* If we're already at a newline, we need to
+ * simply delete that newline, instead of
+ * moving to the next one.
+ */
+ if (gtk_text_iter_ends_line (&end))
+ {
+ gtk_text_iter_forward_line (&end);
+ --count;
+ }
- while (count > 0)
- {
- if (!gtk_text_iter_forward_to_line_end (&end))
- break;
+ while (count > 0)
+ {
+ if (!gtk_text_iter_forward_to_line_end (&end))
+ break;
- --count;
+ --count;
+ }
}
+ else if (count < 0)
+ {
+ if (gtk_text_iter_starts_line (&start))
+ {
+ gtk_text_iter_backward_line (&start);
+ if (!gtk_text_iter_ends_line (&end))
+ gtk_text_iter_forward_to_line_end (&start);
+ }
+ else
+ {
+ gtk_text_iter_set_line_offset (&start, 0);
+ }
+ ++count;
- /* FIXME figure out what a negative count means
- and support that */
+ gtk_text_iter_backward_lines (&start, -count);
+ }
break;
case GTK_DELETE_PARAGRAPHS:
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), "insert"));
+ gtk_text_buffer_get_insert (get_buffer (text_view)));
}
else
{
clipboard,
NULL,
text_view->editable);
+}
+
+static void
+gtk_text_view_paste_done_handler (GtkTextBuffer *buffer,
+ GtkClipboard *clipboard,
+ gpointer data)
+{
+ GtkTextView *text_view = data;
DV(g_print (G_STRLOC": scrolling onscreen\n"));
- gtk_text_view_scroll_mark_onscreen (text_view,
- gtk_text_buffer_get_insert (get_buffer (text_view)));
+ gtk_text_view_scroll_mark_onscreen (text_view, gtk_text_buffer_get_insert (buffer));
}
static void
{
/* if this is a signal emission, chain up */
- GValue instance_and_params[2] = { { 0, }, { 0, } };
- GValue return_value = { 0, };
-
- g_value_init (&instance_and_params[0], GTK_TYPE_WIDGET);
- g_value_set_object (&instance_and_params[0], text_view);
-
- g_value_init (&instance_and_params[1], GTK_TYPE_DIRECTION_TYPE);
- g_value_set_enum (&instance_and_params[1], direction_type);
-
- g_value_init (&return_value, G_TYPE_BOOLEAN);
-
- g_signal_chain_from_overridden (instance_and_params, &return_value);
+ gboolean retval;
- g_value_unset (&instance_and_params[0]);
- g_value_unset (&instance_and_params[1]);
- g_value_unset (&return_value);
+ g_signal_chain_from_overridden_handler (text_view,
+ direction_type, &retval);
}
else
{
{
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_buffer_get_iter_at_mark (get_buffer (text_view), &insert,
+ gtk_text_buffer_get_insert (get_buffer (text_view)));
gtk_text_buffer_move_mark (get_buffer (text_view),
- gtk_text_buffer_get_mark (get_buffer (text_view),
- "selection_bound"),
+ gtk_text_buffer_get_selection_bound (get_buffer (text_view)),
&insert);
}
DV(g_print (G_STRLOC": calling move_mark_to_pointer_and_scroll\n"));
gtk_text_view_scroll_mark_onscreen (text_view,
- gtk_text_buffer_get_mark (get_buffer (text_view),
- "insert"));
+ gtk_text_buffer_get_insert (get_buffer (text_view)));
return TRUE; /* remain installed. */
}
gtk_text_view_check_cursor_blink (text_view);
text_view->selection_drag_handler = g_signal_connect_data (text_view,
- "motion_notify_event",
+ "motion-notify-event",
G_CALLBACK (selection_motion_event_handler),
data,
(GClosureNotify) selection_data_free, 0);
text_view);
g_signal_connect (text_view->layout,
- "allocate_child",
+ "allocate-child",
G_CALLBACK (gtk_text_view_child_allocated),
text_view);
if (get_buffer (text_view))
gtk_text_layout_set_buffer (text_view->layout, get_buffer (text_view));
- if ((GTK_WIDGET_HAS_FOCUS (text_view) && text_view->cursor_visible))
+ if ((gtk_widget_has_focus (widget) && text_view->cursor_visible))
gtk_text_view_pend_cursor_blink (text_view);
else
gtk_text_layout_set_cursor_visible (text_view->layout, FALSE);
invalidated_handler,
text_view);
g_signal_handlers_disconnect_by_func (text_view->layout,
- changed_handler,
+ changed_handler,
text_view);
-
+
/* Remove layout from all anchored children */
tmp_list = text_view->children;
while (tmp_list != NULL)
tmp_list = g_slist_next (tmp_list);
}
-
+
gtk_text_view_stop_cursor_blink (text_view);
gtk_text_view_end_selection_drag (text_view);
target_list = gtk_text_buffer_get_copy_target_list (get_buffer (text_view));
- g_signal_connect (text_view, "drag_begin",
+ g_signal_connect (text_view, "drag-begin",
G_CALLBACK (drag_begin_cb), NULL);
gtk_drag_begin (GTK_WIDGET (text_view), target_list,
GDK_ACTION_COPY | GDK_ACTION_MOVE,
text_view->hadjustment = hadj;
g_object_ref_sink (text_view->hadjustment);
- g_signal_connect (text_view->hadjustment, "value_changed",
+ g_signal_connect (text_view->hadjustment, "value-changed",
G_CALLBACK (gtk_text_view_value_changed),
text_view);
need_adjust = TRUE;
text_view->vadjustment = vadj;
g_object_ref_sink (text_view->vadjustment);
- g_signal_connect (text_view->vadjustment, "value_changed",
+ g_signal_connect (text_view->vadjustment, "value-changed",
G_CALLBACK (gtk_text_view_value_changed),
text_view);
need_adjust = TRUE;
/* The window to which widget->window is relative */
#define ALLOCATION_WINDOW(widget) \
- (GTK_WIDGET_NO_WINDOW (widget) ? \
+ (!gtk_widget_get_has_window (widget) ? \
(widget)->window : \
gdk_window_get_parent ((widget)->window))
*/
if (!GTK_WIDGET_REALIZED (widget))
{
- if (GTK_WIDGET_VISIBLE (widget))
+ if (gtk_widget_get_visible (widget))
{
GdkRectangle tmp_rectangle = widget->allocation;
tmp_rectangle.x += scroll_data->dx;
*/
gtk_text_view_update_layout_width (text_view);
+ /* We also update the IM spot location here, since the IM context
+ * might do something that leads to validation.
+ */
+ gtk_text_view_update_im_spot_location (text_view);
+
/* note that validation of onscreen could invoke this function
* recursively, by scrolling to maintain first_para, or in response
* to updating the layout width, however there is no problem with
text_view->first_validate_idle = 0;
}
+ /* Finally we update the IM cursor location again, to ensure any
+ * changes made by the validation are pushed through.
+ */
gtk_text_view_update_im_spot_location (text_view);
DV(g_print(">End scroll offset changed handler ("G_STRLOC")\n"));
if (!had_selection && text_view->overwrite_mode)
{
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_buffer_get_insert (get_buffer (text_view)));
if (!gtk_text_iter_ends_line (&insert))
gtk_text_view_delete_from_cursor (text_view, GTK_DELETE_CHARS, 1);
}
gtk_text_view_set_virtual_cursor_pos (text_view, -1, -1);
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),
- "insert"));
+ gtk_text_buffer_get_insert (get_buffer (text_view)));
}
static void
gint cursor_pos;
GtkTextIter iter;
- gtk_text_buffer_get_iter_at_mark (text_view->buffer, &iter,
+ gtk_text_buffer_get_iter_at_mark (text_view->buffer, &iter,
gtk_text_buffer_get_insert (text_view->buffer));
- /* Keypress events are passed to input method even if cursor position is not editable;
- * so beep here if it's multi-key input sequence, input method will be reset in
- * key-press-event handler. */
- if (!gtk_text_iter_can_insert (&iter, text_view->editable))
+ /* Keypress events are passed to input method even if cursor position is
+ * not editable; so beep here if it's multi-key input sequence, input
+ * method will be reset in key-press-event handler.
+ */
+ gtk_im_context_get_preedit_string (context, &str, &attrs, &cursor_pos);
+
+ if (str && str[0] && !gtk_text_iter_can_insert (&iter, text_view->editable))
{
gtk_widget_error_bell (GTK_WIDGET (text_view));
- return;
+ goto out;
}
- 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);
+ g_signal_emit (text_view, signals[PREEDIT_CHANGED], 0, str);
- if (GTK_WIDGET_HAS_FOCUS (text_view))
+ if (text_view->layout)
+ gtk_text_layout_set_preedit_string (text_view->layout, str, attrs, cursor_pos);
+ if (gtk_widget_has_focus (GTK_WIDGET (text_view)))
gtk_text_view_scroll_mark_onscreen (text_view,
- gtk_text_buffer_get_mark (get_buffer (text_view),
- "insert"));
+ gtk_text_buffer_get_insert (get_buffer (text_view)));
+
+out:
+ pango_attr_list_unref (attrs);
+ g_free (str);
}
static gboolean
gint pos;
gchar *text;
- gtk_text_buffer_get_iter_at_mark (text_view->buffer, &start,
+ gtk_text_buffer_get_iter_at_mark (text_view->buffer, &start,
gtk_text_buffer_get_insert (text_view->buffer));
end = start;
GtkTextIter start;
GtkTextIter end;
- gtk_text_buffer_get_iter_at_mark (text_view->buffer, &start,
+ gtk_text_buffer_get_iter_at_mark (text_view->buffer, &start,
gtk_text_buffer_get_insert (text_view->buffer));
end = start;
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_buffer_get_insert (get_buffer (text_view)));
gtk_text_layout_get_cursor_locations (text_view->layout, &insert, pos, NULL);
}
static void
gtk_text_view_get_virtual_cursor_pos (GtkTextView *text_view,
+ GtkTextIter *cursor,
gint *x,
gint *y)
{
+ GtkTextIter insert;
GdkRectangle pos;
+ if (cursor)
+ insert = *cursor;
+ else
+ gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &insert,
+ gtk_text_buffer_get_insert (get_buffer (text_view)));
+
if ((x && text_view->virtual_cursor_x == -1) ||
(y && text_view->virtual_cursor_y == -1))
- gtk_text_view_get_cursor_location (text_view, &pos);
+ gtk_text_layout_get_cursor_locations (text_view->layout, &insert, &pos, NULL);
if (x)
{
can_insert = gtk_text_iter_can_insert (&iter, text_view->editable);
- append_action_signal (text_view, text_view->popup_menu, GTK_STOCK_CUT, "cut_clipboard",
+ append_action_signal (text_view, text_view->popup_menu, GTK_STOCK_CUT, "cut-clipboard",
have_selection &&
range_contains_editable_text (&sel_start, &sel_end,
text_view->editable));
- append_action_signal (text_view, text_view->popup_menu, GTK_STOCK_COPY, "copy_clipboard",
+ append_action_signal (text_view, text_view->popup_menu, GTK_STOCK_COPY, "copy-clipboard",
have_selection);
- append_action_signal (text_view, text_view->popup_menu, GTK_STOCK_PASTE, "paste_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);
if (win->type == GTK_TEXT_WINDOW_TEXT)
{
- if (GTK_WIDGET_IS_SENSITIVE (widget))
+ if (gtk_widget_is_sensitive (widget))
{
/* I-beam cursor */
cursor = gdk_cursor_new_for_display (gdk_drawable_get_display (widget->window),
break;
default:
- g_warning ("%s: bug!", G_STRLOC);
+ g_warning ("%s: bug!", G_STRFUNC);
return;
break;
}
* height is 0, and are nonexistent before the widget has been
* realized.
*
- * Return value: a #GdkWindow, or %NULL
+ * Return value: (transfer none): a #GdkWindow, or %NULL
**/
GdkWindow*
gtk_text_view_get_window (GtkTextView *text_view,
break;
case GTK_TEXT_WINDOW_PRIVATE:
- g_warning ("%s: You can't get GTK_TEXT_WINDOW_PRIVATE, it has \"PRIVATE\" in the name because it is private.", G_GNUC_FUNCTION);
+ g_warning ("%s: You can't get GTK_TEXT_WINDOW_PRIVATE, it has \"PRIVATE\" in the name because it is private.", G_STRFUNC);
return NULL;
break;
}
- g_warning ("%s: Unknown GtkTextWindowType", G_GNUC_FUNCTION);
+ g_warning ("%s: Unknown GtkTextWindowType", G_STRFUNC);
return NULL;
}
break;
case GTK_TEXT_WINDOW_PRIVATE:
- g_warning ("%s: can't get coords for private windows", G_STRLOC);
+ g_warning ("%s: can't get coords for private windows", G_STRFUNC);
break;
default:
- g_warning ("%s: Unknown GtkTextWindowType", G_STRLOC);
+ g_warning ("%s: Unknown GtkTextWindowType", G_STRFUNC);
break;
}
}
break;
case GTK_TEXT_WINDOW_PRIVATE:
- g_warning ("%s: can't get coords for private windows", G_STRLOC);
+ g_warning ("%s: can't get coords for private windows", G_STRFUNC);
break;
default:
- g_warning ("%s: Unknown GtkTextWindowType", G_STRLOC);
+ g_warning ("%s: Unknown GtkTextWindowType", G_STRFUNC);
break;
}
}
vc->x = xpos;
vc->y = ypos;
- if (GTK_WIDGET_VISIBLE (child) && GTK_WIDGET_VISIBLE (text_view))
+ if (gtk_widget_get_visible (child) &&
+ gtk_widget_get_visible (GTK_WIDGET (text_view)))
gtk_widget_queue_resize (child);
}