/* -*- Mode: C; c-file-style: "gnu"; tab-width: 8 -*- */ /* GTK - The GIMP Toolkit * gtktextview . c Copyright ( C ) 2000 Red Hat , Inc . * * This library is free software ; you can redistribute it and / or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation ; either * version 2 of the License , or ( at your option ) any later version . * * This library is distributed in the hope that it will be useful , * but WITHOUT ANY WARRANTY ; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the GNU * Lesser General Public License for more details . * * You should have received a copy of the GNU Lesser General Public * License along with this library . If not , see < http : //www.gnu.org/licenses/>. /* * Modified by the GTK + Team and others 1997 - 2000 . See the AUTHORS * file for a list of people on the GTK + Team . See the ChangeLog * files for a list of changes . These files are distributed with * GTK + at ftp : //ftp.gtk.org/pub/gtk/. #include "config.h" #include "gtktextviewprivate.h" #include <string.h>#include <glib/gi18n-lib.h>#include "gtkaccessibletextprivate.h" #include "gtkadjustmentprivate.h" #include "gtkcsscolorvalueprivate.h" #include "gtkcssenumvalueprivate.h" #include "gtkcsslineheightvalueprivate.h" #include "gtkdebug.h" #include "gtkdragsourceprivate.h" #include "gtkdropcontrollermotion.h" #include "gtkemojichooser.h" #include "gtkimcontextprivate.h" #include "gtkimmulticontext.h" #include "gtkjoinedmenuprivate.h" #include "gtkmagnifierprivate.h" #include "gtkmain.h" #include "gtkmarshalers.h" #include "gtknative.h" #include "gtkpangoprivate.h" #include "gtkrenderbackgroundprivate.h" #include "gtkrenderborderprivate.h" #include "gtkscrollable.h" #include "gtksettings.h" #include "gtkshortcut.h" #include "gtkshortcuttrigger.h" #include "gtksnapshot.h" #include "gtktextiterprivate.h" #include "gtktexthandleprivate.h" #include "gtktextviewchildprivate.h" #include "gtkpopover.h" #include "gtkprivate.h" #include "gtktextbufferprivate.h" #include "gtktextutilprivate.h" #include "gtktypebuiltins.h" #include "gtkwidgetprivate.h" #include "gtkwindow.h" /** * GtkTextView : * * Displays the contents of a [ class @ Gtk . TextBuffer ] . * * < picture > * < source srcset = " multiline - text - dark . png " media = " ( prefers - color - scheme : dark ) " > * < img alt = " An example GtkTextView " src = " multiline - text . png " > * < / picture > * * You may wish to begin by reading the [ conceptual overview ] ( section - text - widget . html ) , * which gives an overview of all the objects and data types related to the * text widget and how they work together . * * # # Shortcuts and Gestures * * ` GtkTextView ` supports the following keyboard shortcuts : * * - < kbd > Shift < / kbd > + < kbd > F10 < / kbd > or < kbd > Menu < / kbd > opens the context menu . * - < kbd > Ctrl < / kbd > + < kbd > Z < / kbd > undoes the last modification . * - < kbd > Ctrl < / kbd > + < kbd > Y < / kbd > or < kbd > Ctrl < / kbd > + < kbd > Shift < / kbd > + < kbd > Z < / kbd > * redoes the last undone modification . * - < kbd > Clear < / kbd > clears the content . * * Additionally , the following signals have default keybindings : * * - [ signal @ Gtk . TextView : : backspace ] * - [ signal @ Gtk . TextView : : copy - clipboard ] * - [ signal @ Gtk . TextView : : cut - clipboard ] * - [ signal @ Gtk . TextView : : delete - from - cursor ] * - [ signal @ Gtk . TextView : : insert - emoji ] * - [ signal @ Gtk . TextView : : move - cursor ] * - [ signal @ Gtk . TextView : : paste - clipboard ] * - [ signal @ Gtk . TextView : : select - all ] * - [ signal @ Gtk . TextView : : toggle - cursor - visible ] * - [ signal @ Gtk . TextView : : toggle - overwrite ] * * # # Actions * * ` GtkTextView ` defines a set of built - in actions : * * - ` clipboard . copy ` copies the contents to the clipboard . * - ` clipboard . cut ` copies the contents to the clipboard and deletes it from * the widget . * - ` clipboard . paste ` inserts the contents of the clipboard into the widget . * - ` menu . popup ` opens the context menu . * - ` misc . insert - emoji ` opens the Emoji chooser . * - ` selection . delete ` deletes the current selection . * - ` selection . select - all ` selects all of the widgets content . * - ` text . redo ` redoes the last change to the contents . * - ` text . undo ` undoes the last change to the contents . * - ` text . clear ` clears the content . * * # # CSS nodes * * ` ` ` * textview . view * ├ ─ ─ border . top * ├ ─ ─ border . left * ├ ─ ─ text * │ ├ ─ ─ [ preedit [ . whole ] [ . selection ] [ . prediction ] [ . prefix / . suffix ] [ . spelling - error ] [ . compose - error ] ] * │ ╰ ─ ─ [ selection ] * ├ ─ ─ border . right * ├ ─ ─ border . bottom * ╰ ─ ─ [ window . popup ] * ` ` ` * * ` GtkTextView ` has a main css node with name textview and style class . view , * and subnodes for each of the border windows , and the main text area , * with names border and text , respectively . The border nodes each get * one of the style classes . left , . right , . top or . bottom . * * A node representing the selection will appear below the text node . * * If a context menu is opened , the window node will appear as a subnode * of the main node . * * If using an input method with a pre - edit buffer , this string will be styled * with a ` preedit ` subnode of the ` text ` node . the different style classes * express the possible roles of a piece of text in the pre - edit buffer : * * - ` . whole ` denotes the parts of the pre - edit buffer without a special role * - ` . selection ` , ` . prefix ` and ` . suffix ` style classes will be used to * highlight the specific portions of the pre - edit buffer being edited and its * surroundings * - ` . prediction ` will be used for parts of the pre - edit buffer not typed by the * user ( e . g . autocompletion ) * - ` . spelling - error ` and ` . compose - error ` will be respectively used to indicate * errors in spelling or character composition ( e . g . non - existent transliterations ) . * * # # Accessibility * * ` GtkTextView ` uses the [ enum @ Gtk . AccessibleRole . text_box ] role . /* How scrolling, validation, exposes, etc. work. * * The expose_event handler has the invariant that the onscreen lines * have been validated . * * There are two ways that onscreen lines can become invalid . The first * is to change which lines are onscreen . This happens when the value * of a scroll adjustment changes . So the code path begins in * gtk_text_view_value_changed ( ) and goes like this : * - gdk_surface_scroll ( ) to reflect the new adjustment value * - validate the lines that were moved onscreen * - gdk_surface_process_updates ( ) to handle the exposes immediately * * The second way is that you get the “ invalidated ” signal from the layout , * indicating that lines have become invalid . This code path begins in * invalidated_handler ( ) and goes like this : * - install high - priority idle which does the rest of the steps * - if a scroll is pending from scroll_to_mark ( ) , do the scroll , * jumping to the gtk_text_view_value_changed ( ) code path * - otherwise , validate the onscreen lines * - DO NOT process updates * * In both cases , validating the onscreen lines can trigger a scroll * due to maintaining the first_para on the top of the screen . * If validation triggers a scroll , we jump to the top of the code path * for value_changed , and bail out of the current code path . * * Also , in size_allocate , if we invalidate some lines from changing * the layout width , we need to go ahead and run the high - priority idle , * because GTK sends exposes right after doing the size allocates without * returning to the main loop . This is also why the high - priority idle * is at a higher priority than resizing . * #if 0 #define DEBUG_VALIDATION_AND_SCROLLING#endif #ifdef DEBUG_VALIDATION_AND_SCROLLING#define DV(x) (x)#else #define DV(x)#endif #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 _GtkTextWindow GtkTextWindow;typedef struct _GtkTextPendingScroll GtkTextPendingScroll;enum struct _GtkTextViewPrivate/* time in msec the cursor has blinked since last user event */ char *im_module;int dnd_x;int dnd_y;/* X offset between widget coordinates and buffer coordinates double xoffset;/* Y offset between widget coordinates and buffer coordinates * taking top_margin in account double yoffset;/* Width and height of the buffer */ int width;int height;/* 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 . int virtual_cursor_x; /* -1 means use actual cursor position */ int virtual_cursor_y; /* -1 means use actual cursor position */ /* Mark at the beginning of the first onscreen paragraph */ int first_para_pixels; /* Offset of top of screen in the first onscreen paragraph */ float cursor_alpha;/* Idle to revalidate onscreen portion, runs before resize */ /* Idle to revalidate offscreen portions, runs after redraw */ /* Mark for drop target */ /* Mark for selection of drag source */ /* Default style settings */ int pixels_above_lines;int pixels_below_lines;int pixels_inside_wrap;int left_margin;int right_margin;int top_margin;int bottom_margin;int indent;1 ;1 ;1 ;/* if we have reset the IM since the last character entered */ 1 ;1 ;/* debug flag - means that we've validated onscreen since the * last " invalidate " signal from the layout 1 ;1 ;1 ;1 ;/* GtkScrollablePolicy needs to be checked when 1 ;1 ;1 ;1 ;1 ;struct _GtkTextPendingScrolldouble within_margin;double xalign;double yalign;typedef enum enum enum /* GtkScrollable */ static GParamSpec *props[N_PROPS] = { NULL, };static GQuark quark_text_selection_data = 0 ;static GQuark quark_gtk_signal = 0 ;static GQuark quark_text_view_child = 0 ;static void gtk_text_view_finalize (GObject *object);static void gtk_text_view_set_property (GObject *object,const GValue *value,static void gtk_text_view_get_property (GObject *object,static void gtk_text_view_dispose (GObject *object);static void gtk_text_view_measure (GtkWidget *widget,int for_size,int *minimum,int *natural,int *minimum_baseline,int *natural_baseline);static void gtk_text_view_size_allocate (GtkWidget *widget,int width,int height,int baseline);static void gtk_text_view_realize (GtkWidget *widget);static void gtk_text_view_unrealize (GtkWidget *widget);static void gtk_text_view_map (GtkWidget *widget);static void gtk_text_view_css_changed (GtkWidget *widget,static void gtk_text_view_direction_changed (GtkWidget *widget,static void gtk_text_view_system_setting_changed (GtkWidget *widget,static void gtk_text_view_state_flags_changed (GtkWidget *widget,static void gtk_text_view_click_gesture_pressed (GtkGestureClick *gesture,int n_press,double x,double y,static void gtk_text_view_click_gesture_released (GtkGestureClick *gesture,int n_press,double x,double y,static void gtk_text_view_drag_gesture_update (GtkGestureDrag *gesture,double offset_x,double offset_y,static void gtk_text_view_drag_gesture_end (GtkGestureDrag *gesture,double offset_x,double offset_y,static gboolean gtk_text_view_key_controller_key_pressed (GtkEventControllerKey *controller,static void gtk_text_view_key_controller_im_update (GtkEventControllerKey *controller,static void gtk_text_view_focus_in (GtkWidget *widget);static void gtk_text_view_focus_out (GtkWidget *widget);static void gtk_text_view_motion (GtkEventController *controller,double x,double y,static void gtk_text_view_snapshot (GtkWidget *widget,static void gtk_text_view_select_all (GtkWidget *widget,static gboolean get_middle_click_paste (GtkTextView *text_view);static GtkTextBuffer* gtk_text_view_create_buffer (GtkTextView *text_view);/* Target side drag signals */ static void gtk_text_view_drag_leave (GtkDropTarget *dest,static GdkDragActiondouble x,double y,static gboolean gtk_text_view_drag_drop (GtkDropTarget *dest,const GValue *value,double x,double y,static void gtk_text_view_popup_menu (GtkWidget *widget,const char *action_name,static void gtk_text_view_move_cursor (GtkTextView *text_view,int count,static void gtk_text_view_move_viewport (GtkTextView *text_view,int count);static void gtk_text_view_set_anchor (GtkTextView *text_view);static gboolean gtk_text_view_scroll_pages (GtkTextView *text_view,int count,static gboolean gtk_text_view_scroll_hpages(GtkTextView *text_view,int count,static void gtk_text_view_insert_at_cursor (GtkTextView *text_view,const char *str);static void gtk_text_view_delete_from_cursor (GtkTextView *text_view,int count);static void gtk_text_view_backspace (GtkTextView *text_view);static void gtk_text_view_cut_clipboard (GtkTextView *text_view);static void gtk_text_view_copy_clipboard (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_unselect (GtkTextView *text_view);static void gtk_text_view_validate_onscreen (GtkTextView *text_view);static void gtk_text_view_get_first_para_iter (GtkTextView *text_view,static void gtk_text_view_update_layout_width (GtkTextView *text_view);static void gtk_text_view_set_attributes_from_style (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_start_selection_drag (GtkTextView *text_view,const GtkTextIter *iter,static gboolean gtk_text_view_end_selection_drag (GtkTextView *text_view);static void gtk_text_view_start_selection_dnd (GtkTextView *text_view,const GtkTextIter *iter,int x,int y);static void gtk_text_view_check_cursor_blink (GtkTextView *text_view);static void gtk_text_view_pend_cursor_blink (GtkTextView *text_view);static void gtk_text_view_stop_cursor_blink (GtkTextView *text_view);static void gtk_text_view_reset_blink_time (GtkTextView *text_view);static void gtk_text_view_value_changed (GtkAdjustment *adjustment,static void gtk_text_view_commit_handler (GtkIMContext *context,const char *str,static void gtk_text_view_commit_text (GtkTextView *text_view,const char *text,static void gtk_text_view_preedit_start_handler (GtkIMContext *context,static void gtk_text_view_preedit_changed_handler (GtkIMContext *context,static gboolean gtk_text_view_retrieve_surrounding_handler (GtkIMContext *context,static gboolean gtk_text_view_delete_surrounding_handler (GtkIMContext *context,int offset,int n_chars,static void gtk_text_view_mark_set_handler (GtkTextBuffer *buffer,const GtkTextIter *location,static void gtk_text_view_paste_done_handler (GtkTextBuffer *buffer,static void gtk_text_view_buffer_changed_handler (GtkTextBuffer *buffer,static void gtk_text_view_insert_text_handler (GtkTextBuffer *buffer,char *text,int len,static void gtk_text_view_delete_range_handler (GtkTextBuffer *buffer,static void gtk_text_view_update_redo_action (GtkTextView *view);static void gtk_text_view_update_undo_action (GtkTextView *view);static void gtk_text_view_get_virtual_cursor_pos (GtkTextView *text_view,int *x,int *y);static void gtk_text_view_set_virtual_cursor_pos (GtkTextView *text_view,int x,int y);static void gtk_text_view_do_popup (GtkTextView *text_view,static void cancel_pending_scroll (GtkTextView *text_view);static void gtk_text_view_queue_scroll (GtkTextView *text_view,double within_margin,double xalign,double yalign);static gboolean gtk_text_view_flush_scroll (GtkTextView *text_view);static void gtk_text_view_update_adjustments (GtkTextView *text_view);static void gtk_text_view_invalidate (GtkTextView *text_view);static void gtk_text_view_flush_first_validate (GtkTextView *text_view);static void gtk_text_view_set_hadjustment (GtkTextView *text_view,static void gtk_text_view_set_vadjustment (GtkTextView *text_view,static void gtk_text_view_set_hadjustment_values (GtkTextView *text_view);static void gtk_text_view_set_vadjustment_values (GtkTextView *text_view);static void gtk_text_view_update_im_spot_location (GtkTextView *text_view);static void gtk_text_view_insert_emoji (GtkTextView *text_view);static void update_node_ordering (GtkWidget *widget);static void gtk_text_view_update_pango_contexts (GtkTextView *text_view);/* GtkTextHandle handlers */ static void gtk_text_view_handle_drag_started (GtkTextHandle *handle,static void gtk_text_view_handle_dragged (GtkTextHandle *handle,int x,int y,static void gtk_text_view_handle_drag_finished (GtkTextHandle *handle,static void gtk_text_view_update_handles (GtkTextView *text_view);static void gtk_text_view_selection_bubble_popup_unset (GtkTextView *text_view);static void gtk_text_view_selection_bubble_popup_set (GtkTextView *text_view);static gboolean gtk_text_view_extend_selection (GtkTextView *text_view,const GtkTextIter *location,static void extend_selection (GtkTextView *text_view,const GtkTextIter *location,static void gtk_text_view_update_clipboard_actions (GtkTextView *text_view);static void gtk_text_view_update_emoji_action (GtkTextView *text_view);static void gtk_text_view_update_clear_action (GtkTextView *text_view);static void gtk_text_view_activate_clipboard_cut (GtkWidget *widget,const char *action_name,static void gtk_text_view_activate_clipboard_copy (GtkWidget *widget,const char *action_name,static void gtk_text_view_activate_clipboard_paste (GtkWidget *widget,const char *action_name,static void gtk_text_view_activate_selection_delete (GtkWidget *widget,const char *action_name,static void gtk_text_view_activate_selection_select_all (GtkWidget *widget,const char *action_name,static void gtk_text_view_activate_misc_insert_emoji (GtkWidget *widget,const char *action_name,static void gtk_text_view_clear (GtkWidget *widget,const char *action_name,static void gtk_text_view_real_undo (GtkWidget *widget,const char *action_name,static void gtk_text_view_real_redo (GtkWidget *widget,const char *action_name,static double quantize_value (GtkAdjustment *adjustment,/* FIXME probably need the focus methods. */ typedef struct int from_top_of_line;int from_left_of_buffer;static AnchoredChild *anchored_child_new (GtkWidget *child,static void anchored_child_free (AnchoredChild *child);struct _GtkTextWindowstatic GtkTextWindow *text_window_new (GtkWidget *widget);static void text_window_free (GtkTextWindow *win);static void text_window_size_allocate (GtkTextWindow *win,static int text_window_get_width (GtkTextWindow *win);static int text_window_get_height (GtkTextWindow *win);static guint signals[LAST_SIGNAL] = { 0 };static void gtk_text_view_accessible_text_init (GtkAccessibleTextInterface *iface);static GtkTextBuffer*if (text_view->priv->buffer == NULL)return text_view->priv->buffer;#define UPPER_OFFSET_ANCHOR 0 .8 #define LOWER_OFFSET_ANCHOR 0 .2 static gbooleandouble offset, GtkAdjustment *adjustment)if ((offset > UPPER_OFFSET_ANCHOR &&_adjustment_get_upper (adjustment)) ||return TRUE ;return FALSE ;static int double pointer_xoffset, pointer_yoffset;double ) priv->dnd_x / text_window_get_width (priv->text_window);double ) priv->dnd_y / text_window_get_height (priv->text_window);if (check_scroll (pointer_xoffset, priv->hadjustment) ||/* do not make offsets surpass lower nor upper anchors, this makes * scrolling speed relative to the distance of the pointer to the * anchors when it moves beyond them . 0 ., TRUE , pointer_xoffset, pointer_yoffset);return G_SOURCE_CONTINUE;static void double x,double y,if (x < target_rect.x ||1 ;return ;/* DnD uses text window coords, so subtract extra widget * coords that happen e . g . when displaying line numbers . if (!priv->scroll_timeout)100 , gtk_text_view_drop_motion_scroll_timeout, self);"[gtk] gtk_text_view_drop_motion_scroll_timeout" );static void 1 ;static void int count)const guint *keys;0 );if (keys == NULL)1 ;for (unsigned int i = 0 ; i < n_keys; i++)"move-cursor" ,"(iib)" , step, count, FALSE );/* Selection-extending version */ "move-cursor" ,"(iib)" , step, count, TRUE );static void if (pspec->name == I_("has-focus" ))if (G_OBJECT_CLASS (gtk_text_view_parent_class)->notify)static void if (gtk_css_style_change_affects (change, GTK_CSS_AFFECTS_REDRAW))TRUE ;static void /* Default handlers and virtual methods /* * Properties /** * GtkTextView : pixels - above - lines : * * Pixels of blank space above paragraphs . "pixels-above-lines" , NULL, NULL,0 , G_MAXINT, 0 ,/** * GtkTextView : pixels - below - lines : * * Pixels of blank space below paragraphs . "pixels-below-lines" , NULL, NULL,0 , G_MAXINT, 0 ,/** * GtkTextView : pixels - inside - wrap : * * Pixels of blank space between wrapped lines in a paragraph . "pixels-inside-wrap" , NULL, NULL,0 , G_MAXINT, 0 ,/** * GtkTextView : editable : * * Whether the text can be modified by the user . "editable" , NULL, NULL,TRUE ,/** * GtkTextView : wrap - mode : * * Whether to wrap lines never , at word boundaries , or at character boundaries . "wrap-mode" , NULL, NULL,/** * GtkTextView : justification : * * Left , right , or center justification . "justification" , NULL, NULL,/** * GtkTextView : left - margin : * * The default left margin for text in the text view . * * Tags in the buffer may override the default . * * Note that this property is confusingly named . In CSS terms , * the value set here is padding , and it is applied in addition * to the padding from the theme . "left-margin" , NULL, NULL,0 , G_MAXINT, 0 ,/** * GtkTextView : right - margin : * * The default right margin for text in the text view . * * Tags in the buffer may override the default . * * Note that this property is confusingly named . In CSS terms , * the value set here is padding , and it is applied in addition * to the padding from the theme . "right-margin" , NULL, NULL,0 , G_MAXINT, 0 ,/** * GtkTextView : top - margin : * * The top margin for text in the text view . * * Note that this property is confusingly named . In CSS terms , * the value set here is padding , and it is applied in addition * to the padding from the theme . * * Don ' t confuse this property with [ property @ Gtk . Widget : margin - top ] . "top-margin" , NULL, NULL,0 , G_MAXINT, 0 ,/** * GtkTextView : bottom - margin : * * The bottom margin for text in the text view . * * Note that this property is confusingly named . In CSS terms , * the value set here is padding , and it is applied in addition * to the padding from the theme . * * Don ' t confuse this property with [ property @ Gtk . Widget : margin - bottom ] . "bottom-margin" , NULL, NULL,0 , G_MAXINT, 0 ,/** * GtkTextView : indent : * * Amount to indent the paragraph , in pixels . * * A negative value of indent will produce a hanging indentation . * That is , the first line will have the full width , and subsequent * lines will be indented by the absolute value of indent . * "indent" , NULL, NULL,0 ,/** * GtkTextView : tabs : * * Custom tabs for this text . "tabs" , NULL, NULL,/** * GtkTextView : cursor - visible : * * If the insertion cursor is shown . "cursor-visible" , NULL, NULL,TRUE ,/** * GtkTextView : buffer : * * The buffer which is displayed . "buffer" , NULL, NULL,/** * GtkTextView : overwrite : * * Whether entered text overwrites existing contents . "overwrite" , NULL, NULL,FALSE ,/** * GtkTextView : accepts - tab : * * Whether Tab will result in a tab character being entered . "accepts-tab" , NULL, NULL,TRUE ,/** * GtkTextView : im - module : * * Which IM ( input method ) module should be used for this text_view . * * See [ class @ Gtk . IMMulticontext ] . * * Setting this to a non - % NULL value overrides the system - wide IM module * setting . See the GtkSettings [ property @ Gtk . Settings : gtk - im - module ] property . "im-module" , NULL, NULL,/** * GtkTextView : input - purpose : * * The purpose of this text field . * * This property can be used by on - screen keyboards and other input * methods to adjust their behaviour . "input-purpose" , NULL, NULL,/** * GtkTextView : input - hints : * * Additional hints ( beyond [ property @ Gtk . TextView : input - purpose ] ) * that allow input methods to fine - tune their behaviour . "input-hints" , NULL, NULL,/** * GtkTextView : monospace : * * Whether text should be displayed in a monospace font . * * If % TRUE , set the . monospace style class on the * text view to indicate that a monospace font is desired . "monospace" , NULL, NULL,FALSE ,/** * GtkTextView : extra - menu : * * A menu model whose contents will be appended to the context menu . "extra-menu" , NULL, NULL,/* GtkScrollable interface */ "hadjustment" ,"hadjustment" ));"vadjustment" ,"vadjustment" ));"hscroll-policy" ,"hscroll-policy" ));"vscroll-policy" ,"vscroll-policy" ));/* * Signals /** * GtkTextView : : move - cursor : * @ 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 * * Gets emitted when the user initiates a cursor movement . * * The : : move - cursor signal is a [ keybinding signal ] ( class . SignalAction . html ) . * 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 the cursor * programmatically . * * * The default bindings for this signal come in two variants , * the variant with the < kbd > Shift < / kbd > modifier extends the * selection , the variant without it does not . * There are too many key combinations to list them all here . * * - < kbd > ← < / kbd > , < kbd > → < / kbd > , < kbd > ↑ < / kbd > , < kbd > ↓ < / kbd > * move by individual characters / lines * - < kbd > Ctrl < / kbd > + < kbd > ← < / kbd > , etc . move by words / paragraphs * - < kbd > Home < / kbd > and < kbd > End < / kbd > move to the ends of the buffer * - < kbd > PgUp < / kbd > and < kbd > PgDn < / kbd > move vertically by pages * - < kbd > Ctrl < / kbd > + < kbd > PgUp < / kbd > and < kbd > Ctrl < / kbd > + < kbd > PgDn < / kbd > * move horizontally by pages "move-cursor" ),3 ,/** * GtkTextView : : move - viewport : * @ text_view : the object which received the signal * @ step : the granularity of the movement , as a ` GtkScrollStep ` * @ count : the number of @ step units to move * * Gets emitted to move the viewport . * * The : : move - viewport signal is a [ keybinding signal ] ( class . SignalAction . html ) , * 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 . "move-viewport" ),2 ,/** * GtkTextView : : set - anchor : * @ text_view : the object which received the signal * * Gets emitted when the user initiates settings the " anchor " mark . * * The : : set - anchor signal is a [ keybinding signal ] ( class . SignalAction . html ) * 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 . "set-anchor" ),0 );/** * GtkTextView : : insert - at - cursor : * @ text_view : the object which received the signal * @ string : the string to insert * * Gets emitted when the user initiates the insertion of a * fixed string at the cursor . * * The : : insert - at - cursor signal is a [ keybinding signal ] ( class . SignalAction . html ) . * * This signal has no default bindings . "insert-at-cursor" ),1 ,/** * 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 * * Gets emitted when the user initiates a text deletion . * * The : : delete - from - cursor signal is a [ keybinding signal ] ( class . SignalAction . html ) . * * 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 < kbd > Delete < / kbd > for * deleting a character , < kbd > Ctrl < / kbd > + < kbd > Delete < / kbd > for * deleting a word and < kbd > Ctrl < / kbd > + < kbd > Backspace < / kbd > for * deleting a word backwards . "delete-from-cursor" ),2 ,/** * GtkTextView : : backspace : * @ text_view : the object which received the signal * * Gets emitted when the user asks for it . * * The : : backspace signal is a [ keybinding signal ] ( class . SignalAction . html ) . * * The default bindings for this signal are * < kbd > Backspace < / kbd > and < kbd > Shift < / kbd > + < kbd > Backspace < / kbd > . "backspace" ),0 );/** * GtkTextView : : cut - clipboard : * @ text_view : the object which received the signal * * Gets emitted to cut the selection to the clipboard . * * The : : cut - clipboard signal is a [ keybinding signal ] ( class . SignalAction . html ) . * * The default bindings for this signal are * < kbd > Ctrl < / kbd > + < kbd > x < / kbd > and * < kbd > Shift < / kbd > + < kbd > Delete < / kbd > . "cut-clipboard" ),0 );/** * GtkTextView : : copy - clipboard : * @ text_view : the object which received the signal * * Gets emitted to copy the selection to the clipboard . * * The : : copy - clipboard signal is a [ keybinding signal ] ( class . SignalAction . html ) . * * The default bindings for this signal are * < kbd > Ctrl < / kbd > + < kbd > c < / kbd > and * < kbd > Ctrl < / kbd > + < kbd > Insert < / kbd > . "copy-clipboard" ),0 );/** * GtkTextView : : paste - clipboard : * @ text_view : the object which received the signal * * Gets emitted to paste the contents of the clipboard * into the text view . * * The : : paste - clipboard signal is a [ keybinding signal ] ( class . SignalAction . html ) . * * The default bindings for this signal are * < kbd > Ctrl < / kbd > + < kbd > v < / kbd > and * < kbd > Shift < / kbd > + < kbd > Insert < / kbd > . "paste-clipboard" ),0 );/** * GtkTextView : : toggle - overwrite : * @ text_view : the object which received the signal * * Gets emitted to toggle the overwrite mode of the text view . * * The : : toggle - overwrite signal is a [ keybinding signal ] ( class . SignalAction . html ) . * * The default binding for this signal is < kbd > Insert < / kbd > . "toggle-overwrite" ),0 );/** * GtkTextView : : select - all : * @ text_view : the object which received the signal * @ select : % TRUE to select , % FALSE to unselect * * Gets emitted to select or unselect the complete contents of the text view . * * The : : select - all signal is a [ keybinding signal ] ( class . SignalAction . html ) . * * The default bindings for this signal are * < kbd > Ctrl < / kbd > + < kbd > a < / kbd > and * < kbd > Ctrl < / kbd > + < kbd > / < / kbd > for selecting and * < kbd > Shift < / kbd > + < kbd > Ctrl < / kbd > + < kbd > a < / kbd > and * < kbd > Ctrl < / kbd > + < kbd > \ < / kbd > for unselecting . "select-all" ),1 , G_TYPE_BOOLEAN);/** * GtkTextView : : toggle - cursor - visible : * @ text_view : the object which received the signal * * Gets emitted to toggle the ` cursor - visible ` property . * * The : : toggle - cursor - visible signal is a * [ keybinding signal ] ( class . SignalAction . html ) . * * The default binding for this signal is < kbd > F7 < / kbd > . "toggle-cursor-visible" ),0 );/** * GtkTextView : : preedit - changed : * @ text_view : the object which received the signal * @ preedit : the current preedit string * * Emitted when preedit text of the active IM changes . * * 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 . "preedit-changed" ),1 ,/** * GtkTextView : : extend - selection : * @ text_view : the object which received the signal * @ granularity : the granularity type * @ location : the location where to extend the selection * @ start : where the selection should start * @ end : where the selection should end * * Emitted when the selection needs to be extended at @ location . * * Returns : % GDK_EVENT_STOP to stop other handlers from being invoked for the * event . % GDK_EVENT_PROPAGATE to propagate the event further . "extend-selection" ),4 ,/** * GtkTextView : : insert - emoji : * @ text_view : the object which received the signal * * Gets emitted to present the Emoji chooser for the @ text_view . * * The : : insert - emoji signal is a [ keybinding signal ] ( class . SignalAction . html ) . * * The default bindings for this signal are * < kbd > Ctrl < / kbd > + < kbd > . < / kbd > and * < kbd > Ctrl < / kbd > + < kbd > ; < / kbd > "insert-emoji" ),0 );/* * Actions /** * GtkTextView | clipboard . cut : * * Copies the contents to the clipboard and deletes it from the widget . "clipboard.cut" , NULL,/** * GtkTextView | clipboard . copy : * * Copies the contents to the clipboard . "clipboard.copy" , NULL,/** * GtkTextView | clipboard . paste : * * Inserts the contents of the clipboard into the widget . "clipboard.paste" , NULL,/** * GtkTextView | selection . delete : * * Deletes the current selection . "selection.delete" , NULL,/** * GtkTextView | selection . select - all : * * Selects all of the widgets content . "selection.select-all" , NULL,/** * GtkTextView | misc . insert - emoji : * * Opens the Emoji chooser . "misc.insert-emoji" , NULL,"text.clear" , NULL,/** * GtkTextView | text . undo : * * Undoes the last change to the contents . "text.undo" , NULL, gtk_text_view_real_undo);/** * GtkTextView | text . redo : * * Redoes the last change to the contents . "text.redo" , NULL, gtk_text_view_real_redo);/** * GtkTextView | menu . popup : * * Opens the context menu . "menu.popup" , NULL, gtk_text_view_popup_menu);/* * Key bindings "menu.popup" ));"text.clear" ,/* Moving the insertion point */ 0 ,1 );0 ,1 );1 );1 );0 ,1 );0 ,1 );1 );1 );0 ,1 );0 ,1 );1 );1 );0 ,1 );0 ,1 );1 );1 );#ifdef __APPLE__1 );1 );1 );1 );1 );1 );#endif /* Select all */ #ifdef __APPLE__"select-all" ,"(b)" , TRUE );#else "select-all" ,"(b)" , TRUE );"select-all" ,"(b)" , TRUE );#endif /* Unselect all */ #ifdef __APPLE__"select-all" ,"(b)" , FALSE );#else "select-all" ,"(b)" , FALSE );"select-all" ,"(b)" , FALSE );#endif /* Deleting text */ "delete-from-cursor" ,"(ii)" , GTK_DELETE_CHARS, 1 );"backspace" , NULL);/* Make this do the same as Backspace, to help with mis-typing */ "backspace" , NULL);"delete-from-cursor" ,"(ii)" , GTK_DELETE_WORD_ENDS, 1 );"delete-from-cursor" ,"(ii)" , GTK_DELETE_WORD_ENDS, -1 );#ifdef __APPLE__"delete-from-cursor" ,"(ii)" , GTK_DELETE_WORD_ENDS, 1 );"delete-from-cursor" ,"(ii)" , GTK_DELETE_WORD_ENDS, -1 );#else "delete-from-cursor" ,"(ii)" , GTK_DELETE_PARAGRAPH_ENDS, 1 );"delete-from-cursor" ,"(ii)" , GTK_DELETE_PARAGRAPH_ENDS, -1 );#endif /* Cut/copy/paste */ "cut-clipboard" , NULL);"copy-clipboard" , NULL);"paste-clipboard" , NULL);#ifdef __APPLE__"cut-clipboard" , NULL);"copy-clipboard" , NULL);"paste-clipboard" , NULL);#else "cut-clipboard" , NULL);"copy-clipboard" , NULL);"paste-clipboard" , NULL);"cut-clipboard" , NULL);"copy-clipboard" , NULL);"paste-clipboard" , NULL);#endif /* Undo/Redo */ "text.undo" , NULL);"text.redo" , NULL);#ifdef __APPLE__"text.undo" , NULL);"text.redo" , NULL);#else "text.undo" , NULL);"text.redo" , NULL);"text.redo" , NULL);#endif /* Overwrite */ "toggle-overwrite" , NULL);/* Emoji */ "misc.insert-emoji" ,"misc.insert-emoji" ,/* Caret mode */ "toggle-cursor-visible" ,/* Control-tab focus motion */ "move-focus" ,"(i)" , GTK_DIR_TAB_FORWARD);"move-focus" ,"(i)" , GTK_DIR_TAB_BACKWARD);"textview" ));"gtk-text-view-text-selection-data" );"gtk-signal" );"gtk-text-view-child" );static void int i;for (i = 0 ; i < TEXT_HANDLE_N_HANDLES; i++)if (priv->text_handles[i])continue ;"drag-started" ,"handle-dragged" ,"drag-finished" ,static void TRUE );"view" );"text" );/* Set up default style */ 0 ;0 ;0 ;0 ;TRUE ;1 .0 ;FALSE ;"enter" , G_CALLBACK (gtk_text_view_drag_motion), text_view);"motion" , G_CALLBACK (gtk_text_view_drag_motion), text_view);"leave" , G_CALLBACK (gtk_text_view_drag_leave), text_view);"drop" , G_CALLBACK (gtk_text_view_drag_drop), text_view);"enter" , G_CALLBACK (gtk_text_view_drop_scroll_motion), text_view);"motion" , G_CALLBACK (gtk_text_view_drop_scroll_motion), text_view);"leave" , G_CALLBACK (gtk_text_view_drop_scroll_leave), text_view);1 ;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 ( ) . "commit" ,"preedit-start" ,"preedit-changed" ,"retrieve-surrounding" ,"delete-surrounding" ,TRUE ;TRUE ;0 );"pressed" ,"released" ,"drag-update" ,"drag-end" ,"motion" , G_CALLBACK (gtk_text_view_motion), widget);"key-pressed" ,"im-update" ,ller),"enter" ,"leave" ,"selection" ));E);FALSE );"style-changed" ,"text.can-redo" , FALSE );"text.can-undo" , FALSE );TRUE ,1 );return text_view->priv->text_window->css_node;return text_view->priv->selection_node;static void if (priv->magnifier_popover)return ;2 .0 );"magnifier" );FALSE );TRUE );/** * gtk_text_view_new : * * Creates a new ` GtkTextView ` . * * If you don ’ t call [ method @ Gtk . TextView . set_buffer ] before using the * text view , an empty default buffer will be created for you . Get the * buffer with [ method @ Gtk . TextView . get_buffer ] . If you want to specify * your own buffer , consider [ ctor @ Gtk . TextView . new_with_buffer ] . * * Returns : a new ` GtkTextView ` void )return g_object_new (GTK_TYPE_TEXT_VIEW, NULL);/** * gtk_text_view_new_with_buffer : * @ buffer : a ` GtkTextBuffer ` * * 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 this function is equivalent * to [ ctor @ Gtk . TextView . new ] . The text view adds its own reference count * to the buffer ; it does not take over an existing reference . * * Returns : a new ` GtkTextView ` . return GTK_WIDGET (text_view);/** * gtk_text_view_set_buffer : * @ text_view : a ` GtkTextView ` * @ buffer : ( nullable ) : 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 if (priv->buffer == buffer)return ;if (old_buffer != NULL)0 , gtk_text_buffer_get_char_count (old_buffer));while (priv->anchored_children.length)/* ac is now invalid! */ if (gtk_widget_get_realized (GTK_WIDGET (text_view)))if (priv->layout)if (priv->layout)if (buffer != NULL)0 );"gtk_drag_target" ,FALSE );TRUE );0 ;"mark-set" ,"paste-done" ,"changed" ,"notify::can-undo" ,"notify::can-redo" ,"insert-text" ,"delete-range" ,if (gtk_widget_get_realized (GTK_WIDGET (text_view)))0 , gtk_text_buffer_get_char_count (buffer));if (old_buffer)if (gtk_widget_get_visible (GTK_WIDGET (text_view)))"Invalidating due to set_buffer\n" ));static GtkTextBuffer*return gtk_text_buffer_new (NULL);/** * gtk_text_view_get_buffer : * @ text_view : a ` GtkTextView ` * * Returns the ` GtkTextBuffer ` being displayed by this text view . * * The reference count on the buffer is not incremented ; the caller * of this function won ’ t own a new reference . * * Returns : ( transfer none ) : a ` GtkTextBuffer ` return get_buffer (text_view);/** * gtk_text_view_get_cursor_locations : * @ text_view : a ` GtkTextView ` * @ iter : ( nullable ) : a ` GtkTextIter ` * @ strong : ( out ) ( optional ) : location to store the strong cursor position * @ weak : ( out ) ( optional ) : location to store the weak cursor position * * Determine the positions of the strong and weak cursors if the * insertion point is at @ iter . * * The position of each cursor is stored as a zero - width rectangle . * The strong cursor location is the location where characters of * the directionality equal to the base direction of the paragraph * are inserted . The weak cursor location is the location where * characters of the directionality opposite to the base direction * of the paragraph are inserted . * * If @ iter is % NULL , the actual cursor position is used . * * Note that if @ iter happens to be the actual cursor position , and * there is currently an IM preedit sequence being entered , the * returned locations will be adjusted to account for the preedit * cursor ’ s offset within the preedit sequence . * * The rectangle position is in buffer coordinates ; use * [ method @ Gtk . TextView . buffer_to_window_coords ] to convert these * coordinates to coordinates for one of the windows in the text view . void const GtkTextIter *iter,if (iter)else /** * gtk_text_view_get_iter_at_location : * @ text_view : a ` GtkTextView ` * @ iter : ( out ) : a ` GtkTextIter ` * @ x : x position , in buffer coordinates * @ y : y position , in buffer coordinates * * Retrieves the iterator at buffer coordinates @ x and @ y . * * Buffer coordinates are coordinates for the entire buffer , not just * the currently - displayed portion . If you have coordinates from an * event , you have to convert those to buffer coordinates with * [ method @ Gtk . TextView . window_to_buffer_coords ] . * * Returns : % TRUE if the position is over text int x,int y)FALSE );FALSE );return 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 : ( out ) : a ` GtkTextIter ` * @ trailing : ( out ) ( optional ) : 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 . * @ x : x position , in buffer coordinates * @ y : y position , in buffer coordinates * * Retrieves the iterator pointing to the character at buffer * coordinates @ x and @ y . * * Buffer coordinates are coordinates for the entire buffer , not just * the currently - displayed portion . If you have coordinates from an event , * you have to convert those to buffer coordinates with * [ method @ Gtk . TextView . window_to_buffer_coords ] . * * Note that this is different from [ method @ Gtk . TextView . get_iter_at_location ] , * which returns cursor locations , i . e . positions between characters . * * Returns : % TRUE if the position is over text int *trailing,int x,int y)FALSE );FALSE );return 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 : ( 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 * [ method @ Gtk . TextView . buffer_to_window_coords ] to convert these * coordinates to coordinates for one of the windows in the text view . void const GtkTextIter *iter,/** * gtk_text_view_get_line_yrange : * @ text_view : a ` GtkTextView ` * @ iter : a ` GtkTextIter ` * @ 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 [ method @ Gtk . TextView . buffer_to_window_coords ] . void const GtkTextIter *iter,int *y,int *height)/** * gtk_text_view_get_line_at_y : * @ text_view : a ` GtkTextView ` * @ target_iter : ( out ) : a ` GtkTextIter ` * @ y : a y coordinate * @ 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 window coordinates with * [ method @ Gtk . TextView . window_to_buffer_coords ] . If non - % NULL , * @ line_top will be filled with the coordinate of the top edge * of the line . void int y,int *line_top)/* Same as gtk_text_view_scroll_to_iter but deal with * top_margin and bottom_margin . * When with_border = = TRUE and you scroll on the edges , * all borders are shown for the corresponding edge . * When with_border = = FALSE , only left margin and right_margin * can be seen because they can be can be overwritten by tags . static gbooleandouble within_margin,double xalign,double yalign,int cursor_bottom;int cursor_right;int screen_inner_left;int screen_inner_right;int screen_inner_top;int screen_inner_bottom;int border_xoffset = 0 ;int border_yoffset = 0 ;int within_margin_xoffset;int within_margin_yoffset;int buffer_bottom;int buffer_right;FALSE ;/* FIXME why don't we do the validate-at-scroll-destination thing * from flush_scroll in this function ? I think it wasn ' t done before * because changed_handler was screwed up , but I could be wrong . FALSE );FALSE );0 .0 && within_margin < 0 .5 , FALSE );0 .0 && xalign <= 1 .0 , FALSE );0 .0 && yalign <= 1 .0 , FALSE );"\n" ));" target cursor %d,%d %d x %d\n" , cursor.x, cursor.y, cursor.width, cursor.height));/* In each direction, *_border are the addition of *_padding and *_margin * * Vadjustment value : * ( - priv - > top_margin ) [ top padding ] [ top margin ] ( 0 ) [ text ] [ bottom margin ] [ bottom padding ] * * Hadjustment value : * [ left padding ] ( 0 ) [ left margin ] [ text ] [ right margin ] [ right padding ] * * Buffer coordinates : * on x : ( 0 ) [ left margin ] [ text ] [ right margin ] * on y : ( 0 ) [ text ] * * left margin and right margin are part of the x buffer coordinate * because they are part of the pango layout so that they can be * overwritten by tags . * * Canvas coordinates : * ( the canvas is the virtual window where the content of the buffer is drawn ) * * on x : [ left padding ] ( 0 ) [ left margin ] [ text ] [ right margin ] [ right padding ] * on y : ( - priv - > top_margin ) [ top margin ] [ top padding ] ( 0 ) [ text ] [ bottom margin ] [ bottom padding ] * * ( priv - > xoffset , priv - > yoffset ) is the origin of the view ( visible part of the canvas ) * in canvas coordinates . * As you can see , canvas coordinates and buffer coordinates are compatible but the canvas * can be larger than the buffer depending of the border size . /* Current position of the view in canvas coordinates */ 1 ;2 ;2 ;/* Minimum authorised size check */ if (screen_dest.width < 1 )1 ;if (screen_dest.height < 1 )1 ;/* The alignment affects the point in the target character that we * choose to align . If we ' re doing right / bottom alignment , we align * the right / bottom edge of the character the mark is at ; if we ' re * doing left / top we align the left / top edge of the character ; if * we ' re doing center alignment we align the center of the * character . * * The different cases handle on each direction : * 1 . cursor outside of the inner area define by within_margin * 2 . if use_align = = TRUE , alignment with xalign and yalign * 3 . scrolling on the edges dependent of with_border /* Vertical scroll */ if (use_align)int cursor_y_alignment_offset;else /* move minimum to get onscreen, showing the * top_margin or bottom_margin when necessary if (cursor.y < screen_inner_top)if (cursor.y == 0 )0 ;else if (cursor_bottom > screen_inner_bottom)if (cursor_bottom == buffer_bottom - priv->top_margin)0 ;if (screen_dest.y != screen.y)" vert increment %d\n" , screen_dest.y - screen.y));/* Horizontal scroll */ if (use_align)int cursor_x_alignment_offset;else /* move minimum to get onscreen, showing the * left_margin or right_margin when necessary if (cursor.x < screen_inner_left)if (cursor.x == priv->left_margin)0 ;else if (cursor_right >= screen_inner_right - 1 )if (cursor.x >= buffer_right)0 ;1 ;if (screen_dest.x != screen.x)" horiz increment %d\n" , screen_dest.x - screen.x));">%s (" G_STRLOC")\n" , retval ? "Actually scrolled" : "Didn't end up scrolling" ));return retval;/** * gtk_text_view_scroll_to_iter : * @ 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 * @ 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 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 [ method @ Gtk . TextView . scroll_to_mark ] which saves a point to be * scrolled to after line validation . * * Returns : % TRUE if scrolling occurred double within_margin,double xalign,double yalign)return _gtk_text_view_scroll_to_iter (text_view,FALSE );static void if (!gtk_text_mark_get_deleted (scroll->mark))static void if (text_view->priv->pending_scroll)static void double within_margin,double xalign,double yalign)"\n" ));1 );static gbooleanint height;"\n" ));if (text_view->priv->pending_scroll == NULL)"in flush scroll, no pending scroll\n" ));return FALSE ;/* avoid recursion */ /* Validate area around the scroll destination, so the adjustment * can meaningfully point into that area . We must validate * enough area to be sure that after we scroll , everything onscreen * is valid ; otherwise , validation will maintain the first para * in one place , but may push the target iter off the bottom of * the screen . ">Validating scroll destination (" G_STRLOC")\n" ));2 ),2 );">Done validating scroll destination (" G_STRLOC")\n" ));/* Ensure we have updated width/height */ TRUE );return retval;static void int width = 0 , height = 0 ;">Updating adjustments (" G_STRLOC")\n" ));if (priv->layout)/* Make room for the cursor after the last character in the widest line */ if (priv->width != width || priv->height != height)static void ">Updating layout width (" G_STRLOC")\n" ));1 , SCREEN_WIDTH (text_view) - SPACE_FOR_CURSOR));static void int *width,int *height)if (x_gutter != NULL)0 };else 0 ;if (y_gutter != NULL)0 };else 0 ;static void if (text_view->priv->layout == NULL)return ;int x_offset = 0 ;int y_offset = 0 ;/* Width returned by Pango indicates direction of cursor, * by its sign more than the size of cursor . 0 ;static gboolean0 ;return G_SOURCE_REMOVE;static void /* Use priority a little higher than GTK_TEXT_VIEW_PRIORITY_VALIDATE, if (!priv->im_spot_idle)1 ,"[gtk] do_update_im_spot_location" );static void if (priv->im_spot_idle)/** * gtk_text_view_scroll_to_mark : * @ 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 * @ 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 . void double within_margin,double xalign,double yalign)0 .0 && within_margin < 0 .5 );0 .0 && xalign <= 1 .0 );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 . /* If no validation is pending, we need to go ahead and force an * immediate scroll . if (text_view->priv->layout &&/** * gtk_text_view_scroll_mark_onscreen : * @ text_view : a ` GtkTextView ` * @ mark : a mark in the buffer for @ text_view * * Scrolls @ text_view the minimum distance such that @ mark is contained * within the visible area of the widget . void /* We need to verify that the buffer contains the mark, otherwise this * can lead to data structure corruption later on . 0 .0 , FALSE , 0 .0 , 0 .0 );static gbooleanreturn gtk_text_layout_clamp_iter_to_vrange (text_view->priv->layout, iter,/** * gtk_text_view_move_mark_onscreen : * @ text_view : a ` GtkTextView ` * @ mark : a ` GtkTextMark ` * * Moves a mark within the buffer so that it ' s * located within the currently - visible text area . * * Returns : % TRUE if the mark moved ( wasn ’ t already onscreen ) FALSE );FALSE );if (clamp_iter_onscreen (text_view, &iter))return TRUE ;else return FALSE ;/** * gtk_text_view_get_visible_rect : * @ text_view : a ` GtkTextView ` * @ visible_rect : ( out ) : rectangle to fill * * Fills @ visible_rect with the currently - visible * region of the buffer , in buffer coordinates . * * Convert to window coordinates with * [ method @ Gtk . TextView . buffer_to_window_coords ] . void if (visible_rect)" visible rect: %d,%d %d x %d\n" ,/** * gtk_text_view_get_visible_offset : * @ text_view : a ` GtkTextView ` * @ x_offset : ( out ) ( nullable ) : a location for the X offset * @ y_offset : ( out ) ( nullable ) : a location for the Y offset * * Gets the X , Y offset in buffer coordinates of the top - left corner of * the textview ' s text contents . * * This allows for more - precise positioning than what is provided by * [ method @ Gtk . TextView . get_visible_rect ] as you can discover what * device pixel is being quantized for text positioning . * * You might want this when making ulterior widgets align with quantized * device pixels of the textview contents such as line numbers . * * Since : 4 . 18 void double *x_offset,double *y_offset)if (x_offset)if (y_offset)/** * gtk_text_view_set_wrap_mode : * @ text_view : a ` GtkTextView ` * @ wrap_mode : a ` GtkWrapMode ` * * Sets the line wrapping for the view . void if (priv->wrap_mode != wrap_mode)if (priv->layout && priv->layout->default_style)/** * gtk_text_view_get_wrap_mode : * @ text_view : a ` GtkTextView ` * * Gets the line wrapping for the view . * * Returns : the line wrap setting return text_view->priv->wrap_mode;/** * gtk_text_view_set_editable : * @ text_view : a ` GtkTextView ` * @ setting : whether it ’ s editable * * Sets the default editability of the ` GtkTextView ` . * * You can override this default setting with tags in the buffer , * using the “ editable ” attribute of tags . void FALSE ;if (priv->editable != setting)if (!setting)if (gtk_widget_has_focus (GTK_WIDGET (text_view)))if (setting && gtk_widget_has_focus (GTK_WIDGET (text_view)))ller),if (priv->layout && priv->layout->default_style)1 );/** * gtk_text_view_get_editable : * @ text_view : a ` GtkTextView ` * * Returns the default editability of the ` GtkTextView ` . * * Tags in the buffer may override this setting for some ranges of text . * * Returns : whether text is editable by default FALSE );return text_view->priv->editable;/** * gtk_text_view_set_pixels_above_lines : * @ text_view : a ` GtkTextView ` * @ pixels_above_lines : pixels above paragraphs * * Sets the default number of blank pixels above paragraphs in @ text_view . * * Tags in the buffer for @ text_view may override the defaults . void int pixels_above_lines)if (priv->pixels_above_lines != pixels_above_lines)if (priv->layout && priv->layout->default_style)/** * gtk_text_view_get_pixels_above_lines : * @ text_view : a ` GtkTextView ` * * Gets the default number of pixels to put above paragraphs . * * Adding this function with [ method @ Gtk . TextView . get_pixels_below_lines ] * is equal to the line space between each paragraph . * * Returns : default number of pixels above paragraphs int 0 );return text_view->priv->pixels_above_lines;/** * gtk_text_view_set_pixels_below_lines : * @ text_view : a ` GtkTextView ` * @ pixels_below_lines : pixels below paragraphs * * 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 int pixels_below_lines)if (priv->pixels_below_lines != pixels_below_lines)if (priv->layout && priv->layout->default_style)/** * gtk_text_view_get_pixels_below_lines : * @ text_view : a ` GtkTextView ` * * Gets the default number of pixels to put below paragraphs . * * The line space is the sum of the value returned by this function and * the value returned by [ method @ Gtk . TextView . get_pixels_above_lines ] . * * Returns : default number of blank pixels below paragraphs int 0 );return text_view->priv->pixels_below_lines;/** * gtk_text_view_set_pixels_inside_wrap : * @ text_view : a ` GtkTextView ` * @ pixels_inside_wrap : default number of pixels between wrapped 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 int pixels_inside_wrap)if (priv->pixels_inside_wrap != pixels_inside_wrap)if (priv->layout && priv->layout->default_style)/** * gtk_text_view_get_pixels_inside_wrap : * @ text_view : a ` GtkTextView ` * * Gets the default number of pixels to put between wrapped lines * inside a paragraph . * * Returns : default number of pixels of blank space between wrapped lines int 0 );return text_view->priv->pixels_inside_wrap;/** * gtk_text_view_set_justification : * @ text_view : a ` GtkTextView ` * @ justification : justification * * Sets the default justification of text in @ text_view . * * Tags in the view ’ s buffer may override the default . void if (priv->justify != justification)if (priv->layout && priv->layout->default_style)/** * gtk_text_view_get_justification : * @ text_view : a ` GtkTextView ` * * Gets the default justification of paragraphs in @ text_view . * * Tags in the buffer may override the default . * * Returns : default justification return text_view->priv->justify;/** * gtk_text_view_set_left_margin : * @ text_view : a ` GtkTextView ` * @ left_margin : left margin in pixels * * Sets the default left margin for text in @ text_view . * * Tags in the buffer may override the default . * * Note that this function is confusingly named . * In CSS terms , the value set here is padding . void int left_margin)if (priv->left_margin != left_margin)if (priv->layout && priv->layout->default_style)/** * gtk_text_view_get_left_margin : * @ text_view : a ` GtkTextView ` * * Gets the default left margin size of paragraphs in the @ text_view . * * Tags in the buffer may override the default . * * Returns : left margin in pixels int 0 );return text_view->priv->left_margin;/** * gtk_text_view_set_right_margin : * @ text_view : a ` GtkTextView ` * @ right_margin : right margin in pixels * * Sets the default right margin for text in the text view . * * Tags in the buffer may override the default . * * Note that this function is confusingly named . * In CSS terms , the value set here is padding . void int right_margin)if (priv->right_margin != right_margin)if (priv->layout && priv->layout->default_style)/** * gtk_text_view_get_right_margin : * @ text_view : a ` GtkTextView ` * * Gets the default right margin for text in @ text_view . * * Tags in the buffer may override the default . * * Returns : right margin in pixels int 0 );return text_view->priv->right_margin;/** * gtk_text_view_set_top_margin : * @ text_view : a ` GtkTextView ` * @ top_margin : top margin in pixels * * Sets the top margin for text in @ text_view . * * Note that this function is confusingly named . * In CSS terms , the value set here is padding . void int top_margin)if (priv->top_margin != top_margin)if (priv->layout && priv->layout->default_style)/** * gtk_text_view_get_top_margin : * @ text_view : a ` GtkTextView ` * * Gets the top margin for text in the @ text_view . * * Returns : top margin in pixels int 0 );return text_view->priv->top_margin;/** * gtk_text_view_set_bottom_margin : * @ text_view : a ` GtkTextView ` * @ bottom_margin : bottom margin in pixels * * Sets the bottom margin for text in @ text_view . * * Note that this function is confusingly named . * In CSS terms , the value set here is padding . void int bottom_margin)if (priv->bottom_margin != bottom_margin)if (priv->layout && priv->layout->default_style)/** * gtk_text_view_get_bottom_margin : * @ text_view : a ` GtkTextView ` * * Gets the bottom margin for text in the @ text_view . * * Returns : bottom margin in pixels int 0 );return text_view->priv->bottom_margin;/** * gtk_text_view_set_indent : * @ text_view : a ` GtkTextView ` * @ indent : indentation in pixels * * Sets the default indentation for paragraphs in @ text_view . * * Tags in the buffer may override the default . void int indent)if (priv->indent != indent)if (priv->layout && priv->layout->default_style)/** * gtk_text_view_get_indent : * @ text_view : a ` GtkTextView ` * * Gets the default indentation of paragraphs in @ text_view . * * Tags in the view ’ s buffer may override the default . * The indentation may be negative . * * Returns : number of pixels of indentation int 0 );return text_view->priv->indent;/** * gtk_text_view_set_tabs : * @ text_view : a ` GtkTextView ` * @ tabs : tabs as a ` PangoTabArray ` * * Sets the default tab stops for paragraphs in @ text_view . * * Tags in the buffer may override the default . void if (priv->tabs)if (priv->layout && priv->layout->default_style)/* some unkosher futzing in internal struct details... */ if (priv->layout->default_style->tabs)/** * gtk_text_view_get_tabs : * @ text_view : a ` GtkTextView ` * * Gets the default tabs for @ text_view . * * Tags in the buffer may override the defaults . The returned array * will be % NULL if “ standard ” ( 8 - space ) tabs are used . Free the * return value with [ method @ Pango . TabArray . free ] . * * Returns : ( nullable ) ( transfer full ) : copy of default tab array , * or % NULL if standard tabs are used ; must be freed with * [ method @ Pango . TabArray . free ] . return text_view->priv->tabs ? pango_tab_array_copy (text_view->priv->tabs) : NULL;static void /** * gtk_text_view_set_cursor_visible : * @ text_view : a ` GtkTextView ` * @ setting : whether to show the insertion cursor * * Toggles whether the insertion point should be displayed . * * A buffer with no editable text probably shouldn ’ t have a visible * cursor , so you may want to turn the cursor off . * * Note that this property may be overridden by the * [ property @ Gtk . Settings : gtk - keynav - use - caret ] setting . void FALSE );if (priv->cursor_visible != setting)if (gtk_widget_has_focus (GTK_WIDGET (text_view)))if (priv->layout)/** * gtk_text_view_get_cursor_visible : * @ text_view : a ` GtkTextView ` * * Find out whether the cursor should be displayed . * * Returns : whether the insertion mark is visible FALSE );return text_view->priv->cursor_visible;/** * gtk_text_view_reset_cursor_blink : * @ text_view : a ` GtkTextView ` * * Ensures that the cursor is shown . * * This also resets the time that it will stay blinking ( or * visible , in case blinking is disabled ) . * * This function should be called in response to user input * ( e . g . from derived classes that override the textview ' s * event handlers ) . void /** * gtk_text_view_place_cursor_onscreen : * @ text_view : a ` GtkTextView ` * * Moves the cursor to the currently visible region of the * buffer . * * Returns : % TRUE if the cursor had to be moved . FALSE );if (clamp_iter_onscreen (text_view, &insert))return TRUE ;else return FALSE ;static void if (priv->first_validate_idle != 0 )"Removing first validate idle: %s\n" , G_STRLOC));static void "gtk-emoji-chooser" );if (child)"gtk-emoji-chooser" , NULL);if (priv->magnifier)rent);dget_unparent);while ((child = gtk_widget_get_first_child (GTK_WIDGET (text_view))))static void /* at this point, no "notify::buffer" handler should recreate the buffer. */ /* Ensure all children were removed */ 0 );if (priv->tabs)if (priv->hadjustment)if (priv->vadjustment)static void const GValue *value,switch (prop_id)case PROP_PIXELS_ABOVE_LINES:break ;case PROP_PIXELS_BELOW_LINES:break ;case PROP_PIXELS_INSIDE_WRAP:break ;case PROP_EDITABLE:break ;case PROP_WRAP_MODE:break ;case PROP_JUSTIFICATION:break ;case PROP_LEFT_MARGIN:break ;case PROP_RIGHT_MARGIN:break ;case PROP_TOP_MARGIN:break ;case PROP_BOTTOM_MARGIN:break ;case PROP_INDENT:break ;case PROP_TABS:break ;case PROP_CURSOR_VISIBLE:break ;case PROP_OVERWRITE:break ;case PROP_BUFFER:break ;case PROP_ACCEPTS_TAB:break ;case PROP_IM_MODULE:if (GTK_IS_IM_MULTICONTEXT (priv->im_context))module);break ;case PROP_HADJUSTMENT:break ;case PROP_VADJUSTMENT:break ;case PROP_HSCROLL_POLICY:if (priv->hscroll_policy != g_value_get_enum (value))break ;case PROP_VSCROLL_POLICY:if (priv->vscroll_policy != g_value_get_enum (value))break ;case PROP_INPUT_PURPOSE:break ;case PROP_INPUT_HINTS:break ;case PROP_MONOSPACE:break ;case PROP_EXTRA_MENU:break ;default :break ;static void switch (prop_id)case PROP_PIXELS_ABOVE_LINES:break ;case PROP_PIXELS_BELOW_LINES:break ;case PROP_PIXELS_INSIDE_WRAP:break ;case PROP_EDITABLE:break ;case PROP_WRAP_MODE:break ;case PROP_JUSTIFICATION:break ;case PROP_LEFT_MARGIN:break ;case PROP_RIGHT_MARGIN:break ;case PROP_TOP_MARGIN:break ;case PROP_BOTTOM_MARGIN:break ;case PROP_INDENT:break ;case PROP_TABS:break ;case PROP_CURSOR_VISIBLE:break ;case PROP_BUFFER:break ;case PROP_OVERWRITE:break ;case PROP_ACCEPTS_TAB:break ;case PROP_IM_MODULE:break ;case PROP_HADJUSTMENT:break ;case PROP_VADJUSTMENT:break ;case PROP_HSCROLL_POLICY:break ;case PROP_VSCROLL_POLICY:break ;case PROP_INPUT_PURPOSE:break ;case PROP_INPUT_HINTS:break ;case PROP_MONOSPACE:break ;case PROP_EXTRA_MENU:break ;default :break ;static void int left = 0 ;int right = 0 ;int top = 0 ;int bottom = 0 ;if (priv->left_child)1 ,if (priv->right_child)1 ,if (priv->top_child)1 ,if (priv->bottom_child)1 ,static void int for_size,int *minimum,int *natural,int *minimum_baseline,int *natural_baseline)const GList *list;int min = 0 ;int nat = 0 ;int extra;if (priv->center_child)for (list = priv->anchored_children.head; list; list = list->next)const AnchoredChild *child = list->data;int child_min = 0 ;int child_nat = 0 ;/* Invalidate layout lines if required */ if (child->anchor && priv->layout)if (orientation == GTK_ORIENTATION_HORIZONTAL)else static void const AnchoredChild *vc,int gutter_width,int gutter_height)int buffer_y;static void const AnchoredChild *vc,int gutter_width,int gutter_height)ght);1 ,#if 0 "allocation for %p allocated to %lf,%lf yoffset = %lf\n" ,#endif static void int x,int y,int x_offset = 0 ;int y_offset = 0 ;/* x,y is the position of the child from the top of the line, and * from the left of the buffer . We have to translate that into text * window coordinates , then size_allocate the child . "child allocated at %d,%d\n" , x, y));static void const GList *iter;"\n" ));for (iter = priv->anchored_children.head; iter; iter = iter->next)const AnchoredChild *child = iter->data;/* We need to force-validate the regions containing children. */ /* Since anchored children are only ever allocated from * gtk_text_layout_get_line_display ( ) we have to make sure * that the display line caching in the layout doesn ' t * get in the way . Invalidating the layout around the anchor * achieves this . if (_gtk_widget_get_alloc_needed (child->widget))0 , 1 );1000 - child_req.width;1000 - child_req.height;1 );static GtkTextViewChild **switch (window_type)case GTK_TEXT_WINDOW_LEFT:return &text_view->priv->left_child;case GTK_TEXT_WINDOW_RIGHT:return &text_view->priv->right_child;case GTK_TEXT_WINDOW_TOP:return &text_view->priv->top_child;case GTK_TEXT_WINDOW_BOTTOM:return &text_view->priv->bottom_child;case GTK_TEXT_WINDOW_TEXT:return &text_view->priv->center_child;case GTK_TEXT_WINDOW_WIDGET:default :return NULL;/** * gtk_text_view_get_gutter : * @ text_view : a ` GtkTextView ` * @ win : a ` GtkTextWindowType ` * * Gets a ` GtkWidget ` that has previously been set as gutter . * * See [ method @ Gtk . TextView . set_gutter ] . * * @ win must be one of % GTK_TEXT_WINDOW_LEFT , % GTK_TEXT_WINDOW_RIGHT , * % GTK_TEXT_WINDOW_TOP , or % GTK_TEXT_WINDOW_BOTTOM . * * Returns : ( transfer none ) ( nullable ) : a ` GtkWidget ` if (childp != NULL && *childp != NULL)return GTK_WIDGET (*childp);return NULL;/** * gtk_text_view_set_gutter : * @ text_view : a ` GtkTextView ` * @ win : a ` GtkTextWindowType ` * @ widget : ( nullable ) : a ` GtkWidget ` * * Places @ widget into the gutter specified by @ win . * * @ win must be one of % GTK_TEXT_WINDOW_LEFT , % GTK_TEXT_WINDOW_RIGHT , * % GTK_TEXT_WINDOW_TOP , or % GTK_TEXT_WINDOW_BOTTOM . void if (childp == NULL)return ;if ((GtkWidget *)old_child == widget)return ;if (old_child != NULL)if (widget == NULL)return ;static void int widget_width,int widget_height,int baseline)int width, height;"\n" ));/* distribute width/height among child windows. Ensure all * windows get at least a 1 x1 allocation . 1 , width);1 , height);/* Origins */ 0 ;0 ;/* Update adjustments */ if (!gtk_adjustment_is_animating (priv->hadjustment))if (!gtk_adjustment_is_animating (priv->vadjustment))if (priv->center_child)1 );if (priv->left_child)1 );if (priv->right_child)1 );if (priv->top_child)1 );if (priv->bottom_child)1 );/* Note that this will do some layout validation */ /* Optimize display cache size */ "X" );if (height > 0 )3 ;/* The GTK resize loop processes all the pending exposes right * after doing the resize stuff , so the idle sizer won ' t have a * chance to run . So we do the work here . "gtk-emoji-chooser" );if (chooser)if (priv->magnifier_popover)if (priv->popup_menu)if (priv->text_handles[TEXT_HANDLE_CURSOR])if (priv->text_handles[TEXT_HANDLE_SELECTION_BOUND])if (priv->selection_bubble)static void static void ">Validating onscreen (" G_STRLOC")\n" ));if (SCREEN_HEIGHT (widget) > 0 )/* Be sure we've validated the stuff onscreen; if we * scrolled , these calls won ' t have any effect , because * they were called in the recursive validate_onscreen 0 ,TRUE ;">Done validating onscreen, onscreen_validated = TRUE (" G_STRLOC")\n" ));/* This can have the odd side effect of triggering a scroll, which should * flip " onscreen_validated " back to FALSE , but should also get us * back into this function to turn it on again . static void if (priv->first_validate_idle == 0 )return ;/* Do this first, which means that if an "invalidate" * occurs during any of this process , a new first_validate_callback * will be installed , and we ' ll start again . "removing first validate in %s\n" , G_STRLOC));/* 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 (priv->first_validate_idle != 0 )">Width change forced requeue (" G_STRLOC")\n" ));else /* scroll to any marks, if that's pending. This can jump us to * the validation codepath used for scrolling onscreen , if so we * bail out . It won ' t jump if already in that codepath since * value_changed is not recursive , so also validate if * necessary . if (!gtk_text_view_flush_scroll (text_view) ||">Leaving first validate idle (" G_STRLOC")\n" ));static gboolean/* Note that some of this code is duplicated at the end of size_allocate, * keep in sync with that . "\n" ));return G_SOURCE_REMOVE;static gbooleanTRUE ;"\n" ));2000 );if (gtk_text_layout_is_valid (text_view->priv->layout))0 ;FALSE ;return result;static void ">Invalidate, onscreen_validated = %d now FALSE (" G_STRLOC")\n" ,FALSE ;/* We'll invalidate when the layout is created */ if (priv->layout == NULL)return ;if (!priv->first_validate_idle)2 , first_validate_callback, text_view, NULL);"[gtk] first_validate_callback" );": adding first validate idle %d\n" ,if (!priv->incremental_validate_idle)ncremental_validate_callback, text_view, NULL);"[gtk] incremental_validate_callback" );": adding incremental validate idle %d\n" ,static void "Invalidating due to layout invalidate signal\n" ));static void int start_y,int old_height,int new_height,">Lines Validated (" G_STRLOC")\n" ));if (gtk_widget_get_realized (widget))if (old_height != new_height)const GList *iter;int new_first_para_top;int old_first_para_top;int x_offset = 0 ;int y_offset = 0 ;/* If the bottom of the old area was above the top of the * screen , we need to scroll to keep the current top of the * screen in place . Remember that first_para_pixels is the * position of the top of the screen in coordinates relative to * the first paragraph onscreen . * * In short we are adding the height delta of the portion of the * changed region above first_para_mark to priv - > yoffset . if (new_first_para_top != old_first_para_top)/* FIXME be smarter about which anchored widgets we update */ for (iter = priv->anchored_children.head; iter; iter = iter->next)const AnchoredChild *ac = iter->data;static void if (gtk_widget_is_sensitive (widget))if (priv->buffer)/* Ensure updating the spot location. */ static void if (priv->buffer)static void "text" );static void if ((change == NULL ||if ((change == NULL ||static void if (priv->layout && priv->layout->default_style)static void if (!priv->layout)return ;XT_DIR_LTR);XT_DIR_RTL);if (update_ltr || update_rtl)static void if (setting == GTK_SYSTEM_SETTING_DPI ||static void if (!gtk_widget_is_sensitive (widget))/* Clear any selection */ if (priv->layout)static void if (text_view->priv->mouse_cursor_obscured)return ;"none" );TRUE ;static void if (text_view->priv->mouse_cursor_obscured &&"text" );FALSE ;/* * Events static void int *x,int *y)static void int *x,int *y)static void int x, y;if (!gtk_text_handle_get_is_dragged (handle) &&0 || x > SCREEN_WIDTH (text_view) ||0 || y > SCREEN_HEIGHT (text_view)))/* Hide the handle if it's not being manipulated * and fell outside of the visible text area . FALSE );else 0 };TRUE );0 , SCREEN_WIDTH (text_view));0 , SCREEN_HEIGHT (text_view));if (gtk_text_iter_get_attributes (iter, &attributes))static void int x,int y)#define N_LINES 1 /* Set size/content depending on iter rect */ 4 ) / 3 , 80 );2 );0 , gtk_widget_get_width (GTK_WIDGET (text_view)));4 ;4 ;#undef N_LINESstatic void int x,int y,if (handle == priv->text_handles[TEXT_HANDLE_CURSOR])/* Avoid running past the other handle in selection mode */ if (gtk_text_iter_compare (&iter, &bound) >= 0 &&))else if (handle == priv->text_handles[TEXT_HANDLE_SELECTION_BOUND])/* Avoid running past the other handle */ if (gtk_text_iter_compare (&iter, &cursor) <= 0 )else if (gtk_text_iter_compare (&iter, old_iter) != 0 )if (handle == priv->text_handles[TEXT_HANDLE_CURSOR] &&_ROLE_CURSOR)else if (handle == priv->text_handles[TEXT_HANDLE_CURSOR])TRUE ;else if (handle == priv->text_handles[TEXT_HANDLE_SELECTION_BOUND])TRUE ;static void FALSE ;FALSE ;static void if (!priv->cursor_handle_dragged && !priv->selection_handle_dragged)"gtk-double-click-time" , &double_click_time, NULL);if (g_get_monotonic_time() - priv->handle_place_time < double_click_time * 1000 )else if (priv->magnifier_popover)static gboolean cursor_visible (GtkTextView *text_view);static void if (!priv->text_handles_enabled)if (priv->text_handles[TEXT_HANDLE_CURSOR])FALSE );if (priv->text_handles[TEXT_HANDLE_SELECTION_BOUND])), FALSE );else if (gtk_text_iter_compare (&cursor, &bound) == 0 && priv->editable)/* Cursor mode */ ), FALSE );else if (gtk_text_iter_compare (&cursor, &bound) != 0 )/* Selection mode */ else FALSE );), FALSE );static gbooleanFALSE ;if (priv->layout == NULL || get_buffer (text_view) == NULL)return FALSE ;/* Make sure input method knows where it is */ oller));/* use overall editability not can_insert, more predictable for users */ if (priv->editable &&/* this won't actually insert the newline if the cursor isn't * editable "\n" , timestamp);TRUE ;/* Pass through Tab as literal tab, unless Control is held down */ else if ((keyval == GDK_KEY_Tab ||/* If the text widget isn't editable overall, or if the application * has turned off " accepts_tab " , move the focus instead if (priv->accepts_tab && priv->editable)"\t" , timestamp);else "move-focus" ,TRUE ;else FALSE ;FALSE ;return retval;static void TRUE ;static gbooleanint *x,int *y)int xcoord, ycoord;double px, py;if (!gtk_gesture_get_point (gesture, sequence, &px, &py))return FALSE ;if (x)if (y)return TRUE ;static void int n_press,double x,double y,if (n_press == 1 )/* Always emit reset when preedit is shown */ TRUE ;if (n_press == 1 &&else if (button == GDK_BUTTON_MIDDLE &&else if (button == GDK_BUTTON_PRIMARY)FALSE ;if (state & GDK_SHIFT_MASK)TRUE ;if (n_press > 1 )/* Reset count if double/triple clicking on a different line */ if (gtk_text_iter_get_line (&cur) !=return ;switch (n_press)case 1 :/* If we're in the selection, start a drag copy/move of the * selection ; otherwise , start creating a new selection . if (gtk_text_buffer_get_selection_bounds (get_buffer (text_view),if (gtk_event_treat_as_touch (event))if (!priv->selection_bubble ||FALSE ;else else /* Claim the sequence on the drag gesture, but attach no * selection data , this is a special case to start DnD . break ;else if (gtk_event_treat_as_touch (event))else break ;case 2 :case 3 :2 ? SELECT_WORDS : SELECT_LINES,break ;default :break ;if (n_press >= 3 )static void int n_press,double x,double y,if (gtk_event_treat_as_touch (event) &&0 &&0 )static void static void ": focus_in\n" ));if (cursor_visible (text_view) && priv->layout)TRUE );if (seat)else if (keyboard)"notify::direction" ,if (priv->editable)TRUE ;static void ": focus_out\n" ));if (cursor_visible (text_view) && priv->layout)FALSE );if (seat)else if (keyboard)FALSE ;if (priv->editable)TRUE ;static void double x,double y,static void 0 );while (priv->first_validate_idle != 0 )": first_validate_idle: %d\n" ,if (!priv->onscreen_validated)": somehow some text lines were modified or scrolling occurred since the last validation of lines on the screen - may be a text widget bug." );FALSE ;static void FALSE ;if (priv->border_window_size.left || priv->border_window_size.top)TRUE ;0 ,0 ,if (GTK_TEXT_VIEW_GET_CLASS (text_view)->snapshot_layer != NULL)BELOW_TEXT, snapshot);if (GTK_TEXT_VIEW_GET_CLASS (text_view)->snapshot_layer != NULL)ABOVE_TEXT, snapshot);if (did_save)static inline void if (child != NULL)static void const GList *iter;">Exposed (" G_STRLOC")\n" ));for (iter = priv->anchored_children.head; iter; iter = iter->next)const AnchoredChild *vc = iter->data;/** * gtk_text_view_remove : * @ text_view : a ` GtkTextView ` * @ child : the child to remove * * Removes a child widget from @ text_view . void if (GTK_IS_TEXT_VIEW_CHILD (child))if (vc == priv->left_child)else if (vc == priv->right_child)else if (vc == priv->top_child)else if (vc == priv->bottom_child)else if (vc == priv->center_child)else if (vcp)return ;if (ac == NULL)"%s is not a child of %s" ,return ;#define CURSOR_ON_MULTIPLIER 2 #define CURSOR_OFF_MULTIPLIER 1 #define CURSOR_PEND_MULTIPLIER 3 #define CURSOR_DIVIDER 3 static gbooleanif (!GTK_IS_WINDOW (root))return FALSE ;#ifdef DEBUG_VALIDATION_AND_SCROLLINGreturn FALSE ;#endif if (gtk_widget_get_mapped (GTK_WIDGET (text_view)) &&"gtk-cursor-blink" , &blink, NULL);if (!blink)return FALSE ;if (text_view->priv->editable)if (gtk_text_iter_editable (&iter, text_view->priv->editable))return blink;return FALSE ;static gboolean"gtk-keynav-use-caret" , &use_caret, NULL);return use_caret || text_view->priv->cursor_visible;static gboolean"gtk-enable-primary-paste" , &paste, NULL);return paste;static int int time;"gtk-cursor-blink-time" , &time, NULL);return time;static int int time;"gtk-cursor-blink-timeout" , &time, NULL);return time;/* * Blink ! typedef struct {static gboolean blink_cb (GtkWidget *widget,static void int blink_time;1 .0 ;1 );if (delay)1000 / 2 ;1000 ;static void if (priv->blink_tick)0 ;static float float phase)/* keep it simple, and split the blink cycle evenly * into visible , fading out , invisible , fading in if (phase < 0 .25 )return 1 ;else if (phase < 0 .5 )return 1 - 4 * (phase - 0 .25 );else if (phase < 0 .75 )return 0 ;else return 4 * (phase - 0 .75 );static gbooleanint blink_timeout;int blink_time;float phase;float alpha;if (now > priv->blink_start_time + blink_timeout * 1000000 )/* we've blinked enough without the user doing anything, stop blinking */ 1 .0 ;return G_SOURCE_REMOVE;float ) (data->end - data->start);if (now >= data->end)1000 ;if (priv->cursor_alpha != alpha)return G_SOURCE_CONTINUE;static void static void if (cursor_blinks (text_view) && cursor_visible (text_view))if (!priv->blink_tick)FALSE );else if (priv->blink_tick)static void if (cursor_blinks (text_view) && cursor_visible (text_view))TRUE );static void /* * Key binding handlers static gbooleanint count)TRUE ;while (count < 0 )while (count > 0 )return ret;static void const GtkTextIter *new_location,if (extend_selection)"insert" ,else static gbooleanconst GtkTextIter *iter)char *text;0 );1 );return direction == PANGO_DIRECTION_RTL;static void int count,FALSE ;int cursor_x_pos = 0 ;1 ;if (!cursor_visible (text_view))double old_xpos, old_ypos;switch (step)case GTK_MOVEMENT_VISUAL_POSITIONS:0 ? GTK_DIR_RIGHT : GTK_DIR_LEFT;case GTK_MOVEMENT_LOGICAL_POSITIONS:case GTK_MOVEMENT_WORDS:break ;case GTK_MOVEMENT_DISPLAY_LINE_ENDS:break ;case GTK_MOVEMENT_DISPLAY_LINES:0 ? GTK_DIR_DOWN : GTK_DIR_UP;case GTK_MOVEMENT_PARAGRAPHS:case GTK_MOVEMENT_PARAGRAPH_ENDS:break ;case GTK_MOVEMENT_PAGES:break ;case GTK_MOVEMENT_HORIZONTAL_PAGES:break ;case GTK_MOVEMENT_BUFFER_ENDS:break ;default :break ;if ((old_xpos == gtk_adjustment_get_target_value (priv->hadjustment) &&1 &&"move-focus" , leave_direction);return ;if (step == GTK_MOVEMENT_PAGES)if (!gtk_text_view_scroll_pages (text_view, count, extend_selection))return ;else if (step == GTK_MOVEMENT_HORIZONTAL_PAGES)if (!gtk_text_view_scroll_hpages (text_view, count, extend_selection))return ;if (! extend_selection)0 ;if (iter_line_is_rtl (&insert))/* 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 (move_forward)else /* 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))TRUE ;if (step == GTK_MOVEMENT_DISPLAY_LINES)switch (step)case GTK_MOVEMENT_LOGICAL_POSITIONS:if (! cancel_selection)break ;case GTK_MOVEMENT_VISUAL_POSITIONS:if (! cancel_selection)break ;case GTK_MOVEMENT_WORDS:if (iter_line_is_rtl (&newplace))1 ;if (count < 0 )if (!gtk_text_iter_backward_visible_word_starts (&newplace, -count))0 );else if (count > 0 )if (!gtk_text_iter_forward_visible_word_ends (&newplace, count))break ;case GTK_MOVEMENT_DISPLAY_LINES:if (count < 0 )if (gtk_text_view_move_iter_by_lines (text_view, &newplace, count))else 0 );if (count > 0 )if (gtk_text_view_move_iter_by_lines (text_view, &newplace, count))else break ;case GTK_MOVEMENT_DISPLAY_LINE_ENDS:if (count > 1 )else if (count < -1 )if (count != 0 )break ;case GTK_MOVEMENT_PARAGRAPHS:if (count > 0 )if (!gtk_text_iter_ends_line (&newplace))else if (count < 0 )if (gtk_text_iter_get_line_offset (&newplace) > 0 )0 );0 );break ;case GTK_MOVEMENT_PARAGRAPH_ENDS:if (count > 0 )if (!gtk_text_iter_ends_line (&newplace))else if (count < 0 )0 );break ;case GTK_MOVEMENT_BUFFER_ENDS:if (count > 0 )else if (count < 0 )0 );break ;case GTK_MOVEMENT_PAGES:case GTK_MOVEMENT_HORIZONTAL_PAGES:/* We handle these cases above and return early from them. */ default :break ;/* call move_cursor() even if the cursor hasn't moved, since it cancels the selection ": scrolling onscreen\n" ));if (step == GTK_MOVEMENT_DISPLAY_LINES)1 );if (gtk_text_iter_equal (&insert, &newplace))if (leave_direction != (GtkDirectionType)-1 )if (!gtk_widget_keynav_failed (GTK_WIDGET (text_view), leave_direction))"move-focus" , leave_direction);else if (!cancel_selection)TRUE ;static void int count)double increment;double value;switch (step)case GTK_SCROLL_STEPS:case GTK_SCROLL_PAGES:case GTK_SCROLL_ENDS:break ;case GTK_SCROLL_HORIZONTAL_STEPS:case GTK_SCROLL_HORIZONTAL_PAGES:case GTK_SCROLL_HORIZONTAL_ENDS:break ;default :break ;switch (step)case GTK_SCROLL_STEPS:case GTK_SCROLL_HORIZONTAL_STEPS:break ;case GTK_SCROLL_PAGES:case GTK_SCROLL_HORIZONTAL_PAGES:break ;case GTK_SCROLL_ENDS:case GTK_SCROLL_HORIZONTAL_ENDS:nt);break ;default :0 .0 ;break ;static void "anchor" , &insert, TRUE );static gbooleanint count,int cursor_x_pos, cursor_y_pos;double newval;double oldval;int y0, y1;FALSE );/* 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 (priv->pending_scroll)else /* Validate the region that will be brought into view by the cursor motion if (count < 0 )ent (adjustment);else ize (adjustment);0 ;/* FIXME do we need to update the adjustment ranges here? */ if (count < 0 && gtk_adjustment_get_value (adjustment) <= (gtk_adjustment_get_lower (adjustment) + 1 e-12 ))/* already at top, just be sure we are at offset 0 */ else if (count > 0 && gtk_adjustment_get_value (adjustment) >= (gtk_adjustment_get_upper (adjustment) - gtk_adjustment_get_page_size (adjustment) - 1 e-12 ))/* already at bottom, just be sure we are at the end */ else /* Adjust to have the cursor _entirely_ onscreen, move_mark_onscreen * only guarantees 1 pixel onscreen . ": scrolling onscreen\n" ));return !gtk_text_iter_equal (&old_insert, &new_insert);static gbooleanint count,int cursor_x_pos, cursor_y_pos;double newval;double oldval;int y, height;FALSE );/* 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 (priv->pending_scroll)else /* Validate the line that we're moving within. /* FIXME do we need to update the adjustment ranges here? */ if (count < 0 && gtk_adjustment_get_value (adjustment) <= (gtk_adjustment_get_lower (adjustment) + 1 e-12 ))/* already at far left, just be sure we are at offset 0 */ 0 );else if (count > 0 && gtk_adjustment_get_value (adjustment) >= (gtk_adjustment_get_upper (adjustment) - gtk_adjustment_get_page_size (adjustment) - 1 e-12 ))/* already at far right, just be sure we are at the end */ if (!gtk_text_iter_ends_line (&new_insert))else /* FIXME for lines shorter than the overall widget width, this results in a * " bounce " effect as we scroll to the right of the widget , then scroll * back to get the end of the line onscreen . * http : //bugzilla.gnome.org/show_bug.cgi?id=68963 /* Adjust to have the cursor _entirely_ onscreen, move_mark_onscreen * only guarantees 1 pixel onscreen . ": scrolling onscreen\n" ));return !gtk_text_iter_equal (&old_insert, &new_insert);static gbooleanreturn (ch == ' ' || ch == '\t' );static gbooleanreturn !whitespace (ch, user_data);static gbooleanconst GtkTextIter *center,if (gtk_text_iter_backward_find_char (start, not_whitespace, NULL, NULL))/* we want the first whitespace... */ if (whitespace (gtk_text_iter_get_char (end), NULL))return !gtk_text_iter_equal (start, end);static void const char *str)if (!gtk_text_buffer_insert_interactive_at_cursor (get_buffer (text_view), str, -1 ,static void int count)FALSE ;/* If a selection exists, we operate on it first */ if (gtk_text_buffer_delete_selection (get_buffer (text_view), TRUE ,TRUE ;return ;switch (type)case GTK_DELETE_CHARS:break ;case GTK_DELETE_WORD_ENDS:if (count > 0 )else if (count < 0 )if (!gtk_text_iter_backward_word_starts (&start, 0 - count))0 );break ;case GTK_DELETE_WORDS:break ;case GTK_DELETE_DISPLAY_LINE_ENDS:break ;case GTK_DELETE_DISPLAY_LINES:break ;case GTK_DELETE_PARAGRAPH_ENDS:if (count > 0 )/* 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))while (count > 0 )if (!gtk_text_iter_forward_to_line_end (&end))break ;else if (count < 0 )if (gtk_text_iter_starts_line (&start))if (!gtk_text_iter_ends_line (&end))else 0 );break ;case GTK_DELETE_PARAGRAPHS:if (count > 0 )0 );/* Do the lines beyond the first. */ while (count > 1 )/* FIXME negative count? */ break ;case GTK_DELETE_WHITESPACE:break ;default :break ;if (!gtk_text_iter_equal (&start, &end))if (gtk_text_buffer_delete_interactive (get_buffer (text_view), &start, &end,if (leave_one)" " , 1 ,else 1 , -1 );": scrolling onscreen\n" ));else TRUE ;static void /* Backspace deletes the selection, if one exists */ if (gtk_text_buffer_delete_selection (get_buffer (text_view), TRUE ,TRUE ;return ;if (gtk_text_buffer_backspace (get_buffer (text_view), &insert,TRUE , priv->editable))1 , -1 );": scrolling onscreen\n" ));TRUE ;else static void ": scrolling onscreen\n" ));static void /* on copy do not scroll, we are already onscreen */ static void TRUE ;static void if (priv->scroll_after_paste)": scrolling onscreen\n" ));;FALSE ;static void static void char *text,int len,int position;int length;static void static void if (priv->layout)/** * gtk_text_view_get_overwrite : * @ text_view : a ` GtkTextView ` * * Returns whether the ` GtkTextView ` is in overwrite mode or not . * * Returns : whether @ text_view is in overwrite mode or not . FALSE );return text_view->priv->overwrite_mode;/** * gtk_text_view_set_overwrite : * @ text_view : a ` GtkTextView ` * @ overwrite : % TRUE to turn on overwrite mode , % FALSE to turn it off * * Changes the ` GtkTextView ` overwrite mode . void FALSE ;if (text_view->priv->overwrite_mode != overwrite)/** * gtk_text_view_set_accepts_tab : * @ text_view : A ` GtkTextView ` * @ accepts_tab : % TRUE if pressing the Tab key should insert a tab * character , % FALSE , if pressing the Tab key should move the * keyboard focus . * * Sets the behavior of the text widget when the < kbd > Tab < / kbd > 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 . * * Focus can always be moved using < kbd > Ctrl < / kbd > + < kbd > Tab < / kbd > . void FALSE ;if (text_view->priv->accepts_tab != accepts_tab)/** * gtk_text_view_get_accepts_tab : * @ text_view : A ` GtkTextView ` * * Returns whether pressing the < kbd > Tab < / kbd > key inserts a tab characters . * * See [ method @ Gtk . TextView . set_accepts_tab ] . * * Returns : % TRUE if pressing the Tab key inserts a tab character , * % FALSE if pressing the Tab key moves the keyboard focus . FALSE );return text_view->priv->accepts_tab;/* * Selections static void static void const char *mark_name)/* This may invalidate the layout */ ": move mark\n" ));": scrolling onscreen\n" ));"first validate idle leaving %s is %d\n" ,static gbooleanreturn G_SOURCE_CONTINUE; /* remain installed. */ static void const GtkTextIter *location,FALSE ;switch (granularity)case SELECT_CHARACTERS:return ;case SELECT_WORDS:break ;case SELECT_LINES:break ;default :0 ,if (!handled)static gbooleanconst GtkTextIter *location,switch (granularity)case GTK_TEXT_EXTEND_SELECTION_WORD:if (gtk_text_iter_inside_word (start))if (!gtk_text_iter_starts_word (start))if (!gtk_text_iter_ends_word (end))if (!gtk_text_iter_forward_visible_word_end (end))else /* @start is not contained in a word: the selection is extended to all * the white spaces between the end of the word preceding @ start and * the start of the one following . if (gtk_text_iter_backward_visible_word_start (&tmp))if (gtk_text_iter_get_line (&tmp) == gtk_text_iter_get_line (start))else 0 );if (!gtk_text_iter_forward_visible_word_end (&tmp))if (gtk_text_iter_ends_word (&tmp))if (gtk_text_iter_get_line (&tmp) == gtk_text_iter_get_line (end))break ;case GTK_TEXT_EXTEND_SELECTION_LINE:if (gtk_text_view_starts_display_line (text_view, start))/* If on a display line boundary, we assume the user * clicked off the end of a line and we therefore select * the line before the boundary . else /* start isn't on the start of a line, so we move it to the * start , and move end to the end unless it ' s already there . if (!gtk_text_view_starts_display_line (text_view, end))break ;default :return GDK_EVENT_STOP;typedef struct static void if (data->orig_start != NULL)if (data->orig_end != NULL)static gbooleanint *start_x,int *start_y,int *x,int *y)double sx, sy, ox, oy;if (!gtk_gesture_drag_get_start_point (gesture, &sx, &sy) ||return FALSE ;return TRUE ;static void double offset_x,double offset_y,int start_x, start_y, x, y;if (!drag_gesture_get_text_surface_coords (gesture, text_view,return ;if (!data)/* If no data is attached, the initial press happened within the current * text selection , check for drag and drop to be initiated . if (gtk_drag_check_threshold_double (GTK_WIDGET (text_view), 0 , 0 , offset_x, offset_y))if (!gtk_event_treat_as_touch (event))int buffer_x, buffer_y;/* Deny the gesture so we don't get further updates */ return ;else TRUE );else return ;/* Text selection */ if (data->granularity == SELECT_CHARACTERS)"insert" );else /* either the selection extends to the front, or end (or not) */ if (gtk_text_iter_compare (&orig_start, &start) < 0 )if (gtk_text_iter_compare (&orig_end, &end) > 0 )if (gtk_text_iter_compare (&orig_start, &start) != 0 ||0 )/* If we had to scroll offscreen, insert a timeout to do so * again . Note that in the timeout , even if the mouse doesn ' t * move , due to this scroll xoffset / yoffset will have changed * and we ' ll need to scroll again . if (text_view->priv->scroll_timeout != 0 ) /* reset on every motion event */ 50 , selection_scan_timeout, text_view);"[gtk] selection_scan_timeout" );if (gtk_event_treat_as_touch (event))TRUE ;static void double offset_x,double offset_y,int start_x, start_y, x, y;re));if (priv->magnifier_popover)FALSE );if (!drag_gesture_get_text_surface_coords (gesture, text_view,return ;/* Check whether the drag was cancelled rather than finished */ if (!gtk_gesture_handles_sequence (GTK_GESTURE (gesture), sequence))return ;if ((gtk_event_treat_as_touch (event) || clicked_in_selection) &&0 , 0 , offset_x, offset_y))/* Unselect everything; we clicked inside selection, but * didn ' t move by the drag threshold , so just clear selection * and place cursor . static void const GtkTextIter *iter,1 );if (extend)/* Extend selection */ ;(buffer));/* move the front cursor, if the mouse is in front of the selection. Should the * cursor however be inside the selection ( this happens on triple click ) then we if (gtk_text_iter_compare (&cursor, &old_start) <= 0 ||0 &&0 ))else /* Store any previous selection */ if (gtk_text_iter_compare (&old_start, &old_end) != 0 )TRUE );TRUE );// gtk_gesture_set_state (priv->drag_gesture, // GTK_EVENT_SEQUENCE_CLAIMED); /* returns whether we were really dragging */ static gbooleanif (!gtk_gesture_is_active (priv->drag_gesture))return FALSE ;if (priv->magnifier_popover)FALSE );return TRUE ;/* * Layout utils static void const GdkRGBA black = { 0 , };const GdkRGBA *decoration_color;if (!values->appearance.bg_rgba)if (!values->appearance.fg_rgba)olor);if (values->font)/* text-decoration */ xt_decoration_line);text_decoration_style);if (decoration_line & GTK_CSS_TEXT_DECORATION_LINE_UNDERLINE)switch (decoration_style)case GTK_CSS_TEXT_DECORATION_STYLE_DOUBLE:break ;case GTK_CSS_TEXT_DECORATION_STYLE_WAVY:break ;case GTK_CSS_TEXT_DECORATION_STYLE_SOLID:default :break ;if (values->appearance.underline_rgba)else else if (decoration_line & GTK_CSS_TEXT_DECORATION_LINE_OVERLINE)if (values->appearance.overline_rgba)else else if (decoration_line & GTK_CSS_TEXT_DECORATION_LINE_LINE_THROUGH)TRUE ;if (values->appearance.strikethrough_rgba)else else FALSE ;/* letter-spacing */ 100 ) * PANGO_SCALE;/* line-height */ FALSE ;if (values->line_height != 0 .0 )if (gtk_css_number_value_get_dimension (style->font->line_height) == GTK_CSS_DIMENSION_LENGTH)TRUE ;/* OpenType features */ /* text-transform */ static void if (!priv->layout)return ;;if (seat)else if (keyboard)else "gtk-split-cursor" , &split_cursor,if (direction == PANGO_DIRECTION_RTL)else if (split_cursor)else static void if (priv->layout == NULL)const GList *iter;"\n" ));"invalidated" ,"changed" ,"allocate-child" ,if (get_buffer (text_view))if ((gtk_widget_has_focus (widget) && cursor_visible (text_view)))else FALSE );/* Set layout for all anchored children */ while (iter != NULL)const AnchoredChild *ac = iter->data;/* ac may now be invalid! */ return priv->layout;return gtk_text_attributes_copy (text_view->priv->layout->default_style);static void if (priv->layout)const GList *iter;while (iter != NULL)const AnchoredChild *ac = iter->data;/* vc may now be invalid! */ /** * 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 . void if (text_view->priv->need_im_reset)FALSE ;/** * 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 [ method @ Gtk . IMContext . 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 ` . * * ` ` ` c * static gboolean * gtk_foo_bar_key_press_event ( GtkWidget * widget , * GdkEvent * event ) * { * guint keyval ; * * gdk_event_get_keyval ( ( GdkEvent * ) event , & keyval ) ; * * if ( keyval = = GDK_KEY_Return | | keyval = = GDK_KEY_KP_Enter ) * { * if ( gtk_text_view_im_context_filter_keypress ( GTK_TEXT_VIEW ( widget ) , event ) ) * return TRUE ; * } * * // Do some stuff * * return GTK_WIDGET_CLASS ( gtk_foo_bar_parent_class ) - > key_press_event ( widget , event ) ; * } * ` ` ` * * Returns : % TRUE if the input method handled the key event . FALSE );return gtk_im_context_filter_keypress (text_view->priv->im_context, event);/* * DND feature static void if (self->priv->dnd_drag_begin_mark)if (gdk_drag_get_selected_action (drag) == GDK_ACTION_MOVE)static void if (self->priv->dnd_drag_begin_mark)static void const GtkTextIter *iter,int x,int y)if (text_view->priv->editable)else "dnd-finished" , G_CALLBACK (dnd_finished_cb), text_view);"cancel" , G_CALLBACK (dnd_cancel_cb), text_view);if (gtk_text_buffer_get_selection_bounds (buffer, &start, &end))0 , 0 );TRUE TRUE );static void FALSE );static GdkDragActiondouble x,double y,int bx, by;FALSE ;if (gtk_text_buffer_get_selection_bounds (get_buffer (text_view),0 &&0 )/* We're inside the selection. */ else if (can_accept)if (text_view->priv->drag)return GDK_ACTION_MOVE;else return GDK_ACTION_COPY;else FALSE );return 0 ;static gbooleanconst GValue *value,double x,double y,if (!gtk_text_iter_can_insert (&drop_point, priv->editable))return FALSE ;if (!gtk_text_buffer_insert_interactive (buffer,char *) g_value_get_string (value), -1 ,return TRUE ;static void if (adjustment && priv->hadjustment == adjustment)return ;if (priv->hadjustment != NULL)if (adjustment == NULL)0 .0 , 0 .0 , 0 .0 , 0 .0 , 0 .0 , 0 .0 );"value-changed" ,static void if (adjustment && priv->vadjustment == adjustment)return ;if (priv->vadjustment != NULL)if (adjustment == NULL)0 .0 , 0 .0 , 0 .0 , 0 .0 , 0 .0 , 0 .0 );"value-changed" ,static void int screen_width;double old_value;double new_value;double new_upper;"lower" , 0 .0 ,"upper" , new_upper,"page-size" , (double )screen_width,"step-increment" , screen_width * 0 .1 ,"page-increment" , screen_width * 0 .9 ,0 , new_upper - screen_width);if (new_value != old_value)static void int screen_height;int y;double old_value;double new_value;double new_upper;"lower" , 0 .0 ,"upper" , new_upper,"page-size" , (double )screen_height,"step-increment" , screen_height * 0 .1 ,"page-increment" , screen_height * 0 .9 ,/* Now adjust the value of the adjustment to keep the cursor at the 0 , new_upper - screen_height);if (new_value != old_value)static void int line_top;double dx = 0 ;double dy = 0 ;double value;/* Note that we oddly call this function with adjustment == NULL * sometimes FALSE ;">Scroll offset changed %s/%g, onscreen_validated = FALSE (" G_STRLOC")\n" ,"hadjustment" : adjustment == priv->vadjustment ? "vadjustment" : "none" ,0 .0 ));if (adjustment == priv->hadjustment)else if (adjustment == priv->vadjustment)if (priv->layout)if (dx != 0 || dy != 0 )if (gtk_widget_get_realized (GTK_WIDGET (text_view)))if (priv->selection_bubble)FALSE );/* This could result in invalidation, which would install the * first_validate_idle , which would validate onscreen ; * but we ' re going to go ahead and validate here , so * first_validate_idle shouldn ' t have anything to do . /* We also update the IM spot location here, since the IM context * might do something that leads to validation . /* 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 * that , or shouldn ' t be . /* If this got installed, get rid of it, it's just a waste of time. */ /* Allow to extend selection with mouse scrollwheel. Bug 710612 */ if (gtk_gesture_is_active (priv->drag_gesture))rag_gesture));if (current_event != NULL)if (gdk_event_get_event_type (current_event) == GDK_SCROLL)"insert" );/* Finally we update the IM cursor location again, to ensure any * changes made by the validation are pushed through . if (priv->anchored_children.length > 0 ||else ">End scroll offset changed handler (" G_STRLOC")\n" ));static void const char *str,static void const char *str,if (gtk_text_buffer_delete_selection (get_buffer (text_view), TRUE , priv->editable))/* If something was deleted, create a second group for the insert. This * ensures that there are two undo operations . One for the deletion , and * one for the insertion of new text . However , if there is only a single * character overwritten , that isn ' t very useful , just keep the single * undo group . if (length > 1 )if (strcmp (str, "\n" ) == 0 )if (!gtk_text_buffer_insert_interactive_at_cursor (get_buffer (text_view), "\n" , 1 ,else if (!had_selection && priv->overwrite_mode)if (!gtk_text_iter_ends_line (&insert))1 );if (!gtk_text_buffer_insert_interactive_at_cursor (get_buffer (text_view), str, -1 ,1 , -1 );": scrolling onscreen\n" ));static void TRUE , self->priv->editable);static void char *str;int 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 when the event is handled by GTK . if (str && str[0 ] && !gtk_text_iter_can_insert (&iter, priv->editable))goto out;0 , str);if (priv->layout)if (gtk_widget_has_focus (GTK_WIDGET (text_view)))static gbooleanint cursor_pos;int anchor_pos;char *text;char *pre;char *sel;char *post;0 ;0 );3 );if (gtk_text_iter_compare (&start2, &start1) < 0 )3 );if (gtk_text_iter_compare (&end2, &end1) > 0 )if (flip)else 1 , cursor_pos, anchor_pos);return TRUE ;static gbooleanint offset,int n_chars,return TRUE ;static void const GtkTextIter *location,FALSE ;if (mark == gtk_text_buffer_get_insert (buffer))1 ;1 ;TRUE ;else if (mark == gtk_text_buffer_get_selection_bound (buffer))TRUE ;if (need_reset)LL);if (has_selection)static void int *x,int *y)if ((x && priv->virtual_cursor_x == -1 ) ||1 ))if (cursor)else if (x)if (priv->virtual_cursor_x != -1 )else if (y)if (priv->virtual_cursor_y != -1 )else 2 ;else if (x)if (y)static void int x,int y)if (!text_view->priv->layout)return ;if (x == -1 || y == -1 )if (x == -1 )if (y == -1 )2 ;static void if (priv->selection_bubble && gtk_widget_get_visible (priv->selection_bubble))FALSE );static void if (select)else "selection_bound" , &insert);static gbooleanconst GtkTextIter *start,const GtkTextIter *end,while (gtk_text_iter_compare (&iter, end) < 0 )if (gtk_text_iter_editable (&iter, default_editability))return TRUE ;return FALSE ;static void const char *action_name,"cut-clipboard" );static void const char *action_name,"copy-clipboard" );static void const char *action_name,"paste-clipboard" );static void const char *action_name,TRUE );static void const char *action_name,TRUE ,static void const char *action_name,static void const char *action_name,static void , G_TYPE_STRING);"clipboard.cut" ,"clipboard.copy" ,"clipboard.paste" ,"selection.delete" ,"selection.select-all" ,0 );static void "misc.insert-emoji" ,0 &&static void "text.clear" , text_view->priv->editable);static GMenuModel *"Cu_t" ), "clipboard.cut" );"touch-icon" , "s" , "edit-cut-symbolic" );"_Copy" ), "clipboard.copy" );"touch-icon" , "s" , "edit-copy-symbolic" );"_Paste" ), "clipboard.paste" );"touch-icon" , "s" , "edit-paste-symbolic" );"_Delete" ), "selection.delete" );"touch-icon" , "s" , "edit-delete-symbolic" );"_Undo" ), "text.undo" );"touch-icon" , "s" , "edit-undo-symbolic" );"_Redo" ), "text.redo" );"touch-icon" , "s" , "edit-redo-symbolic" );"Select _All" ), "selection.select-all" );"touch-icon" , "s" , "edit-select-all-symbolic" );"Insert _Emoji" ), "misc.insert-emoji" );"hidden-when" , "s" , "action-disabled" );"touch-icon" , "s" , "face-smile-symbolic" );if (priv->extra_menu)return G_MENU_MODEL (joined);static void if (!gtk_widget_get_realized (GTK_WIDGET (text_view)))return ;if (!priv->popup_menu)FALSE );"Context menu" ),1 );if (trigger_event && gdk_event_triggers_context_menu (trigger_event))0 , 0 , 1 , 1 };if (device == gdk_seat_get_keyboard (seat))if (device)double px, py;double nx, ny;if (!gtk_widget_compute_point (GTK_WIDGET (gtk_widget_get_native (GTK_WIDGET (text_view))),else if (is_visible)static void const char *action_name,static void int x1, y1, x2, y2;static void static void int index)const char *icon_name;const char *action_name;FALSE ;const GVariantType *param_type;const GVariantType *state_type;"section" );if (link)int i;for (i = 0 ; i < g_menu_model_get_n_items (link); i++)return ;"touch-icon" , G_VARIANT_TYPE_STRING);if (att == NULL)return ;"action" , G_VARIANT_TYPE_STRING);if (att == NULL)return ;FALSE );if (muxer)if (!gtk_action_muxer_query_action (muxer, action_name, &enabled, ¶m_type, &state_type, NULL, NULL))return ;if (!enabled)return ;if (param_type == NULL &&TRUE ;if (is_toggle_action)else FALSE );"image-button" );static gbooleanint i;0 ;"touch-selection" );FALSE );"notify::visible" ,5 );10 );10 );10 );10 );0 );"linked" );for (i = 0 ; i < g_menu_model_get_n_items (model); i++)5 ;5 ;10 ;10 ;TRUE );return G_SOURCE_REMOVE;static void if (priv->selection_bubble)FALSE );static void if (priv->selection_bubble_timeout_id)50 , gtk_text_view_selection_bubble_popup_show, text_view);"[gtk] gtk_text_view_selection_bubble_popup_cb" );/* Child GdkSurfaces */ static void if (gtk_css_style_change_affects (change, GTK_CSS_AFFECTS_SIZE))else static void if (priv->text_window == NULL)return ;if (priv->left_child)if (priv->top_child)if (priv->right_child)if (priv->bottom_child)static GtkTextWindow*1 );0 ;0 ;0 ;0 ;"style-changed" , G_CALLBACK (node_style_changed_cb), widget, 0 );"text" ));return win;static void static void static int return win->allocation.width;static int return win->allocation.height;/* Windows */ /** * gtk_text_view_buffer_to_window_coords : * @ text_view : a ` GtkTextView ` * @ win : a ` GtkTextWindowType ` * @ buffer_x : buffer x coordinate * @ buffer_y : buffer y coordinate * @ window_x : ( out ) ( optional ) : window x coordinate return location * @ window_y : ( out ) ( optional ) : window y coordinate return location * * Converts buffer coordinates to window coordinates . void int buffer_x,int buffer_y,int *window_x,int *window_y)switch (win)case GTK_TEXT_WINDOW_WIDGET:break ;case GTK_TEXT_WINDOW_TEXT:break ;case GTK_TEXT_WINDOW_LEFT:break ;case GTK_TEXT_WINDOW_RIGHT:break ;case GTK_TEXT_WINDOW_TOP:break ;case GTK_TEXT_WINDOW_BOTTOM:break ;default :"%s: Unknown GtkTextWindowType" , G_STRFUNC);break ;if (window_x)if (window_y)/** * gtk_text_view_window_to_buffer_coords : * @ text_view : a ` GtkTextView ` * @ win : a ` GtkTextWindowType ` * @ window_x : window x coordinate * @ window_y : window y coordinate * @ buffer_x : ( out ) ( optional ) : buffer x coordinate return location * @ buffer_y : ( out ) ( optional ) : buffer y coordinate return location * * Converts coordinates on the window identified by @ win to buffer * coordinates . void int window_x,int window_y,int *buffer_x,int *buffer_y)switch (win)case GTK_TEXT_WINDOW_WIDGET:break ;case GTK_TEXT_WINDOW_TEXT:break ;case GTK_TEXT_WINDOW_LEFT:break ;case GTK_TEXT_WINDOW_RIGHT:break ;case GTK_TEXT_WINDOW_TOP:break ;case GTK_TEXT_WINDOW_BOTTOM:break ;default :"%s: Unknown GtkTextWindowType" , G_STRFUNC);break ;if (buffer_x)if (buffer_y)/* * Child widgets static AnchoredChild *1 );0 ;0 ;return vc;static void static void /** * gtk_text_view_add_child_at_anchor : * @ text_view : a ` GtkTextView ` * @ child : a ` GtkWidget ` * @ anchor : a ` GtkTextChildAnchor ` in the ` GtkTextBuffer ` for @ text_view * * Adds a child widget in the text buffer , at the given @ anchor . void static void if (*child != NULL)return ;/** * gtk_text_view_add_overlay : * @ text_view : a ` GtkTextView ` * @ child : a ` GtkWidget ` * @ xpos : X position of child in window coordinates * @ ypos : Y position of child in window coordinates * * Adds @ child at a fixed coordinate in the ` GtkTextView ` ' s text window . * * The @ xpos and @ ypos must be in buffer coordinates ( see * [ method @ Gtk . TextView . get_iter_location ] to convert to * buffer coordinates ) . * * @ child will scroll with the text view . * * If instead you want a widget that will not move with the * ` GtkTextView ` contents see ` GtkOverlay ` . void int xpos,int ypos)/** * gtk_text_view_move_overlay : * @ text_view : a ` GtkTextView ` * @ child : a widget already added with [ method @ Gtk . TextView . add_overlay ] * @ xpos : new X position in buffer coordinates * @ ypos : new Y position in buffer coordinates * * Updates the position of a child . * * See [ method @ Gtk . TextView . add_overlay ] . void int xpos,int ypos)_child);/* Iterator operations */ /** * gtk_text_view_forward_display_line : * @ 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 * separated by newlines or other paragraph separator characters . * 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 * views , since they depend on the contents of the ` GtkTextBuffer ` . * * Returns : % TRUE if @ iter was moved and is not on the end iterator FALSE );FALSE );return gtk_text_layout_move_iter_to_next_line (text_view->priv->layout, iter);/** * gtk_text_view_backward_display_line : * @ 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 * separated by newlines or other paragraph separator characters . * 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 * views , since they depend on the contents of the ` GtkTextBuffer ` . * * Returns : % TRUE if @ iter was moved and is not on the end iterator FALSE );FALSE );return gtk_text_layout_move_iter_to_previous_line (text_view->priv->layout, iter);/** * gtk_text_view_forward_display_line_end : * @ 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 * separated by newlines or other paragraph separator characters . * 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 * views , since they depend on the contents of the ` GtkTextBuffer ` . * * Returns : % TRUE if @ iter was moved and is not on the end iterator FALSE );FALSE );return gtk_text_layout_move_iter_to_line_end (text_view->priv->layout, iter, 1 );/** * gtk_text_view_backward_display_line_start : * @ 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 * separated by newlines or other paragraph separator characters . * 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 * views , since they depend on the contents of the ` GtkTextBuffer ` . * * Returns : % TRUE if @ iter was moved and is not on the end iterator FALSE );FALSE );return gtk_text_layout_move_iter_to_line_end (text_view->priv->layout, iter, -1 );/** * gtk_text_view_starts_display_line : * @ text_view : a ` GtkTextView ` * @ iter : a ` GtkTextIter ` * * Determines whether @ iter is at the start of a display line . * * See [ method @ Gtk . TextView . forward_display_line ] for an * explanation of display lines vs . paragraphs . * * Returns : % TRUE if @ iter begins a wrapped line const GtkTextIter *iter)FALSE );FALSE );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 ) * * Move the iterator a given number of characters visually , treating * it as the strong cursor position . * * If @ count is positive , then the new strong cursor position will * be @ count positions to the right of the old cursor position . * If @ count is negative then the new strong cursor position will * be @ count positions to the left of the old cursor position . * * In the presence of 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 . * * Returns : % TRUE if @ iter moved and is not on the end iterator int count)FALSE );FALSE );return gtk_text_layout_move_iter_visually (text_view->priv->layout, iter, count);/** * gtk_text_view_set_input_purpose : * @ text_view : a ` GtkTextView ` * @ purpose : the purpose * * Sets the ` input - purpose ` of the ` GtkTextView ` . * * The ` input - purpose ` can be used by on - screen keyboards * and other input methods to adjust their behaviour . void if (gtk_text_view_get_input_purpose (text_view) != purpose)"input-purpose" , purpose,/** * gtk_text_view_get_input_purpose : * @ text_view : a ` GtkTextView ` * * Gets the ` input - purpose ` of the ` GtkTextView ` . * * Returns : the input purpose "input-purpose" , &purpose,return purpose;/** * gtk_text_view_set_input_hints : * @ text_view : a ` GtkTextView ` * @ hints : the hints * * Sets the ` input - hints ` of the ` GtkTextView ` . * * The ` input - hints ` allow input methods to fine - tune * their behaviour . void if (gtk_text_view_get_input_hints (text_view) != hints)"input-hints" , hints,/** * gtk_text_view_get_input_hints : * @ text_view : a ` GtkTextView ` * * Gets the ` input - hints ` of the ` GtkTextView ` . * * Returns : the input hints "input-hints" , &hints,return hints;/** * gtk_text_view_set_monospace : * @ text_view : a ` GtkTextView ` * @ monospace : % TRUE to request monospace styling * * Sets whether the ` GtkTextView ` should display text in * monospace styling . void if (has_monospace != monospace)if (monospace)"monospace" );else "monospace" );/** * gtk_text_view_get_monospace : * @ text_view : a ` GtkTextView ` * * Gets whether the ` GtkTextView ` uses monospace styling . * * Return : % TRUE if monospace fonts are desired FALSE );return gtk_widget_has_css_class (GTK_WIDGET (text_view), "monospace" );static void const char *text,TRUE , TRUE );1 );static void if (gtk_widget_get_ancestor (GTK_WIDGET (text_view), GTK_TYPE_EMOJI_CHOOSER) != NULL)return ;"gtk-emoji-chooser" ));if (!chooser)"gtk-emoji-chooser" , chooser);"emoji-picked" , G_CALLBACK (emoji_picked), text_view);1 );1 );if (!gdk_rectangle_intersect (&rect2, &rect, &rect))2 ;2 ;0 ;0 ;/** * gtk_text_view_set_extra_menu : * @ text_view : a ` GtkTextView ` * @ model : ( nullable ) : a ` GMenuModel ` * * Sets a menu model to add when constructing the context * menu for @ text_view . * * You can pass % NULL to remove a previously set extra menu . void if (g_set_object (&priv->extra_menu, model))/** * gtk_text_view_get_extra_menu : * @ text_view : a ` GtkTextView ` * * Gets the menu model that gets added to the context menu * or % NULL if none has been set . * * Returns : ( transfer none ) ( nullable ) : the menu model return priv->extra_menu;static void const char *action_name,if (gtk_text_view_get_editable (text_view))static void const char *action_name,if (gtk_text_view_get_editable (text_view))static void "text.redo" ,static void "text.undo" ,/** * gtk_text_view_get_ltr_context : * @ text_view : a ` GtkTextView ` * * Gets the ` PangoContext ` that is used for rendering LTR directed * text layouts . * * The context may be replaced when CSS changes occur . * * Returns : ( transfer none ) : a ` PangoContext ` * * Since : 4 . 4 return text_view->priv->layout->ltr_context;/** * gtk_text_view_get_rtl_context : * @ text_view : a ` GtkTextView ` * * Gets the ` PangoContext ` that is used for rendering RTL directed * text layouts . * * The context may be replaced when CSS changes occur . * * Returns : ( transfer none ) : a ` PangoContext ` * * Since : 4 . 4 return text_view->priv->layout->rtl_context;return text_view->priv->key_controller;static double double inv_scale;if (!(native = gtk_widget_get_native (widget)) ||return (int )gtk_adjustment_get_value (adjustment);1 . / gdk_surface_get_scale (surface);return round (gtk_adjustment_get_value (adjustment) / inv_scale) * inv_scale;/* {{{ GtkAccessibleText implementation */ static GBytes *unsigned int start,unsigned int end)char *string;1 : end);FALSE );return g_bytes_new_take (string, strlen (string) + 1 );static GBytes *unsigned int offset,unsigned int *start,unsigned int *end)char *string;unsigned int line_start, line_end, line_offset;FALSE )->layout;if (start != NULL)if (end != NULL)return g_bytes_new_take (string, strlen (string));static unsigned int return gtk_text_iter_get_offset (&iter);static gbooleanint start, end;if (!gtk_text_buffer_get_selection_bounds (buffer, &start_iter, &end_iter))0 ;return FALSE ;1 ;1 );0 ].start = start;0 ].length = end - start;return TRUE ;static gbooleanunsigned int offset,char ***attribute_names,char ***attribute_values)int start, end;if (n_attrs == 0 )0 ;return FALSE ;char *, n_attrs + 1 );char *, n_attrs + 1 );0 ;while (g_hash_table_iter_next (&iter, &key, &value))1 ;return TRUE ;void if (font)char **names, **values;for (unsigned i = 0 ; names[i] != NULL; i++)#define ADD_STR_ATTR(ht,name,value) \#define ADD_BOOL_ATTR(ht,name,value) \"true" ) : g_strdup ("false" ))#define ADD_COLOR_ATTR(ht,name,color) G_STMT_START { \char *__value = g_strdup_printf ("%u,%u,%u" , \65535 ), \65535 ), \65535 )); \#define ADD_FLOAT_ATTR(ht,name,value) G_STMT_START { \char *__value = g_strdup_printf ("%g" , (value)); \#define ADD_INT_ATTR(ht,name,value) G_STMT_START { \char *__value = g_strdup_printf ("%i" , (value)); \"justification" , gtk_justification_to_string (text_attrs->justification));"direction" , gtk_text_direction_to_string (text_attrs->direction));"wrap-mode" , gtk_wrap_mode_to_string (text_attrs->wrap_mode));"underline" , pango_underline_to_string (text_attrs->appearance.underline));"editable" , text_attrs->editable);"invisible" , text_attrs->invisible);"bg-full-height" , text_attrs->bg_full_height);"strikethrough" , text_attrs->appearance.strikethrough);"bg-color" , text_attrs->appearance.bg_rgba);"fg-color" , text_attrs->appearance.fg_rgba);"scale" , text_attrs->font_scale);"language" , (const char *) text_attrs->language);"rise" , text_attrs->appearance.rise);"pixels-inside-wrap" , text_attrs->pixels_inside_wrap);"pixels-below-lines" , text_attrs->pixels_below_lines);"pixels-above-lines" , text_attrs->pixels_above_lines);"indent" , text_attrs->indent);"left-margin" , text_attrs->left_margin);"right-margin" , text_attrs->right_margin);#undef ADD_STR_ATTR#undef ADD_BOOL_ATTR#undef ADD_COLOR_ATTR#undef ADD_FLOAT_ATTR#undef ADD_INT_ATTR/*< private > * gtk_text_view_get_attributes_run : * @ self : a text view * @ offset : the offset , in characters * @ include_defaults : whether the default attributes should be included * @ start : ( out ) : the beginning of the run , in characters * @ end : ( out ) : the end of the run , in characters * * Retrieves the text attributes at the given offset . * * The serialization format is private to GTK , but conforms to the AT - SPI * text attributes for default attribute names . * * Returns : ( transfer full ) ( element - type utf8 , utf8 ) : a dictionary of * text attributes int offset,int *start,int *end)if (include_defaults)return attrs;static void char ***attribute_names,char ***attribute_values)if (n_attrs == 0 )return ;char *, n_attrs + 1 );char *, n_attrs + 1 );0 ;while (g_hash_table_iter_next (&iter, &key, &value))1 ;static gbooleanunsigned int start,unsigned int end,do while (gtk_text_iter_compare (&start_iter, &end_iter) < 0 );return TRUE ;static gbooleanconst graphene_point_t *point,unsigned int *offset)int x, y;if (!gtk_text_view_get_iter_at_location (text_view, &iter, x, y))return FALSE ;return TRUE ;static gbooleanunsigned int offset)return TRUE ;static gbooleanif (i != 0 )return FALSE ;return TRUE ;static void s;/* }}} */ /* vim:set foldmethod=marker: */
Messung V0.5 in Prozent C=98 H=97 G=97
¤ Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.0.709Bemerkung:
(vorverarbeitet am 2026-07-03)
¤ *Bot Zugriff
