* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
-#include <config.h>
+#include "config.h"
#include <string.h>
#define GTK_TEXT_USE_INTERNAL_UNSUPPORTED_API
#include "gtkseparatormenuitem.h"
#include "gtksettings.h"
#include "gtkstock.h"
+#include "gtksizerequest.h"
#include "gtktextbufferrichtext.h"
#include "gtktextdisplay.h"
#include "gtktextview.h"
#include "gtkprivate.h"
#include "gtktextutil.h"
#include "gtkwindow.h"
-#include "gtkalias.h"
+
/* How scrolling, validation, exposes, etc. work.
*
#define DV(x)
#endif
-#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 SCREEN_WIDTH(widget) text_window_get_width (GTK_TEXT_VIEW (widget)->priv->text_window)
+#define SCREEN_HEIGHT(widget) text_window_get_height (GTK_TEXT_VIEW (widget)->priv->text_window)
#define SPACE_FOR_CURSOR 1
-typedef struct _GtkTextViewPrivate GtkTextViewPrivate;
-
#define GTK_TEXT_VIEW_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GTK_TYPE_TEXT_VIEW, GtkTextViewPrivate))
+typedef struct _GtkTextWindow GtkTextWindow;
+typedef struct _GtkTextPendingScroll GtkTextPendingScroll;
+
struct _GtkTextViewPrivate
{
+ GtkTextLayout *layout;
+ GtkTextBuffer *buffer;
+
guint blink_time; /* time in msec the cursor has blinked since last user event */
-};
+ guint im_spot_idle;
+ gchar *im_module;
+ GdkDevice *grab_device;
+ GdkDevice *dnd_device;
+
+ guint selection_drag_handler;
+ guint scroll_timeout;
+
+ GtkTextWindow *text_window;
+ GtkTextWindow *left_window;
+ GtkTextWindow *right_window;
+ GtkTextWindow *top_window;
+ GtkTextWindow *bottom_window;
+
+ GtkAdjustment *hadjustment;
+ GtkAdjustment *vadjustment;
+
+ gint xoffset; /* Offsets between widget coordinates and buffer coordinates */
+ gint yoffset;
+ gint width; /* Width and height of the buffer */
+ gint height;
+
+ /* This is used to monitor the overall size request
+ * and decide whether we need to queue resizes when
+ * the buffer content changes.
+ *
+ * FIXME: This could be done in a simpler way by
+ * consulting the above width/height of the buffer + some
+ * padding values, however all of this request code needs
+ * to be changed to use GtkSizeRequestIface and deserves
+ * more attention.
+ */
+ GtkRequisition cached_size_request;
+
+ /* The virtual cursor position is normally the same as the
+ * actual (strong) cursor position, except in two circumstances:
+ *
+ * a) When the cursor is moved vertically with the keyboard
+ * b) When the text view is scrolled with the keyboard
+ *
+ * In case a), virtual_cursor_x is preserved, but not virtual_cursor_y
+ * In case b), both virtual_cursor_x and virtual_cursor_y are preserved.
+ */
+ gint virtual_cursor_x; /* -1 means use actual cursor position */
+ gint virtual_cursor_y; /* -1 means use actual cursor position */
+
+ GtkTextMark *first_para_mark; /* Mark at the beginning of the first onscreen paragraph */
+ gint first_para_pixels; /* Offset of top of screen in the first onscreen paragraph */
+
+ GtkTextMark *dnd_mark;
+ guint blink_timeout;
+
+ guint first_validate_idle; /* Idle to revalidate onscreen portion, runs before resize */
+ guint incremental_validate_idle; /* Idle to revalidate offscreen portions, runs after redraw */
+
+ GtkIMContext *im_context;
+ GtkWidget *popup_menu;
+
+ gint drag_start_x;
+ gint drag_start_y;
+
+ GSList *children;
+
+ GtkTextPendingScroll *pending_scroll;
+
+ gint pending_place_cursor_button;
+
+ /* Default style settings */
+ gint pixels_above_lines;
+ gint pixels_below_lines;
+ gint pixels_inside_wrap;
+ GtkWrapMode wrap_mode;
+ GtkJustification justify;
+ gint left_margin;
+ gint right_margin;
+ gint indent;
+ PangoTabArray *tabs;
+ guint editable : 1;
+
+ guint overwrite_mode : 1;
+ guint cursor_visible : 1;
+
+ /* if we have reset the IM since the last character entered */
+ guint need_im_reset : 1;
+
+ guint accepts_tab : 1;
+
+ guint width_changed : 1;
+ /* debug flag - means that we've validated onscreen since the
+ * last "invalidate" signal from the layout
+ */
+ guint onscreen_validated : 1;
+
+ guint mouse_cursor_obscured : 1;
+
+ guint scroll_after_paste : 1;
+};
struct _GtkTextPendingScroll
{
gdouble xalign;
gdouble yalign;
};
-
+
enum
{
SET_SCROLL_ADJUSTMENTS,
COPY_CLIPBOARD,
PASTE_CLIPBOARD,
TOGGLE_OVERWRITE,
- MOVE_FOCUS,
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_draw_focus (GtkWidget *widget);
static gboolean gtk_text_view_focus (GtkWidget *widget,
GtkDirectionType direction);
+static void gtk_text_view_move_focus (GtkWidget *widget,
+ GtkDirectionType direction_type);
static void gtk_text_view_select_all (GtkWidget *widget,
gboolean select);
GtkMovementStep step,
gint count,
gboolean extend_selection);
-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,
+static gboolean 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_paste_clipboard (GtkTextView *text_view);
static void gtk_text_view_toggle_overwrite (GtkTextView *text_view);
static void gtk_text_view_toggle_cursor_visible (GtkTextView *text_view);
-static void gtk_text_view_move_focus (GtkTextView *text_view,
+static void gtk_text_view_compat_move_focus(GtkTextView *text_view,
GtkDirectionType direction_type);
static void gtk_text_view_unselect (GtkTextView *text_view);
static void gtk_text_view_ensure_layout (GtkTextView *text_view);
static void gtk_text_view_destroy_layout (GtkTextView *text_view);
static void gtk_text_view_check_keymap_direction (GtkTextView *text_view);
-static void gtk_text_view_reset_im_context (GtkTextView *text_view);
static void gtk_text_view_start_selection_drag (GtkTextView *text_view,
const GtkTextIter *iter,
GdkEventButton *event);
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->motion_notify_event = gtk_text_view_motion_event;
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_handler,
+ * because the signal slot is not available in GtkWidgetCLass
+ */
+ g_signal_override_class_handler ("move-focus",
+ GTK_TYPE_TEXT_VIEW,
+ 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;
widget_class->drag_data_get = gtk_text_view_drag_data_get;
container_class->forall = gtk_text_view_forall;
klass->move_cursor = gtk_text_view_move_cursor;
- klass->page_horizontally = gtk_text_view_page_horizontally;
klass->set_anchor = gtk_text_view_set_anchor;
klass->insert_at_cursor = gtk_text_view_insert_at_cursor;
klass->delete_from_cursor = gtk_text_view_delete_from_cursor;
klass->copy_clipboard = gtk_text_view_copy_clipboard;
klass->paste_clipboard = gtk_text_view_paste_clipboard;
klass->toggle_overwrite = gtk_text_view_toggle_overwrite;
- klass->move_focus = gtk_text_view_move_focus;
+ klass->move_focus = gtk_text_view_compat_move_focus;
klass->set_scroll_adjustments = gtk_text_view_set_scroll_adjustments;
/*
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
*/
/**
* GtkTextView::move-cursor:
- * @widget: the object which received the signal
+ * @text_view: the object which received the signal
* @step: the granularity of the move, as a #GtkMovementStep
* @count: the number of @step units to move
* @extend_selection: %TRUE if the move should extend the selection
*
- * The ::move-cursor signal is a keybinding signal which gets emitted
- * when the user initiates a cursor movement.
+ * The ::move-cursor signal is a
+ * <link linkend="keybinding-signals">keybinding signal</link>
+ * which gets emitted when the user initiates a cursor movement.
+ * If the cursor is not visible in @text_view, this signal causes
+ * 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,
+ * the variant with the Shift modifier extends the selection,
+ * the variant without the Shift modifer does not.
+ * There are too many key combinations to list them all here.
+ * <itemizedlist>
+ * <listitem>Arrow keys move by individual characters/lines</listitem>
+ * <listitem>Ctrl-arrow key combinations move by words/paragraphs</listitem>
+ * <listitem>Home/End keys move to the ends of the buffer</listitem>
+ * <listitem>PageUp/PageDown keys move vertically by pages</listitem>
+ * <listitem>Ctrl-PageUp/PageDown keys move horizontally by pages</listitem>
+ * </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),
G_TYPE_INT,
G_TYPE_BOOLEAN);
- signals[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),
- NULL, NULL,
- _gtk_marshal_VOID__INT_BOOLEAN,
- G_TYPE_NONE, 2,
- G_TYPE_INT,
- G_TYPE_BOOLEAN);
-
+ /**
+ * GtkTextView::move-viewport:
+ * @text_view: the object which received the signal
+ * @step: the granularity of the move, as a #GtkMovementStep
+ * @count: the number of @step units to move
+ *
+ * The ::move-viewport signal is a
+ * <link linkend="keybinding-signals">keybinding signal</link>
+ * which can be bound to key combinations to allow the user
+ * to move the viewport, i.e. change what part of the text view
+ * is visible in a containing scrolled window.
+ *
+ * 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),
G_TYPE_NONE, 1,
G_TYPE_STRING);
+ /**
+ * GtkTextView::delete-from-cursor:
+ * @text_view: the object which received the signal
+ * @type: the granularity of the deletion, as a #GtkDeleteType
+ * @count: the number of @type units to delete
+ *
+ * The ::delete-from-cursor signal is a
+ * <link linkend="keybinding-signals">keybinding signal</link>
+ * which gets emitted when the user initiates a text deletion.
+ *
+ * If the @type is %GTK_DELETE_CHARS, GTK+ deletes the selection
+ * if there is one, otherwise it deletes the requested number
+ * of characters.
+ *
+ * The default bindings for this signal are
+ * Delete for deleting a character, Ctrl-Delete for
+ * deleting a word and Ctrl-Backspace for deleting a word
+ * 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),
GTK_TYPE_DELETE_TYPE,
G_TYPE_INT);
+ /**
+ * GtkTextView::backspace:
+ * @text_view: the object which received the signal
+ *
+ * The ::backspace signal is a
+ * <link linkend="keybinding-signals">keybinding signal</link>
+ * which gets emitted when the user asks for it.
+ *
+ * The default bindings for this signal are
+ * Backspace and Shift-Backspace.
+ */
signals[BACKSPACE] =
g_signal_new (I_("backspace"),
G_OBJECT_CLASS_TYPE (gobject_class),
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
+ /**
+ * GtkTextView::cut-clipboard:
+ * @text_view: the object which received the signal
+ *
+ * The ::cut-clipboard signal is a
+ * <link linkend="keybinding-signals">keybinding signal</link>
+ * which gets emitted to cut the selection to the clipboard.
+ *
+ * The default bindings for this signal are
+ * 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),
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
+ /**
+ * GtkTextView::copy-clipboard:
+ * @text_view: the object which received the signal
+ *
+ * The ::copy-clipboard signal is a
+ * <link linkend="keybinding-signals">keybinding signal</link>
+ * which gets emitted to copy the selection to the clipboard.
+ *
+ * The default bindings for this signal are
+ * 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),
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
+ /**
+ * GtkTextView::paste-clipboard:
+ * @text_view: the object which received the signal
+ *
+ * The ::paste-clipboard signal is a
+ * <link linkend="keybinding-signals">keybinding signal</link>
+ * which gets emitted to paste the contents of the clipboard
+ * into the text view.
+ *
+ * The default bindings for this signal are
+ * 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),
_gtk_marshal_VOID__VOID,
G_TYPE_NONE, 0);
+ /**
+ * GtkTextView::toggle-overwrite:
+ * @text_view: the object which received the signal
+ *
+ * The ::toggle-overwrite signal is a
+ * <link linkend="keybinding-signals">keybinding signal</link>
+ * 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);
- signals[MOVE_FOCUS] =
- g_signal_new (I_("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);
-
+ /**
+ * 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),
G_TYPE_NONE, 1,
GTK_TYPE_MENU);
+ /**
+ * GtkTextView::select-all:
+ * @text_view: the object which received the signal
+ * @select: %TRUE to select, %FALSE to unselect
+ *
+ * The ::select-all signal is a
+ * <link linkend="keybinding-signals">keybinding signal</link>
+ * which gets emitted to select or unselect the complete
+ * contents of the text view.
+ *
+ * The default bindings for this signal are Ctrl-a and Ctrl-/
+ * 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:
+ * @text_view: the object which received the signal
+ *
+ * The ::toggle-cursor-visible signal is a
+ * <link linkend="keybinding-signals">keybinding signal</link>
+ * which gets emitted to toggle the visibility of the cursor.
+ *
+ * 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
binding_set = gtk_binding_set_by_class (klass);
/* Moving the insertion point */
- add_move_binding (binding_set, GDK_Right, 0,
+ add_move_binding (binding_set, GDK_KEY_Right, 0,
GTK_MOVEMENT_VISUAL_POSITIONS, 1);
- add_move_binding (binding_set, GDK_KP_Right, 0,
+ add_move_binding (binding_set, GDK_KEY_KP_Right, 0,
GTK_MOVEMENT_VISUAL_POSITIONS, 1);
- add_move_binding (binding_set, GDK_Left, 0,
+ add_move_binding (binding_set, GDK_KEY_Left, 0,
GTK_MOVEMENT_VISUAL_POSITIONS, -1);
- add_move_binding (binding_set, GDK_KP_Left, 0,
+ add_move_binding (binding_set, GDK_KEY_KP_Left, 0,
GTK_MOVEMENT_VISUAL_POSITIONS, -1);
- add_move_binding (binding_set, GDK_Right, GDK_CONTROL_MASK,
+ add_move_binding (binding_set, GDK_KEY_Right, GDK_CONTROL_MASK,
GTK_MOVEMENT_WORDS, 1);
- add_move_binding (binding_set, GDK_KP_Right, GDK_CONTROL_MASK,
+ add_move_binding (binding_set, GDK_KEY_KP_Right, GDK_CONTROL_MASK,
GTK_MOVEMENT_WORDS, 1);
- add_move_binding (binding_set, GDK_Left, GDK_CONTROL_MASK,
+ add_move_binding (binding_set, GDK_KEY_Left, GDK_CONTROL_MASK,
GTK_MOVEMENT_WORDS, -1);
- add_move_binding (binding_set, GDK_KP_Left, GDK_CONTROL_MASK,
+ add_move_binding (binding_set, GDK_KEY_KP_Left, GDK_CONTROL_MASK,
GTK_MOVEMENT_WORDS, -1);
- add_move_binding (binding_set, GDK_Up, 0,
+ add_move_binding (binding_set, GDK_KEY_Up, 0,
GTK_MOVEMENT_DISPLAY_LINES, -1);
- add_move_binding (binding_set, GDK_KP_Up, 0,
+ add_move_binding (binding_set, GDK_KEY_KP_Up, 0,
GTK_MOVEMENT_DISPLAY_LINES, -1);
- add_move_binding (binding_set, GDK_Down, 0,
+ add_move_binding (binding_set, GDK_KEY_Down, 0,
GTK_MOVEMENT_DISPLAY_LINES, 1);
- add_move_binding (binding_set, GDK_KP_Down, 0,
+ add_move_binding (binding_set, GDK_KEY_KP_Down, 0,
GTK_MOVEMENT_DISPLAY_LINES, 1);
- add_move_binding (binding_set, GDK_Up, GDK_CONTROL_MASK,
+ add_move_binding (binding_set, GDK_KEY_Up, GDK_CONTROL_MASK,
GTK_MOVEMENT_PARAGRAPHS, -1);
- add_move_binding (binding_set, GDK_KP_Up, GDK_CONTROL_MASK,
+ add_move_binding (binding_set, GDK_KEY_KP_Up, GDK_CONTROL_MASK,
GTK_MOVEMENT_PARAGRAPHS, -1);
- add_move_binding (binding_set, GDK_Down, GDK_CONTROL_MASK,
+ add_move_binding (binding_set, GDK_KEY_Down, GDK_CONTROL_MASK,
GTK_MOVEMENT_PARAGRAPHS, 1);
- add_move_binding (binding_set, GDK_KP_Down, GDK_CONTROL_MASK,
+ add_move_binding (binding_set, GDK_KEY_KP_Down, GDK_CONTROL_MASK,
GTK_MOVEMENT_PARAGRAPHS, 1);
- add_move_binding (binding_set, GDK_Home, 0,
+ add_move_binding (binding_set, GDK_KEY_Home, 0,
GTK_MOVEMENT_DISPLAY_LINE_ENDS, -1);
- add_move_binding (binding_set, GDK_KP_Home, 0,
+ add_move_binding (binding_set, GDK_KEY_KP_Home, 0,
GTK_MOVEMENT_DISPLAY_LINE_ENDS, -1);
- add_move_binding (binding_set, GDK_End, 0,
+ add_move_binding (binding_set, GDK_KEY_End, 0,
GTK_MOVEMENT_DISPLAY_LINE_ENDS, 1);
- add_move_binding (binding_set, GDK_KP_End, 0,
+ add_move_binding (binding_set, GDK_KEY_KP_End, 0,
GTK_MOVEMENT_DISPLAY_LINE_ENDS, 1);
- add_move_binding (binding_set, GDK_Home, GDK_CONTROL_MASK,
+ add_move_binding (binding_set, GDK_KEY_Home, GDK_CONTROL_MASK,
GTK_MOVEMENT_BUFFER_ENDS, -1);
- add_move_binding (binding_set, GDK_KP_Home, GDK_CONTROL_MASK,
+ add_move_binding (binding_set, GDK_KEY_KP_Home, GDK_CONTROL_MASK,
GTK_MOVEMENT_BUFFER_ENDS, -1);
- add_move_binding (binding_set, GDK_End, GDK_CONTROL_MASK,
+ add_move_binding (binding_set, GDK_KEY_End, GDK_CONTROL_MASK,
GTK_MOVEMENT_BUFFER_ENDS, 1);
- add_move_binding (binding_set, GDK_KP_End, GDK_CONTROL_MASK,
+ add_move_binding (binding_set, GDK_KEY_KP_End, GDK_CONTROL_MASK,
GTK_MOVEMENT_BUFFER_ENDS, 1);
- add_move_binding (binding_set, GDK_Page_Up, 0,
+ add_move_binding (binding_set, GDK_KEY_Page_Up, 0,
GTK_MOVEMENT_PAGES, -1);
- add_move_binding (binding_set, GDK_KP_Page_Up, 0,
+ add_move_binding (binding_set, GDK_KEY_KP_Page_Up, 0,
GTK_MOVEMENT_PAGES, -1);
- add_move_binding (binding_set, GDK_Page_Down, 0,
+ add_move_binding (binding_set, GDK_KEY_Page_Down, 0,
GTK_MOVEMENT_PAGES, 1);
- add_move_binding (binding_set, GDK_KP_Page_Down, 0,
+ add_move_binding (binding_set, GDK_KEY_KP_Page_Down, 0,
GTK_MOVEMENT_PAGES, 1);
- add_move_binding (binding_set, GDK_Page_Up, GDK_CONTROL_MASK,
+ add_move_binding (binding_set, GDK_KEY_Page_Up, GDK_CONTROL_MASK,
GTK_MOVEMENT_HORIZONTAL_PAGES, -1);
- add_move_binding (binding_set, GDK_KP_Page_Up, GDK_CONTROL_MASK,
+ add_move_binding (binding_set, GDK_KEY_KP_Page_Up, GDK_CONTROL_MASK,
GTK_MOVEMENT_HORIZONTAL_PAGES, -1);
- add_move_binding (binding_set, GDK_Page_Down, GDK_CONTROL_MASK,
+ add_move_binding (binding_set, GDK_KEY_Page_Down, GDK_CONTROL_MASK,
GTK_MOVEMENT_HORIZONTAL_PAGES, 1);
- add_move_binding (binding_set, GDK_KP_Page_Down, GDK_CONTROL_MASK,
+ add_move_binding (binding_set, GDK_KEY_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,
- "select_all", 1,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_a, GDK_CONTROL_MASK,
+ "select-all", 1,
G_TYPE_BOOLEAN, TRUE);
- gtk_binding_entry_add_signal (binding_set, GDK_slash, GDK_CONTROL_MASK,
- "select_all", 1,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_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,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_backslash, GDK_CONTROL_MASK,
+ "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,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_a, GDK_SHIFT_MASK | 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_binding_entry_add_signal (binding_set, GDK_KEY_Delete, 0,
+ "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_binding_entry_add_signal (binding_set, GDK_KEY_KP_Delete, 0,
+ "delete-from-cursor", 2,
G_TYPE_ENUM, GTK_DELETE_CHARS,
G_TYPE_INT, 1);
- gtk_binding_entry_add_signal (binding_set, GDK_BackSpace, 0,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_BackSpace, 0,
"backspace", 0);
/* Make this do the same as Backspace, to help with mis-typing */
- gtk_binding_entry_add_signal (binding_set, GDK_BackSpace, GDK_SHIFT_MASK,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_BackSpace, GDK_SHIFT_MASK,
"backspace", 0);
- gtk_binding_entry_add_signal (binding_set, GDK_Delete, GDK_CONTROL_MASK,
- "delete_from_cursor", 2,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_Delete, GDK_CONTROL_MASK,
+ "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_binding_entry_add_signal (binding_set, GDK_KEY_KP_Delete, GDK_CONTROL_MASK,
+ "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_binding_entry_add_signal (binding_set, GDK_KEY_BackSpace, GDK_CONTROL_MASK,
+ "delete-from-cursor", 2,
G_TYPE_ENUM, GTK_DELETE_WORD_ENDS,
G_TYPE_INT, -1);
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_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_KEY_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_KEY_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);
- gtk_binding_entry_add_signal (binding_set, GDK_c, GDK_CONTROL_MASK,
- "copy_clipboard", 0);
- gtk_binding_entry_add_signal (binding_set, GDK_v, GDK_CONTROL_MASK,
- "paste_clipboard", 0);
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_x, GDK_CONTROL_MASK,
+ "cut-clipboard", 0);
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_c, GDK_CONTROL_MASK,
+ "copy-clipboard", 0);
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_v, GDK_CONTROL_MASK,
+ "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);
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_Delete, GDK_SHIFT_MASK,
+ "cut-clipboard", 0);
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_Insert, GDK_CONTROL_MASK,
+ "copy-clipboard", 0);
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_Insert, GDK_SHIFT_MASK,
+ "paste-clipboard", 0);
/* Overwrite */
- gtk_binding_entry_add_signal (binding_set, GDK_Insert, 0,
- "toggle_overwrite", 0);
- gtk_binding_entry_add_signal (binding_set, GDK_KP_Insert, 0,
- "toggle_overwrite", 0);
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_Insert, 0,
+ "toggle-overwrite", 0);
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_KP_Insert, 0,
+ "toggle-overwrite", 0);
/* Caret mode */
- gtk_binding_entry_add_signal (binding_set, GDK_F7, 0,
- "toggle_cursor_visible", 0);
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_F7, 0,
+ "toggle-cursor-visible", 0);
/* Control-tab focus motion */
- gtk_binding_entry_add_signal (binding_set, GDK_Tab, GDK_CONTROL_MASK,
- "move_focus", 1,
+ gtk_binding_entry_add_signal (binding_set, GDK_KEY_Tab, GDK_CONTROL_MASK,
+ "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_binding_entry_add_signal (binding_set, GDK_KEY_KP_Tab, GDK_CONTROL_MASK,
+ "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_binding_entry_add_signal (binding_set, GDK_KEY_Tab, GDK_SHIFT_MASK | GDK_CONTROL_MASK,
+ "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_binding_entry_add_signal (binding_set, GDK_KEY_KP_Tab, GDK_SHIFT_MASK | GDK_CONTROL_MASK,
+ "move-focus", 1,
GTK_TYPE_DIRECTION_TYPE, GTK_DIR_TAB_BACKWARD);
g_type_class_add_private (gobject_class, sizeof (GtkTextViewPrivate));
{
GtkWidget *widget = GTK_WIDGET (text_view);
GtkTargetList *target_list;
+ GtkTextViewPrivate *priv;
+
+ text_view->priv = GTK_TEXT_VIEW_GET_PRIVATE (text_view);
+ priv = text_view->priv;
- GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_FOCUS);
+ gtk_widget_set_can_focus (widget, TRUE);
/* Set up default style */
- text_view->wrap_mode = GTK_WRAP_NONE;
- text_view->pixels_above_lines = 0;
- text_view->pixels_below_lines = 0;
- text_view->pixels_inside_wrap = 0;
- text_view->justify = GTK_JUSTIFY_LEFT;
- text_view->left_margin = 0;
- text_view->right_margin = 0;
- text_view->indent = 0;
- text_view->tabs = NULL;
- text_view->editable = TRUE;
+ priv->wrap_mode = GTK_WRAP_NONE;
+ priv->pixels_above_lines = 0;
+ priv->pixels_below_lines = 0;
+ priv->pixels_inside_wrap = 0;
+ priv->justify = GTK_JUSTIFY_LEFT;
+ priv->left_margin = 0;
+ priv->right_margin = 0;
+ priv->indent = 0;
+ priv->tabs = NULL;
+ priv->editable = TRUE;
+
+ priv->scroll_after_paste = TRUE;
gtk_drag_dest_set (widget, 0, NULL, 0,
GDK_ACTION_COPY | GDK_ACTION_MOVE);
gtk_drag_dest_set_target_list (widget, target_list);
gtk_target_list_unref (target_list);
- text_view->virtual_cursor_x = -1;
- text_view->virtual_cursor_y = -1;
+ priv->virtual_cursor_x = -1;
+ priv->virtual_cursor_y = -1;
/* This object is completely private. No external entity can gain a reference
* to it; so we create it here and destroy it in finalize ().
*/
- text_view->im_context = gtk_im_multicontext_new ();
+ priv->im_context = gtk_im_multicontext_new ();
- g_signal_connect (text_view->im_context, "commit",
+ g_signal_connect (priv->im_context, "commit",
G_CALLBACK (gtk_text_view_commit_handler), text_view);
- g_signal_connect (text_view->im_context, "preedit_changed",
+ g_signal_connect (priv->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 (priv->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 (priv->im_context, "delete-surrounding",
G_CALLBACK (gtk_text_view_delete_surrounding_handler), text_view);
- text_view->cursor_visible = TRUE;
+ priv->cursor_visible = TRUE;
- text_view->accepts_tab = TRUE;
+ priv->accepts_tab = TRUE;
- text_view->text_window = text_window_new (GTK_TEXT_WINDOW_TEXT,
- widget, 200, 200);
+ priv->text_window = text_window_new (GTK_TEXT_WINDOW_TEXT,
+ widget, 200, 200);
- text_view->drag_start_x = -1;
- text_view->drag_start_y = -1;
+ priv->drag_start_x = -1;
+ priv->drag_start_y = -1;
- text_view->pending_place_cursor_button = 0;
+ priv->pending_place_cursor_button = 0;
/* We handle all our own redrawing */
gtk_widget_set_redraw_on_allocate (widget, FALSE);
*
* Creates a new #GtkTextView widget displaying the buffer
* @buffer. One buffer can be shared among many widgets.
- * @buffer may be NULL to create a default buffer, in which case
+ * @buffer may be %NULL to create a default buffer, in which case
* this function is equivalent to gtk_text_view_new(). The
* text view adds its own reference count to the buffer; it does not
* take over an existing reference.
/**
* 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
* added to @buffer. If you owned a reference to @buffer before passing it
* to this function, you must remove that reference yourself; #GtkTextView
* will not "adopt" it.
- *
**/
void
gtk_text_view_set_buffer (GtkTextView *text_view,
GtkTextBuffer *buffer)
{
+ GtkTextViewPrivate *priv;
+
g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
g_return_if_fail (buffer == NULL || GTK_IS_TEXT_BUFFER (buffer));
- if (text_view->buffer == buffer)
+ priv = text_view->priv;
+
+ if (priv->buffer == buffer)
return;
- if (text_view->buffer != NULL)
+ if (priv->buffer != NULL)
{
/* Destroy all anchored children */
GSList *tmp_list;
GSList *copy;
- copy = g_slist_copy (text_view->children);
+ copy = g_slist_copy (priv->children);
tmp_list = copy;
while (tmp_list != NULL)
{
g_slist_free (copy);
- g_signal_handlers_disconnect_by_func (text_view->buffer,
+ g_signal_handlers_disconnect_by_func (priv->buffer,
gtk_text_view_mark_set_handler,
text_view);
- g_signal_handlers_disconnect_by_func (text_view->buffer,
+ g_signal_handlers_disconnect_by_func (priv->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 (priv->buffer,
+ gtk_text_view_paste_done_handler,
+ text_view);
- if (GTK_WIDGET_REALIZED (text_view))
+ if (gtk_widget_get_realized (GTK_WIDGET (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);
- }
+ gtk_text_buffer_remove_selection_clipboard (priv->buffer, clipboard);
+ }
+
+ if (priv->layout)
+ gtk_text_layout_set_buffer (priv->layout, NULL);
+
+ g_object_unref (priv->buffer);
+ priv->dnd_mark = NULL;
+ priv->first_para_mark = NULL;
+ cancel_pending_scroll (text_view);
}
- text_view->buffer = buffer;
+ priv->buffer = buffer;
+
+ if (priv->layout)
+ gtk_text_layout_set_buffer (priv->layout, buffer);
if (buffer != NULL)
{
g_object_ref (buffer);
- if (text_view->layout)
- gtk_text_layout_set_buffer (text_view->layout, buffer);
+ gtk_text_buffer_get_iter_at_offset (priv->buffer, &start, 0);
- gtk_text_buffer_get_iter_at_offset (text_view->buffer, &start, 0);
+ priv->dnd_mark = gtk_text_buffer_create_mark (priv->buffer,
+ "gtk_drag_target",
+ &start, FALSE);
- text_view->dnd_mark = gtk_text_buffer_create_mark (text_view->buffer,
- "gtk_drag_target",
- &start, FALSE);
+ priv->first_para_mark = gtk_text_buffer_create_mark (priv->buffer,
+ NULL,
+ &start, TRUE);
- text_view->first_para_mark = gtk_text_buffer_create_mark (text_view->buffer,
- NULL,
- &start, TRUE);
+ priv->first_para_pixels = 0;
- text_view->first_para_pixels = 0;
- g_signal_connect (text_view->buffer, "mark_set",
+ g_signal_connect (priv->buffer, "mark-set",
G_CALLBACK (gtk_text_view_mark_set_handler),
text_view);
- g_signal_connect (text_view->buffer, "notify::paste-target-list",
+ g_signal_connect (priv->buffer, "notify::paste-target-list",
G_CALLBACK (gtk_text_view_target_list_notify),
text_view);
+ g_signal_connect (priv->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);
+ gtk_text_view_target_list_notify (priv->buffer, NULL, text_view);
- if (GTK_WIDGET_REALIZED (text_view))
+ if (gtk_widget_get_realized (GTK_WIDGET (text_view)))
{
GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (text_view),
GDK_SELECTION_PRIMARY);
- gtk_text_buffer_add_selection_clipboard (text_view->buffer, clipboard);
+ gtk_text_buffer_add_selection_clipboard (priv->buffer, clipboard);
}
}
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"));
static GtkTextBuffer*
get_buffer (GtkTextView *text_view)
{
- if (text_view->buffer == NULL)
+ if (text_view->priv->buffer == NULL)
{
GtkTextBuffer *b;
b = gtk_text_buffer_new (NULL);
g_object_unref (b);
}
- return text_view->buffer;
+ return text_view->priv->buffer;
}
/**
* 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_location:
* @text_view: a #GtkTextView
- * @iter: a #GtkTextIter
+ * @iter: (out): a #GtkTextIter
* @x: x position, in buffer coordinates
* @y: y position, in buffer coordinates
*
* currently-displayed portion. If you have coordinates from an
* event, you have to convert those to buffer coordinates with
* gtk_text_view_window_to_buffer_coords().
- *
**/
void
gtk_text_view_get_iter_at_location (GtkTextView *text_view,
gtk_text_view_ensure_layout (text_view);
- gtk_text_layout_get_iter_at_pixel (text_view->layout,
+ gtk_text_layout_get_iter_at_pixel (text_view->priv->layout,
iter, x, y);
}
/**
* gtk_text_view_get_iter_at_position:
* @text_view: a #GtkTextView
- * @iter: a #GtkTextIter
- * @trailing: location to store an integer indicating where
+ * @iter: (out): a #GtkTextIter
+ * @trailing: (out) (allow-none): 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.
gtk_text_view_ensure_layout (text_view);
- gtk_text_layout_get_iter_at_position (text_view->layout,
+ gtk_text_layout_get_iter_at_position (text_view->priv->layout,
iter, trailing, x, y);
}
* gtk_text_view_get_iter_location:
* @text_view: a #GtkTextView
* @iter: a #GtkTextIter
- * @location: bounds of the character at @iter
+ * @location: (out): bounds of the character at @iter
*
* Gets a rectangle which roughly contains the character at @iter.
* The rectangle position is in buffer coordinates; use
* gtk_text_view_buffer_to_window_coords() to convert these
* coordinates to coordinates for one of the windows in the text view.
- *
**/
void
gtk_text_view_get_iter_location (GtkTextView *text_view,
gtk_text_view_ensure_layout (text_view);
- gtk_text_layout_get_iter_location (text_view->layout, iter, location);
+ gtk_text_layout_get_iter_location (text_view->priv->layout, iter, location);
}
/**
* gtk_text_view_get_line_yrange:
* @text_view: a #GtkTextView
* @iter: a #GtkTextIter
- * @y: return location for a y coordinate
- * @height: return location for a height
+ * @y: (out): return location for a y coordinate
+ * @height: (out): return location for a height
*
* Gets the y coordinate of the top of the line containing @iter,
* and the height of the line. The coordinate is a buffer coordinate;
* convert to window coordinates with gtk_text_view_buffer_to_window_coords().
- *
**/
void
gtk_text_view_get_line_yrange (GtkTextView *text_view,
gtk_text_view_ensure_layout (text_view);
- gtk_text_layout_get_line_yrange (text_view->layout,
+ gtk_text_layout_get_line_yrange (text_view->priv->layout,
iter,
y,
height);
/**
* gtk_text_view_get_line_at_y:
* @text_view: a #GtkTextView
- * @target_iter: a #GtkTextIter
+ * @target_iter: (out): a #GtkTextIter
* @y: a y coordinate
- * @line_top: return location for top coordinate of the line
+ * @line_top: (out): return location for top coordinate of the line
*
* Gets the #GtkTextIter at the start of the line containing
* the coordinate @y. @y is in buffer coordinates, convert from
gtk_text_view_ensure_layout (text_view);
- gtk_text_layout_get_line_at_y (text_view->layout,
+ gtk_text_layout_get_line_at_y (text_view->priv->layout,
target_iter,
y,
line_top);
* @text_view: a #GtkTextView
* @iter: a #GtkTextIter
* @within_margin: margin as a [0.0,0.5) fraction of screen size
- * @use_align: whether to use alignment arguments (if %FALSE, just get the mark onscreen)
- * @xalign: horizontal alignment of mark within visible area.
+ * @use_align: whether to use alignment arguments (if %FALSE,
+ * just get the mark onscreen)
+ * @xalign: horizontal alignment of mark within visible area
* @yalign: vertical alignment of mark within visible area
*
* Scrolls @text_view so that @iter is on the screen in the position
* indicated by @xalign and @yalign. An alignment of 0.0 indicates
- * left or top, 1.0 indicates right or bottom, 0.5 means center. If @use_align
- * is %FALSE, the text scrolls the minimal distance to get the mark onscreen,
- * possibly not scrolling at all. The effective screen for purposes
- * of this function is reduced by a margin of size @within_margin.
- * NOTE: This function uses the currently-computed height of the
- * lines in the text buffer. Note that line heights are computed
- * in an idle handler; so this function may not have the desired effect
- * if it's called before the height computations. To avoid oddness,
- * consider using gtk_text_view_scroll_to_mark() which saves a point
- * to be scrolled to after line validation.
+ * left or top, 1.0 indicates right or bottom, 0.5 means center.
+ * If @use_align is %FALSE, the text scrolls the minimal distance to
+ * get the mark onscreen, possibly not scrolling at all. The effective
+ * screen for purposes of this function is reduced by a margin of size
+ * @within_margin.
+ *
+ * Note that this function uses the currently-computed height of the
+ * lines in the text buffer. Line heights are computed in an idle
+ * handler; so this function may not have the desired effect if it's
+ * called before the height computations. To avoid oddness, consider
+ * using gtk_text_view_scroll_to_mark() which saves a point to be
+ * scrolled to after line validation.
*
* Return value: %TRUE if scrolling occurred
**/
DV(g_print(G_STRLOC"\n"));
- gtk_text_layout_get_iter_location (text_view->layout,
+ gtk_text_layout_get_iter_location (text_view->priv->layout,
iter,
&rect);
DV (g_print (" target rect %d,%d %d x %d\n", rect.x, rect.y, rect.width, rect.height));
- current_x_scroll = text_view->xoffset;
- current_y_scroll = text_view->yoffset;
+ current_x_scroll = text_view->priv->xoffset;
+ current_y_scroll = text_view->priv->yoffset;
screen.x = current_x_scroll;
screen.y = current_y_scroll;
}
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;
}
static void
cancel_pending_scroll (GtkTextView *text_view)
{
- if (text_view->pending_scroll)
+ if (text_view->priv->pending_scroll)
{
- free_pending_scroll (text_view->pending_scroll);
- text_view->pending_scroll = NULL;
+ free_pending_scroll (text_view->priv->pending_scroll);
+ text_view->priv->pending_scroll = NULL;
}
}
-
+
static void
gtk_text_view_queue_scroll (GtkTextView *text_view,
GtkTextMark *mark,
cancel_pending_scroll (text_view);
- text_view->pending_scroll = scroll;
+ text_view->priv->pending_scroll = scroll;
}
static gboolean
gtk_text_view_flush_scroll (GtkTextView *text_view)
{
+ GtkAllocation allocation;
GtkTextIter iter;
GtkTextPendingScroll *scroll;
gboolean retval;
DV(g_print(G_STRLOC"\n"));
- if (text_view->pending_scroll == NULL)
+ if (text_view->priv->pending_scroll == NULL)
{
DV (g_print ("in flush scroll, no pending scroll\n"));
return FALSE;
}
- scroll = text_view->pending_scroll;
+ scroll = text_view->priv->pending_scroll;
/* avoid recursion */
- text_view->pending_scroll = NULL;
+ text_view->priv->pending_scroll = NULL;
gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &iter, scroll->mark);
* the screen.
*/
DV(g_print (">Validating scroll destination ("G_STRLOC")\n"));
- gtk_text_layout_validate_yrange (text_view->layout, &iter,
- - (widget->allocation.height * 2),
- widget->allocation.height * 2);
-
+ gtk_widget_get_allocation (widget, &allocation);
+ gtk_text_layout_validate_yrange (text_view->priv->layout, &iter,
+ -(allocation.height * 2),
+ allocation.height * 2);
+
DV(g_print (">Done validating scroll destination ("G_STRLOC")\n"));
/* Ensure we have updated width/height */
static void
gtk_text_view_update_adjustments (GtkTextView *text_view)
{
+ GtkTextViewPrivate *priv;
gint width = 0, height = 0;
DV(g_print(">Updating adjustments ("G_STRLOC")\n"));
- if (text_view->layout)
- gtk_text_layout_get_size (text_view->layout, &width, &height);
+ priv = text_view->priv;
+
+ if (priv->layout)
+ gtk_text_layout_get_size (priv->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)
+ if (priv->width != width || priv->height != height)
{
- if (text_view->width != width)
- text_view->width_changed = TRUE;
+ if (priv->width != width)
+ priv->width_changed = TRUE;
- text_view->width = width;
- text_view->height = height;
+ priv->width = width;
+ priv->height = height;
gtk_text_view_set_adjustment_upper (get_hadjustment (text_view),
MAX (SCREEN_WIDTH (text_view), width));
/* Set up the step sizes; we'll say that a page is
our allocation minus one step, and a step is
1/10 of our allocation. */
- text_view->hadjustment->step_increment =
+ priv->hadjustment->step_increment =
SCREEN_WIDTH (text_view) / 10.0;
- text_view->hadjustment->page_increment =
+ priv->hadjustment->page_increment =
SCREEN_WIDTH (text_view) * 0.9;
- text_view->vadjustment->step_increment =
+ priv->vadjustment->step_increment =
SCREEN_HEIGHT (text_view) / 10.0;
- text_view->vadjustment->page_increment =
+ priv->vadjustment->page_increment =
SCREEN_HEIGHT (text_view) * 0.9;
gtk_adjustment_changed (get_hadjustment (text_view));
gtk_text_view_ensure_layout (text_view);
- gtk_text_layout_set_screen_width (text_view->layout,
+ gtk_text_layout_set_screen_width (text_view->priv->layout,
MAX (1, SCREEN_WIDTH (text_view) - SPACE_FOR_CURSOR));
}
{
GdkRectangle area;
- if (text_view->layout == NULL)
+ if (text_view->priv->layout == NULL)
return;
gtk_text_view_get_cursor_location (text_view, &area);
- area.x -= text_view->xoffset;
- area.y -= text_view->yoffset;
+ area.x -= text_view->priv->xoffset;
+ area.y -= text_view->priv->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);
+ gtk_im_context_set_cursor_location (text_view->priv->im_context, &area);
+}
+
+static gboolean
+do_update_im_spot_location (gpointer text_view)
+{
+ GtkTextViewPrivate *priv;
+
+ priv = GTK_TEXT_VIEW (text_view)->priv;
+ 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 = text_view->priv;
+
+ /* 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 = text_view->priv;
+
+ 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);
+ }
}
/**
* @text_view: a #GtkTextView
* @mark: a #GtkTextMark
* @within_margin: margin as a [0.0,0.5) fraction of screen size
- * @use_align: whether to use alignment arguments (if %FALSE, just get the mark onscreen)
- * @xalign: horizontal alignment of mark within visible area.
+ * @use_align: whether to use alignment arguments (if %FALSE, just
+ * get the mark onscreen)
+ * @xalign: horizontal alignment of mark within visible area
* @yalign: vertical alignment of mark within visible area
*
* Scrolls @text_view so that @mark is on the screen in the position
* indicated by @xalign and @yalign. An alignment of 0.0 indicates
- * left or top, 1.0 indicates right or bottom, 0.5 means center. If @use_align
- * is %FALSE, the text scrolls the minimal distance to get the mark onscreen,
- * possibly not scrolling at all. The effective screen for purposes
- * of this function is reduced by a margin of size @within_margin.
- *
+ * left or top, 1.0 indicates right or bottom, 0.5 means center.
+ * If @use_align is %FALSE, the text scrolls the minimal distance to
+ * get the mark onscreen, possibly not scrolling at all. The effective
+ * screen for purposes of this function is reduced by a margin of size
+ * @within_margin.
**/
void
gtk_text_view_scroll_to_mark (GtkTextView *text_view,
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,
/* If no validation is pending, we need to go ahead and force an
* immediate scroll.
*/
- if (text_view->layout &&
- gtk_text_layout_is_valid (text_view->layout))
+ if (text_view->priv->layout &&
+ gtk_text_layout_is_valid (text_view->priv->layout))
gtk_text_view_flush_scroll (text_view);
}
*
* Scrolls @text_view the minimum distance such that @mark is contained
* within the visible area of the widget.
- *
**/
void
gtk_text_view_scroll_mark_onscreen (GtkTextView *text_view,
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);
}
GdkRectangle visible_rect;
gtk_text_view_get_visible_rect (text_view, &visible_rect);
- return gtk_text_layout_clamp_iter_to_vrange (text_view->layout, iter,
+ return gtk_text_layout_clamp_iter_to_vrange (text_view->priv->layout, iter,
visible_rect.y,
visible_rect.y + visible_rect.height);
}
if (visible_rect)
{
- visible_rect->x = text_view->xoffset;
- visible_rect->y = text_view->yoffset;
+ visible_rect->x = text_view->priv->xoffset;
+ visible_rect->y = text_view->priv->yoffset;
visible_rect->width = SCREEN_WIDTH (widget);
visible_rect->height = SCREEN_HEIGHT (widget);
gtk_text_view_set_wrap_mode (GtkTextView *text_view,
GtkWrapMode wrap_mode)
{
+ GtkTextViewPrivate *priv;
+
g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
- if (text_view->wrap_mode != wrap_mode)
+ priv = text_view->priv;
+
+ if (priv->wrap_mode != wrap_mode)
{
- text_view->wrap_mode = wrap_mode;
+ priv->wrap_mode = wrap_mode;
- if (text_view->layout)
+ if (priv->layout)
{
- text_view->layout->default_style->wrap_mode = wrap_mode;
- gtk_text_layout_default_style_changed (text_view->layout);
+ priv->layout->default_style->wrap_mode = wrap_mode;
+ gtk_text_layout_default_style_changed (priv->layout);
}
}
{
g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), GTK_WRAP_NONE);
- return text_view->wrap_mode;
+ return text_view->priv->wrap_mode;
}
/**
gtk_text_view_set_editable (GtkTextView *text_view,
gboolean setting)
{
+ GtkTextViewPrivate *priv;
+
g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
+
+ priv = text_view->priv;
setting = setting != FALSE;
- if (text_view->editable != setting)
+ if (priv->editable != setting)
{
- 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 (priv->im_context);
+ }
- if (text_view->layout)
+ priv->editable = setting;
+
+ if (setting && gtk_widget_has_focus (GTK_WIDGET (text_view)))
+ gtk_im_context_focus_in (priv->im_context);
+
+ if (priv->layout)
{
- text_view->layout->default_style->editable = text_view->editable;
- gtk_text_layout_default_style_changed (text_view->layout);
+ gtk_text_layout_set_overwrite_mode (priv->layout,
+ priv->overwrite_mode && priv->editable);
+ priv->layout->default_style->editable = priv->editable;
+ gtk_text_layout_default_style_changed (priv->layout);
}
g_object_notify (G_OBJECT (text_view), "editable");
{
g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), FALSE);
- return text_view->editable;
+ return text_view->priv->editable;
}
/**
*
* Sets the default number of blank pixels above paragraphs in @text_view.
* Tags in the buffer for @text_view may override the defaults.
- *
**/
void
gtk_text_view_set_pixels_above_lines (GtkTextView *text_view,
gint pixels_above_lines)
{
+ GtkTextViewPrivate *priv;
+
g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
- if (text_view->pixels_above_lines != pixels_above_lines)
+ priv = text_view->priv;
+
+ if (priv->pixels_above_lines != pixels_above_lines)
{
- text_view->pixels_above_lines = pixels_above_lines;
+ priv->pixels_above_lines = pixels_above_lines;
- if (text_view->layout)
+ if (priv->layout)
{
- text_view->layout->default_style->pixels_above_lines = pixels_above_lines;
- gtk_text_layout_default_style_changed (text_view->layout);
+ priv->layout->default_style->pixels_above_lines = pixels_above_lines;
+ gtk_text_layout_default_style_changed (priv->layout);
}
g_object_notify (G_OBJECT (text_view), "pixels-above-lines");
{
g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), 0);
- return text_view->pixels_above_lines;
+ return text_view->priv->pixels_above_lines;
}
/**
* Sets the default number of pixels of blank space
* to put below paragraphs in @text_view. May be overridden
* by tags applied to @text_view's buffer.
- *
**/
void
gtk_text_view_set_pixels_below_lines (GtkTextView *text_view,
gint pixels_below_lines)
{
+ GtkTextViewPrivate *priv;
+
g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
- if (text_view->pixels_below_lines != pixels_below_lines)
+ priv = text_view->priv;
+
+ if (priv->pixels_below_lines != pixels_below_lines)
{
- text_view->pixels_below_lines = pixels_below_lines;
+ priv->pixels_below_lines = pixels_below_lines;
- if (text_view->layout)
+ if (priv->layout)
{
- text_view->layout->default_style->pixels_below_lines = pixels_below_lines;
- gtk_text_layout_default_style_changed (text_view->layout);
+ priv->layout->default_style->pixels_below_lines = pixels_below_lines;
+ gtk_text_layout_default_style_changed (priv->layout);
}
g_object_notify (G_OBJECT (text_view), "pixels-below-lines");
{
g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), 0);
- return text_view->pixels_below_lines;
+ return text_view->priv->pixels_below_lines;
}
/**
* Sets the default number of pixels of blank space to leave between
* display/wrapped lines within a paragraph. May be overridden by
* tags in @text_view's buffer.
- *
**/
void
gtk_text_view_set_pixels_inside_wrap (GtkTextView *text_view,
gint pixels_inside_wrap)
{
+ GtkTextViewPrivate *priv;
+
g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
- if (text_view->pixels_inside_wrap != pixels_inside_wrap)
+ priv = text_view->priv;
+
+ if (priv->pixels_inside_wrap != pixels_inside_wrap)
{
- text_view->pixels_inside_wrap = pixels_inside_wrap;
+ priv->pixels_inside_wrap = pixels_inside_wrap;
- if (text_view->layout)
+ if (priv->layout)
{
- text_view->layout->default_style->pixels_inside_wrap = pixels_inside_wrap;
- gtk_text_layout_default_style_changed (text_view->layout);
+ priv->layout->default_style->pixels_inside_wrap = pixels_inside_wrap;
+ gtk_text_layout_default_style_changed (priv->layout);
}
g_object_notify (G_OBJECT (text_view), "pixels-inside-wrap");
{
g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), 0);
- return text_view->pixels_inside_wrap;
+ return text_view->priv->pixels_inside_wrap;
}
/**
gtk_text_view_set_justification (GtkTextView *text_view,
GtkJustification justification)
{
+ GtkTextViewPrivate *priv;
+
g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
- if (text_view->justify != justification)
+ priv = text_view->priv;
+
+ if (priv->justify != justification)
{
- text_view->justify = justification;
+ priv->justify = justification;
- if (text_view->layout)
+ if (priv->layout)
{
- text_view->layout->default_style->justification = justification;
- gtk_text_layout_default_style_changed (text_view->layout);
+ priv->layout->default_style->justification = justification;
+ gtk_text_layout_default_style_changed (priv->layout);
}
g_object_notify (G_OBJECT (text_view), "justification");
{
g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), GTK_JUSTIFY_LEFT);
- return text_view->justify;
+ return text_view->priv->justify;
}
/**
*
* Sets the default left margin for text in @text_view.
* Tags in the buffer may override the default.
- *
**/
void
gtk_text_view_set_left_margin (GtkTextView *text_view,
gint left_margin)
{
+ GtkTextViewPrivate *priv;
+
g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
- if (text_view->left_margin != left_margin)
+ priv = text_view->priv;
+
+ if (priv->left_margin != left_margin)
{
- text_view->left_margin = left_margin;
+ priv->left_margin = left_margin;
- if (text_view->layout)
+ if (priv->layout)
{
- text_view->layout->default_style->left_margin = left_margin;
- gtk_text_layout_default_style_changed (text_view->layout);
+ priv->layout->default_style->left_margin = left_margin;
+ gtk_text_layout_default_style_changed (priv->layout);
}
g_object_notify (G_OBJECT (text_view), "left-margin");
{
g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), 0);
- return text_view->left_margin;
+ return text_view->priv->left_margin;
}
/**
*
* Sets the default right margin for text in the text view.
* Tags in the buffer may override the default.
- *
**/
void
gtk_text_view_set_right_margin (GtkTextView *text_view,
gint right_margin)
{
+ GtkTextViewPrivate *priv = text_view->priv;
+
g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
- if (text_view->right_margin != right_margin)
+ if (priv->right_margin != right_margin)
{
- text_view->right_margin = right_margin;
+ priv->right_margin = right_margin;
- if (text_view->layout)
+ if (priv->layout)
{
- text_view->layout->default_style->right_margin = right_margin;
- gtk_text_layout_default_style_changed (text_view->layout);
+ priv->layout->default_style->right_margin = right_margin;
+ gtk_text_layout_default_style_changed (priv->layout);
}
g_object_notify (G_OBJECT (text_view), "right-margin");
{
g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), 0);
- return text_view->right_margin;
+ return text_view->priv->right_margin;
}
/**
*
* Sets the default indentation for paragraphs in @text_view.
* Tags in the buffer may override the default.
- *
**/
void
gtk_text_view_set_indent (GtkTextView *text_view,
gint indent)
{
+ GtkTextViewPrivate *priv;
+
g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
- if (text_view->indent != indent)
+ priv = text_view->priv;
+
+ if (priv->indent != indent)
{
- text_view->indent = indent;
+ priv->indent = indent;
- if (text_view->layout)
+ if (priv->layout)
{
- text_view->layout->default_style->indent = indent;
- gtk_text_layout_default_style_changed (text_view->layout);
+ priv->layout->default_style->indent = indent;
+ gtk_text_layout_default_style_changed (priv->layout);
}
g_object_notify (G_OBJECT (text_view), "indent");
{
g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), 0);
- return text_view->indent;
+ return text_view->priv->indent;
}
/**
*
* Sets the default tab stops for paragraphs in @text_view.
* Tags in the buffer may override the default.
- *
**/
void
gtk_text_view_set_tabs (GtkTextView *text_view,
PangoTabArray *tabs)
{
+ GtkTextViewPrivate *priv;
+
g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
- if (text_view->tabs)
- pango_tab_array_free (text_view->tabs);
+ priv = text_view->priv;
+
+ if (priv->tabs)
+ pango_tab_array_free (priv->tabs);
- text_view->tabs = tabs ? pango_tab_array_copy (tabs) : NULL;
+ priv->tabs = tabs ? pango_tab_array_copy (tabs) : NULL;
- if (text_view->layout)
+ if (priv->layout)
{
/* some unkosher futzing in internal struct details... */
- if (text_view->layout->default_style->tabs)
- pango_tab_array_free (text_view->layout->default_style->tabs);
+ if (priv->layout->default_style->tabs)
+ pango_tab_array_free (priv->layout->default_style->tabs);
- text_view->layout->default_style->tabs =
- text_view->tabs ? pango_tab_array_copy (text_view->tabs) : NULL;
+ priv->layout->default_style->tabs =
+ priv->tabs ? pango_tab_array_copy (priv->tabs) : NULL;
- gtk_text_layout_default_style_changed (text_view->layout);
+ gtk_text_layout_default_style_changed (priv->layout);
}
g_object_notify (G_OBJECT (text_view), "tabs");
* "standard" (8-space) tabs are used. Free the return value
* with pango_tab_array_free().
*
- * Return value: copy of default tab array, or %NULL if "standard" tabs are used; must be freed with pango_tab_array_free().
+ * Return value: copy of default tab array, or %NULL if "standard"
+ * tabs are used; must be freed with pango_tab_array_free().
**/
PangoTabArray*
gtk_text_view_get_tabs (GtkTextView *text_view)
{
g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), NULL);
- return text_view->tabs ? pango_tab_array_copy (text_view->tabs) : NULL;
+ return text_view->priv->tabs ? pango_tab_array_copy (text_view->priv->tabs) : NULL;
}
static void
gtk_text_view_toggle_cursor_visible (GtkTextView *text_view)
{
- gtk_text_view_set_cursor_visible (!text_view->cursor_visible);
+ gtk_text_view_set_cursor_visible (text_view, !text_view->priv->cursor_visible);
}
/**
gtk_text_view_set_cursor_visible (GtkTextView *text_view,
gboolean setting)
{
+ GtkTextViewPrivate *priv;
+
g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
+ priv = text_view->priv;
setting = (setting != FALSE);
- if (text_view->cursor_visible != setting)
+ if (priv->cursor_visible != setting)
{
- text_view->cursor_visible = setting;
+ priv->cursor_visible = setting;
- if (GTK_WIDGET_HAS_FOCUS (text_view))
+ if (gtk_widget_has_focus (GTK_WIDGET (text_view)))
{
- if (text_view->layout)
+ if (priv->layout)
{
- gtk_text_layout_set_cursor_visible (text_view->layout, setting);
+ gtk_text_layout_set_cursor_visible (priv->layout, setting);
gtk_text_view_check_cursor_blink (text_view);
}
}
{
g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), FALSE);
- return text_view->cursor_visible;
+ return text_view->priv->cursor_visible;
}
* Moves the cursor to the currently visible region of the
* buffer, it it isn't there already.
*
- * Return value: TRUE if the cursor had to be moved.
+ * Return value: %TRUE if the cursor had to be moved.
**/
gboolean
gtk_text_view_place_cursor_onscreen (GtkTextView *text_view)
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))
{
static void
gtk_text_view_remove_validate_idles (GtkTextView *text_view)
{
- if (text_view->first_validate_idle != 0)
+ GtkTextViewPrivate *priv = text_view->priv;
+
+ if (priv->first_validate_idle != 0)
{
DV (g_print ("Removing first validate idle: %s\n", G_STRLOC));
- g_source_remove (text_view->first_validate_idle);
- text_view->first_validate_idle = 0;
+ g_source_remove (priv->first_validate_idle);
+ priv->first_validate_idle = 0;
}
- if (text_view->incremental_validate_idle != 0)
+ if (priv->incremental_validate_idle != 0)
{
- g_source_remove (text_view->incremental_validate_idle);
- text_view->incremental_validate_idle = 0;
+ g_source_remove (priv->incremental_validate_idle);
+ priv->incremental_validate_idle = 0;
}
}
gtk_text_view_destroy (GtkObject *object)
{
GtkTextView *text_view;
-
+ GtkTextViewPrivate *priv;
+
text_view = GTK_TEXT_VIEW (object);
+ priv = text_view->priv;
gtk_text_view_remove_validate_idles (text_view);
gtk_text_view_set_buffer (text_view, NULL);
gtk_text_view_destroy_layout (text_view);
- if (text_view->scroll_timeout)
+ if (text_view->priv->scroll_timeout)
+ {
+ g_source_remove (text_view->priv->scroll_timeout);
+ text_view->priv->scroll_timeout = 0;
+ }
+
+ if (priv->im_spot_idle)
{
- g_source_remove (text_view->scroll_timeout);
- text_view->scroll_timeout = 0;
+ g_source_remove (priv->im_spot_idle);
+ priv->im_spot_idle = 0;
}
- (* GTK_OBJECT_CLASS (gtk_text_view_parent_class)->destroy) (object);
+ 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 = text_view->priv;
- g_assert (text_view->buffer == NULL);
+ g_assert (priv->buffer == NULL);
gtk_text_view_destroy_layout (text_view);
gtk_text_view_set_buffer (text_view, NULL);
cancel_pending_scroll (text_view);
- if (text_view->tabs)
- pango_tab_array_free (text_view->tabs);
+ if (priv->tabs)
+ pango_tab_array_free (priv->tabs);
- if (text_view->hadjustment)
- g_object_unref (text_view->hadjustment);
- if (text_view->vadjustment)
- g_object_unref (text_view->vadjustment);
+ if (priv->hadjustment)
+ g_object_unref (priv->hadjustment);
+ if (priv->vadjustment)
+ g_object_unref (priv->vadjustment);
- text_window_free (text_view->text_window);
+ text_window_free (priv->text_window);
- if (text_view->left_window)
- text_window_free (text_view->left_window);
+ if (priv->left_window)
+ text_window_free (priv->left_window);
- if (text_view->top_window)
- text_window_free (text_view->top_window);
+ if (priv->top_window)
+ text_window_free (priv->top_window);
- if (text_view->right_window)
- text_window_free (text_view->right_window);
+ if (priv->right_window)
+ text_window_free (priv->right_window);
- if (text_view->bottom_window)
- text_window_free (text_view->bottom_window);
+ if (priv->bottom_window)
+ text_window_free (priv->bottom_window);
- g_object_unref (text_view->im_context);
-
- (* G_OBJECT_CLASS (gtk_text_view_parent_class)->finalize) (object);
+ g_object_unref (priv->im_context);
+
+ 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 = text_view->priv;
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 (priv->im_context))
+ gtk_im_multicontext_set_context_id (GTK_IM_MULTICONTEXT (priv->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 = text_view->priv;
switch (prop_id)
{
case PROP_PIXELS_ABOVE_LINES:
- g_value_set_int (value, text_view->pixels_above_lines);
+ g_value_set_int (value, priv->pixels_above_lines);
break;
case PROP_PIXELS_BELOW_LINES:
- g_value_set_int (value, text_view->pixels_below_lines);
+ g_value_set_int (value, priv->pixels_below_lines);
break;
case PROP_PIXELS_INSIDE_WRAP:
- g_value_set_int (value, text_view->pixels_inside_wrap);
+ g_value_set_int (value, priv->pixels_inside_wrap);
break;
case PROP_EDITABLE:
- g_value_set_boolean (value, text_view->editable);
+ g_value_set_boolean (value, priv->editable);
break;
case PROP_WRAP_MODE:
- g_value_set_enum (value, text_view->wrap_mode);
+ g_value_set_enum (value, priv->wrap_mode);
break;
case PROP_JUSTIFICATION:
- g_value_set_enum (value, text_view->justify);
+ g_value_set_enum (value, priv->justify);
break;
case PROP_LEFT_MARGIN:
- g_value_set_int (value, text_view->left_margin);
+ g_value_set_int (value, priv->left_margin);
break;
case PROP_RIGHT_MARGIN:
- g_value_set_int (value, text_view->right_margin);
+ g_value_set_int (value, priv->right_margin);
break;
case PROP_INDENT:
- g_value_set_int (value, text_view->indent);
+ g_value_set_int (value, priv->indent);
break;
case PROP_TABS:
- g_value_set_boxed (value, text_view->tabs);
+ g_value_set_boxed (value, priv->tabs);
break;
case PROP_CURSOR_VISIBLE:
- g_value_set_boolean (value, text_view->cursor_visible);
+ g_value_set_boolean (value, priv->cursor_visible);
break;
case PROP_BUFFER:
break;
case PROP_OVERWRITE:
- g_value_set_boolean (value, text_view->overwrite_mode);
+ g_value_set_boolean (value, priv->overwrite_mode);
break;
case PROP_ACCEPTS_TAB:
- g_value_set_boolean (value, text_view->accepts_tab);
+ g_value_set_boolean (value, priv->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;
GtkRequisition *requisition)
{
GtkTextView *text_view;
+ GtkTextViewPrivate *priv;
GSList *tmp_list;
gint focus_edge_width;
gint focus_width;
+ guint border_width;
gboolean interior_focus;
-
+
text_view = GTK_TEXT_VIEW (widget);
+ priv = text_view->priv;
gtk_widget_style_get (widget,
"interior-focus", &interior_focus,
else
focus_edge_width = focus_width;
- if (text_view->layout)
+ if (priv->layout)
{
- text_view->text_window->requisition.width = text_view->layout->width;
- text_view->text_window->requisition.height = text_view->layout->height;
+ priv->text_window->requisition.width = priv->layout->width;
+ priv->text_window->requisition.height = priv->layout->height;
}
else
{
- text_view->text_window->requisition.width = 0;
- text_view->text_window->requisition.height = 0;
+ priv->text_window->requisition.width = 0;
+ priv->text_window->requisition.height = 0;
}
- requisition->width = text_view->text_window->requisition.width + focus_edge_width * 2;
- requisition->height = text_view->text_window->requisition.height + focus_edge_width * 2;
+ requisition->width = priv->text_window->requisition.width + focus_edge_width * 2;
+ requisition->height = priv->text_window->requisition.height + focus_edge_width * 2;
- if (text_view->left_window)
- requisition->width += text_view->left_window->requisition.width;
+ if (priv->left_window)
+ requisition->width += priv->left_window->requisition.width;
- if (text_view->right_window)
- requisition->width += text_view->right_window->requisition.width;
+ if (priv->right_window)
+ requisition->width += priv->right_window->requisition.width;
- if (text_view->top_window)
- requisition->height += text_view->top_window->requisition.height;
+ if (priv->top_window)
+ requisition->height += priv->top_window->requisition.height;
- if (text_view->bottom_window)
- requisition->height += text_view->bottom_window->requisition.height;
+ if (priv->bottom_window)
+ requisition->height += priv->bottom_window->requisition.height;
- requisition->width += GTK_CONTAINER (text_view)->border_width * 2;
- requisition->height += GTK_CONTAINER (text_view)->border_width * 2;
+ border_width = gtk_container_get_border_width (GTK_CONTAINER (text_view));
+ requisition->width += border_width * 2;
+ requisition->height += border_width * 2;
- tmp_list = text_view->children;
+ tmp_list = priv->children;
while (tmp_list != NULL)
{
GtkTextViewChild *child = tmp_list->data;
gtk_widget_get_child_requisition (child->widget, &child_req);
/* Invalidate layout lines if required */
- if (text_view->layout &&
+ if (priv->layout &&
(old_req.width != child_req.width ||
old_req.height != child_req.height))
gtk_text_child_anchor_queue_resize (child->anchor,
- text_view->layout);
+ priv->layout);
}
else
{
tmp_list = g_slist_next (tmp_list);
}
+
+ /* Cache the requested size of the text view so we can
+ * compare it in the changed_handler() */
+ priv->cached_size_request = *requisition;
}
static void
&iter,
vc->anchor);
- gtk_text_layout_get_line_yrange (text_view->layout, &iter,
+ gtk_text_layout_get_line_yrange (text_view->priv->layout, &iter,
&buffer_y, NULL);
buffer_y += vc->from_top_of_line;
- allocation->x = vc->from_left_of_buffer - text_view->xoffset;
- allocation->y = buffer_y - text_view->yoffset;
+ allocation->x = vc->from_left_of_buffer - text_view->priv->xoffset;
+ allocation->y = buffer_y - text_view->priv->yoffset;
gtk_widget_get_child_requisition (vc->widget, &req);
allocation->width = req.width;
vc->widget,
vc->widget->allocation.x,
vc->widget->allocation.y,
- text_view->yoffset);
+ text_view->priv->yoffset);
#endif
}
DV(g_print(G_STRLOC"\n"));
- tmp_list = text_view->children;
+ tmp_list = text_view->priv->children;
while (tmp_list != NULL)
{
GtkTextViewChild *child = tmp_list->data;
{
GtkTextIter end = child_loc;
gtk_text_iter_forward_char (&end);
- gtk_text_layout_invalidate (text_view->layout, &child_loc, &end);
+ gtk_text_layout_invalidate (text_view->priv->layout, &child_loc, &end);
}
- gtk_text_layout_validate_yrange (text_view->layout,
+ gtk_text_layout_validate_yrange (text_view->priv->layout,
&child_loc,
0, 1);
}
else
{
- GtkAllocation allocation;
+ GtkAllocation allocation;
GtkRequisition child_req;
allocation.x = child->x;
gtk_text_view_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
+ GtkAllocation widget_allocation;
GtkTextView *text_view;
+ GtkTextViewPrivate *priv;
GtkTextIter first_para;
gint y;
gint width, height;
GdkRectangle bottom_rect;
gint focus_edge_width;
gint focus_width;
+ guint border_width;
gboolean interior_focus;
gboolean size_changed;
text_view = GTK_TEXT_VIEW (widget);
+ priv = text_view->priv;
DV(g_print(G_STRLOC"\n"));
+ gtk_widget_get_allocation (widget, &widget_allocation);
size_changed =
- widget->allocation.width != allocation->width ||
- widget->allocation.height != allocation->height;
-
- widget->allocation = *allocation;
+ widget_allocation.width != allocation->width ||
+ widget_allocation.height != allocation->height;
- if (GTK_WIDGET_REALIZED (widget))
+ border_width = gtk_container_get_border_width (GTK_CONTAINER (text_view));
+
+ gtk_widget_set_allocation (widget, allocation);
+
+ if (gtk_widget_get_realized (widget))
{
- gdk_window_move_resize (widget->window,
+ gdk_window_move_resize (gtk_widget_get_window (widget),
allocation->x, allocation->y,
allocation->width, allocation->height);
}
else
focus_edge_width = focus_width;
- width = allocation->width - focus_edge_width * 2 - GTK_CONTAINER (text_view)->border_width * 2;
+ width = allocation->width - focus_edge_width * 2 - border_width * 2;
- if (text_view->left_window)
- left_rect.width = text_view->left_window->requisition.width;
+ if (priv->left_window)
+ left_rect.width = priv->left_window->requisition.width;
else
left_rect.width = 0;
width -= left_rect.width;
- if (text_view->right_window)
- right_rect.width = text_view->right_window->requisition.width;
+ if (priv->right_window)
+ right_rect.width = priv->right_window->requisition.width;
else
right_rect.width = 0;
bottom_rect.width = text_rect.width;
- height = allocation->height - focus_edge_width * 2 - GTK_CONTAINER (text_view)->border_width * 2;
+ height = allocation->height - focus_edge_width * 2 - border_width * 2;
- if (text_view->top_window)
- top_rect.height = text_view->top_window->requisition.height;
+ if (priv->top_window)
+ top_rect.height = priv->top_window->requisition.height;
else
top_rect.height = 0;
height -= top_rect.height;
- if (text_view->bottom_window)
- bottom_rect.height = text_view->bottom_window->requisition.height;
+ if (priv->bottom_window)
+ bottom_rect.height = priv->bottom_window->requisition.height;
else
bottom_rect.height = 0;
right_rect.height = text_rect.height;
/* Origins */
- left_rect.x = focus_edge_width + GTK_CONTAINER (text_view)->border_width;
- top_rect.y = focus_edge_width + GTK_CONTAINER (text_view)->border_width;
+ left_rect.x = focus_edge_width + border_width;
+ top_rect.y = focus_edge_width + border_width;
text_rect.x = left_rect.x + left_rect.width;
text_rect.y = top_rect.y + top_rect.height;
right_rect.x = text_rect.x + text_rect.width;
bottom_rect.y = text_rect.y + text_rect.height;
- text_window_size_allocate (text_view->text_window,
+ text_window_size_allocate (priv->text_window,
&text_rect);
- if (text_view->left_window)
- text_window_size_allocate (text_view->left_window,
+ if (priv->left_window)
+ text_window_size_allocate (priv->left_window,
&left_rect);
- if (text_view->right_window)
- text_window_size_allocate (text_view->right_window,
+ if (priv->right_window)
+ text_window_size_allocate (priv->right_window,
&right_rect);
- if (text_view->top_window)
- text_window_size_allocate (text_view->top_window,
+ if (priv->top_window)
+ text_window_size_allocate (priv->top_window,
&top_rect);
- if (text_view->bottom_window)
- text_window_size_allocate (text_view->bottom_window,
+ if (priv->bottom_window)
+ text_window_size_allocate (priv->bottom_window,
&bottom_rect);
gtk_text_view_update_layout_width (text_view);
get_hadjustment (text_view);
get_vadjustment (text_view);
- 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);
+ priv->hadjustment->page_size = SCREEN_WIDTH (text_view);
+ priv->hadjustment->page_increment = SCREEN_WIDTH (text_view) * 0.9;
+ priv->hadjustment->step_increment = SCREEN_WIDTH (text_view) * 0.1;
+ priv->hadjustment->lower = 0;
+ priv->hadjustment->upper = MAX (SCREEN_WIDTH (text_view),
+ priv->width);
- 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));
+ if (priv->hadjustment->value > priv->hadjustment->upper - priv->hadjustment->page_size)
+ gtk_adjustment_set_value (priv->hadjustment, MAX (0, priv->hadjustment->upper - priv->hadjustment->page_size));
- gtk_adjustment_changed (text_view->hadjustment);
+ gtk_adjustment_changed (priv->hadjustment);
- text_view->vadjustment->page_size = SCREEN_HEIGHT (text_view);
- text_view->vadjustment->page_increment = SCREEN_HEIGHT (text_view) * 0.9;
- text_view->vadjustment->step_increment = SCREEN_HEIGHT (text_view) * 0.1;
- text_view->vadjustment->lower = 0;
- text_view->vadjustment->upper = MAX (SCREEN_HEIGHT (text_view),
- text_view->height);
+ priv->vadjustment->page_size = SCREEN_HEIGHT (text_view);
+ priv->vadjustment->page_increment = SCREEN_HEIGHT (text_view) * 0.9;
+ priv->vadjustment->step_increment = SCREEN_HEIGHT (text_view) * 0.1;
+ priv->vadjustment->lower = 0;
+ priv->vadjustment->upper = MAX (SCREEN_HEIGHT (text_view),
+ priv->height);
/* 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);
+ gtk_text_layout_get_line_yrange (priv->layout, &first_para, &y, NULL);
- y += text_view->first_para_pixels;
+ y += priv->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 > priv->vadjustment->upper - priv->vadjustment->page_size)
+ y = MAX (0, priv->vadjustment->upper - priv->vadjustment->page_size);
- if (y != text_view->yoffset)
- gtk_adjustment_set_value (text_view->vadjustment, y);
+ if (y != priv->yoffset)
+ gtk_adjustment_set_value (priv->vadjustment, y);
- gtk_adjustment_changed (text_view->vadjustment);
+ gtk_adjustment_changed (priv->vadjustment);
/* The GTK resize loop processes all the pending exposes right
* after doing the resize stuff, so the idle sizer won't have a
/* widget->window doesn't get auto-redrawn as the layout is computed, so has to
* be invalidated
*/
- if (size_changed && GTK_WIDGET_REALIZED (widget))
- gdk_window_invalidate_rect (widget->window, NULL, FALSE);
+ if (size_changed && gtk_widget_get_realized (widget))
+ gdk_window_invalidate_rect (gtk_widget_get_window (widget), NULL, FALSE);
}
static void
GtkTextIter *iter)
{
gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), iter,
- text_view->first_para_mark);
+ text_view->priv->first_para_mark);
}
static void
gtk_text_view_validate_onscreen (GtkTextView *text_view)
{
- GtkWidget *widget = GTK_WIDGET (text_view);
+ GtkWidget *widget;
+ GtkTextViewPrivate *priv;
+
+ widget = GTK_WIDGET (text_view);
+ priv = text_view->priv;
DV(g_print(">Validating onscreen ("G_STRLOC")\n"));
*/
gtk_text_view_get_first_para_iter (text_view, &first_para);
- gtk_text_layout_validate_yrange (text_view->layout,
+ gtk_text_layout_validate_yrange (priv->layout,
&first_para,
0,
- text_view->first_para_pixels +
+ priv->first_para_pixels +
SCREEN_HEIGHT (widget));
}
- text_view->onscreen_validated = TRUE;
+ priv->onscreen_validated = TRUE;
DV(g_print(">Done validating onscreen, onscreen_validated = TRUE ("G_STRLOC")\n"));
*/
gtk_text_view_update_adjustments (text_view);
- g_assert (text_view->onscreen_validated);
+ g_assert (priv->onscreen_validated);
}
static void
gtk_text_view_flush_first_validate (GtkTextView *text_view)
{
- if (text_view->first_validate_idle == 0)
+ GtkTextViewPrivate *priv = text_view->priv;
+
+ if (priv->first_validate_idle == 0)
return;
/* Do this first, which means that if an "invalidate"
* will be installed, and we'll start again.
*/
DV (g_print ("removing first validate in %s\n", G_STRLOC));
- g_source_remove (text_view->first_validate_idle);
- text_view->first_validate_idle = 0;
+ g_source_remove (priv->first_validate_idle);
+ priv->first_validate_idle = 0;
/* be sure we have up-to-date screen size set on the
* layout.
/* Bail out if we invalidated stuff; scrolling right away will just
* confuse the issue.
*/
- if (text_view->first_validate_idle != 0)
+ if (priv->first_validate_idle != 0)
{
DV(g_print(">Width change forced requeue ("G_STRLOC")\n"));
}
* necessary.
*/
if (!gtk_text_view_flush_scroll (text_view) ||
- !text_view->onscreen_validated)
+ !priv->onscreen_validated)
gtk_text_view_validate_onscreen (text_view);
DV(g_print(">Leaving first validate idle ("G_STRLOC")\n"));
- g_assert (text_view->onscreen_validated);
+ g_assert (priv->onscreen_validated);
}
}
DV(g_print(G_STRLOC"\n"));
- gtk_text_layout_validate (text_view->layout, 2000);
+ gtk_text_layout_validate (text_view->priv->layout, 2000);
gtk_text_view_update_adjustments (text_view);
- if (gtk_text_layout_is_valid (text_view->layout))
+ if (gtk_text_layout_is_valid (text_view->priv->layout))
{
- text_view->incremental_validate_idle = 0;
+ text_view->priv->incremental_validate_idle = 0;
result = FALSE;
}
static void
gtk_text_view_invalidate (GtkTextView *text_view)
-{
+{
+ GtkTextViewPrivate *priv = text_view->priv;
+
DV (g_print (">Invalidate, onscreen_validated = %d now FALSE ("G_STRLOC")\n",
- text_view->onscreen_validated));
+ priv->onscreen_validated));
- text_view->onscreen_validated = FALSE;
+ priv->onscreen_validated = FALSE;
/* We'll invalidate when the layout is created */
- if (text_view->layout == NULL)
+ if (priv->layout == NULL)
return;
- if (!text_view->first_validate_idle)
+ if (!priv->first_validate_idle)
{
- text_view->first_validate_idle = gdk_threads_add_idle_full (GTK_PRIORITY_RESIZE - 2, first_validate_callback, text_view, NULL);
+ priv->first_validate_idle = gdk_threads_add_idle_full (GTK_PRIORITY_RESIZE - 2, first_validate_callback, text_view, NULL);
DV (g_print (G_STRLOC": adding first validate idle %d\n",
- text_view->first_validate_idle));
+ priv->first_validate_idle));
}
- if (!text_view->incremental_validate_idle)
+ if (!priv->incremental_validate_idle)
{
- text_view->incremental_validate_idle = gdk_threads_add_idle_full (GTK_TEXT_VIEW_PRIORITY_VALIDATE, incremental_validate_callback, text_view, NULL);
+ priv->incremental_validate_idle = gdk_threads_add_idle_full (GTK_TEXT_VIEW_PRIORITY_VALIDATE, incremental_validate_callback, text_view, NULL);
DV (g_print (G_STRLOC": adding incremental validate idle %d\n",
- text_view->incremental_validate_idle));
+ priv->incremental_validate_idle));
}
}
gpointer data)
{
GtkTextView *text_view;
+ GtkTextViewPrivate *priv;
GtkWidget *widget;
GdkRectangle visible_rect;
GdkRectangle redraw_rect;
text_view = GTK_TEXT_VIEW (data);
+ priv = text_view->priv;
widget = GTK_WIDGET (data);
DV(g_print(">Lines Validated ("G_STRLOC")\n"));
- if (GTK_WIDGET_REALIZED (text_view))
+ if (gtk_widget_get_realized (widget))
{
gtk_text_view_get_visible_rect (text_view, &visible_rect);
if (gdk_rectangle_intersect (&redraw_rect, &visible_rect, &redraw_rect))
{
/* text_window_invalidate_rect() takes buffer coordinates */
- text_window_invalidate_rect (text_view->text_window,
+ text_window_invalidate_rect (priv->text_window,
&redraw_rect);
DV(g_print(" invalidated rect: %d,%d %d x %d\n",
redraw_rect.width,
redraw_rect.height));
- if (text_view->left_window)
- text_window_invalidate_rect (text_view->left_window,
+ if (priv->left_window)
+ text_window_invalidate_rect (priv->left_window,
&redraw_rect);
- if (text_view->right_window)
- text_window_invalidate_rect (text_view->right_window,
+ if (priv->right_window)
+ text_window_invalidate_rect (priv->right_window,
&redraw_rect);
- if (text_view->top_window)
- text_window_invalidate_rect (text_view->top_window,
+ if (priv->top_window)
+ text_window_invalidate_rect (priv->top_window,
&redraw_rect);
- if (text_view->bottom_window)
- text_window_invalidate_rect (text_view->bottom_window,
+ if (priv->bottom_window)
+ text_window_invalidate_rect (priv->bottom_window,
&redraw_rect);
- gtk_text_view_update_im_spot_location (text_view);
+ queue_update_im_spot_location (text_view);
}
}
* the first paragraph onscreen.
*
* In short we are adding the height delta of the portion of the
- * changed region above first_para_mark to text_view->yoffset.
+ * changed region above first_para_mark to priv->yoffset.
*/
gtk_text_buffer_get_iter_at_mark (get_buffer (text_view), &first,
- text_view->first_para_mark);
+ priv->first_para_mark);
gtk_text_layout_get_line_yrange (layout, &first, &new_first_para_top, NULL);
- old_first_para_top = text_view->yoffset - text_view->first_para_pixels;
+ old_first_para_top = priv->yoffset - priv->first_para_pixels;
if (new_first_para_top != old_first_para_top)
{
- text_view->yoffset += new_first_para_top - old_first_para_top;
+ priv->yoffset += new_first_para_top - old_first_para_top;
- get_vadjustment (text_view)->value = text_view->yoffset;
+ get_vadjustment (text_view)->value = priv->yoffset;
yoffset_changed = TRUE;
}
/* FIXME be smarter about which anchored widgets we update */
- tmp_list = text_view->children;
+ tmp_list = priv->children;
while (tmp_list != NULL)
{
GtkTextViewChild *child = tmp_list->data;
}
{
- GtkRequisition old_req;
+ GtkRequisition old_req = priv->cached_size_request;
GtkRequisition new_req;
- old_req = widget->requisition;
-
/* Use this instead of gtk_widget_size_request wrapper
* to avoid the optimization which just returns widget->requisition
* if a resize hasn't been queued.
static void
gtk_text_view_realize (GtkWidget *widget)
{
+ GtkAllocation allocation;
GtkTextView *text_view;
+ GtkTextViewPrivate *priv;
+ GdkWindow *window;
GdkWindowAttr attributes;
gint attributes_mask;
GSList *tmp_list;
text_view = GTK_TEXT_VIEW (widget);
- GTK_WIDGET_SET_FLAGS (text_view, GTK_REALIZED);
+ priv = text_view->priv;
+
+ gtk_widget_set_realized (widget, TRUE);
+
+ gtk_widget_get_allocation (widget, &allocation);
attributes.window_type = GDK_WINDOW_CHILD;
- attributes.x = widget->allocation.x;
- attributes.y = widget->allocation.y;
- attributes.width = widget->allocation.width;
- attributes.height = widget->allocation.height;
+ attributes.x = allocation.x;
+ attributes.y = allocation.y;
+ attributes.width = allocation.width;
+ attributes.height = allocation.height;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.visual = gtk_widget_get_visual (widget);
attributes.colormap = gtk_widget_get_colormap (widget);
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
- widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),
- &attributes, attributes_mask);
- gdk_window_set_user_data (widget->window, widget);
+ window = gdk_window_new (gtk_widget_get_parent_window (widget),
+ &attributes, attributes_mask);
+ gtk_widget_set_window (widget, window);
+ gdk_window_set_user_data (window, widget);
/* must come before text_window_realize calls */
- widget->style = gtk_style_attach (widget->style, widget->window);
+ gtk_widget_style_attach (widget);
- gdk_window_set_background (widget->window,
- &widget->style->bg[GTK_WIDGET_STATE (widget)]);
+ gdk_window_set_background (window,
+ >k_widget_get_style (widget)->bg[gtk_widget_get_state (widget)]);
- text_window_realize (text_view->text_window, widget);
+ text_window_realize (priv->text_window, widget);
- if (text_view->left_window)
- text_window_realize (text_view->left_window, widget);
+ if (priv->left_window)
+ text_window_realize (priv->left_window, widget);
- if (text_view->top_window)
- text_window_realize (text_view->top_window, widget);
+ if (priv->top_window)
+ text_window_realize (priv->top_window, widget);
- if (text_view->right_window)
- text_window_realize (text_view->right_window, widget);
+ if (priv->right_window)
+ text_window_realize (priv->right_window, widget);
- if (text_view->bottom_window)
- text_window_realize (text_view->bottom_window, widget);
+ if (priv->bottom_window)
+ text_window_realize (priv->bottom_window, widget);
gtk_text_view_ensure_layout (text_view);
- if (text_view->buffer)
+ if (priv->buffer)
{
GtkClipboard *clipboard = gtk_widget_get_clipboard (GTK_WIDGET (text_view),
GDK_SELECTION_PRIMARY);
- gtk_text_buffer_add_selection_clipboard (text_view->buffer, clipboard);
+ gtk_text_buffer_add_selection_clipboard (priv->buffer, clipboard);
}
- tmp_list = text_view->children;
+ tmp_list = priv->children;
while (tmp_list != NULL)
{
GtkTextViewChild *vc = tmp_list->data;
tmp_list = tmp_list->next;
}
+
+ /* Ensure updating the spot location. */
+ gtk_text_view_update_im_spot_location (text_view);
}
static void
gtk_text_view_unrealize (GtkWidget *widget)
{
GtkTextView *text_view;
-
+ GtkTextViewPrivate *priv;
+
text_view = GTK_TEXT_VIEW (widget);
+ priv = text_view->priv;
- if (text_view->buffer)
+ if (priv->buffer)
{
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_buffer_remove_selection_clipboard (priv->buffer, clipboard);
}
gtk_text_view_remove_validate_idles (text_view);
- if (text_view->popup_menu)
+ if (priv->popup_menu)
{
- gtk_widget_destroy (text_view->popup_menu);
- text_view->popup_menu = NULL;
+ gtk_widget_destroy (priv->popup_menu);
+ priv->popup_menu = NULL;
}
- text_window_unrealize (text_view->text_window);
+ text_window_unrealize (priv->text_window);
- if (text_view->left_window)
- text_window_unrealize (text_view->left_window);
+ if (priv->left_window)
+ text_window_unrealize (priv->left_window);
- if (text_view->top_window)
- text_window_unrealize (text_view->top_window);
+ if (priv->top_window)
+ text_window_unrealize (priv->top_window);
- if (text_view->right_window)
- text_window_unrealize (text_view->right_window);
+ if (priv->right_window)
+ text_window_unrealize (priv->right_window);
- if (text_view->bottom_window)
- text_window_unrealize (text_view->bottom_window);
+ if (priv->bottom_window)
+ text_window_unrealize (priv->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);
+ GtkStyle *style;
+ GtkStateType state;
+ GtkWidget *widget;
+ GtkTextViewPrivate *priv;
- 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)]);
+ widget = GTK_WIDGET (text_view);
+ priv = text_view->priv;
+
+ style = gtk_widget_get_style (widget);
+ state = gtk_widget_get_state (widget);
+
+ gdk_window_set_background (gtk_widget_get_window (widget),
+ &style->bg[state]);
+
+ gdk_window_set_background (priv->text_window->bin_window,
+ &style->base[state]);
+
+ if (priv->left_window)
+ gdk_window_set_background (priv->left_window->bin_window,
+ &style->bg[state]);
+ if (priv->right_window)
+ gdk_window_set_background (priv->right_window->bin_window,
+ &style->bg[state]);
+
+ if (priv->top_window)
+ gdk_window_set_background (priv->top_window->bin_window,
+ &style->bg[state]);
+
+ if (priv->bottom_window)
+ gdk_window_set_background (priv->bottom_window->bin_window,
+ &style->bg[state]);
}
static void
gtk_text_view_style_set (GtkWidget *widget,
GtkStyle *previous_style)
{
- GtkTextView *text_view = GTK_TEXT_VIEW (widget);
+ GtkTextView *text_view;
+ GtkTextViewPrivate *priv;
PangoContext *ltr_context, *rtl_context;
- if (GTK_WIDGET_REALIZED (widget))
+ text_view = GTK_TEXT_VIEW (widget);
+ priv = text_view->priv;
+
+ if (gtk_widget_get_realized (widget))
{
gtk_text_view_set_background (text_view);
}
- if (text_view->layout && previous_style)
+ if (priv->layout && previous_style)
{
gtk_text_view_set_attributes_from_style (text_view,
- text_view->layout->default_style,
- widget->style);
-
-
+ priv->layout->default_style,
+ gtk_widget_get_style (widget));
+
ltr_context = gtk_widget_create_pango_context (widget);
pango_context_set_base_dir (ltr_context, PANGO_DIRECTION_LTR);
rtl_context = gtk_widget_create_pango_context (widget);
pango_context_set_base_dir (rtl_context, PANGO_DIRECTION_RTL);
- gtk_text_layout_set_contexts (text_view->layout, ltr_context, rtl_context);
+ gtk_text_layout_set_contexts (priv->layout, ltr_context, rtl_context);
g_object_unref (ltr_context);
g_object_unref (rtl_context);
gtk_text_view_direction_changed (GtkWidget *widget,
GtkTextDirection previous_direction)
{
- GtkTextView *text_view = GTK_TEXT_VIEW (widget);
+ GtkTextViewPrivate *priv = GTK_TEXT_VIEW (widget)->priv;
- if (text_view->layout)
+ if (priv->layout)
{
- text_view->layout->default_style->direction = gtk_widget_get_direction (widget);
+ priv->layout->default_style->direction = gtk_widget_get_direction (widget);
- gtk_text_layout_default_style_changed (text_view->layout);
+ gtk_text_layout_default_style_changed (priv->layout);
}
}
GtkTextView *text_view = GTK_TEXT_VIEW (widget);
GdkCursor *cursor;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
{
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;
- gdk_window_set_cursor (text_view->text_window->bin_window, cursor);
+ gdk_window_set_cursor (text_view->priv->text_window->bin_window, cursor);
if (cursor)
gdk_cursor_unref (cursor);
- text_view->mouse_cursor_obscured = FALSE;
+ text_view->priv->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
gtk_text_view_obscure_mouse_cursor (GtkTextView *text_view)
{
- if (text_view->mouse_cursor_obscured)
+ if (text_view->priv->mouse_cursor_obscured)
return;
- set_invisible_cursor (text_view->text_window->bin_window);
+ set_invisible_cursor (text_view->priv->text_window->bin_window);
- text_view->mouse_cursor_obscured = TRUE;
+ text_view->priv->mouse_cursor_obscured = TRUE;
}
static void
gtk_text_view_unobscure_mouse_cursor (GtkTextView *text_view)
{
- if (text_view->mouse_cursor_obscured)
+ if (text_view->priv->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_window_set_cursor (text_view->priv->text_window->bin_window, cursor);
gdk_cursor_unref (cursor);
- text_view->mouse_cursor_obscured = FALSE;
+ text_view->priv->mouse_cursor_obscured = FALSE;
}
}
gtk_text_view_grab_notify (GtkWidget *widget,
gboolean was_grabbed)
{
- if (!was_grabbed)
+ GtkTextViewPrivate *priv;
+
+ priv = GTK_TEXT_VIEW (widget)->priv;
+
+ if (priv->grab_device &&
+ gtk_widget_device_is_shadowed (widget, priv->grab_device))
{
gtk_text_view_end_selection_drag (GTK_TEXT_VIEW (widget));
gtk_text_view_unobscure_mouse_cursor (GTK_TEXT_VIEW (widget));
gtk_text_view_event (GtkWidget *widget, GdkEvent *event)
{
GtkTextView *text_view;
+ GtkTextViewPrivate *priv;
gint x = 0, y = 0;
text_view = GTK_TEXT_VIEW (widget);
+ priv = text_view->priv;
- if (text_view->layout == NULL ||
+ if (priv->layout == NULL ||
get_buffer (text_view) == NULL)
return FALSE;
- if (event->any.window != text_view->text_window->bin_window)
+ if (event->any.window != priv->text_window->bin_window)
return FALSE;
if (get_event_coordinates (event, &x, &y))
{
GtkTextIter iter;
- x += text_view->xoffset;
- y += text_view->yoffset;
+ x += priv->xoffset;
+ y += priv->yoffset;
/* FIXME this is slow and we do it twice per event.
* My favorite solution is to have GtkTextLayout cache
* the last couple lookups.
*/
- gtk_text_layout_get_iter_at_pixel (text_view->layout,
+ gtk_text_layout_get_iter_at_pixel (priv->layout,
&iter,
x, y);
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);
}
static gint
gtk_text_view_key_press_event (GtkWidget *widget, GdkEventKey *event)
{
- gboolean retval = FALSE;
- gboolean obscure = FALSE;
- GtkTextView *text_view = GTK_TEXT_VIEW (widget);
+ GtkTextView *text_view;
+ GtkTextViewPrivate *priv;
GtkTextMark *insert;
GtkTextIter iter;
gboolean can_insert;
+ gboolean retval = FALSE;
+ gboolean obscure = FALSE;
+
+ text_view = GTK_TEXT_VIEW (widget);
+ priv = text_view->priv;
- if (text_view->layout == NULL ||
+ if (priv->layout == NULL ||
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);
- if (gtk_im_context_filter_keypress (text_view->im_context, event))
+ can_insert = gtk_text_iter_can_insert (&iter, priv->editable);
+ if (gtk_im_context_filter_keypress (priv->im_context, event))
{
- text_view->need_im_reset = TRUE;
+ priv->need_im_reset = TRUE;
if (!can_insert)
gtk_text_view_reset_im_context (text_view);
obscure = can_insert;
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_KP_Enter))
+ else if (priv->editable &&
+ (event->keyval == GDK_KEY_Return ||
+ event->keyval == GDK_KEY_ISO_Enter ||
+ event->keyval == GDK_KEY_KP_Enter))
{
/* this won't actually insert the newline if the cursor isn't
* editable
retval = TRUE;
}
/* Pass through Tab as literal tab, unless Control is held down */
- else if ((event->keyval == GDK_Tab ||
- event->keyval == GDK_KP_Tab ||
- event->keyval == GDK_ISO_Left_Tab) &&
+ else if ((event->keyval == GDK_KEY_Tab ||
+ event->keyval == GDK_KEY_KP_Tab ||
+ event->keyval == GDK_KEY_ISO_Left_Tab) &&
!(event->state & GDK_CONTROL_MASK))
{
/* 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)
+ if (priv->accepts_tab && priv->editable)
{
gtk_text_view_reset_im_context (text_view);
gtk_text_view_commit_text (text_view, "\t");
obscure = TRUE;
}
else
- gtk_text_view_move_focus (text_view,
- (event->state & GDK_SHIFT_MASK) ?
- GTK_DIR_TAB_BACKWARD: GTK_DIR_TAB_FORWARD);
+ g_signal_emit_by_name (text_view, "move-focus",
+ (event->state & GDK_SHIFT_MASK) ?
+ GTK_DIR_TAB_BACKWARD : GTK_DIR_TAB_FORWARD);
retval = TRUE;
}
static gint
gtk_text_view_key_release_event (GtkWidget *widget, GdkEventKey *event)
{
- GtkTextView *text_view = GTK_TEXT_VIEW (widget);
+ GtkTextView *text_view;
+ GtkTextViewPrivate *priv;
GtkTextMark *insert;
GtkTextIter iter;
- if (text_view->layout == NULL || get_buffer (text_view) == NULL)
+ text_view = GTK_TEXT_VIEW (widget);
+ priv = text_view->priv;
+
+ if (priv->layout == NULL || get_buffer (text_view) == NULL)
return FALSE;
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) &&
- gtk_im_context_filter_keypress (text_view->im_context, event))
+ if (gtk_text_iter_can_insert (&iter, priv->editable) &&
+ gtk_im_context_filter_keypress (priv->im_context, event))
{
- text_view->need_im_reset = TRUE;
+ priv->need_im_reset = TRUE;
return TRUE;
}
else
gtk_text_view_button_press_event (GtkWidget *widget, GdkEventButton *event)
{
GtkTextView *text_view;
+ GtkTextViewPrivate *priv;
text_view = GTK_TEXT_VIEW (widget);
+ priv = text_view->priv;
gtk_widget_grab_focus (widget);
- if (event->window != text_view->text_window->bin_window)
+ if (event->window != priv->text_window->bin_window)
{
/* Remove selection if any. */
gtk_text_view_unselect (text_view);
GtkTextIter iter;
GtkTextIter start, end;
- gtk_text_layout_get_iter_at_pixel (text_view->layout,
+ gtk_text_layout_get_iter_at_pixel (priv->layout,
&iter,
- event->x + text_view->xoffset,
- event->y + text_view->yoffset);
+ event->x + priv->xoffset,
+ event->y + priv->yoffset);
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;
- text_view->pending_place_cursor_button = event->button;
+ priv->drag_start_x = event->x;
+ priv->drag_start_y = event->y;
+ priv->pending_place_cursor_button = event->button;
}
else
{
{
GtkTextIter iter;
- gtk_text_layout_get_iter_at_pixel (text_view->layout,
+ /* We do not want to scroll back to the insert iter when we paste
+ with the middle button */
+ priv->scroll_after_paste = FALSE;
+
+ gtk_text_layout_get_iter_at_pixel (priv->layout,
&iter,
- event->x + text_view->xoffset,
- event->y + text_view->yoffset);
+ event->x + priv->xoffset,
+ event->y + priv->yoffset);
gtk_text_buffer_paste_clipboard (get_buffer (text_view),
gtk_widget_get_clipboard (widget, GDK_SELECTION_PRIMARY),
&iter,
- text_view->editable);
+ priv->editable);
return TRUE;
}
else if (event->button == 3)
gtk_text_view_end_selection_drag (text_view);
- gtk_text_layout_get_iter_at_pixel (text_view->layout,
+ gtk_text_layout_get_iter_at_pixel (priv->layout,
&iter,
- event->x + text_view->xoffset,
- event->y + text_view->yoffset);
+ event->x + priv->xoffset,
+ event->y + priv->yoffset);
gtk_text_view_start_selection_drag (text_view, &iter, event);
return TRUE;
gtk_text_view_button_release_event (GtkWidget *widget, GdkEventButton *event)
{
GtkTextView *text_view;
+ GtkTextViewPrivate *priv;
text_view = GTK_TEXT_VIEW (widget);
+ priv = text_view->priv;
- if (event->window != text_view->text_window->bin_window)
+ if (event->window != priv->text_window->bin_window)
return FALSE;
if (event->button == 1)
{
- if (text_view->drag_start_x >= 0)
+ if (priv->drag_start_x >= 0)
{
- text_view->drag_start_x = -1;
- text_view->drag_start_y = -1;
+ priv->drag_start_x = -1;
+ priv->drag_start_y = -1;
}
if (gtk_text_view_end_selection_drag (GTK_TEXT_VIEW (widget)))
return TRUE;
- else if (text_view->pending_place_cursor_button == event->button)
+ else if (priv->pending_place_cursor_button == event->button)
{
GtkTextIter iter;
* didn't move by the drag threshold, so just clear selection
* and place cursor.
*/
- gtk_text_layout_get_iter_at_pixel (text_view->layout,
+ gtk_text_layout_get_iter_at_pixel (priv->layout,
&iter,
- event->x + text_view->xoffset,
- event->y + text_view->yoffset);
+ event->x + priv->xoffset,
+ event->y + priv->yoffset);
gtk_text_buffer_place_cursor (get_buffer (text_view), &iter);
gtk_text_view_check_cursor_blink (text_view);
- text_view->pending_place_cursor_button = 0;
+ priv->pending_place_cursor_button = 0;
return FALSE;
}
static gint
gtk_text_view_focus_in_event (GtkWidget *widget, GdkEventFocus *event)
{
- GtkTextView *text_view = GTK_TEXT_VIEW (widget);
+ GtkTextView *text_view;
+ GtkTextViewPrivate *priv;
+
+ text_view = GTK_TEXT_VIEW (widget);
+ priv = text_view->priv;
gtk_widget_queue_draw (widget);
gtk_text_view_reset_blink_time (text_view);
- if (text_view->cursor_visible && text_view->layout)
+ if (priv->cursor_visible && priv->layout)
{
- gtk_text_layout_set_cursor_visible (text_view->layout, TRUE);
+ gtk_text_layout_set_cursor_visible (priv->layout, TRUE);
gtk_text_view_check_cursor_blink (text_view);
}
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 (priv->editable)
+ {
+ priv->need_im_reset = TRUE;
+ gtk_im_context_focus_in (priv->im_context);
+ }
return FALSE;
}
static gint
gtk_text_view_focus_out_event (GtkWidget *widget, GdkEventFocus *event)
{
- GtkTextView *text_view = GTK_TEXT_VIEW (widget);
+ GtkTextView *text_view;
+ GtkTextViewPrivate *priv;
+
+ text_view = GTK_TEXT_VIEW (widget);
+ priv = text_view->priv;
gtk_text_view_end_selection_drag (text_view);
DV(g_print (G_STRLOC": focus_out_event\n"));
- if (text_view->cursor_visible && text_view->layout)
+ if (priv->cursor_visible && priv->layout)
{
gtk_text_view_check_cursor_blink (text_view);
- gtk_text_layout_set_cursor_visible (text_view->layout, FALSE);
+ gtk_text_layout_set_cursor_visible (priv->layout, FALSE);
}
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);
+ if (priv->editable)
+ {
+ priv->need_im_reset = TRUE;
+ gtk_im_context_focus_out (priv->im_context);
+ }
return FALSE;
}
static gint
gtk_text_view_motion_event (GtkWidget *widget, GdkEventMotion *event)
{
- GtkTextView *text_view = GTK_TEXT_VIEW (widget);
+ GtkTextView *text_view;
+ GtkTextViewPrivate *priv;
+
+ text_view = GTK_TEXT_VIEW (widget);
+ priv = text_view->priv;
gtk_text_view_unobscure_mouse_cursor (text_view);
- if (event->window == text_view->text_window->bin_window &&
- text_view->drag_start_x >= 0)
+ if (event->window == priv->text_window->bin_window &&
+ priv->drag_start_x >= 0)
{
gint x = event->x;
gint y = event->y;
gdk_event_request_motions (event);
if (gtk_drag_check_threshold (widget,
- text_view->drag_start_x,
- text_view->drag_start_y,
+ priv->drag_start_x,
+ priv->drag_start_y,
x, y))
{
GtkTextIter iter;
gtk_text_view_window_to_buffer_coords (text_view,
GTK_TEXT_WINDOW_TEXT,
- text_view->drag_start_x,
- text_view->drag_start_y,
+ priv->drag_start_x,
+ priv->drag_start_y,
&buffer_x,
&buffer_y);
- gtk_text_layout_get_iter_at_pixel (text_view->layout,
+ gtk_text_layout_get_iter_at_pixel (priv->layout,
&iter,
buffer_x, buffer_y);
GdkEventExpose *event)
{
GtkTextView *text_view;
+ GtkTextViewPrivate *priv;
GList *child_exposes;
GList *tmp_list;
- GdkRegion *updates;
text_view = GTK_TEXT_VIEW (widget);
+ priv = text_view->priv;
- g_return_if_fail (text_view->layout != NULL);
- g_return_if_fail (text_view->xoffset >= 0);
- g_return_if_fail (text_view->yoffset >= 0);
+ g_return_if_fail (priv->layout != NULL);
+ g_return_if_fail (priv->xoffset >= 0);
+ g_return_if_fail (priv->yoffset >= 0);
- while (text_view->first_validate_idle != 0)
+ while (priv->first_validate_idle != 0)
{
DV (g_print (G_STRLOC": first_validate_idle: %d\n",
- text_view->first_validate_idle));
+ priv->first_validate_idle));
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)
+ if (!priv->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_assert_not_reached ();
#endif
child_exposes = NULL;
- gtk_text_layout_draw (text_view->layout,
+ gtk_text_layout_draw (priv->layout,
widget,
- text_view->text_window->bin_window,
+ priv->text_window->bin_window,
NULL,
- text_view->xoffset,
- text_view->yoffset,
+ priv->xoffset,
+ priv->yoffset,
area->x, area->y,
area->width, area->height,
&child_exposes);
gtk_text_view_paint (widget, &event->area, event);
}
- if (event->window == widget->window)
+ if (event->window == gtk_widget_get_window (widget))
gtk_text_view_draw_focus (widget);
/* Propagate exposes to all unanchored children.
* Anchored children are handled in gtk_text_view_paint().
*/
- tmp_list = GTK_TEXT_VIEW (widget)->children;
+ tmp_list = GTK_TEXT_VIEW (widget)->priv->children;
while (tmp_list != NULL)
{
GtkTextViewChild *vc = tmp_list->data;
static void
gtk_text_view_draw_focus (GtkWidget *widget)
{
+ GtkAllocation allocation;
+ GdkWindow *window;
gboolean interior_focus;
/* We clear the focus if we are in interior focus mode. */
"interior-focus", &interior_focus,
NULL);
- if (GTK_WIDGET_DRAWABLE (widget))
+ if (gtk_widget_is_drawable (widget))
{
- if (GTK_WIDGET_HAS_FOCUS (widget) && !interior_focus)
- {
- gtk_paint_focus (widget->style, widget->window, GTK_WIDGET_STATE (widget),
+ window = gtk_widget_get_window (widget);
+
+ if (gtk_widget_has_focus (widget) && !interior_focus)
+ {
+ gtk_widget_get_allocation (widget, &allocation);
+ gtk_paint_focus (gtk_widget_get_style (widget),
+ window,
+ gtk_widget_get_state (widget),
NULL, widget, "textview",
0, 0,
- widget->allocation.width,
- widget->allocation.height);
+ allocation.width, allocation.height);
}
else
{
- gdk_window_clear (widget->window);
+ gdk_window_clear (window);
}
}
}
container = GTK_CONTAINER (widget);
if (!gtk_widget_is_focus (widget) &&
- container->focus_child == NULL)
+ gtk_container_get_focus_child (container) == NULL)
{
gtk_widget_grab_focus (widget);
return TRUE;
* Unset CAN_FOCUS flag so that gtk_container_focus() allows
* children to get the focus
*/
- GTK_WIDGET_UNSET_FLAGS (widget, GTK_CAN_FOCUS);
+ gtk_widget_set_can_focus (widget, FALSE);
result = GTK_WIDGET_CLASS (gtk_text_view_parent_class)->focus (widget, direction);
- GTK_WIDGET_SET_FLAGS (widget, GTK_CAN_FOCUS);
+ gtk_widget_set_can_focus (widget, TRUE);
return result;
}
}
+static void
+gtk_text_view_move_focus (GtkWidget *widget,
+ GtkDirectionType direction_type)
+{
+ GtkTextView *text_view = GTK_TEXT_VIEW (widget);
+
+ if (GTK_TEXT_VIEW_GET_CLASS (text_view)->move_focus)
+ GTK_TEXT_VIEW_GET_CLASS (text_view)->move_focus (text_view,
+ direction_type);
+}
+
/*
* Container
*/
gtk_text_view_remove (GtkContainer *container,
GtkWidget *child)
{
- GSList *iter;
GtkTextView *text_view;
+ GtkTextViewPrivate *priv;
GtkTextViewChild *vc;
+ GSList *iter;
text_view = GTK_TEXT_VIEW (container);
+ priv = text_view->priv;
vc = NULL;
- iter = text_view->children;
+ iter = priv->children;
while (iter != NULL)
{
g_assert (iter != NULL); /* be sure we had the child in the list */
- text_view->children = g_slist_remove (text_view->children, vc);
+ priv->children = g_slist_remove (priv->children, vc);
gtk_widget_unparent (vc->widget);
text_view = GTK_TEXT_VIEW (container);
- copy = g_slist_copy (text_view->children);
+ copy = g_slist_copy (text_view->priv->children);
iter = copy;
while (iter != NULL)
#ifdef DEBUG_VALIDATION_AND_SCROLLING
return FALSE;
#endif
- if (gtk_debug_flags & GTK_DEBUG_UPDATES)
+ if (gtk_get_debug_flags () & GTK_DEBUG_UPDATES)
return FALSE;
g_object_get (settings, "gtk-cursor-blink", &blink, NULL);
if (!blink)
return FALSE;
- if (text_view->editable)
+ if (text_view->priv->editable)
{
GtkTextMark *insert;
GtkTextIter iter;
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_editable (&iter, text_view->editable))
+ if (gtk_text_iter_editable (&iter, text_view->priv->editable))
return blink;
}
gint blink_timeout;
text_view = GTK_TEXT_VIEW (data);
- priv = GTK_TEXT_VIEW_GET_PRIVATE (text_view);
+ priv = text_view->priv;
- 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"
return FALSE;
}
- g_assert (text_view->layout);
- g_assert (text_view->cursor_visible);
+ g_assert (priv->layout);
+ g_assert (priv->cursor_visible);
- visible = gtk_text_layout_get_cursor_visible (text_view->layout);
+ visible = gtk_text_layout_get_cursor_visible (priv->layout);
blink_timeout = get_cursor_blink_timeout (text_view);
if (priv->blink_time > 1000 * blink_timeout &&
{
/* we've blinked enough without the user doing anything, stop blinking */
visible = 0;
- text_view->blink_timeout = 0;
+ priv->blink_timeout = 0;
}
else if (visible)
- text_view->blink_timeout = gdk_threads_add_timeout (get_cursor_time (text_view) * CURSOR_OFF_MULTIPLIER / CURSOR_DIVIDER,
- blink_cb,
- text_view);
+ priv->blink_timeout = gdk_threads_add_timeout (get_cursor_time (text_view) * CURSOR_OFF_MULTIPLIER / CURSOR_DIVIDER,
+ blink_cb,
+ text_view);
else
{
- text_view->blink_timeout = gdk_threads_add_timeout (get_cursor_time (text_view) * CURSOR_ON_MULTIPLIER / CURSOR_DIVIDER,
- blink_cb,
- text_view);
+ priv->blink_timeout = gdk_threads_add_timeout (get_cursor_time (text_view) * CURSOR_ON_MULTIPLIER / CURSOR_DIVIDER,
+ blink_cb,
+ text_view);
priv->blink_time += get_cursor_time (text_view);
}
* because it would expose the whole paragraph. Instead, we expose
* the cursor's area(s) manually below.
*/
- g_signal_handlers_block_by_func (text_view->layout,
+ g_signal_handlers_block_by_func (priv->layout,
changed_handler,
text_view);
- gtk_text_layout_set_cursor_visible (text_view->layout, !visible);
- g_signal_handlers_unblock_by_func (text_view->layout,
+ gtk_text_layout_set_cursor_visible (priv->layout, !visible);
+ g_signal_handlers_unblock_by_func (priv->layout,
changed_handler,
text_view);
- text_window_invalidate_cursors (text_view->text_window);
+ text_window_invalidate_cursors (priv->text_window);
/* Remove ourselves */
return FALSE;
static void
gtk_text_view_stop_cursor_blink (GtkTextView *text_view)
{
- if (text_view->blink_timeout)
+ if (text_view->priv->blink_timeout)
{
- g_source_remove (text_view->blink_timeout);
- text_view->blink_timeout = 0;
+ g_source_remove (text_view->priv->blink_timeout);
+ text_view->priv->blink_timeout = 0;
}
}
static void
gtk_text_view_check_cursor_blink (GtkTextView *text_view)
{
- if (text_view->layout != NULL &&
- text_view->cursor_visible &&
- GTK_WIDGET_HAS_FOCUS (text_view))
+ GtkTextViewPrivate *priv = text_view->priv;
+
+ if (priv->layout != NULL &&
+ priv->cursor_visible &&
+ gtk_widget_has_focus (GTK_WIDGET (text_view)))
{
if (cursor_blinks (text_view))
{
- if (text_view->blink_timeout == 0)
+ if (priv->blink_timeout == 0)
{
- gtk_text_layout_set_cursor_visible (text_view->layout, TRUE);
+ gtk_text_layout_set_cursor_visible (priv->layout, TRUE);
- text_view->blink_timeout = gdk_threads_add_timeout (get_cursor_time (text_view) * CURSOR_OFF_MULTIPLIER / CURSOR_DIVIDER,
- blink_cb,
- text_view);
+ priv->blink_timeout = gdk_threads_add_timeout (get_cursor_time (text_view) * CURSOR_OFF_MULTIPLIER / CURSOR_DIVIDER,
+ blink_cb,
+ text_view);
}
}
else
{
gtk_text_view_stop_cursor_blink (text_view);
- gtk_text_layout_set_cursor_visible (text_view->layout, TRUE);
+ gtk_text_layout_set_cursor_visible (priv->layout, TRUE);
}
}
else
{
gtk_text_view_stop_cursor_blink (text_view);
- gtk_text_layout_set_cursor_visible (text_view->layout, FALSE);
+ gtk_text_layout_set_cursor_visible (priv->layout, FALSE);
}
}
static void
gtk_text_view_pend_cursor_blink (GtkTextView *text_view)
{
- if (text_view->layout != NULL &&
- text_view->cursor_visible &&
- GTK_WIDGET_HAS_FOCUS (text_view) &&
+ GtkTextViewPrivate *priv = text_view->priv;
+
+ if (priv->layout != NULL &&
+ priv->cursor_visible &&
+ gtk_widget_has_focus (GTK_WIDGET (text_view)) &&
cursor_blinks (text_view))
{
gtk_text_view_stop_cursor_blink (text_view);
- gtk_text_layout_set_cursor_visible (text_view->layout, TRUE);
+ gtk_text_layout_set_cursor_visible (priv->layout, TRUE);
- text_view->blink_timeout = gdk_threads_add_timeout (get_cursor_time (text_view) * CURSOR_PEND_MULTIPLIER / CURSOR_DIVIDER,
- blink_cb,
- text_view);
+ priv->blink_timeout = gdk_threads_add_timeout (get_cursor_time (text_view) * CURSOR_PEND_MULTIPLIER / CURSOR_DIVIDER,
+ blink_cb,
+ text_view);
}
}
static void
gtk_text_view_reset_blink_time (GtkTextView *text_view)
{
- GtkTextViewPrivate *priv;
-
- priv = GTK_TEXT_VIEW_GET_PRIVATE (text_view);
+ GtkTextViewPrivate *priv = text_view->priv;
priv->blink_time = 0;
}
while (count < 0)
{
- ret = gtk_text_layout_move_iter_to_previous_line (text_view->layout, newplace);
+ ret = gtk_text_layout_move_iter_to_previous_line (text_view->priv->layout, newplace);
count++;
}
while (count > 0)
{
- ret = gtk_text_layout_move_iter_to_next_line (text_view->layout, newplace);
+ ret = gtk_text_layout_move_iter_to_next_line (text_view->priv->layout, newplace);
count--;
}
gint count,
gboolean extend_selection)
{
+ GtkTextViewPrivate *priv;
GtkTextIter insert;
GtkTextIter newplace;
+ gboolean cancel_selection = FALSE;
gint cursor_x_pos = 0;
GtkDirectionType leave_direction = -1;
- if (!text_view->cursor_visible)
+ priv = text_view->priv;
+
+ if (!priv->cursor_visible)
{
GtkScrollStep scroll_step;
switch (step)
{
- case GTK_MOVEMENT_LOGICAL_POSITIONS:
case GTK_MOVEMENT_VISUAL_POSITIONS:
+ leave_direction = count > 0 ? GTK_DIR_RIGHT : GTK_DIR_LEFT;
+ /* fall through */
+ case GTK_MOVEMENT_LOGICAL_POSITIONS:
case GTK_MOVEMENT_WORDS:
scroll_step = GTK_SCROLL_HORIZONTAL_STEPS;
break;
scroll_step = GTK_SCROLL_HORIZONTAL_ENDS;
break;
case GTK_MOVEMENT_DISPLAY_LINES:
+ leave_direction = count > 0 ? GTK_DIR_DOWN : GTK_DIR_UP;
+ /* fall through */
case GTK_MOVEMENT_PARAGRAPHS:
case GTK_MOVEMENT_PARAGRAPH_ENDS:
scroll_step = GTK_SCROLL_STEPS;
scroll_step = GTK_SCROLL_PAGES;
break;
}
-
- gtk_text_view_move_viewport (text_view, scroll_step, count);
+
+ if (!gtk_text_view_move_viewport (text_view, scroll_step, count))
+ {
+ if (leave_direction != -1 &&
+ !gtk_widget_keynav_failed (GTK_WIDGET (text_view),
+ leave_direction))
+ {
+ g_signal_emit_by_name (text_view, "move-focus", leave_direction);
+ }
+ }
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_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 (priv->layout,
+ &newplace, count);
break;
case GTK_MOVEMENT_WORDS:
leave_direction = GTK_DIR_UP;
if (gtk_text_view_move_iter_by_lines (text_view, &newplace, count))
- gtk_text_layout_move_iter_to_x (text_view->layout, &newplace, cursor_x_pos);
+ gtk_text_layout_move_iter_to_x (priv->layout, &newplace, cursor_x_pos);
else
gtk_text_iter_set_line_offset (&newplace, 0);
}
leave_direction = GTK_DIR_DOWN;
if (gtk_text_view_move_iter_by_lines (text_view, &newplace, count))
- gtk_text_layout_move_iter_to_x (text_view->layout, &newplace, cursor_x_pos);
+ gtk_text_layout_move_iter_to_x (priv->layout, &newplace, cursor_x_pos);
else
gtk_text_iter_forward_to_line_end (&newplace);
}
gtk_text_view_move_iter_by_lines (text_view, &newplace, ++count);
if (count != 0)
- gtk_text_layout_move_iter_to_line_end (text_view->layout, &newplace, count);
+ gtk_text_layout_move_iter_to_line_end (priv->layout, &newplace, count);
break;
case GTK_MOVEMENT_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)));
if (step == GTK_MOVEMENT_DISPLAY_LINES)
gtk_text_view_set_virtual_cursor_pos (text_view, cursor_x_pos, -1);
if (!gtk_widget_keynav_failed (GTK_WIDGET (text_view),
leave_direction))
{
- gtk_text_view_move_focus (text_view, leave_direction);
+ g_signal_emit_by_name (text_view, "move-focus", leave_direction);
}
}
- else
+ else if (! cancel_selection)
{
gtk_widget_error_bell (GTK_WIDGET (text_view));
}
gtk_text_view_move_cursor_internal (text_view, step, count, extend_selection);
}
-static void
-gtk_text_view_page_horizontally (GtkTextView *text_view,
- gint count,
- gboolean extend_selection)
-{
- gtk_text_view_move_cursor_internal (text_view, GTK_MOVEMENT_HORIZONTAL_PAGES,
- count, extend_selection);
-}
-
-
-static void
+static gboolean
gtk_text_view_move_viewport (GtkTextView *text_view,
GtkScrollStep step,
gint count)
break;
}
- set_adjustment_clamped (adjustment, adjustment->value + count * increment);
+ return set_adjustment_clamped (adjustment, adjustment->value + count * increment);
}
static void
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);
}
gint count,
gboolean extend_selection)
{
- gdouble newval;
- gdouble oldval;
+ GtkTextViewPrivate *priv;
GtkAdjustment *adj;
gint cursor_x_pos, cursor_y_pos;
+ GtkTextMark *insert_mark;
GtkTextIter old_insert;
GtkTextIter new_insert;
GtkTextIter anchor;
+ gdouble newval;
+ gdouble oldval;
gint y0, y1;
- g_return_val_if_fail (text_view->vadjustment != NULL, FALSE);
+ priv = text_view->priv;
+
+ g_return_val_if_fail (priv->vadjustment != NULL, FALSE);
- adj = text_view->vadjustment;
+ adj = priv->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)
+ if (priv->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)
{
y1 = 0;
}
- gtk_text_layout_validate_yrange (text_view->layout, &anchor, y0, y1);
+ gtk_text_layout_validate_yrange (priv->layout, &anchor, y0, y1);
/* FIXME do we need to update the adjustment ranges here? */
new_insert = old_insert;
}
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;
set_adjustment_clamped (adj, newval);
cursor_y_pos += adj->value - oldval;
- gtk_text_layout_get_iter_at_pixel (text_view->layout, &new_insert, cursor_x_pos, cursor_y_pos);
+ gtk_text_layout_get_iter_at_pixel (priv->layout, &new_insert, cursor_x_pos, cursor_y_pos);
clamp_iter_onscreen (text_view, &new_insert);
move_cursor (text_view, &new_insert, extend_selection);
* 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);
}
gint count,
gboolean extend_selection)
{
- gdouble newval;
- gdouble oldval;
+ GtkTextViewPrivate *priv;
GtkAdjustment *adj;
gint cursor_x_pos, cursor_y_pos;
+ GtkTextMark *insert_mark;
GtkTextIter old_insert;
GtkTextIter new_insert;
+ gdouble newval;
+ gdouble oldval;
gint y, height;
-
- g_return_val_if_fail (text_view->hadjustment != NULL, FALSE);
- adj = text_view->hadjustment;
+ priv = text_view->priv;
+
+ g_return_val_if_fail (priv->hadjustment != NULL, FALSE);
+
+ adj = priv->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)
+ if (priv->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"));
- 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);
+ &old_insert, insert_mark);
+
+ gtk_text_layout_get_line_yrange (priv->layout, &old_insert, &y, &height);
+ gtk_text_layout_validate_yrange (priv->layout, &old_insert, y, y + height);
/* FIXME do we need to update the adjustment ranges here? */
new_insert = old_insert;
}
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;
set_adjustment_clamped (adj, newval);
cursor_x_pos += adj->value - oldval;
- gtk_text_layout_get_iter_at_pixel (text_view->layout, &new_insert, cursor_x_pos, cursor_y_pos);
+ gtk_text_layout_get_iter_at_pixel (priv->layout, &new_insert, cursor_x_pos, cursor_y_pos);
clamp_iter_onscreen (text_view, &new_insert);
move_cursor (text_view, &new_insert, extend_selection);
* 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);
}
const gchar *str)
{
if (!gtk_text_buffer_insert_interactive_at_cursor (get_buffer (text_view), str, -1,
- text_view->editable))
+ text_view->priv->editable))
{
gtk_widget_error_bell (GTK_WIDGET (text_view));
}
GtkDeleteType type,
gint count)
{
+ GtkTextViewPrivate *priv;
GtkTextIter insert;
GtkTextIter start;
GtkTextIter end;
gboolean leave_one = FALSE;
+ priv = text_view->priv;
+
gtk_text_view_reset_im_context (text_view);
if (type == GTK_DELETE_CHARS)
{
/* Char delete deletes the selection, if one exists */
if (gtk_text_buffer_delete_selection (get_buffer (text_view), TRUE,
- text_view->editable))
+ priv->editable))
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:
gtk_text_buffer_begin_user_action (get_buffer (text_view));
if (gtk_text_buffer_delete_interactive (get_buffer (text_view), &start, &end,
- text_view->editable))
+ priv->editable))
{
if (leave_one)
gtk_text_buffer_insert_interactive_at_cursor (get_buffer (text_view),
" ", 1,
- text_view->editable);
+ priv->editable);
}
else
{
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
{
static void
gtk_text_view_backspace (GtkTextView *text_view)
{
+ GtkTextViewPrivate *priv;
GtkTextIter insert;
+ priv = text_view->priv;
+
gtk_text_view_reset_im_context (text_view);
/* Backspace deletes the selection, if one exists */
if (gtk_text_buffer_delete_selection (get_buffer (text_view), TRUE,
- text_view->editable))
+ priv->editable))
return;
gtk_text_buffer_get_iter_at_mark (get_buffer (text_view),
gtk_text_buffer_get_insert (get_buffer (text_view)));
if (gtk_text_buffer_backspace (get_buffer (text_view), &insert,
- TRUE, text_view->editable))
+ TRUE, priv->editable))
{
gtk_text_view_set_virtual_cursor_pos (text_view, -1, -1);
DV(g_print (G_STRLOC": scrolling onscreen\n"));
gtk_text_buffer_cut_clipboard (get_buffer (text_view),
clipboard,
- text_view->editable);
+ text_view->priv->editable);
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_buffer_paste_clipboard (get_buffer (text_view),
clipboard,
NULL,
- text_view->editable);
- 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)));
+ text_view->priv->editable);
+}
+
+static void
+gtk_text_view_paste_done_handler (GtkTextBuffer *buffer,
+ GtkClipboard *clipboard,
+ gpointer data)
+{
+ GtkTextView *text_view = data;
+ GtkTextViewPrivate *priv;
+
+ priv = text_view->priv;
+
+ if (priv->scroll_after_paste)
+ {
+ DV(g_print (G_STRLOC": scrolling onscreen\n"));
+ gtk_text_view_scroll_mark_onscreen (text_view, gtk_text_buffer_get_insert (buffer));
+ }
+
+ priv->scroll_after_paste = TRUE;
}
static void
gtk_text_view_toggle_overwrite (GtkTextView *text_view)
{
- text_view->overwrite_mode = !text_view->overwrite_mode;
+ GtkTextViewPrivate *priv = text_view->priv;
+
+ if (priv->text_window)
+ text_window_invalidate_cursors (priv->text_window);
+
+ priv->overwrite_mode = !priv->overwrite_mode;
+
+ if (priv->layout)
+ gtk_text_layout_set_overwrite_mode (priv->layout,
+ priv->overwrite_mode && priv->editable);
+
+ if (priv->text_window)
+ text_window_invalidate_cursors (priv->text_window);
+
+ gtk_text_view_pend_cursor_blink (text_view);
+
g_object_notify (G_OBJECT (text_view), "overwrite");
}
{
g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), FALSE);
- return text_view->overwrite_mode;
+ return text_view->priv->overwrite_mode;
}
/**
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");
- }
+ if (text_view->priv->overwrite_mode != overwrite)
+ gtk_text_view_toggle_overwrite (text_view);
}
/**
* 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.
+ * @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.
+ * 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
**/
accepts_tab = accepts_tab != FALSE;
- if (text_view->accepts_tab != accepts_tab)
+ if (text_view->priv->accepts_tab != accepts_tab)
{
- text_view->accepts_tab = accepts_tab;
+ text_view->priv->accepts_tab = accepts_tab;
g_object_notify (G_OBJECT (text_view), "accepts-tab");
}
* 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.
+ * 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
**/
{
g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), FALSE);
- return text_view->accepts_tab;
+ return text_view->priv->accepts_tab;
}
static void
-gtk_text_view_move_focus (GtkTextView *text_view,
- GtkDirectionType direction_type)
+gtk_text_view_compat_move_focus (GtkTextView *text_view,
+ GtkDirectionType direction_type)
{
- GtkWidget *toplevel = gtk_widget_get_toplevel (GTK_WIDGET (text_view));
+ GSignalInvocationHint *hint = g_signal_get_invocation_hint (text_view);
- if (!GTK_WIDGET_TOPLEVEL (toplevel))
- return;
+ /* as of GTK+ 2.12, the "move-focus" signal has been moved to GtkWidget,
+ * the evil code below makes sure that both emitting the signal and
+ * calling the virtual function directly continue to work as expetcted
+ */
+
+ if (hint->signal_id == g_signal_lookup ("move-focus", GTK_TYPE_WIDGET))
+ {
+ /* if this is a signal emission, chain up */
+
+ gboolean retval;
- /* Propagate to toplevel */
- g_signal_emit_by_name (toplevel, "move_focus", direction_type);
+ g_signal_chain_from_overridden_handler (text_view,
+ direction_type, &retval);
+ }
+ else
+ {
+ /* otherwise emit the signal, since somebody called the virtual
+ * function directly
+ */
+
+ g_signal_emit_by_name (text_view, "move-focus", direction_type);
+ }
}
/*
{
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);
}
static void
get_iter_at_pointer (GtkTextView *text_view,
+ GdkDevice *device,
GtkTextIter *iter,
gint *x,
gint *y)
{
+ GtkTextViewPrivate *priv;
gint xcoord, ycoord;
GdkModifierType state;
- gdk_window_get_pointer (text_view->text_window->bin_window,
- &xcoord, &ycoord, &state);
-
- gtk_text_layout_get_iter_at_pixel (text_view->layout,
+ priv = text_view->priv;
+
+ gdk_window_get_device_position (priv->text_window->bin_window,
+ device, &xcoord, &ycoord, &state);
+
+ gtk_text_layout_get_iter_at_pixel (priv->layout,
iter,
- xcoord + text_view->xoffset,
- ycoord + text_view->yoffset);
+ xcoord + priv->xoffset,
+ ycoord + priv->yoffset);
if (x)
*x = xcoord;
static void
move_mark_to_pointer_and_scroll (GtkTextView *text_view,
- const gchar *mark_name)
+ const gchar *mark_name,
+ GdkDevice *device)
{
GtkTextIter newplace;
GtkTextMark *mark;
- get_iter_at_pointer (text_view, &newplace, NULL, NULL);
+ get_iter_at_pointer (text_view, device, &newplace, NULL, NULL);
mark = gtk_text_buffer_get_mark (get_buffer (text_view), mark_name);
gtk_text_view_scroll_mark_onscreen (text_view, mark);
DV (g_print ("first validate idle leaving %s is %d\n",
- G_STRLOC, text_view->first_validate_idle));
+ G_STRLOC, text_view->priv->first_validate_idle));
}
static gboolean
text_view = GTK_TEXT_VIEW (data);
- 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. */
}
drag_scan_timeout (gpointer data)
{
GtkTextView *text_view;
+ GtkTextViewPrivate *priv;
GtkTextIter newplace;
gint x, y, width, height;
gdouble pointer_xoffset, pointer_yoffset;
text_view = GTK_TEXT_VIEW (data);
+ priv = text_view->priv;
- get_iter_at_pointer (text_view, &newplace, &x, &y);
- gdk_drawable_get_size (text_view->text_window->bin_window, &width, &height);
+ get_iter_at_pointer (text_view, priv->dnd_device, &newplace, &x, &y);
+ gdk_drawable_get_size (priv->text_window->bin_window, &width, &height);
gtk_text_buffer_move_mark (get_buffer (text_view),
- text_view->dnd_mark,
+ priv->dnd_mark,
&newplace);
pointer_xoffset = (gdouble) x / width;
pointer_yoffset = (gdouble) y / height;
- if (check_scroll (pointer_xoffset, text_view->hadjustment) ||
- check_scroll (pointer_yoffset, text_view->vadjustment))
+ if (check_scroll (pointer_xoffset, priv->hadjustment) ||
+ check_scroll (pointer_yoffset, priv->vadjustment))
{
/* do not make offsets surpass lower nor upper anchors, this makes
* scrolling speed relative to the distance of the pointer to the
pointer_yoffset = CLAMP (pointer_yoffset, LOWER_OFFSET_ANCHOR, UPPER_OFFSET_ANCHOR);
gtk_text_view_scroll_to_mark (text_view,
- text_view->dnd_mark,
+ priv->dnd_mark,
0., TRUE, pointer_xoffset, pointer_yoffset);
}
GdkEventMotion *event,
SelectionData *data)
{
+ GtkTextViewPrivate *priv;
+
+ priv = text_view->priv;
gdk_event_request_motions (event);
+ if (priv->grab_device != event->device)
+ return FALSE;
+
if (data->granularity == SELECT_CHARACTERS)
{
- move_mark_to_pointer_and_scroll (text_view, "insert");
+ move_mark_to_pointer_and_scroll (text_view, "insert", event->device);
}
else
{
gtk_text_buffer_get_iter_at_mark (buffer, &orig_start, data->orig_start);
gtk_text_buffer_get_iter_at_mark (buffer, &orig_end, data->orig_end);
- get_iter_at_pointer (text_view, &cursor, NULL, NULL);
+ get_iter_at_pointer (text_view, event->device, &cursor, NULL, NULL);
start = cursor;
extend_selection (text_view, data->granularity, &start, &end);
* 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 */
- g_source_remove (text_view->scroll_timeout);
+ if (text_view->priv->scroll_timeout != 0) /* reset on every motion event */
+ g_source_remove (text_view->priv->scroll_timeout);
- text_view->scroll_timeout =
+ text_view->priv->scroll_timeout =
gdk_threads_add_timeout (50, selection_scan_timeout, text_view);
return TRUE;
const GtkTextIter *iter,
GdkEventButton *button)
{
+ GtkTextViewPrivate *priv;
GtkTextIter cursor, ins, bound;
GtkTextIter orig_start, orig_end;
GtkTextBuffer *buffer;
SelectionData *data;
- if (text_view->selection_drag_handler != 0)
+ if (text_view->priv->selection_drag_handler != 0)
return;
-
+
+ priv = text_view->priv;
data = g_new0 (SelectionData, 1);
if (button->type == GDK_2BUTTON_PRESS)
else
data->granularity = SELECT_CHARACTERS;
- gtk_grab_add (GTK_WIDGET (text_view));
+ priv->grab_device = button->device;
+ gtk_device_grab_add (GTK_WIDGET (text_view),
+ priv->grab_device,
+ TRUE);
buffer = get_buffer (text_view);
&orig_start, TRUE);
data->orig_end = gtk_text_buffer_create_mark (buffer, NULL,
&orig_end, TRUE);
-
gtk_text_view_check_cursor_blink (text_view);
- text_view->selection_drag_handler = g_signal_connect_data (text_view,
- "motion_notify_event",
- G_CALLBACK (selection_motion_event_handler),
- data,
- (GClosureNotify) selection_data_free, 0);
+ text_view->priv->selection_drag_handler = g_signal_connect_data (text_view,
+ "motion-notify-event",
+ G_CALLBACK (selection_motion_event_handler),
+ data,
+ (GClosureNotify) selection_data_free, 0);
}
/* returns whether we were really dragging */
static gboolean
-gtk_text_view_end_selection_drag (GtkTextView *text_view)
+gtk_text_view_end_selection_drag (GtkTextView *text_view)
{
- if (text_view->selection_drag_handler == 0)
+ GtkTextViewPrivate *priv;
+
+ priv = text_view->priv;
+
+ if (!priv->grab_device)
+ return FALSE;
+
+ if (priv->selection_drag_handler == 0)
return FALSE;
- g_signal_handler_disconnect (text_view, text_view->selection_drag_handler);
- text_view->selection_drag_handler = 0;
+ g_signal_handler_disconnect (text_view, priv->selection_drag_handler);
+ priv->selection_drag_handler = 0;
- if (text_view->scroll_timeout != 0)
+ if (priv->scroll_timeout != 0)
{
- g_source_remove (text_view->scroll_timeout);
- text_view->scroll_timeout = 0;
+ g_source_remove (priv->scroll_timeout);
+ priv->scroll_timeout = 0;
}
- gtk_grab_remove (GTK_WIDGET (text_view));
+ gtk_device_grab_remove (GTK_WIDGET (text_view),
+ priv->grab_device);
+ priv->grab_device = NULL;
return TRUE;
}
static void
gtk_text_view_check_keymap_direction (GtkTextView *text_view)
{
- if (text_view->layout)
+ GtkTextViewPrivate *priv = text_view->priv;
+
+ if (priv->layout)
{
GtkSettings *settings = gtk_widget_get_settings (GTK_WIDGET (text_view));
GdkKeymap *keymap = gdk_keymap_get_for_display (gtk_widget_get_display (GTK_WIDGET (text_view)));
else
new_cursor_dir = new_keyboard_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);
+ gtk_text_layout_set_cursor_direction (priv->layout, new_cursor_dir);
+ gtk_text_layout_set_keyboard_direction (priv->layout, new_keyboard_dir);
}
}
gtk_text_view_ensure_layout (GtkTextView *text_view)
{
GtkWidget *widget;
+ GtkTextViewPrivate *priv;
widget = GTK_WIDGET (text_view);
+ priv = text_view->priv;
- if (text_view->layout == NULL)
+ if (priv->layout == NULL)
{
GtkTextAttributes *style;
PangoContext *ltr_context, *rtl_context;
DV(g_print(G_STRLOC"\n"));
- text_view->layout = gtk_text_layout_new ();
+ priv->layout = gtk_text_layout_new ();
- g_signal_connect (text_view->layout,
+ g_signal_connect (priv->layout,
"invalidated",
G_CALLBACK (invalidated_handler),
text_view);
- g_signal_connect (text_view->layout,
+ g_signal_connect (priv->layout,
"changed",
G_CALLBACK (changed_handler),
text_view);
- g_signal_connect (text_view->layout,
- "allocate_child",
+ g_signal_connect (priv->layout,
+ "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));
+ gtk_text_layout_set_buffer (priv->layout, get_buffer (text_view));
- if ((GTK_WIDGET_HAS_FOCUS (text_view) && text_view->cursor_visible))
+ if ((gtk_widget_has_focus (widget) && priv->cursor_visible))
gtk_text_view_pend_cursor_blink (text_view);
else
- gtk_text_layout_set_cursor_visible (text_view->layout, FALSE);
+ gtk_text_layout_set_cursor_visible (priv->layout, FALSE);
+
+ gtk_text_layout_set_overwrite_mode (priv->layout,
+ priv->overwrite_mode && priv->editable);
ltr_context = gtk_widget_create_pango_context (GTK_WIDGET (text_view));
pango_context_set_base_dir (ltr_context, PANGO_DIRECTION_LTR);
rtl_context = gtk_widget_create_pango_context (GTK_WIDGET (text_view));
pango_context_set_base_dir (rtl_context, PANGO_DIRECTION_RTL);
- gtk_text_layout_set_contexts (text_view->layout, ltr_context, rtl_context);
+ gtk_text_layout_set_contexts (priv->layout, ltr_context, rtl_context);
g_object_unref (ltr_context);
g_object_unref (rtl_context);
gtk_widget_ensure_style (widget);
gtk_text_view_set_attributes_from_style (text_view,
- style, widget->style);
-
- style->pixels_above_lines = text_view->pixels_above_lines;
- style->pixels_below_lines = text_view->pixels_below_lines;
- style->pixels_inside_wrap = text_view->pixels_inside_wrap;
- style->left_margin = text_view->left_margin;
- style->right_margin = text_view->right_margin;
- style->indent = text_view->indent;
- style->tabs = text_view->tabs ? pango_tab_array_copy (text_view->tabs) : NULL;
-
- style->wrap_mode = text_view->wrap_mode;
- style->justification = text_view->justify;
+ style,
+ gtk_widget_get_style (widget));
+
+ style->pixels_above_lines = priv->pixels_above_lines;
+ style->pixels_below_lines = priv->pixels_below_lines;
+ style->pixels_inside_wrap = priv->pixels_inside_wrap;
+ style->left_margin = priv->left_margin;
+ style->right_margin = priv->right_margin;
+ style->indent = priv->indent;
+ style->tabs = priv->tabs ? pango_tab_array_copy (priv->tabs) : NULL;
+
+ style->wrap_mode = priv->wrap_mode;
+ style->justification = priv->justify;
style->direction = gtk_widget_get_direction (GTK_WIDGET (text_view));
- gtk_text_layout_set_default_style (text_view->layout, style);
+ gtk_text_layout_set_default_style (priv->layout, style);
gtk_text_attributes_unref (style);
/* Set layout for all anchored children */
- tmp_list = text_view->children;
+ tmp_list = priv->children;
while (tmp_list != NULL)
{
GtkTextViewChild *vc = tmp_list->data;
if (vc->anchor)
{
gtk_text_anchored_child_set_layout (vc->widget,
- text_view->layout);
+ priv->layout);
/* vc may now be invalid! */
}
gtk_text_view_ensure_layout (text_view);
- return gtk_text_attributes_copy (text_view->layout->default_style);
+ return gtk_text_attributes_copy (text_view->priv->layout->default_style);
}
static void
gtk_text_view_destroy_layout (GtkTextView *text_view)
{
- if (text_view->layout)
+ GtkTextViewPrivate *priv = text_view->priv;
+
+ if (priv->layout)
{
GSList *tmp_list;
gtk_text_view_remove_validate_idles (text_view);
- g_signal_handlers_disconnect_by_func (text_view->layout,
+ g_signal_handlers_disconnect_by_func (priv->layout,
invalidated_handler,
text_view);
- g_signal_handlers_disconnect_by_func (text_view->layout,
- changed_handler,
+ g_signal_handlers_disconnect_by_func (priv->layout,
+ changed_handler,
text_view);
-
+
/* Remove layout from all anchored children */
- tmp_list = text_view->children;
+ tmp_list = priv->children;
while (tmp_list != NULL)
{
GtkTextViewChild *vc = tmp_list->data;
tmp_list = g_slist_next (tmp_list);
}
-
+
gtk_text_view_stop_cursor_blink (text_view);
gtk_text_view_end_selection_drag (text_view);
- g_object_unref (text_view->layout);
- text_view->layout = NULL;
+ g_object_unref (priv->layout);
+ priv->layout = NULL;
}
}
-static void
+/**
+ * gtk_text_view_reset_im_context:
+ * @text_view: a #GtkTextView
+ *
+ * Reset the input method context of the text view if needed.
+ *
+ * This can be necessary in the case where modifying the buffer
+ * would confuse on-going input method behavior.
+ *
+ * Since: 2.22
+ */
+void
gtk_text_view_reset_im_context (GtkTextView *text_view)
{
- if (text_view->need_im_reset)
+ g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
+
+ if (text_view->priv->need_im_reset)
{
- text_view->need_im_reset = FALSE;
- gtk_im_context_reset (text_view->im_context);
+ text_view->priv->need_im_reset = FALSE;
+ gtk_im_context_reset (text_view->priv->im_context);
}
}
+/**
+ * gtk_text_view_im_context_filter_keypress:
+ * @text_view: a #GtkTextView
+ * @event: the key event
+ *
+ * Allow the #GtkTextView input method to internally handle key press
+ * and release events. If this function returns %TRUE, then no further
+ * processing should be done for this key event. See
+ * gtk_im_context_filter_keypress().
+ *
+ * Note that you are expected to call this function from your handler
+ * when overriding key event handling. This is needed in the case when
+ * you need to insert your own key handling between the input method
+ * and the default key event handling of the #GtkTextView.
+ *
+ * |[
+ * static gboolean
+ * gtk_foo_bar_key_press_event (GtkWidget *widget,
+ * GdkEventKey *event)
+ * {
+ * if ((key->keyval == GDK_Return || key->keyval == GDK_KP_Enter))
+ * {
+ * if (gtk_text_view_im_context_filter_keypress (GTK_TEXT_VIEW (view), event))
+ * return TRUE;
+ * }
+ *
+ * /* Do some stuff */
+ *
+ * return GTK_WIDGET_CLASS (gtk_foo_bar_parent_class)->key_press_event (widget, event);
+ * }
+ * ]|
+ *
+ * Return value: %TRUE if the input method handled the key event.
+ *
+ * Since: 2.22
+ */
+gboolean
+gtk_text_view_im_context_filter_keypress (GtkTextView *text_view,
+ GdkEventKey *event)
+{
+ g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), FALSE);
+
+ return gtk_im_context_filter_keypress (text_view->priv->im_context, event);
+}
+
/*
* DND feature
*/
{
GtkTargetList *target_list;
- text_view->drag_start_x = -1;
- text_view->drag_start_y = -1;
- text_view->pending_place_cursor_button = 0;
+ text_view->priv->drag_start_x = -1;
+ text_view->priv->drag_start_y = -1;
+ text_view->priv->pending_place_cursor_button = 0;
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,
gtk_text_view_drag_data_delete (GtkWidget *widget,
GdkDragContext *context)
{
- gtk_text_buffer_delete_selection (GTK_TEXT_VIEW (widget)->buffer,
- TRUE, GTK_TEXT_VIEW (widget)->editable);
+ gtk_text_buffer_delete_selection (GTK_TEXT_VIEW (widget)->priv->buffer,
+ TRUE, GTK_TEXT_VIEW (widget)->priv->editable);
}
static void
guint time)
{
GtkTextView *text_view;
+ GtkTextViewPrivate *priv;
text_view = GTK_TEXT_VIEW (widget);
+ priv = text_view->priv;
- gtk_text_mark_set_visible (text_view->dnd_mark, FALSE);
-
- if (text_view->scroll_timeout != 0)
- g_source_remove (text_view->scroll_timeout);
+ gtk_text_mark_set_visible (priv->dnd_mark, FALSE);
- text_view->scroll_timeout = 0;
+ if (priv->dnd_device)
+ priv->dnd_device = NULL;
+
+ if (priv->scroll_timeout != 0)
+ g_source_remove (priv->scroll_timeout);
+
+ priv->scroll_timeout = 0;
}
static gboolean
{
GtkTextIter newplace;
GtkTextView *text_view;
+ GtkTextViewPrivate *priv;
GtkTextIter start;
GtkTextIter end;
GdkRectangle target_rect;
GdkDragAction suggested_action = 0;
text_view = GTK_TEXT_VIEW (widget);
+ priv = text_view->priv;
- target_rect = text_view->text_window->allocation;
+ target_rect = priv->text_window->allocation;
if (x < target_rect.x ||
y < target_rect.y ||
x, y,
&bx, &by);
- gtk_text_layout_get_iter_at_pixel (text_view->layout,
+ gtk_text_layout_get_iter_at_pixel (priv->layout,
&newplace,
bx, by);
}
else
{
- if (gtk_text_iter_can_insert (&newplace, text_view->editable))
+ if (gtk_text_iter_can_insert (&newplace, priv->editable))
{
GtkWidget *source_widget;
if (suggested_action != 0)
{
- gtk_text_mark_set_visible (text_view->dnd_mark,
- text_view->cursor_visible);
+ gtk_text_mark_set_visible (priv->dnd_mark,
+ priv->cursor_visible);
gdk_drag_status (context, suggested_action, time);
}
else
{
gdk_drag_status (context, 0, time);
- gtk_text_mark_set_visible (text_view->dnd_mark, FALSE);
+ gtk_text_mark_set_visible (priv->dnd_mark, FALSE);
}
-
- if (!text_view->scroll_timeout)
- text_view->scroll_timeout =
+
+ priv->dnd_device = gdk_drag_context_get_device (context);
+
+ if (!priv->scroll_timeout)
+ priv->scroll_timeout =
gdk_threads_add_timeout (100, drag_scan_timeout, text_view);
/* TRUE return means don't propagate the drag motion to parent
guint time)
{
GtkTextView *text_view;
+ GtkTextViewPrivate *priv;
GtkTextIter drop_point;
GdkAtom target = GDK_NONE;
-
+
text_view = GTK_TEXT_VIEW (widget);
-
- if (text_view->scroll_timeout != 0)
- g_source_remove (text_view->scroll_timeout);
+ priv = text_view->priv;
- text_view->scroll_timeout = 0;
+ if (priv->scroll_timeout != 0)
+ g_source_remove (priv->scroll_timeout);
- gtk_text_mark_set_visible (text_view->dnd_mark, FALSE);
+ priv->scroll_timeout = 0;
+
+ gtk_text_mark_set_visible (priv->dnd_mark, FALSE);
gtk_text_buffer_get_iter_at_mark (get_buffer (text_view),
&drop_point,
- text_view->dnd_mark);
+ priv->dnd_mark);
- if (gtk_text_iter_can_insert (&drop_point, text_view->editable))
+ if (gtk_text_iter_can_insert (&drop_point, priv->editable))
target = gtk_drag_dest_find_target (widget, context, NULL);
if (target != GDK_NONE)
{
if (!gtk_text_buffer_insert_interactive (get_buffer (text_view),
drop_point, (gchar *) str, -1,
- text_view->editable))
+ text_view->priv->editable))
{
gtk_widget_error_bell (GTK_WIDGET (text_view));
}
{
GtkTextIter drop_point;
GtkTextView *text_view;
+ GtkTextViewPrivate *priv;
gboolean success = FALSE;
GtkTextBuffer *buffer = NULL;
text_view = GTK_TEXT_VIEW (widget);
+ priv = text_view->priv;
- if (!text_view->dnd_mark)
+ if (!priv->dnd_mark)
goto done;
buffer = get_buffer (text_view);
gtk_text_buffer_get_iter_at_mark (buffer,
&drop_point,
- text_view->dnd_mark);
+ priv->dnd_mark);
- if (!gtk_text_iter_can_insert (&drop_point, text_view->editable))
+ if (!gtk_text_iter_can_insert (&drop_point, priv->editable))
goto done;
success = TRUE;
&drop_point,
&start,
&end,
- text_view->editable);
+ priv->editable);
else
{
gchar *str;
str = gtk_text_iter_get_visible_text (&start, &end);
gtk_text_buffer_insert_interactive (buffer,
&drop_point, str, -1,
- text_view->editable);
+ priv->editable);
g_free (str);
}
}
{
gtk_text_buffer_get_iter_at_mark (buffer,
&drop_point,
- text_view->dnd_mark);
+ priv->dnd_mark);
gtk_text_buffer_place_cursor (buffer, &drop_point);
gtk_text_buffer_end_user_action (buffer);
}
}
+/**
+ * gtk_text_view_get_hadjustment:
+ * @text_view: a #GtkTextView
+ *
+ * Gets the horizontal-scrolling #GtkAdjustment.
+ *
+ * Returns: (transfer none): pointer to the horizontal #GtkAdjustment
+ *
+ * Since: 2.22
+ **/
+GtkAdjustment*
+gtk_text_view_get_hadjustment (GtkTextView *text_view)
+{
+ g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), NULL);
+
+ return get_hadjustment (text_view);
+}
+
+/**
+ * gtk_text_view_get_vadjustment:
+ * @text_view: a #GtkTextView
+ *
+ * Gets the vertical-scrolling #GtkAdjustment.
+ *
+ * Returns: (transfer none): pointer to the vertical #GtkAdjustment
+ *
+ * Since: 2.22
+ **/
+GtkAdjustment*
+gtk_text_view_get_vadjustment (GtkTextView *text_view)
+{
+ g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), NULL);
+
+ return get_vadjustment (text_view);
+}
+
static GtkAdjustment*
get_hadjustment (GtkTextView *text_view)
{
- if (text_view->hadjustment == NULL)
+ if (text_view->priv->hadjustment == NULL)
gtk_text_view_set_scroll_adjustments (text_view,
NULL, /* forces creation */
- text_view->vadjustment);
+ text_view->priv->vadjustment);
- return text_view->hadjustment;
+ return text_view->priv->hadjustment;
}
static GtkAdjustment*
get_vadjustment (GtkTextView *text_view)
{
- if (text_view->vadjustment == NULL)
+ if (text_view->priv->vadjustment == NULL)
gtk_text_view_set_scroll_adjustments (text_view,
- text_view->hadjustment,
+ text_view->priv->hadjustment,
NULL); /* forces creation */
- return text_view->vadjustment;
+ return text_view->priv->vadjustment;
}
GtkAdjustment *hadj,
GtkAdjustment *vadj)
{
+ GtkTextViewPrivate *priv = text_view->priv;
gboolean need_adjust = FALSE;
if (hadj)
else
vadj = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, 0.0, 0.0, 0.0, 0.0));
- if (text_view->hadjustment && (text_view->hadjustment != hadj))
+ if (priv->hadjustment && (priv->hadjustment != hadj))
{
- g_signal_handlers_disconnect_by_func (text_view->hadjustment,
+ g_signal_handlers_disconnect_by_func (priv->hadjustment,
gtk_text_view_value_changed,
text_view);
- g_object_unref (text_view->hadjustment);
+ g_object_unref (priv->hadjustment);
}
- if (text_view->vadjustment && (text_view->vadjustment != vadj))
+ if (priv->vadjustment && (priv->vadjustment != vadj))
{
- g_signal_handlers_disconnect_by_func (text_view->vadjustment,
+ g_signal_handlers_disconnect_by_func (priv->vadjustment,
gtk_text_view_value_changed,
text_view);
- g_object_unref (text_view->vadjustment);
+ g_object_unref (priv->vadjustment);
}
- if (text_view->hadjustment != hadj)
+ if (priv->hadjustment != hadj)
{
- text_view->hadjustment = hadj;
- g_object_ref_sink (text_view->hadjustment);
+ priv->hadjustment = hadj;
+ g_object_ref_sink (priv->hadjustment);
- g_signal_connect (text_view->hadjustment, "value_changed",
+ g_signal_connect (priv->hadjustment, "value-changed",
G_CALLBACK (gtk_text_view_value_changed),
text_view);
need_adjust = TRUE;
}
- if (text_view->vadjustment != vadj)
+ if (priv->vadjustment != vadj)
{
- text_view->vadjustment = vadj;
- g_object_ref_sink (text_view->vadjustment);
+ priv->vadjustment = vadj;
+ g_object_ref_sink (priv->vadjustment);
- g_signal_connect (text_view->vadjustment, "value_changed",
+ g_signal_connect (priv->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) ? \
- (widget)->window : \
- gdk_window_get_parent ((widget)->window))
+ (!gtk_widget_get_has_window (widget) ? \
+ gtk_widget_get_window (widget) : \
+ gdk_window_get_parent (gtk_widget_get_window (widget)))
static void
adjust_allocation_recurse (GtkWidget *widget,
gpointer data)
{
+ GtkAllocation allocation;
ScrollData *scroll_data = data;
/* Need to really size allocate instead of just poking
* into widget->allocation if the widget is not realized.
* FIXME someone figure out why this was.
*/
- if (!GTK_WIDGET_REALIZED (widget))
+ if (!gtk_widget_get_realized (widget))
{
- if (GTK_WIDGET_VISIBLE (widget))
+ if (gtk_widget_get_visible (widget))
{
- GdkRectangle tmp_rectangle = widget->allocation;
+ GdkRectangle tmp_rectangle;
+
+ tmp_rectangle = allocation;
tmp_rectangle.x += scroll_data->dx;
tmp_rectangle.y += scroll_data->dy;
{
if (ALLOCATION_WINDOW (widget) == scroll_data->window)
{
- widget->allocation.x += scroll_data->dx;
- widget->allocation.y += scroll_data->dy;
-
+ allocation.x += scroll_data->dx;
+ allocation.y += scroll_data->dy;
+ gtk_widget_set_allocation (widget, &allocation);
+
if (GTK_IS_CONTAINER (widget))
gtk_container_forall (GTK_CONTAINER (widget),
adjust_allocation_recurse,
{
ScrollData scroll_data;
- if (GTK_WIDGET_REALIZED (widget))
+ if (gtk_widget_get_realized (widget))
scroll_data.window = ALLOCATION_WINDOW (widget);
else
scroll_data.window = NULL;
gtk_text_view_value_changed (GtkAdjustment *adj,
GtkTextView *text_view)
{
+ GtkTextViewPrivate *priv;
GtkTextIter iter;
gint line_top;
gint dx = 0;
gint dy = 0;
-
+
+ priv = text_view->priv;
+
/* Note that we oddly call this function with adj == NULL
* sometimes
*/
- text_view->onscreen_validated = FALSE;
+ priv->onscreen_validated = FALSE;
DV(g_print(">Scroll offset changed %s/%g, onscreen_validated = FALSE ("G_STRLOC")\n",
- adj == text_view->hadjustment ? "hadj" : adj == text_view->vadjustment ? "vadj" : "none",
+ adj == priv->hadjustment ? "hadj" : adj == priv->vadjustment ? "vadj" : "none",
adj ? adj->value : 0.0));
- if (adj == text_view->hadjustment)
+ if (adj == priv->hadjustment)
{
- dx = text_view->xoffset - (gint)adj->value;
- text_view->xoffset = adj->value;
+ dx = priv->xoffset - (gint)adj->value;
+ priv->xoffset = adj->value;
/* If the change is due to a size change we need
* to invalidate the entire text window because there might be
* right-aligned or centered text
*/
- if (text_view->width_changed)
+ if (priv->width_changed)
{
- if (GTK_WIDGET_REALIZED (text_view))
- gdk_window_invalidate_rect (text_view->text_window->bin_window, NULL, FALSE);
+ if (gtk_widget_get_realized (GTK_WIDGET (text_view)))
+ gdk_window_invalidate_rect (priv->text_window->bin_window, NULL, FALSE);
- text_view->width_changed = FALSE;
+ priv->width_changed = FALSE;
}
}
- else if (adj == text_view->vadjustment)
+ else if (adj == priv->vadjustment)
{
- dy = text_view->yoffset - (gint)adj->value;
- text_view->yoffset = adj->value;
+ dy = priv->yoffset - (gint)adj->value;
+ priv->yoffset = adj->value;
- if (text_view->layout)
+ if (priv->layout)
{
- gtk_text_layout_get_line_at_y (text_view->layout, &iter, adj->value, &line_top);
+ gtk_text_layout_get_line_at_y (priv->layout, &iter, adj->value, &line_top);
- gtk_text_buffer_move_mark (get_buffer (text_view), text_view->first_para_mark, &iter);
+ gtk_text_buffer_move_mark (get_buffer (text_view), priv->first_para_mark, &iter);
- text_view->first_para_pixels = adj->value - line_top;
+ priv->first_para_pixels = adj->value - line_top;
}
}
{
GSList *tmp_list;
- if (GTK_WIDGET_REALIZED (text_view))
+ if (gtk_widget_get_realized (GTK_WIDGET (text_view)))
{
if (dy != 0)
{
- if (text_view->left_window)
- text_window_scroll (text_view->left_window, 0, dy);
- if (text_view->right_window)
- text_window_scroll (text_view->right_window, 0, dy);
+ if (priv->left_window)
+ text_window_scroll (priv->left_window, 0, dy);
+ if (priv->right_window)
+ text_window_scroll (priv->right_window, 0, dy);
}
if (dx != 0)
{
- if (text_view->top_window)
- text_window_scroll (text_view->top_window, dx, 0);
- if (text_view->bottom_window)
- text_window_scroll (text_view->bottom_window, dx, 0);
+ if (priv->top_window)
+ text_window_scroll (priv->top_window, dx, 0);
+ if (priv->bottom_window)
+ text_window_scroll (priv->bottom_window, dx, 0);
}
/* It looks nicer to scroll the main area last, because
* afterward emphasizes the slowness of scrolling the
* main area.
*/
- text_window_scroll (text_view->text_window, dx, dy);
+ text_window_scroll (priv->text_window, dx, dy);
}
/* Children are now "moved" in the text window, poke
* into widget->allocation for each child
*/
- tmp_list = text_view->children;
+ tmp_list = priv->children;
while (tmp_list != NULL)
{
GtkTextViewChild *child = tmp_list->data;
*/
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
gtk_text_view_validate_onscreen (text_view);
/* process exposes */
- if (GTK_WIDGET_REALIZED (text_view))
+ if (gtk_widget_get_realized (GTK_WIDGET (text_view)))
{
DV (g_print ("Processing updates (%s)\n", G_STRLOC));
- if (text_view->left_window)
- gdk_window_process_updates (text_view->left_window->bin_window, TRUE);
+ if (priv->left_window)
+ gdk_window_process_updates (priv->left_window->bin_window, TRUE);
- if (text_view->right_window)
- gdk_window_process_updates (text_view->right_window->bin_window, TRUE);
+ if (priv->right_window)
+ gdk_window_process_updates (priv->right_window->bin_window, TRUE);
- if (text_view->top_window)
- gdk_window_process_updates (text_view->top_window->bin_window, TRUE);
+ if (priv->top_window)
+ gdk_window_process_updates (priv->top_window->bin_window, TRUE);
- if (text_view->bottom_window)
- gdk_window_process_updates (text_view->bottom_window->bin_window, TRUE);
+ if (priv->bottom_window)
+ gdk_window_process_updates (priv->bottom_window->bin_window, TRUE);
- gdk_window_process_updates (text_view->text_window->bin_window, TRUE);
+ gdk_window_process_updates (priv->text_window->bin_window, TRUE);
}
/* If this got installed, get rid of it, it's just a waste of time. */
- if (text_view->first_validate_idle != 0)
+ if (priv->first_validate_idle != 0)
{
- g_source_remove (text_view->first_validate_idle);
- text_view->first_validate_idle = 0;
+ g_source_remove (priv->first_validate_idle);
+ priv->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"));
gtk_text_view_commit_text (GtkTextView *text_view,
const gchar *str)
{
+ GtkTextViewPrivate *priv;
gboolean had_selection;
-
+
+ priv = text_view->priv;
+
gtk_text_buffer_begin_user_action (get_buffer (text_view));
had_selection = gtk_text_buffer_get_selection_bounds (get_buffer (text_view),
NULL, NULL);
gtk_text_buffer_delete_selection (get_buffer (text_view), TRUE,
- text_view->editable);
+ priv->editable);
if (!strcmp (str, "\n"))
{
if (!gtk_text_buffer_insert_interactive_at_cursor (get_buffer (text_view), "\n", 1,
- text_view->editable))
+ priv->editable))
{
gtk_widget_error_bell (GTK_WIDGET (text_view));
}
}
else
{
- if (!had_selection && text_view->overwrite_mode)
+ if (!had_selection && priv->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);
}
if (!gtk_text_buffer_insert_interactive_at_cursor (get_buffer (text_view), str, -1,
- text_view->editable))
+ priv->editable))
{
gtk_widget_error_bell (GTK_WIDGET (text_view));
}
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
gtk_text_view_preedit_changed_handler (GtkIMContext *context,
GtkTextView *text_view)
{
+ GtkTextViewPrivate *priv;
gchar *str;
PangoAttrList *attrs;
gint cursor_pos;
GtkTextIter iter;
- gtk_text_buffer_get_iter_at_mark (text_view->buffer, &iter,
- gtk_text_buffer_get_insert (text_view->buffer));
+ priv = text_view->priv;
+
+ gtk_text_buffer_get_iter_at_mark (priv->buffer, &iter,
+ gtk_text_buffer_get_insert (priv->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.
+ */
+ gtk_im_context_get_preedit_string (context, &str, &attrs, &cursor_pos);
- /* 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))
+ if (str && str[0] && !gtk_text_iter_can_insert (&iter, priv->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 (priv->layout)
+ gtk_text_layout_set_preedit_string (priv->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_insert (text_view->buffer));
+ gtk_text_buffer_get_iter_at_mark (text_view->priv->buffer, &start,
+ gtk_text_buffer_get_insert (text_view->priv->buffer));
end = start;
pos = gtk_text_iter_get_line_index (&start);
gint n_chars,
GtkTextView *text_view)
{
+ GtkTextViewPrivate *priv;
GtkTextIter start;
GtkTextIter end;
- gtk_text_buffer_get_iter_at_mark (text_view->buffer, &start,
- gtk_text_buffer_get_insert (text_view->buffer));
+ priv = text_view->priv;
+
+ gtk_text_buffer_get_iter_at_mark (priv->buffer, &start,
+ gtk_text_buffer_get_insert (priv->buffer));
end = start;
gtk_text_iter_forward_chars (&start, offset);
gtk_text_iter_forward_chars (&end, offset + n_chars);
- gtk_text_buffer_delete_interactive (text_view->buffer, &start, &end,
- text_view->editable);
+ gtk_text_buffer_delete_interactive (priv->buffer, &start, &end,
+ priv->editable);
return TRUE;
}
if (mark == gtk_text_buffer_get_insert (buffer))
{
- text_view->virtual_cursor_x = -1;
- text_view->virtual_cursor_y = -1;
+ text_view->priv->virtual_cursor_x = -1;
+ text_view->priv->virtual_cursor_y = -1;
gtk_text_view_update_im_spot_location (text_view);
need_reset = TRUE;
}
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);
+ gtk_text_layout_get_cursor_locations (text_view->priv->layout, &insert, pos, NULL);
}
static void
gtk_text_view_get_virtual_cursor_pos (GtkTextView *text_view,
+ GtkTextIter *cursor,
gint *x,
gint *y)
{
+ GtkTextViewPrivate *priv;
+ GtkTextIter insert;
GdkRectangle pos;
- if ((x && text_view->virtual_cursor_x == -1) ||
- (y && text_view->virtual_cursor_y == -1))
- gtk_text_view_get_cursor_location (text_view, &pos);
+ priv = text_view->priv;
+
+ 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 && priv->virtual_cursor_x == -1) ||
+ (y && priv->virtual_cursor_y == -1))
+ gtk_text_layout_get_cursor_locations (priv->layout, &insert, &pos, NULL);
if (x)
{
- if (text_view->virtual_cursor_x != -1)
- *x = text_view->virtual_cursor_x;
+ if (priv->virtual_cursor_x != -1)
+ *x = priv->virtual_cursor_x;
else
*x = pos.x;
}
if (y)
{
- if (text_view->virtual_cursor_x != -1)
- *y = text_view->virtual_cursor_y;
+ if (priv->virtual_cursor_x != -1)
+ *y = priv->virtual_cursor_y;
else
*y = pos.y + pos.height / 2;
}
{
GdkRectangle pos;
- if (!text_view->layout)
+ if (!text_view->priv->layout)
return;
if (x == -1 || y == -1)
gtk_text_view_get_cursor_location (text_view, &pos);
- text_view->virtual_cursor_x = (x == -1) ? pos.x : x;
- text_view->virtual_cursor_y = (y == -1) ? pos.y + pos.height / 2 : y;
+ text_view->priv->virtual_cursor_x = (x == -1) ? pos.x : x;
+ text_view->priv->virtual_cursor_y = (y == -1) ? pos.y + pos.height / 2 : y;
}
/* Quick hack of a popup menu
GtkTextBuffer *buffer;
GtkTextIter start_iter, end_iter, insert;
- buffer = text_view->buffer;
+ buffer = text_view->priv->buffer;
if (select)
{
gtk_text_buffer_get_bounds (buffer, &start_iter, &end_iter);
delete_cb (GtkTextView *text_view)
{
gtk_text_buffer_delete_selection (get_buffer (text_view), TRUE,
- text_view->editable);
+ text_view->priv->editable);
}
static void
popup_menu_detach (GtkWidget *attach_widget,
GtkMenu *menu)
{
- GTK_TEXT_VIEW (attach_widget)->popup_menu = NULL;
+ GTK_TEXT_VIEW (attach_widget)->priv->popup_menu = NULL;
}
static void
gboolean *push_in,
gpointer user_data)
{
+ GtkAllocation allocation;
GtkTextView *text_view;
GtkWidget *widget;
GdkRectangle cursor_rect;
text_view = GTK_TEXT_VIEW (user_data);
widget = GTK_WIDGET (text_view);
- g_return_if_fail (GTK_WIDGET_REALIZED (text_view));
+ g_return_if_fail (gtk_widget_get_realized (widget));
screen = gtk_widget_get_screen (widget);
- gdk_window_get_origin (widget->window, &root_x, &root_y);
+ gdk_window_get_origin (gtk_widget_get_window (widget),
+ &root_x, &root_y);
gtk_text_buffer_get_iter_at_mark (get_buffer (text_view),
&iter,
gtk_text_view_get_visible_rect (text_view, &onscreen_rect);
- gtk_widget_size_request (text_view->popup_menu, &req);
+ gtk_widget_size_request (text_view->priv->popup_menu, &req);
+
+ gtk_widget_get_allocation (widget, &allocation);
/* can't use rectangle_intersect since cursor rect can have 0 width */
if (cursor_rect.x >= onscreen_rect.x &&
}
else
{
- /* Just center the menu, since cursor is offscreen. */
- *x = root_x + (widget->allocation.width / 2 - req.width / 2);
- *y = root_y + (widget->allocation.height / 2 - req.height / 2);
+ /* Just center the menu, since cursor is offscreen. */
+ *x = root_x + (allocation.width / 2 - req.width / 2);
+ *y = root_y + (allocation.height / 2 - req.height / 2);
}
-
+
/* Ensure sanity */
- *x = CLAMP (*x, root_x, (root_x + widget->allocation.width));
- *y = CLAMP (*y, root_y, (root_y + widget->allocation.height));
+ *x = CLAMP (*x, root_x, (root_x + allocation.width));
+ *y = CLAMP (*y, root_y, (root_y + allocation.height));
monitor_num = gdk_screen_get_monitor_at_point (screen, *x, *y);
gtk_menu_set_monitor (menu, monitor_num);
gpointer user_data)
{
PopupInfo *info = user_data;
- GtkTextView *text_view = info->text_view;
-
- if (GTK_WIDGET_REALIZED (text_view))
+ GtkTextView *text_view;
+ GtkTextViewPrivate *priv;
+
+ text_view = info->text_view;
+ priv = text_view->priv;
+
+ if (gtk_widget_get_realized (GTK_WIDGET (text_view)))
{
/* We implicitely rely here on the fact that if we are pasting ourself, we'll
* have text targets as well as the private GTK_TEXT_BUFFER_CONTENTS target.
clipboard_contains_text = gtk_selection_data_targets_include_text (data);
- if (text_view->popup_menu)
- gtk_widget_destroy (text_view->popup_menu);
+ if (priv->popup_menu)
+ gtk_widget_destroy (priv->popup_menu);
- text_view->popup_menu = gtk_menu_new ();
+ priv->popup_menu = gtk_menu_new ();
- gtk_menu_attach_to_widget (GTK_MENU (text_view->popup_menu),
+ gtk_menu_attach_to_widget (GTK_MENU (priv->popup_menu),
GTK_WIDGET (text_view),
popup_menu_detach);
&iter,
gtk_text_buffer_get_insert (get_buffer (text_view)));
- can_insert = gtk_text_iter_can_insert (&iter, text_view->editable);
+ can_insert = gtk_text_iter_can_insert (&iter, priv->editable);
- append_action_signal (text_view, text_view->popup_menu, GTK_STOCK_CUT, "cut_clipboard",
+ append_action_signal (text_view, priv->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",
+ priv->editable));
+ append_action_signal (text_view, priv->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, priv->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));
+ priv->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);
+ gtk_menu_shell_append (GTK_MENU_SHELL (priv->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);
+ gtk_menu_shell_append (GTK_MENU_SHELL (priv->popup_menu), menuitem);
menuitem = gtk_image_menu_item_new_from_stock (GTK_STOCK_SELECT_ALL, NULL);
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);
+ gtk_menu_shell_append (GTK_MENU_SHELL (priv->popup_menu), menuitem);
g_object_get (gtk_widget_get_settings (GTK_WIDGET (text_view)),
"gtk-show-input-method-menu", &show_input_method_menu,
{
menuitem = gtk_separator_menu_item_new ();
gtk_widget_show (menuitem);
- gtk_menu_shell_append (GTK_MENU_SHELL (text_view->popup_menu), menuitem);
+ gtk_menu_shell_append (GTK_MENU_SHELL (priv->popup_menu), menuitem);
}
if (show_input_method_menu)
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);
+ gtk_menu_shell_append (GTK_MENU_SHELL (priv->popup_menu), menuitem);
- gtk_im_multicontext_append_menuitems (GTK_IM_MULTICONTEXT (text_view->im_context),
+ gtk_im_multicontext_append_menuitems (GTK_IM_MULTICONTEXT (priv->im_context),
GTK_MENU_SHELL (submenu));
}
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);
+ gtk_menu_shell_append (GTK_MENU_SHELL (priv->popup_menu), menuitem);
_gtk_text_util_append_special_char_menuitems (GTK_MENU_SHELL (submenu),
unichar_chosen_func,
g_signal_emit (text_view,
signals[POPULATE_POPUP],
0,
- text_view->popup_menu);
+ priv->popup_menu);
if (info->button)
- gtk_menu_popup (GTK_MENU (text_view->popup_menu), NULL, NULL,
+ gtk_menu_popup (GTK_MENU (priv->popup_menu), NULL, NULL,
NULL, NULL,
info->button, info->time);
else
{
- gtk_menu_popup (GTK_MENU (text_view->popup_menu), NULL, NULL,
+ gtk_menu_popup (GTK_MENU (priv->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), FALSE);
+ gtk_menu_shell_select_first (GTK_MENU_SHELL (priv->popup_menu), FALSE);
}
}
text_window_realize (GtkTextWindow *win,
GtkWidget *widget)
{
+ GdkWindow *window;
GdkWindowAttr attributes;
gint attributes_mask;
GdkCursor *cursor;
attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;
- win->window = gdk_window_new (widget->window,
- &attributes,
- attributes_mask);
+ window = gtk_widget_get_window (widget);
+
+ win->window = gdk_window_new (window,
+ &attributes, attributes_mask);
gdk_window_set_back_pixmap (win->window, NULL, FALSE);
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),
+ cursor = gdk_cursor_new_for_display (gdk_drawable_get_display (window),
GDK_XTERM);
gdk_window_set_cursor (win->bin_window, cursor);
gdk_cursor_unref (cursor);
}
- gtk_im_context_set_client_window (GTK_TEXT_VIEW (widget)->im_context,
+ gtk_im_context_set_client_window (GTK_TEXT_VIEW (widget)->priv->im_context,
win->window);
gdk_window_set_background (win->bin_window,
- &widget->style->base[GTK_WIDGET_STATE (widget)]);
+ >k_widget_get_style (widget)->base[gtk_widget_get_state (widget)]);
}
else
{
gdk_window_set_background (win->bin_window,
- &widget->style->bg[GTK_WIDGET_STATE (widget)]);
+ >k_widget_get_style (widget)->bg[gtk_widget_get_state (widget)]);
}
g_object_set_qdata (G_OBJECT (win->window),
{
if (win->type == GTK_TEXT_WINDOW_TEXT)
{
- gtk_im_context_set_client_window (GTK_TEXT_VIEW (win->widget)->im_context,
+ gtk_im_context_set_client_window (GTK_TEXT_VIEW (win->widget)->priv->im_context,
NULL);
}
break;
default:
- g_warning ("%s: bug!", G_STRLOC);
+ g_warning ("%s: bug!", G_STRFUNC);
return;
break;
}
static void
text_window_invalidate_cursors (GtkTextWindow *win)
{
- GtkTextView *text_view = GTK_TEXT_VIEW (win->widget);
+ GtkTextView *text_view;
+ GtkTextViewPrivate *priv;
GtkTextIter iter;
GdkRectangle strong;
GdkRectangle weak;
gint stem_width;
gint arrow_width;
- gtk_text_buffer_get_iter_at_mark (text_view->buffer, &iter,
- gtk_text_buffer_get_insert (text_view->buffer));
+ text_view = GTK_TEXT_VIEW (win->widget);
+ priv = text_view->priv;
+
+ gtk_text_buffer_get_iter_at_mark (priv->buffer, &iter,
+ gtk_text_buffer_get_insert (priv->buffer));
+
+ if (_gtk_text_layout_get_block_cursor (priv->layout, &strong))
+ {
+ text_window_invalidate_rect (win, &strong);
+ return;
+ }
- gtk_text_layout_get_cursor_locations (text_view->layout, &iter,
+ gtk_text_layout_get_cursor_locations (priv->layout, &iter,
&strong, &weak);
/* cursor width calculation as in gtkstyle.c:draw_insertion_cursor(),
* 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,
GtkTextWindowType win)
{
+ GtkTextViewPrivate *priv = text_view->priv;
+
g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), NULL);
switch (win)
{
case GTK_TEXT_WINDOW_WIDGET:
- return GTK_WIDGET (text_view)->window;
+ return gtk_widget_get_window (GTK_WIDGET (text_view));
break;
case GTK_TEXT_WINDOW_TEXT:
- return text_view->text_window->bin_window;
+ return priv->text_window->bin_window;
break;
case GTK_TEXT_WINDOW_LEFT:
- if (text_view->left_window)
- return text_view->left_window->bin_window;
+ if (priv->left_window)
+ return priv->left_window->bin_window;
else
return NULL;
break;
case GTK_TEXT_WINDOW_RIGHT:
- if (text_view->right_window)
- return text_view->right_window->bin_window;
+ if (priv->right_window)
+ return priv->right_window->bin_window;
else
return NULL;
break;
case GTK_TEXT_WINDOW_TOP:
- if (text_view->top_window)
- return text_view->top_window->bin_window;
+ if (priv->top_window)
+ return priv->top_window->bin_window;
else
return NULL;
break;
case GTK_TEXT_WINDOW_BOTTOM:
- if (text_view->bottom_window)
- return text_view->bottom_window->bin_window;
+ if (priv->bottom_window)
+ return priv->bottom_window->bin_window;
else
return NULL;
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;
}
g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), 0);
g_return_val_if_fail (GDK_IS_WINDOW (window), 0);
- if (window == GTK_WIDGET (text_view)->window)
+ if (window == gtk_widget_get_window (GTK_WIDGET (text_view)))
return GTK_TEXT_WINDOW_WIDGET;
win = g_object_get_qdata (G_OBJECT (window),
gint buffer_y,
gint *window_x,
gint *window_y)
-{
+{
+ GtkTextViewPrivate *priv = text_view->priv;
+
if (window_x)
{
- *window_x = buffer_x - text_view->xoffset;
- *window_x += text_view->text_window->allocation.x;
+ *window_x = buffer_x - priv->xoffset;
+ *window_x += priv->text_window->allocation.x;
}
if (window_y)
{
- *window_y = buffer_y - text_view->yoffset;
- *window_y += text_view->text_window->allocation.y;
+ *window_y = buffer_y - priv->yoffset;
+ *window_y += priv->text_window->allocation.y;
}
}
* @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
+ * @window_x: (out) (allow-none): window x coordinate return location or %NULL
+ * @window_y: (out) (allow-none): window y coordinate return location or %NULL
*
* Converts coordinate (@buffer_x, @buffer_y) to coordinates for the window
* @win, and stores the result in (@window_x, @window_y).
gint *window_x,
gint *window_y)
{
+ GtkTextViewPrivate *priv = text_view->priv;
+
g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
switch (win)
case GTK_TEXT_WINDOW_TEXT:
if (window_x)
- *window_x = buffer_x - text_view->xoffset;
+ *window_x = buffer_x - priv->xoffset;
if (window_y)
- *window_y = buffer_y - text_view->yoffset;
+ *window_y = buffer_y - priv->yoffset;
break;
case GTK_TEXT_WINDOW_LEFT:
buffer_to_text_window (text_view,
- text_view->left_window,
+ priv->left_window,
buffer_x, buffer_y,
window_x, window_y);
break;
case GTK_TEXT_WINDOW_RIGHT:
buffer_to_text_window (text_view,
- text_view->right_window,
+ priv->right_window,
buffer_x, buffer_y,
window_x, window_y);
break;
case GTK_TEXT_WINDOW_TOP:
buffer_to_text_window (text_view,
- text_view->top_window,
+ priv->top_window,
buffer_x, buffer_y,
window_x, window_y);
break;
case GTK_TEXT_WINDOW_BOTTOM:
buffer_to_text_window (text_view,
- text_view->bottom_window,
+ priv->bottom_window,
buffer_x, buffer_y,
window_x, window_y);
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;
}
}
gint widget_y,
gint *buffer_x,
gint *buffer_y)
-{
+{
+ GtkTextViewPrivate *priv = text_view->priv;
+
if (buffer_x)
{
- *buffer_x = widget_x + text_view->xoffset;
- *buffer_x -= text_view->text_window->allocation.x;
+ *buffer_x = widget_x + priv->xoffset;
+ *buffer_x -= priv->text_window->allocation.x;
}
if (buffer_y)
{
- *buffer_y = widget_y + text_view->yoffset;
- *buffer_y -= text_view->text_window->allocation.y;
+ *buffer_y = widget_y + priv->yoffset;
+ *buffer_y -= priv->text_window->allocation.y;
}
}
* @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
- * @buffer_y: buffer y coordinate return location
+ * @buffer_x: (out) (allow-none): buffer x coordinate return location or %NULL
+ * @buffer_y: (out) (allow-none): buffer y coordinate return location or %NULL
*
* Converts coordinates on the window identified by @win to buffer
* coordinates, storing the result in (@buffer_x,@buffer_y).
gint *buffer_x,
gint *buffer_y)
{
+ GtkTextViewPrivate *priv = text_view->priv;
+
g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
switch (win)
case GTK_TEXT_WINDOW_TEXT:
if (buffer_x)
- *buffer_x = window_x + text_view->xoffset;
+ *buffer_x = window_x + priv->xoffset;
if (buffer_y)
- *buffer_y = window_y + text_view->yoffset;
+ *buffer_y = window_y + priv->yoffset;
break;
case GTK_TEXT_WINDOW_LEFT:
text_window_to_buffer (text_view,
- text_view->left_window,
+ priv->left_window,
window_x, window_y,
buffer_x, buffer_y);
break;
case GTK_TEXT_WINDOW_RIGHT:
text_window_to_buffer (text_view,
- text_view->right_window,
+ priv->right_window,
window_x, window_y,
buffer_x, buffer_y);
break;
case GTK_TEXT_WINDOW_TOP:
text_window_to_buffer (text_view,
- text_view->top_window,
+ priv->top_window,
window_x, window_y,
buffer_x, buffer_y);
break;
case GTK_TEXT_WINDOW_BOTTOM:
text_window_to_buffer (text_view,
- text_view->bottom_window,
+ priv->bottom_window,
window_x, window_y,
buffer_x, buffer_y);
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;
}
}
GTK_WIDGET (text_view),
width, 0);
/* if the widget is already realized we need to realize the child manually */
- if (GTK_WIDGET_REALIZED (text_view))
+ if (gtk_widget_get_realized (GTK_WIDGET (text_view)))
text_window_realize (*winp, GTK_WIDGET (text_view));
}
else
0, height);
/* if the widget is already realized we need to realize the child manually */
- if (GTK_WIDGET_REALIZED (text_view))
+ if (gtk_widget_get_realized (GTK_WIDGET (text_view)))
text_window_realize (*winp, GTK_WIDGET (text_view));
}
else
gtk_text_view_set_border_window_size (GtkTextView *text_view,
GtkTextWindowType type,
gint size)
-
{
+ GtkTextViewPrivate *priv = text_view->priv;
+
g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
g_return_if_fail (size >= 0);
{
case GTK_TEXT_WINDOW_LEFT:
set_window_width (text_view, size, GTK_TEXT_WINDOW_LEFT,
- &text_view->left_window);
+ &priv->left_window);
break;
case GTK_TEXT_WINDOW_RIGHT:
set_window_width (text_view, size, GTK_TEXT_WINDOW_RIGHT,
- &text_view->right_window);
+ &priv->right_window);
break;
case GTK_TEXT_WINDOW_TOP:
set_window_height (text_view, size, GTK_TEXT_WINDOW_TOP,
- &text_view->top_window);
+ &priv->top_window);
break;
case GTK_TEXT_WINDOW_BOTTOM:
set_window_height (text_view, size, GTK_TEXT_WINDOW_BOTTOM,
- &text_view->bottom_window);
+ &priv->bottom_window);
break;
default:
gtk_text_view_get_border_window_size (GtkTextView *text_view,
GtkTextWindowType type)
{
+ GtkTextViewPrivate *priv = text_view->priv;
+
g_return_val_if_fail (GTK_IS_TEXT_VIEW (text_view), 0);
switch (type)
{
case GTK_TEXT_WINDOW_LEFT:
- if (text_view->left_window)
- return text_view->left_window->requisition.width;
+ if (priv->left_window)
+ return priv->left_window->requisition.width;
break;
case GTK_TEXT_WINDOW_RIGHT:
- if (text_view->right_window)
- return text_view->right_window->requisition.width;
+ if (priv->right_window)
+ return priv->right_window->requisition.width;
break;
case GTK_TEXT_WINDOW_TOP:
- if (text_view->top_window)
- return text_view->top_window->requisition.height;
+ if (priv->top_window)
+ return priv->top_window->requisition.height;
break;
case GTK_TEXT_WINDOW_BOTTOM:
- if (text_view->bottom_window)
- return text_view->bottom_window->requisition.height;
+ if (priv->bottom_window)
+ return priv->bottom_window->requisition.height;
break;
default:
{
if (vc->anchor)
gtk_widget_set_parent_window (vc->widget,
- text_view->text_window->bin_window);
+ text_view->priv->text_window->bin_window);
else
{
GdkWindow *window;
add_child (GtkTextView *text_view,
GtkTextViewChild *vc)
{
- text_view->children = g_slist_prepend (text_view->children,
- vc);
+ text_view->priv->children = g_slist_prepend (text_view->priv->children,
+ vc);
- if (GTK_WIDGET_REALIZED (text_view))
+ if (gtk_widget_get_realized (GTK_WIDGET (text_view)))
text_view_child_set_parent_window (text_view, vc);
gtk_widget_set_parent (vc->widget, GTK_WIDGET (text_view));
* @anchor: a #GtkTextChildAnchor in the #GtkTextBuffer for @text_view
*
* Adds a child widget in the text buffer, at the given @anchor.
- *
**/
void
gtk_text_view_add_child_at_anchor (GtkTextView *text_view,
g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
g_return_if_fail (GTK_IS_WIDGET (child));
g_return_if_fail (GTK_IS_TEXT_CHILD_ANCHOR (anchor));
- g_return_if_fail (child->parent == NULL);
+ g_return_if_fail (gtk_widget_get_parent (child) == NULL);
gtk_text_view_ensure_layout (text_view);
vc = text_view_child_new_anchored (child, anchor,
- text_view->layout);
+ text_view->priv->layout);
add_child (text_view, vc);
* @ypos: Y position of child in window coordinates
*
* Adds a child at fixed coordinates in one of the text widget's
- * windows. The window must have nonzero size (see
- * gtk_text_view_set_border_window_size()). Note that the child
+ * windows. The window must have nonzero size (see
+ * gtk_text_view_set_border_window_size()). Note that the child
* coordinates are given relative to the #GdkWindow in question, and
* that these coordinates have no sane relationship to scrolling. When
* placing a child in #GTK_TEXT_WINDOW_WIDGET, scrolling is
* would be to update all child positions when the scroll adjustments
* change or the text buffer changes. See bug 64518 on
* bugzilla.gnome.org for status of fixing this issue.
- *
**/
void
-gtk_text_view_add_child_in_window (GtkTextView *text_view,
- GtkWidget *child,
- GtkTextWindowType which_window,
- gint xpos,
- gint ypos)
+gtk_text_view_add_child_in_window (GtkTextView *text_view,
+ GtkWidget *child,
+ GtkTextWindowType which_window,
+ gint xpos,
+ gint ypos)
{
GtkTextViewChild *vc;
g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
g_return_if_fail (GTK_IS_WIDGET (child));
- g_return_if_fail (child->parent == NULL);
+ g_return_if_fail (gtk_widget_get_parent (child) == NULL);
vc = text_view_child_new_window (child, which_window,
xpos, ypos);
* @ypos: new Y position in window coordinates
*
* Updates the position of a child, as for gtk_text_view_add_child_in_window().
- *
**/
void
-gtk_text_view_move_child (GtkTextView *text_view,
- GtkWidget *child,
- gint xpos,
- gint ypos)
+gtk_text_view_move_child (GtkTextView *text_view,
+ GtkWidget *child,
+ gint xpos,
+ gint ypos)
{
GtkTextViewChild *vc;
g_return_if_fail (GTK_IS_TEXT_VIEW (text_view));
g_return_if_fail (GTK_IS_WIDGET (child));
- g_return_if_fail (child->parent == (GtkWidget*) text_view);
+ g_return_if_fail (gtk_widget_get_parent (child) == GTK_WIDGET (text_view));
vc = g_object_get_data (G_OBJECT (child),
"gtk-text-view-child");
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);
}
* @text_view: a #GtkTextView
* @iter: a #GtkTextIter
*
- * Moves the given @iter forward by one display (wrapped) line. A
- * display line is different from a paragraph. Paragraphs are
+ * Moves the given @iter forward by one display (wrapped) line.
+ * A display line is different from a paragraph. Paragraphs are
* separated by newlines or other paragraph separator characters.
- * Display lines are created by line-wrapping a paragraph. If
+ * Display lines are created by line-wrapping a paragraph. If
* wrapping is turned off, display lines and paragraphs will be the
* same. Display lines are divided differently for each view, since
* they depend on the view's width; paragraphs are the same in all
gtk_text_view_ensure_layout (text_view);
- return gtk_text_layout_move_iter_to_next_line (text_view->layout, iter);
+ return gtk_text_layout_move_iter_to_next_line (text_view->priv->layout, iter);
}
/**
* @text_view: a #GtkTextView
* @iter: a #GtkTextIter
*
- * Moves the given @iter backward by one display (wrapped) line. A
- * display line is different from a paragraph. Paragraphs are
+ * Moves the given @iter backward by one display (wrapped) line.
+ * A display line is different from a paragraph. Paragraphs are
* separated by newlines or other paragraph separator characters.
- * Display lines are created by line-wrapping a paragraph. If
+ * Display lines are created by line-wrapping a paragraph. If
* wrapping is turned off, display lines and paragraphs will be the
* same. Display lines are divided differently for each view, since
* they depend on the view's width; paragraphs are the same in all
gtk_text_view_ensure_layout (text_view);
- return gtk_text_layout_move_iter_to_previous_line (text_view->layout, iter);
+ return gtk_text_layout_move_iter_to_previous_line (text_view->priv->layout, iter);
}
/**
* @text_view: a #GtkTextView
* @iter: a #GtkTextIter
*
- * Moves the given @iter forward to the next display line end. A
- * display line is different from a paragraph. Paragraphs are
+ * Moves the given @iter forward to the next display line end.
+ * A display line is different from a paragraph. Paragraphs are
* separated by newlines or other paragraph separator characters.
- * Display lines are created by line-wrapping a paragraph. If
+ * Display lines are created by line-wrapping a paragraph. If
* wrapping is turned off, display lines and paragraphs will be the
* same. Display lines are divided differently for each view, since
* they depend on the view's width; paragraphs are the same in all
gtk_text_view_ensure_layout (text_view);
- return gtk_text_layout_move_iter_to_line_end (text_view->layout, iter, 1);
+ return gtk_text_layout_move_iter_to_line_end (text_view->priv->layout, iter, 1);
}
/**
* @text_view: a #GtkTextView
* @iter: a #GtkTextIter
*
- * Moves the given @iter backward to the next display line start. A
- * display line is different from a paragraph. Paragraphs are
+ * Moves the given @iter backward to the next display line start.
+ * A display line is different from a paragraph. Paragraphs are
* separated by newlines or other paragraph separator characters.
- * Display lines are created by line-wrapping a paragraph. If
+ * Display lines are created by line-wrapping a paragraph. If
* wrapping is turned off, display lines and paragraphs will be the
* same. Display lines are divided differently for each view, since
* they depend on the view's width; paragraphs are the same in all
gtk_text_view_ensure_layout (text_view);
- return gtk_text_layout_move_iter_to_line_end (text_view->layout, iter, -1);
+ return gtk_text_layout_move_iter_to_line_end (text_view->priv->layout, iter, -1);
}
/**
gtk_text_view_ensure_layout (text_view);
- return gtk_text_layout_iter_starts_line (text_view->layout, iter);
+ return gtk_text_layout_iter_starts_line (text_view->priv->layout, iter);
}
/**
* gtk_text_view_move_visually:
* @text_view: a #GtkTextView
* @iter: a #GtkTextIter
- * @count: number of characters to move (negative moves left, positive moves right)
+ * @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
* cursor position will be @count positions to the left of the old
* cursor position.
*
- * In the presence of bidirection text, the correspondence
+ * In the presence of bi-directional 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.
gtk_text_view_ensure_layout (text_view);
- return gtk_text_layout_move_iter_visually (text_view->layout, iter, count);
+ return gtk_text_layout_move_iter_visually (text_view->priv->layout, iter, count);
}
-
-#define __GTK_TEXT_VIEW_C__
-#include "gtkaliasdef.c"
projects / ~andy / gtk / blobdiff