/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* GTK - The GIMP Toolkit * Copyright ( C ) 1995 - 1997 Peter Mattis , Spencer Kimball and Josh MacDonald * Copyright ( C ) 2004 - 2006 Christian Hammond * Copyright ( C ) 2008 Cody Russell * Copyright ( C ) 2008 Red Hat , Inc . * * This library is free software ; you can redistribute it and / or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation ; either * version 2 of the License , or ( at your option ) any later version . * * This library is distributed in the hope that it will be useful , * but WITHOUT ANY WARRANTY ; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the GNU * Lesser General Public License for more details . * * You should have received a copy of the GNU Lesser General Public * License along with this library . If not , see < http : //www.gnu.org/licenses/>. #include "config.h" #include "gtktextprivate.h" #include "gtkaccessibletextprivate.h" #include "gtkactionable.h" #include "gtkactionmuxerprivate.h" #include "gtkadjustment.h" #include "gtkbox.h" #include "gtkbutton.h" #include "gtkdebug.h" #include "gtkdragicon.h" #include "gtkdragsourceprivate.h" #include "gtkdroptarget.h" #include "gtkeditable.h" #include "gtkemojichooser.h" #include "gtkemojicompletionprivate.h" #include "gtkentrybuffer.h" #include "gtkeventcontrollerfocus.h" #include "gtkeventcontrollerkey.h" #include "gtkeventcontrollermotion.h" #include "gtkgestureclick.h" #include "gtkgesturedrag.h" #include "gtkgesturelongpress.h" #include "gtkgesturesingle.h" #include "gtkimageprivate.h" #include "gtkimcontextsimple.h" #include "gtkimmulticontext.h" #include "gtkjoinedmenuprivate.h" #include "gtklabel.h" #include "gtkmagnifierprivate.h" #include "gtkmain.h" #include "gtkmarshalers.h" #include "gtknative.h" #include "gtkpangoprivate.h" #include "gtkpopovermenu.h" #include "gtkprivate.h" #include "gtkrenderbackgroundprivate.h" #include "gtkrenderborderprivate.h" #include "gtkrenderlayoutprivate.h" #include "gtksettings.h" #include "gtkshortcuttrigger.h" #include "gtksnapshot.h" #include "gtktexthandleprivate.h" #include "gtktexthistoryprivate.h" #include "gtktextutilprivate.h" #include "gtktooltip.h" #include "gtktypebuiltins.h" #include "gtkwidgetprivate.h" #include "gtkwindow.h" #include "deprecated/gtkrender.h" #include "a11y/gtkatspipangoprivate.h" #include <string.h>#include <cairo-gobject.h>#include <glib/gi18n-lib.h>/** * GtkText : * * A single - line text entry . * * ` GtkText ` is the common implementation of single - line text editing * that is shared between [ class @ Gtk . Entry ] , [ class @ Gtk . PasswordEntry ] , * [ class @ Gtk . SpinButton ] , and other widgets . In all of these , a ` GtkText ` * instance is used as the delegate for the [ iface @ Gtk . Editable ] implementation . * * A large number of key bindings s supported by default . If the entered * text is longer than the allocation of the widget , the widget will scroll * so that the cursor position is visible . * * When using an entry for passwords and other sensitive information , * it can be put into “ password mode ” using [ method @ Gtk . Text . set_visibility ] . * In this mode , entered text is displayed using an “ invisible ” character . * By default , GTK picks the best invisible character that is available * in the current font , but it can be changed with * [ method @ Gtk . Text . set_invisible_char ] . * * If you want to add icons or progress display in an entry , look at * [ class @ Gtk . Entry ] . There are other alternatives for more specialized * use cases , such as [ class @ Gtk . SearchEntry ] . * * If you need multi - line editable text , use [ class @ Gtk . TextView ] . * * # Shortcuts and Gestures * * ` GtkText ` supports the following keyboard shortcuts : * * - < kbd > Shift < / kbd > + < kbd > F10 < / kbd > or < kbd > Menu < / kbd > opens the context menu . * - < kbd > Ctrl < / kbd > + < kbd > A < / kbd > or < kbd > Ctrl < / kbd > + < kbd > & sol ; < / kbd > * selects all the text . * - < kbd > Ctrl < / kbd > + < kbd > Shift < / kbd > + < kbd > A < / kbd > or * < kbd > Ctrl < / kbd > + < kbd > & bsol ; < / kbd > unselects all . * - < 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 > Ctrl < / kbd > + < kbd > Shift < / kbd > + < kbd > T < / kbd > toggles the text direction . * - < kbd > Clear < / kbd > clears the content . * * Additionally , the following signals have default keybindings : * * - [ signal @ Gtk . Text : : activate ] * - [ signal @ Gtk . Text : : backspace ] * - [ signal @ Gtk . Text : : copy - clipboard ] * - [ signal @ Gtk . Text : : cut - clipboard ] * - [ signal @ Gtk . Text : : delete - from - cursor ] * - [ signal @ Gtk . Text : : insert - emoji ] * - [ signal @ Gtk . Text : : move - cursor ] * - [ signal @ Gtk . Text : : paste - clipboard ] * - [ signal @ Gtk . Text : : toggle - overwrite ] * * # Actions * * ` GtkText ` 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 . * - ` misc . toggle - visibility ` toggles the ` GtkText ` : visibility property . * - ` misc . toggle - direction ` toggles the text direction . * - ` 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 ` removes all content . * * # CSS nodes * * ` ` ` * text [ . read - only ] * ├ ─ ─ placeholder * ├ ─ ─ undershoot . left * ├ ─ ─ undershoot . right * ├ ─ ─ [ selection ] * ├ ─ ─ [ block - cursor ] * ├ ─ ─ [ cursor - handle [ . top / . bottom ] [ . insertion - cursor ] ] * ├ ─ ─ [ preedit [ . whole ] [ . selection ] [ . prediction ] [ . prefix / . suffix ] [ . spelling - error ] [ . compose - error ] ] * ╰ ─ ─ [ window . popup ] * ` ` ` * * ` GtkText ` has a main node with the name ` text ` . Depending on the properties * of the widget , the ` . read - only ` style class may appear . * * When the entry has a selection , it adds a subnode with the name ` selection ` . * * When the entry is in overwrite mode , it adds a subnode with the name * ` block - cursor ` that determines how the block cursor is drawn . * * The CSS node for a context menu is added as a subnode with the name ` popup ` . * * The ` undershoot ` nodes are used to draw the underflow indication when content * is scrolled out of view . These nodes get the ` . left ` or ` . right ` style class * added depending on where the indication is drawn . * * When touch is used and touch selection handles are shown , they are using * CSS nodes with name ` cursor - handle ` . They get the ` . top ` or ` . bottom ` style * class depending on where they are shown in relation to the selection . If * there is just a single handle for the text cursor , it gets the style class * ` . insertion - cursor ` . * * If using an input method with a pre - edit buffer , this string will be styled * with the ` preedit ` CSS 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 * * ` GtkText ` uses the [ enum @ Gtk . AccessibleRole . none ] role , which causes it to be * skipped for accessibility . This is because ` GtkText ` is expected to be used * as a delegate for a ` GtkEditable ` implementation that will be represented * to accessibility . #define NAT_ENTRY_WIDTH 150 #define UNDERSHOOT_SIZE 20 #define DEFAULT_MAX_UNDO 200 static GQuark quark_password_hint = 0 ;enum typedef struct _GtkTextPasswordHint GtkTextPasswordHint;typedef struct _GtkTextPrivate GtkTextPrivate;struct _GtkTextPrivateint text_baseline;char *im_module;2 ];float xalign;int ascent; /* font ascent in pango units */ int current_pos;int descent; /* font descent in pango units */ int dnd_position; /* In chars, -1 == no DND cursor */ int drag_start_x;int drag_start_y;int insert_pos;int selection_bound;int scroll_offset;int width_chars;int max_width_chars;float cursor_alpha;/* length of preedit string, in bytes */ /* length of preedit string, in chars */ /* offset of cursor within preedit string, in chars */ 1 ;1 ;1 ;1 ;1 ;1 ;1 ;8 ;1 ; /* Flag so we don't select all when clicking in entry to focus in */ 1 ;1 ;1 ;1 ;4 ; /* PangoDirection */ 1 ;1 ;1 ;1 ;1 ;1 ;1 ;1 ;1 ;struct _GtkTextPasswordHintint position; /* Position (in text) of the last password hint */ /* Timeout source id */ enum {enum {static GParamSpec *text_props[NUM_PROPERTIES] = { NULL, };static guint signals[LAST_SIGNAL] = { 0 };typedef enum {typedef enum /* The text is being shown */ /* In invisible mode, text replaced by (eg) bullets */ /* In invisible mode, nothing shown at all */ /* GObject methods static void gtk_text_set_property (GObject *object,const GValue *value,static void gtk_text_get_property (GObject *object,static void gtk_text_notify (GObject *object,static void gtk_text_finalize (GObject *object);static void gtk_text_dispose (GObject *object);/* GtkWidget methods static void gtk_text_realize (GtkWidget *widget);static void gtk_text_unrealize (GtkWidget *widget);static void gtk_text_map (GtkWidget *widget);static void gtk_text_unmap (GtkWidget *widget);static void gtk_text_measure (GtkWidget *widget,int for_size,int *minimum,int *natural,int *minimum_baseline,int *natural_baseline);static void gtk_text_size_allocate (GtkWidget *widget,int width,int height,int baseline);static void gtk_text_snapshot (GtkWidget *widget,static void gtk_text_focus_changed (GtkEventControllerFocus *focus,static gboolean gtk_text_grab_focus (GtkWidget *widget);static void gtk_text_css_changed (GtkWidget *widget,static void gtk_text_direction_changed (GtkWidget *widget,static void gtk_text_state_flags_changed (GtkWidget *widget,static gboolean gtk_text_drag_drop (GtkDropTarget *dest,const GValue *value,double x,double y,static gboolean gtk_text_drag_accept (GtkDropTarget *dest,static GdkDragAction gtk_text_drag_motion (GtkDropTarget *dest,double x,double y,static void gtk_text_drag_leave (GtkDropTarget *dest,/* GtkEditable method implementations static void gtk_text_editable_init (GtkEditableInterface *iface);static void gtk_text_insert_text (GtkText *self,const char *text,int length,int *position);static void gtk_text_delete_text (GtkText *self,int start_pos,int end_pos);static void gtk_text_delete_selection (GtkText *self);static void gtk_text_set_selection_bounds (GtkText *self,int start,int end);static gboolean gtk_text_get_selection_bounds (GtkText *self,int *start,int *end);static void gtk_text_set_editable (GtkText *self,static void gtk_text_set_text (GtkText *self,const char *text);static void gtk_text_set_width_chars (GtkText *self,int n_chars);static void gtk_text_set_max_width_chars (GtkText *self,int n_chars);static void gtk_text_set_alignment (GtkText *self,float xalign);static void gtk_text_set_enable_undo (GtkText *self,static void gtk_text_set_input_interceptor (GtkText *self,static GtkWidget * gtk_text_get_input_interceptor (GtkText *self);/* Default signal handlers static GMenuModel *gtk_text_get_menu_model (GtkText *self);static void gtk_text_popup_menu (GtkWidget *widget,const char *action_name,static void gtk_text_move_cursor (GtkText *self,int count,static void gtk_text_insert_at_cursor (GtkText *self,const char *str);static void gtk_text_delete_from_cursor (GtkText *self,int count);static void gtk_text_backspace (GtkText *self);static void gtk_text_cut_clipboard (GtkText *self);static void gtk_text_copy_clipboard (GtkText *self);static void gtk_text_paste_clipboard (GtkText *self);static void gtk_text_toggle_overwrite (GtkText *self);static void gtk_text_insert_emoji (GtkText *self);static gboolean gtk_text_select_all (GtkText *self);static void gtk_text_real_activate (GtkText *self);/* IM Context Callbacks static void gtk_text_commit_cb (GtkIMContext *context,const char *str,static void gtk_text_preedit_start_cb (GtkIMContext *context,static void gtk_text_preedit_changed_cb (GtkIMContext *context,static gboolean gtk_text_retrieve_surrounding_cb (GtkIMContext *context,static gboolean gtk_text_delete_surrounding_cb (GtkIMContext *context,int offset,int n_chars,/* Entry buffer signal handlers static void buffer_inserted_text (GtkEntryBuffer *buffer,const char *chars,static void buffer_deleted_text (GtkEntryBuffer *buffer,static void buffer_notify_text (GtkEntryBuffer *buffer,static void buffer_notify_max_length (GtkEntryBuffer *buffer,/* Event controller callbacks static void gtk_text_motion_controller_motion (GtkEventControllerMotion *controller,double x,double y,static void gtk_text_click_gesture_pressed (GtkGestureClick *gesture,int n_press,double x,double y,static void gtk_text_click_gesture_released (GtkGestureClick *gesture,int n_press,double x,double y,static void gtk_text_long_press_gesture_pressed (GtkGestureLongPress *gesture,double x,double y,static void gtk_text_drag_gesture_update (GtkGestureDrag *gesture,double offset_x,double offset_y,static void gtk_text_drag_gesture_end (GtkGestureDrag *gesture,double offset_x,double offset_y,static gboolean gtk_text_key_controller_key_pressed (GtkEventControllerKey *controller,/* GtkTextHandle handlers */ static void gtk_text_handle_drag_started (GtkTextHandle *handle,static void gtk_text_handle_dragged (GtkTextHandle *handle,int x,int y,static void gtk_text_handle_drag_finished (GtkTextHandle *handle,/* Internal routines static void gtk_text_draw_text (GtkText *self,static void gtk_text_draw_cursor (GtkText *self,static PangoLayout *gtk_text_ensure_layout (GtkText *self,static void gtk_text_reset_layout (GtkText *self);static void gtk_text_recompute (GtkText *self);static int gtk_text_find_position (GtkText *self,int x);static void gtk_text_get_cursor_locations (GtkText *self,int *strong_x,int *weak_x);static void gtk_text_adjust_scroll (GtkText *self);static int gtk_text_move_visually (GtkText *editable,int start,int count);static int gtk_text_move_logically (GtkText *self,int start,int count);static int gtk_text_move_forward_word (GtkText *self,int start,static int gtk_text_move_backward_word (GtkText *self,int start,static void gtk_text_delete_whitespace (GtkText *self);static void gtk_text_select_word (GtkText *self);static void gtk_text_select_line (GtkText *self);static void gtk_text_paste (GtkText *self,static void gtk_text_update_primary_selection (GtkText *self);static void gtk_text_schedule_im_reset (GtkText *self);static gboolean gtk_text_mnemonic_activate (GtkWidget *widget,static void gtk_text_check_cursor_blink (GtkText *self);static void remove_blink_timeout (GtkText *self);static void gtk_text_pend_cursor_blink (GtkText *self);static void gtk_text_reset_blink_time (GtkText *self);static void gtk_text_update_cached_style_values(GtkText *self);static gboolean get_middle_click_paste (GtkText *self);static void gtk_text_get_scroll_limits (GtkText *self,int *min_offset,int *max_offset);static GtkEntryBuffer *get_buffer (GtkText *self);static void set_text_cursor (GtkWidget *widget);static void update_placeholder_visibility (GtkText *self);static void buffer_connect_signals (GtkText *self);static void buffer_disconnect_signals (GtkText *self);static void gtk_text_selection_bubble_popup_set (GtkText *self);static void gtk_text_selection_bubble_popup_unset (GtkText *self);static void begin_change (GtkText *self);static void end_change (GtkText *self);static void emit_changed (GtkText *self);static void gtk_text_update_history (GtkText *self);static void gtk_text_update_clipboard_actions (GtkText *self);static void gtk_text_update_emoji_action (GtkText *self);static void gtk_text_update_clear_action (GtkText *self);static void gtk_text_update_handles (GtkText *self);static void gtk_text_activate_clipboard_cut (GtkWidget *widget,const char *action_name,static void gtk_text_activate_clipboard_copy (GtkWidget *widget,const char *action_name,static void gtk_text_activate_clipboard_paste (GtkWidget *widget,const char *action_name,static void gtk_text_activate_selection_delete (GtkWidget *widget,const char *action_name,static void gtk_text_activate_selection_select_all (GtkWidget *widget,const char *action_name,static void gtk_text_clear (GtkWidget *widget,const char *action_name,static void gtk_text_activate_misc_toggle_direction (GtkWidget *widget,const char *action_name,static void gtk_text_activate_misc_insert_emoji (GtkWidget *widget,const char *action_name,static void gtk_text_real_undo (GtkWidget *widget,const char *action_name,static void gtk_text_real_redo (GtkWidget *widget,const char *action_name,static void gtk_text_history_change_state_cb (gpointer funcs_data,static void gtk_text_history_insert_cb (gpointer funcs_data,const char *text,static void gtk_text_history_delete_cb (gpointer funcs_data,const char *expected_text,static void gtk_text_history_select_cb (gpointer funcs_data,int selection_insert,int selection_bound);/* GtkTextContent implementation #define GTK_TYPE_TEXT_CONTENT (gtk_text_content_get_type ())#define GTK_TEXT_CONTENT(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_TEXT_CONTENT, GtkTextContent))#define GTK_IS_TEXT_CONTENT(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_TEXT_CONTENT))#define GTK_TEXT_CONTENT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_TEXT_CONTENT, GtkTextContentClass))#define GTK_IS_TEXT_CONTENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_TEXT_CONTENT))#define GTK_TEXT_CONTENT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_TEXT_CONTENT, GtkTextContentClass))typedef struct _GtkTextContent GtkTextContent;typedef struct _GtkTextContentClass GtkTextContentClass;struct _GtkTextContentstruct _GtkTextContentClassvoid ) G_GNUC_CONST;static GdkContentFormats *return gdk_content_formats_new_for_gtype (G_TYPE_STRING);static gbooleanif (G_VALUE_HOLDS (value, G_TYPE_STRING))int start, end;if (gtk_text_get_selection_bounds (content->self, &start, &end))char *str = gtk_text_get_display_text (content->self, start, end);return TRUE ;return GDK_CONTENT_PROVIDER_CLASS (gtk_text_content_parent_class)->get_value (provider, value, error);static void int current_pos, selection_bound;static void class )class );static void /* GtkText static const GtkTextHistoryFuncs history_funcs = {static void gtk_text_accessible_text_init (GtkAccessibleTextInterface *iface);static void int count)"move-cursor" ,"(iib)" , step, count, FALSE );/* Selection-extending version */ "move-cursor" ,"(iib)" , step, count, TRUE );static void class )class );class );class ->move_cursor = gtk_text_move_cursor;class ->insert_at_cursor = gtk_text_insert_at_cursor;class ->delete_from_cursor = gtk_text_delete_from_cursor;class ->backspace = gtk_text_backspace;class ->cut_clipboard = gtk_text_cut_clipboard;class ->copy_clipboard = gtk_text_copy_clipboard;class ->paste_clipboard = gtk_text_paste_clipboard;class ->toggle_overwrite = gtk_text_toggle_overwrite;class ->insert_emoji = gtk_text_insert_emoji;class ->activate = gtk_text_real_activate;"gtk-entry-password-hint" );/** * GtkText : buffer : * * The ` GtkEntryBuffer ` object which stores the text . "buffer" , NULL, NULL,;/** * GtkText : max - length : * * Maximum number of characters that are allowed . * * Zero indicates no limit . "max-length" , NULL, NULL,0 , GTK_ENTRY_BUFFER_MAX_SIZE,0 ,/** * GtkText : invisible - char : * * The character to used when masking contents ( in “ password mode ” ) . "invisible-char" , NULL, NULL,'*' ,/** * GtkText : activates - default : * * Whether to activate the default widget when < kbd > Enter < / kbd > is pressed . "activates-default" , NULL, NULL,FALSE ,/** * GtkText : scroll - offset : * * Number of pixels scrolled of the screen to the left . "scroll-offset" , NULL, NULL,0 , G_MAXINT,0 ,/** * GtkText : truncate - multiline : * * When true , pasted multi - line text is truncated to the first line . "truncate-multiline" , NULL, NULL,FALSE ,/** * GtkText : overwrite - mode : * * If text is overwritten when typing . "overwrite-mode" , NULL, NULL,FALSE ,/** * GtkText : invisible - char - set : * * Whether the invisible char has been set . "invisible-char-set" , NULL, NULL,FALSE ,/** * GtkText : placeholder - text : * * The text that will be displayed in the ` GtkText ` when it is empty * and unfocused . "placeholder-text" , NULL, NULL,/** * GtkText : im - module : * * Which input method module should be used . * * See [ class @ Gtk . IMMulticontext ] . * * Setting this to a non - ` NULL ` value overrides the system - wide * input method . See the [ property @ Gtk . Settings : gtk - im - module ] * setting . "im-module" , NULL, NULL,/** * GtkText : input - purpose : * * The purpose of this text field . * * This information can be used by on - screen keyboards and other input * methods to adjust their behaviour . * * Note that setting the purpose to [ enum @ Gtk . InputPurpose . password ] * or [ enum @ Gtk . InputPurpose . pin ] is independent from setting * [ property @ Gtk . Text : visibility ] . "input-purpose" , NULL, NULL,/** * GtkText : input - hints : * * Additional hints that allow input methods to fine - tune * their behaviour . "input-hints" , NULL, NULL,/** * GtkText : attributes : * * A list of Pango attributes to apply to the text . * * This is mainly useful to change the size or weight of the text . * * The ` PangoAttribute ` ' s @ start_index and @ end_index must refer to the * ` GtkEntryBuffer ` text , i . e . without the preedit string . "attributes" , NULL, NULL,/** * GtkText : tabs : * * Custom tabs for this text widget . "tabs" , NULL, NULL,/** * GtkText : enable - emoji - completion : * * Whether to suggest Emoji replacements . "enable-emoji-completion" , NULL, NULL,FALSE ,/** * GtkText : visibility : * * If false , the text is masked with the “ invisible char ” . "visibility" , NULL, NULL,TRUE ,/** * GtkText : propagate - text - width : * * Whether the widget should grow and shrink with the content . "propagate-text-width" , NULL, NULL,FALSE ,/** * GtkText : extra - menu : * * A menu model whose contents will be appended to the context menu . "extra-menu" , NULL, NULL,/* Action signals */ /** * GtkText : : activate : * @ self : the text widget which emitted the signal * * Emitted when the user hits the < kbd > Enter < / kbd > key . * * The default bindings for this signal are all forms * of the < kbd > Enter < / kbd > key . "activate" ),0 );/** * GtkText : : move - cursor : * @ self : the text widget which emitted the signal * @ step : the granularity of the move * @ count : the number of @ step units to move * @ extend : true if the move should extend the selection * * Emitted when the user initiates a cursor movement . * * If the cursor is not visible in @ self , this signal causes * the viewport to be moved instead . * * This is a [ keybinding signal ] ( class . SignalAction . html ) . * * Applications should not connect to it , but may emit it with * [ func @ GObject . 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 "move-cursor" ),3 ,/** * GtkText : : insert - at - cursor : * @ self : the text widget which emitted the signal * @ string : the string to insert * * Emitted when the user initiates the insertion of a * fixed string at the cursor . * * This is a [ keybinding signal ] ( class . SignalAction . html ) . * * This signal has no default bindings . "insert-at-cursor" ),1 ,/** * GtkText : : delete - from - cursor : * @ self : the text widget which emitted the signal * @ type : the granularity of the deletion * @ count : the number of @ type units to delete * * Emitted when the user initiates a text deletion . * * This is a [ keybinding signal ] ( class . SignalAction . html ) . * * If the @ type is [ enum @ Gtk . DeleteType . 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 and < kbd > Ctrl < / kbd > + < kbd > Delete < / kbd > * for deleting a word . "delete-from-cursor" ),2 ,/** * GtkText : : backspace : * @ self : the text widget which emitted the signal * * Emitted when the user asks for it . * * This 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 );/** * GtkText : : cut - clipboard : * @ self : the text widget which emitted the signal * * Emitted to cut the selection to the clipboard . * * This 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 );/** * GtkText : : copy - clipboard : * @ self : the text widget which emitted the signal * * Emitted to copy the selection to the clipboard . * * This 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 );/** * GtkText : : paste - clipboard : * @ self : the text widget which emitted the signal * * Emitted to paste the contents of the clipboard . * * This 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 );/** * GtkText : : toggle - overwrite : * @ self : the text widget which emitted the signal * * Emitted to toggle the overwrite mode . * * This is a [ keybinding signal ] ( class . SignalAction . html ) . * * The default bindings for this signal is < kbd > Insert < / kbd > . "toggle-overwrite" ),0 );/** * GtkText : : preedit - changed : * @ self : the text widget which emitted the signal * @ preedit : the current preedit string * * Emitted when the preedit text 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 . "preedit-changed" ),1 ,/** * GtkText : : insert - emoji : * @ self : the text widget which emitted the signal * * Emitted to present the Emoji chooser . * * This 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 /** * GtkText | clipboard . cut : * * Copies the contents to the clipboard and deletes it from the widget . "clipboard.cut" , NULL,/** * GtkText | clipboard . copy : * * Copies the contents to the clipboard . "clipboard.copy" , NULL,/** * GtkText | clipboard . paste : * * Inserts the contents of the clipboard into the widget . "clipboard.paste" , NULL,/** * GtkText | selection . delete : * * Deletes the current selection . "selection.delete" , NULL,/** * GtkText | selection . select - all : * * Selects all of the widgets content . "selection.select-all" , NULL,"text.clear" , NULL, gtk_text_clear);/** * GtkText | misc . insert - emoji : * * Opens the Emoji chooser . "misc.insert-emoji" , NULL,/** * GtkText | misc . toggle - direction : * * Toggles the text direction . "misc.toggle-direction" , NULL,/** * GtkText | misc . toggle - visibility : * * Toggles the ` GtkText ` : visibility property . "misc.toggle-visibility" ,"visibility" );/** * GtkText | text . undo : * * Undoes the last change to the contents . "text.undo" , NULL, gtk_text_real_undo);/** * GtkText | text . redo : * * Redoes the last change to the contents . "text.redo" , NULL, gtk_text_real_redo);/** * GtkText | menu . popup : * * Opens the context menu . "menu.popup" , NULL, gtk_text_popup_menu);/* * Key bindings "menu.popup" ));"misc.toggle-direction" ,"text.clear" ,/* Moving the insertion point */ 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__#else #endif /* Unselect all */ #ifdef __APPLE__"move-cursor" ,"(iib)" , GTK_MOVEMENT_VISUAL_POSITIONS, 0 , FALSE );#else "move-cursor" ,"(iib)" , GTK_MOVEMENT_VISUAL_POSITIONS, 0 , FALSE );"move-cursor" ,"(iib)" , GTK_MOVEMENT_VISUAL_POSITIONS, 0 , FALSE );#endif /* Activate */ "activate" , NULL);/* Deleting text */ "delete-from-cursor" ,"(ii)" , GTK_DELETE_CHARS, 1 );"backspace" ,"delete-from-cursor" ,"(ii)" , GTK_DELETE_PARAGRAPH_ENDS, -1 );/* Make this do the same as Backspace, to help with mis-typing */ "backspace" ,#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_WORD_ENDS, 1 );"delete-from-cursor" ,"(ii)" , GTK_DELETE_WORD_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 /* Overwrite */ "toggle-overwrite" , NULL);/* Emoji */ "misc.insert-emoji" ,"misc.insert-emoji" ,/* 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 "text" ));static void const char *text,int length,int *position)static void int start_pos,int end_pos)static const char *return gtk_entry_buffer_get_text (get_buffer (GTK_TEXT (editable)));static char *if (priv->editable)char *preedit_string = NULL;int pos;return g_string_free (ret, FALSE );else return g_strdup (editable_get_text (editable));static void int start_pos,int end_pos)static gbooleanint *start_pos,int *end_pos)return gtk_text_get_selection_bounds (GTK_TEXT (editable), start_pos, end_pos);static void static void const GValue *value,switch (prop_id)/* GtkEditable properties */ case NUM_PROPERTIES + GTK_EDITABLE_PROP_EDITABLE:break ;case NUM_PROPERTIES + GTK_EDITABLE_PROP_WIDTH_CHARS:break ;case NUM_PROPERTIES + GTK_EDITABLE_PROP_MAX_WIDTH_CHARS:break ;case NUM_PROPERTIES + GTK_EDITABLE_PROP_TEXT:break ;case NUM_PROPERTIES + GTK_EDITABLE_PROP_XALIGN:break ;case NUM_PROPERTIES + GTK_EDITABLE_PROP_ENABLE_UNDO:break ;case NUM_PROPERTIES + GTK_EDITABLE_PROP_INPUT_INTERCEPTOR:break ;/* GtkText properties */ case PROP_BUFFER:break ;case PROP_MAX_LENGTH:break ;case PROP_VISIBILITY:break ;case PROP_INVISIBLE_CHAR:break ;case PROP_ACTIVATES_DEFAULT:break ;case PROP_TRUNCATE_MULTILINE:break ;case PROP_OVERWRITE_MODE:break ;case PROP_INVISIBLE_CHAR_SET:if (g_value_get_boolean (value))TRUE ;else break ;case PROP_PLACEHOLDER_TEXT:break ;case PROP_IM_MODULE:if (GTK_IS_IM_MULTICONTEXT (priv->im_context))module);break ;case PROP_INPUT_PURPOSE:break ;case PROP_INPUT_HINTS:break ;case PROP_ATTRIBUTES:break ;case PROP_TABS:break ;case PROP_ENABLE_EMOJI_COMPLETION:break ;case PROP_PROPAGATE_TEXT_WIDTH:break ;case PROP_EXTRA_MENU:break ;default :break ;static void switch (prop_id)/* GtkEditable properties */ case NUM_PROPERTIES + GTK_EDITABLE_PROP_CURSOR_POSITION:break ;case NUM_PROPERTIES + GTK_EDITABLE_PROP_SELECTION_BOUND:break ;case NUM_PROPERTIES + GTK_EDITABLE_PROP_EDITABLE:break ;case NUM_PROPERTIES + GTK_EDITABLE_PROP_WIDTH_CHARS:break ;case NUM_PROPERTIES + GTK_EDITABLE_PROP_MAX_WIDTH_CHARS:break ;case NUM_PROPERTIES + GTK_EDITABLE_PROP_TEXT:break ;case NUM_PROPERTIES + GTK_EDITABLE_PROP_XALIGN:break ;case NUM_PROPERTIES + GTK_EDITABLE_PROP_ENABLE_UNDO:break ;case NUM_PROPERTIES + GTK_EDITABLE_PROP_COMPLETE_TEXT:break ;case NUM_PROPERTIES + GTK_EDITABLE_PROP_INPUT_INTERCEPTOR:break ;/* GtkText properties */ case PROP_BUFFER:break ;case PROP_MAX_LENGTH:break ;case PROP_VISIBILITY:break ;case PROP_INVISIBLE_CHAR:break ;case PROP_ACTIVATES_DEFAULT:break ;case PROP_SCROLL_OFFSET:break ;case PROP_TRUNCATE_MULTILINE:break ;case PROP_OVERWRITE_MODE:break ;case PROP_INVISIBLE_CHAR_SET:break ;case PROP_IM_MODULE:break ;case PROP_PLACEHOLDER_TEXT:break ;case PROP_INPUT_PURPOSE:break ;case PROP_INPUT_HINTS:break ;case PROP_ATTRIBUTES:break ;case PROP_TABS:break ;case PROP_ENABLE_EMOJI_COMPLETION:break ;case PROP_PROPAGATE_TEXT_WIDTH:break ;case PROP_EXTRA_MENU:break ;default :break ;static void if (pspec->name == I_("has-focus" ))if (G_OBJECT_CLASS (gtk_text_parent_class)->notify)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 int i;TRUE );TRUE ;TRUE ;1 ;1 ;1 ;FALSE ;0 .0 ;1 ;1 .0 ;0 ;TRUE ;"gtk-text-drop-target" );"accept" , G_CALLBACK (gtk_text_drag_accept), self);"enter" , G_CALLBACK (gtk_text_drag_motion), self);"motion" , G_CALLBACK (gtk_text_drag_motion), self);"leave" , G_CALLBACK (gtk_text_drag_leave), self);"drop" , G_CALLBACK (gtk_text_drag_drop), self);/* This object is completely private. No external entity can gain a reference * to it ; so we create it here and destroy it in finalize ( ) . "preedit-start" ,"commit" ,"preedit-changed" ,"retrieve-surrounding" ,"delete-surrounding" ,"gtk-text-drag-gesture" );"drag-update" ,"drag-end" ,0 );TRUE );e));"gtk-text-click-gesture" );"pressed" ,"released" ,0 );TRUE );TRUE );"pressed" ,"gtk-text-motion-controller" );"motion" ,;"gtk-text-key-controller" );"key-pressed" ,"im-update" ,ller),"gtk-text-focus-controller" );"notify::is-focus" ,for (i = 0 ; i < 2 ; i++)"undershoot" ));0 ? "left" : "right" ));e) & ~GTK_STATE_FLAG_DROP_ACTIVE);static void 0 ;if (priv->blink_tick)0 ;if (priv->magnifier)if (priv->buffer)"gtk-emoji-chooser" );if (chooser)rent);dget_unparent);static void if (priv->tabs)if (priv->attrs)static void if (priv->magnifier_popover)return ;100 , 60 );2 .0 );"magnifier" );FALSE );TRUE );static void static void 0 );if (priv->change_count == 0 )if (priv->real_changed)"changed" );FALSE ;static void if (priv->change_count == 0 )"changed" );else TRUE ;static DisplayModeif (priv->visible)return DISPLAY_NORMAL;if (priv->invisible_char == 0 && priv->invisible_char_set)return DISPLAY_BLANK;return DISPLAY_INVISIBLE;char *int start_pos,int end_pos)const char *start;const char *end;const char *text;char char_str[7 ];int char_len;int i;if (end_pos < 0 || end_pos > length)if (start_pos > length)if (end_pos <= start_pos)return g_strdup ("" );else if (priv->visible)return g_strndup (start, end - start);else 2 );/* Figure out what our invisible char is and encode it */ if (!priv->invisible_char)' ' : '*' ;else /* * Add hidden characters for each character in the text * buffer . If there is a password hint , then keep that * character visible . for (i = start_pos; i < end_pos; ++i)if (password_hint && i == password_hint->position)else return g_string_free (str, FALSE );static void static void FALSE ;1 .0 ;static void if (!priv->editable)return ;static void static void if (gdk_clipboard_get_content (clipboard) == priv->selection_content)static void const int text_width = gtk_widget_get_width (GTK_WIDGET (self));int strong_x;int strong_xoffset;if (strong_xoffset < 0 )0 ;else if (strong_xoffset > text_width)0 ;0 ;static void int x,int y,int height)if (!gtk_text_handle_get_is_dragged (handle) &&0 || x > gtk_widget_get_width (GTK_WIDGET (self))))/* Hide the handle if it's not being manipulated * and fell outside of the visible text area . FALSE );else 1 ;TRUE );static int int x;const char *text;int index;FALSE );if (gtk_widget_get_direction (GTK_WIDGET (self)) == GTK_TEXT_DIR_RTL)else return x;static void const int text_height = gtk_widget_get_height (GTK_WIDGET (self));int strong_x;int cursor, bound;if (!priv->text_handles_enabled)if (priv->text_handles[TEXT_HANDLE_CURSOR])FALSE );if (priv->text_handles[TEXT_HANDLE_SELECTION_BOUND])), FALSE );else if (priv->selection_bound != priv->current_pos)int start, end;if (priv->selection_bound > priv->current_pos)else /* Update start selection bound */ 0 , text_height);0 , text_height);else ), FALSE );0 , text_height);static void int for_size,int *minimum,int *natural,int *minimum_baseline,int *natural_baseline)if (orientation == GTK_ORIENTATION_HORIZONTAL)int min, nat;int char_width;int digit_width;int char_pixels;1 ) / PANGO_SCALE;if (priv->width_chars >= 0 )else 0 ;if (priv->max_width_chars < 0 )else if (priv->propagate_text_width)int act;TRUE );if (priv->placeholder)int pmin, pnat;1 ,else int height, baseline;TRUE );if (priv->placeholder)int min, nat;1 ,if (minimum_baseline)if (natural_baseline)static void int width,int height,int baseline)if (priv->placeholder)0 , 0 , width, height },1 );"gtk-emoji-chooser" );if (chooser)if (priv->emoji_completion)if (priv->magnifier_popover)if (priv->popup_menu)if (priv->selection_bubble)if (priv->text_handles[TEXT_HANDLE_CURSOR])if (priv->text_handles[TEXT_HANDLE_SELECTION_BOUND])static void const int text_width = gtk_widget_get_width (GTK_WIDGET (self));const int text_height = gtk_widget_get_height (GTK_WIDGET (self));int min_offset, max_offset;if (priv->scroll_offset > min_offset)0 ]);0 , 0 , UNDERSHOOT_SIZE, text_height);if (priv->scroll_offset < max_offset)1 ]);0 , UNDERSHOOT_SIZE, text_height);static void /* Draw text and cursor */ if (priv->dnd_position != -1 )if (priv->placeholder)/* When no text is being displayed at all, don't show the cursor */ if (gtk_text_get_display_mode (self) != DISPLAY_BLANK &&static void int **ranges,int *n_ranges)if (priv->selection_bound != priv->current_pos)TRUE );const char *text = pango_layout_get_text (layout);int start_index = g_utf8_offset_to_pointer (text, priv->selection_bound) - text;int end_index = g_utf8_offset_to_pointer (text, priv->current_pos) - text;int real_n_ranges, i;if (ranges)int *r = *ranges;for (i = 0 ; i < real_n_ranges; ++i)2 * i + 1 ] = (r[2 * i + 1 ] - r[2 * i]) / PANGO_SCALE;2 * i] = r[2 * i] / PANGO_SCALE;if (n_ranges)else if (n_ranges)0 ;if (ranges)static gbooleanint x)int *ranges;int n_ranges, i;int retval = FALSE ;for (i = 0 ; i < n_ranges; ++i)if (x >= ranges[2 * i] && x < ranges[2 * i] + ranges[2 * i + 1 ])TRUE ;break ;return retval;static int int tx;double px;return px - tx;static void double x,double y)if (!priv->popup_menu)FALSE );"Context menu" ),1 );if (x != -1 && y != -1 )1 , 1 };else static void int n_press,double widget_x,double widget_y,int x, y, sel_start, sel_end;int tmp_pos;if (!gtk_widget_has_focus (widget))if (!gtk_widget_get_focus_on_click (widget))return ;TRUE ;FALSE ;if (gdk_event_triggers_context_menu (event))else if (n_press == 1 && button == GDK_BUTTON_MIDDLE &&if (priv->editable)else else if (button == GDK_BUTTON_PRIMARY)FALSE ;FALSE ;FALSE ;0 ;/* Always emit reset when preedit is shown */ TRUE ;switch (n_press)case 1 :if (in_selection (self, x))if (gtk_event_treat_as_touch (event))if (priv->selection_bubble &&else else if (extend_selection)/* Truncate current selection, but keep it as big as possible */ if (tmp_pos - sel_start > sel_end - tmp_pos)else /* all done, so skip the extend_to_left stuff later */ FALSE ;else /* We'll either start a drag, or clear the selection */ TRUE ;else if (!extend_selection)else /* select from the current position to the clicked position */ if (!have_selection)break ;case 2 :TRUE ;break ;case 3 :TRUE ;break ;default :break ;if (extend_selection)int start, end;if (tmp_pos == sel_start || tmp_pos == sel_end)else if (extend_to_left)else if (n_press >= 3 )static void int n_press,double widget_x,double widget_y,if (n_press == 1 &&0 )static void double x,double y,static char *if (priv->selection_bound != priv->current_pos)const int start = MIN (priv->selection_bound, priv->current_pos);const int end = MAX (priv->selection_bound, priv->current_pos);const char *text = gtk_entry_buffer_get_text (get_buffer (self));const int start_index = g_utf8_offset_to_pointer (text, start) - text;const int end_index = g_utf8_offset_to_pointer (text, end) - text;return g_strndup (text + start_index, end_index - start_index);return NULL;static void int x,int y)const int text_height = gtk_widget_get_height (GTK_WIDGET (self));1 ;0 ;2 );static void double x,double y,ller));if (priv->mouse_cursor_obscured &&FALSE ;static void if (gdk_drag_get_selected_action (drag) == GDK_ACTION_MOVE)static void static void double offset_x,double offset_y,int x, y;double start_y;if (priv->mouse_cursor_obscured)FALSE ;if (priv->select_lines)return ;if (priv->in_drag)if (gtk_text_get_display_mode (self) == DISPLAY_NORMAL &&0 , 0 , offset_x, offset_y))int *ranges;int n_ranges;char *text;0 );if (priv->editable)else "dnd-finished" , G_CALLBACK (dnd_finished_cb), self);"cancel" , G_CALLBACK (dnd_cancel_cb), self);1 );0 ]),FALSE ;/* Deny the gesture so we don't get further updates */ else int tmp_pos;int pos, bound;if (y < 0 )0 ;else if (y >= gtk_widget_get_height (GTK_WIDGET (self)))else if (priv->select_words)int min, max;int old_min, old_max;TRUE );TRUE );if (min < old_min)else if (old_max < max)else if (pos == old_min)if (priv->current_pos != min)else if (priv->current_pos != max)else 1 ;if (pos != priv->current_pos)/* Update touch handles' position */ if (GTK_DISPLAY_DEBUG_CHECK (display, TOUCHSCREEN) ||TRUE ;static void double offset_x,double offset_y,FALSE ;if (priv->magnifier_popover)/* Check whether the drag was cancelled rather than finished */ if (!gtk_gesture_handles_sequence (GTK_GESTURE (gesture), sequence))return ;if (in_drag)int tmp_pos = gtk_text_find_position (self, priv->drag_start_x);static void if (priv->mouse_cursor_obscured)return ;"none" );TRUE ;static gbooleanFALSE ;if (keyval == GDK_KEY_Return ||if (!priv->editable && unichar != 0 )return FALSE ;static void if (gtk_event_controller_focus_is_focus (controller))else /* Focus out */ FALSE ;if (priv->editable)if (priv->blink_tick)static gbooleanif (!GTK_WIDGET_CLASS (gtk_text_parent_class)->grab_focus (GTK_WIDGET (self)))return FALSE ;if (priv->editable && !priv->in_click && !prev_focus_was_child)"gtk-entry-select-on-focus" ,if (select_on_focus)0 , -1 );return TRUE ;/** * gtk_text_grab_focus_without_selecting : * @ self : a text widget * * Causes the text widget to have the keyboard focus . * * It behaves like [ method @ Gtk . Widget . grab_focus ] , * except that it does not select the contents of @ self . * * You only want to call this on some special entries * which the user usually doesn ' t want to replace all * text in , such as search - as - you - type entries . * * Returns : true if focus is now inside @ self FALSE );return GTK_WIDGET_CLASS (gtk_text_parent_class)->grab_focus (GTK_WIDGET (self));static void static void if (gtk_widget_get_realized (widget))FALSE ;if (!gtk_widget_is_sensitive (widget))/* Clear any selection */ /* Stop blinking */ if (priv->selection_node)if (priv->block_cursor_node)0 ], state);1 ], state);/* GtkEditable method implementations static void const char *text,int length,int *position)int n_inserted;int n_chars;if (length == 0 )return ;/* * The incoming text may a password or other secret . We make sure * not to copy it into temporary buffers . if (priv->change_count == 0 );if (priv->change_count == 0 )if (n_inserted != n_chars)if (priv->propagate_text_width)static void int start_pos,int end_pos)if (end_pos < 0 )if (start_pos == end_pos)return ;if (priv->change_count == 0 )if (priv->change_count == 0 )if (priv->propagate_text_width)static void int start_pos = MIN (priv->selection_bound, priv->current_pos);int end_pos = MAX (priv->selection_bound, priv->current_pos);static void int start,int end)if (start < 0 )if (end < 0 )static gbooleanint *start,int *end)return (priv->selection_bound != priv->current_pos);static gunicharint i;0 x25cf, /* BLACK CIRCLE */ 0 x2022, /* BULLET */ 0 x2731, /* HEAVY ASTERISK */ 0 x273a /* SIXTEEN POINTED ASTERISK */ FALSE ));for (i = 0 ; i < G_N_ELEMENTS (invisible_chars); i++)char text[7 ] = { 0 , };int len, count;if (count == 0 )return invisible_chars[i];return '*' ;static void if (!priv->visible && !priv->invisible_char_set)if (priv->invisible_char != ch)static void if (gtk_css_style_change_affects (change, GTK_CSS_AFFECTS_TEXT |if (gtk_css_style_change_affects (change, GTK_CSS_AFFECTS_TEXT_ATTRS))static void if (password_hint->source_id)static gboolean1 ;0 ;/* Force the string to be redrawn, but now without a visible character */ return G_SOURCE_REMOVE;static void if (priv->placeholder)0 &&0 ));/* GtkEntryBuffer signal handlers static void const char *chars,int selection_bound;if (current_pos > position)if (selection_bound > position)1 );/* Calculate the password hint if it needs to be displayed. */ if (n_chars == 1 && !priv->visible)"gtk-entry-password-hint-timeout" , &password_hint_timeout,if (password_hint_timeout > 0 )if (!password_hint)1 );if (password_hint->source_id)"[gtk] gtk_text_remove_password_hint" );static void if (gtk_text_history_get_enabled (priv->history))char *deleted_text;1 );static void int selection_bound;if (current_pos > position)if (selection_bound > position)/* We might have deleted the selection */ /* Disable the password hint if one exists. */ if (!priv->visible)if (password_hint)if (password_hint->source_id)0 ;1 ;static void "text" );"complete-text" );static void static void "inserted-text" , G_CALLBACK (buffer_inserted_text), self);"deleted-text" , G_CALLBACK (buffer_deleted_text), self);"deleted-text" , G_CALLBACK (buffer_deleted_text_after), self);"notify::text" , G_CALLBACK (buffer_notify_text), self);"notify::max-length" , G_CALLBACK (buffer_notify_max_length), self);static void ;self);elf);/* Compute the X position for an offset that corresponds to the "more important * cursor position for that offset . We use this when trying to guess to which * end of the selection we should go to when the user hits the left or * right arrow key . static int int offset)TRUE );const char *text = pango_layout_get_text (layout);int index = g_utf8_offset_to_pointer (text, offset) - text;if (seat)if (keyboard)"gtk-split-cursor" , &split_cursor,if (split_cursor)return strong_pos.x / PANGO_SCALE;else return (direction == priv->resolved_dir) ? strong_pos.x / PANGO_SCALE : weak_pos.x / PANGO_SCALE;static void if (gtk_css_style_change_affects (change, GTK_CSS_AFFECTS_REDRAW))static void int count,int new_pos = priv->current_pos;if (priv->current_pos != priv->selection_bound && !extend_selection)/* If we have a current selection and aren't extending it, move to the * start / or end of the selection as appropriate switch (step)case GTK_MOVEMENT_VISUAL_POSITIONS:int current_x = get_better_cursor_x (self, priv->current_pos);int bound_x = get_better_cursor_x (self, priv->selection_bound);if (count <= 0 )else break ;case GTK_MOVEMENT_WORDS:if (priv->resolved_dir == PANGO_DIRECTION_RTL)1 ;case GTK_MOVEMENT_LOGICAL_POSITIONS:if (count < 0 )else break ;case GTK_MOVEMENT_DISPLAY_LINE_ENDS:case GTK_MOVEMENT_PARAGRAPH_ENDS:case GTK_MOVEMENT_BUFFER_ENDS:0 ? 0 : gtk_entry_buffer_get_length (get_buffer (self));break ;case GTK_MOVEMENT_DISPLAY_LINES:case GTK_MOVEMENT_PARAGRAPHS:case GTK_MOVEMENT_PAGES:case GTK_MOVEMENT_HORIZONTAL_PAGES:default :break ;else switch (step)case GTK_MOVEMENT_LOGICAL_POSITIONS:break ;case GTK_MOVEMENT_VISUAL_POSITIONS:if (priv->current_pos == new_pos)if (!extend_selection)if (!gtk_widget_keynav_failed (GTK_WIDGET (self),0 ?if (toplevel)0 ?else break ;case GTK_MOVEMENT_WORDS:if (priv->resolved_dir == PANGO_DIRECTION_RTL)1 ;while (count > 0 )FALSE );while (count < 0 )FALSE );if (priv->current_pos == new_pos)break ;case GTK_MOVEMENT_DISPLAY_LINE_ENDS:case GTK_MOVEMENT_PARAGRAPH_ENDS:case GTK_MOVEMENT_BUFFER_ENDS:0 ? 0 : gtk_entry_buffer_get_length (get_buffer (self));if (priv->current_pos == new_pos)break ;case GTK_MOVEMENT_DISPLAY_LINES:case GTK_MOVEMENT_PARAGRAPHS:case GTK_MOVEMENT_PAGES:case GTK_MOVEMENT_HORIZONTAL_PAGES:default :break ;if (extend_selection)else TRUE ;static void const char *str)int pos = priv->current_pos;if (priv->editable)1 , &pos);1 ));static void int count)int start_pos = priv->current_pos;int end_pos = priv->current_pos;int old_n_bytes = gtk_entry_buffer_get_bytes (get_buffer (self));if (!priv->editable)return ;if (priv->selection_bound != priv->current_pos)goto done;switch (type)case GTK_DELETE_CHARS:, end_pos));break ;case GTK_DELETE_WORDS:if (count < 0 )/* Move to end of current word, or if not on a word, end of previous word */ FALSE );FALSE );else if (count > 0 )/* Move to beginning of current word, or if not on a word, beginning of next word */ FALSE );FALSE );case GTK_DELETE_WORD_ENDS:while (count < 0 )FALSE );while (count > 0 )FALSE );break ;case GTK_DELETE_DISPLAY_LINE_ENDS:case GTK_DELETE_PARAGRAPH_ENDS:if (count < 0 )0 , priv->current_pos);else 1 );break ;case GTK_DELETE_DISPLAY_LINES:case GTK_DELETE_PARAGRAPHS:0 , -1 );break ;case GTK_DELETE_WHITESPACE:break ;default :break ;if (gtk_entry_buffer_get_bytes (get_buffer (self)) == old_n_bytes)else static void int prev_pos;if (!priv->editable)return ;if (priv->selection_bound != priv->current_pos)goto done;1 );if (prev_pos < priv->current_pos)FALSE );const PangoLogAttr *log_attrs;int n_attrs;/* Deleting parts of characters */ if (log_attrs[priv->current_pos].backspace_deletes_character)char *cluster_text;char *normalized_text;1 );if (len > 1 )int pos = priv->current_pos;1 ) - normalized_text,else else static void if (priv->selection_bound != priv->current_pos)char *str;if (!priv->visible)return ;if (priv->selection_bound < priv->current_pos)else static void if (!priv->visible)return ;if (priv->editable)if (priv->selection_bound != priv->current_pos)else static void if (priv->editable)else static void if (priv->editable)if (priv->selection_bound != priv->current_pos)static void if (priv->overwrite_mode)if (!priv->block_cursor_node)"block-cursor" ));));else if (priv->block_cursor_node)static gbooleanreturn TRUE ;static void if (priv->activates_default)/* IM Context Callbacks static void static void const char *str,if (priv->editable)static void if (priv->editable)char *preedit_string;int cursor_pos;0 , preedit_string);1 );0 , priv->preedit_length_c);"complete-text" );if (!gtk_widget_has_focus (GTK_WIDGET (self)))"input-intercepted" );static gbooleanchar *text;/* XXXX ??? does this even make sense when text is not visible? Should we return FALSE? */ 0 , -1 );/* Length in bytes */ return TRUE ;static gbooleanint offset,int n_chars,if (priv->editable)return TRUE ;/* Internal functions /* Used for im_commit_cb and inserting Unicode chars */ void const char *str)int tmp_pos;FALSE ;if (priv->selection_bound != priv->current_pos)else if (priv->overwrite_mode)if (priv->current_pos < text_length)1 );/* We do not need to notify the accessible text contents change * here , the insert_text ( ) call will take care of it /* All changes to priv->current_pos and priv->selection_bound * should go through this function . void int current_pos,int selection_bound)FALSE ;if (current_pos != -1 &&TRUE ;"cursor-position" );if (selection_bound != -1 &&TRUE ;"selection-bound" );if (priv->current_pos != priv->selection_bound)if (!priv->selection_node)"selection" ));"style-changed" ,else if (priv->selection_node)if (changed)static void static void if (!gtk_widget_get_mapped (GTK_WIDGET (self)))return ;static void if (gtk_widget_get_direction (GTK_WIDGET (self)) == GTK_TEXT_DIR_RTL)else static PangoLayout *char *preedit_string = NULL;int preedit_length = 0 ;char *display_text;TRUE );et_css_node (widget)));if (!tmp_attrs)0 , -1 );if (include_preedit)if (preedit_length)int pos;TRUE );else if (priv->tabs)return layout;static PangoLayout *if (priv->preedit_length > 0 &&if (!priv->cached_layout)return priv->cached_layout;static void int *x,int *y)const int text_height = gtk_widget_get_height (GTK_WIDGET (self));int y_pos, area_height;TRUE );/* Align primarily for locale's ascent/descent */ if (priv->text_baseline < 0 )2 +else /* Now see if we need to adjust to fit in actual drawn string */ if (logical_rect.height > area_height)2 ;else if (y_pos < 0 )0 ;else if (y_pos + logical_rect.height > area_height)if (x)if (y)#define GRAPHENE_RECT_FROM_RECT(_r) (GRAPHENE_RECT_INIT ((_r)->x, (_r)->y, (_r)->width, (_r)->height))static void int x, y;/* Nothing to display at all */ if (gtk_text_get_display_mode (self) == DISPLAY_BLANK)return ;TRUE );if (priv->selection_bound != priv->current_pos)const char *text = pango_layout_get_text (layout);int start_index = g_utf8_offset_to_pointer (text, priv->selection_bound) - text;int end_index = g_utf8_offset_to_pointer (text, priv->current_pos) - text;int range[2 ];int width, height;0 ] = MIN (start_index, end_index);1 ] = MAX (start_index, end_index);1 );0 , 0 , width, height);static void int cursor_index;const char *text;int x, y;TRUE ));if (type == CURSOR_DND)else - text;if (!priv->overwrite_mode ||else /* overwrite_mode */ int width = gtk_widget_get_width (widget);int height = gtk_widget_get_height (widget);0 , 0 , width, height);static void int x,int y,int cursor_pos, selection_bound_pos, tmp_pos, *old_pos;if (handle == priv->text_handles[TEXT_HANDLE_CURSOR])/* Avoid running past the other handle in selection mode */ if (tmp_pos >= selection_bound_pos &&))1 ;else if (handle == priv->text_handles[TEXT_HANDLE_SELECTION_BOUND])/* Avoid running past the other handle */ if (tmp_pos <= cursor_pos)1 ;else if (tmp_pos != *old_pos)if (handle == priv->text_handles[TEXT_HANDLE_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 void TRUE ;void if (priv->need_im_reset)FALSE ;static int int x)int index;int pos;int trailing;const char *text;int cursor_index;TRUE );if (index >= cursor_index && priv->preedit_length)if (index >= cursor_index + priv->preedit_length)else 0 ;return pos;static void if (mode == DISPLAY_BLANK)if (strong)0 ;0 ;if (weak)0 ;0 ;else TRUE );const char *text = pango_layout_get_text (layout);int index;if (strong)if (weak)static void int *strong_x,int *weak_x)/* Nothing to display at all, so no cursor is relevant */ if (mode == DISPLAY_BLANK)if (strong_x)0 ;if (weak_x)0 ;else TRUE );const char *text = pango_layout_get_text (layout);int index;if (strong_x)if (weak_x)static gbooleanif (priv->current_pos >= priv->selection_bound)else return handle && gtk_text_handle_get_is_dragged (handle);static void int *min_offset,int *max_offset)float xalign;int text_width, width;TRUE );/* Display as much text as we can */ if (priv->resolved_dir == PANGO_DIRECTION_LTR)else 1 .0 - priv->xalign;if (text_width > width)0 ;else static void const int text_width = gtk_widget_get_width (GTK_WIDGET (self));int min_offset, max_offset;if (!gtk_widget_get_realized (GTK_WIDGET (self)))return ;if (gtk_text_get_is_selection_handle_dragged (self))/* The text handle corresponding to the selection bound is * being dragged , ensure it stays onscreen even if we scroll * cursors away , this is so both handles can cause content * to scroll . 1 ;else /* And make sure cursors are on screen. * * We always make sure that the strong cursor is on screen , and * put the weak cursor on screen if possible . if (strong.x - priv->scroll_offset < 0 )else if (strong.x + strong.width - priv->scroll_offset > text_width)if (weak.x - priv->scroll_offset < 0 &&else if (weak.x + weak.width - priv->scroll_offset > text_width &&static int int start,int count)int index;FALSE );const char *text;"gtk-split-cursor" , &split_cursor,if (split_cursor)TRUE ;else if (seat)if (keyboard)while (count != 0 )int new_index, new_trailing;if (count > 0 )0 , 1 , &new_index, &new_trailing);else 0 , -1 , &new_index, &new_trailing);if (new_index < 0 )0 ;else if (new_index != G_MAXINT)while (new_trailing--)return g_utf8_pointer_to_offset (text, text + index);static int int start,int count)int new_pos = start;/* Prevent any leak of information */ if (gtk_text_get_display_mode (self) != DISPLAY_NORMAL)0 , length);else FALSE );const PangoLogAttr *log_attrs;int n_attrs;while (count > 0 && new_pos < length)do while (new_pos < length && !log_attrs[new_pos].is_cursor_position);while (count < 0 && new_pos > 0 )do while (new_pos > 0 && !log_attrs[new_pos].is_cursor_position);return new_pos;static int int start,int new_pos = start;/* Prevent any leak of information */ if (gtk_text_get_display_mode (self) != DISPLAY_NORMAL)else if (new_pos < length)FALSE );const PangoLogAttr *log_attrs;int n_attrs;/* Find the next word boundary */ while (new_pos < n_attrs - 1 && !(log_attrs[new_pos].is_word_end ||return new_pos;static int int start,int new_pos = start;/* Prevent any leak of information */ if (gtk_text_get_display_mode (self) != DISPLAY_NORMAL)0 ;else if (start > 0 )FALSE );const PangoLogAttr *log_attrs;int n_attrs;1 ;/* Find the previous word boundary */ while (new_pos > 0 && !(log_attrs[new_pos].is_word_start ||return new_pos;static void FALSE );const PangoLogAttr *log_attrs;int n_attrs;int start, end;while (start > 0 && log_attrs[start-1 ].is_white)while (end < n_attrs && log_attrs[end].is_white)if (start != end)static void int start_pos = gtk_text_move_backward_word (self, priv->current_pos, TRUE );int end_pos = gtk_text_move_forward_word (self, priv->current_pos, TRUE );static void 0 , -1 );static int const char *text)int length;for (length = 0 ;'\n' && text[length] != '\r' ;return length;static void char *text;int pos, start, end;int length = -1 ;if (text == NULL)return ;if (priv->insert_pos >= 0 )if (!((start <= pos && pos <= end) || (end <= pos && pos <= start)))1 ;if (priv->truncate_multiline)else if (priv->selection_bound != priv->current_pos)static void static void if (!gtk_widget_get_realized (GTK_WIDGET (self)))return ;if (!gtk_widget_has_focus (GTK_WIDGET (self)))return ;if (priv->selection_bound != priv->current_pos)else if (gdk_clipboard_get_content (clipboard) == priv->selection_content)/* Public API /** * gtk_text_new : * * Creates a new ` GtkText ` . * * Returns : the new ` GtkText ` void )return g_object_new (GTK_TYPE_TEXT, NULL);/** * gtk_text_new_with_buffer : * @ buffer : the buffer to use * * Creates a new ` GtkText ` with the specified buffer . * * Returns : a new ` GtkText ` return g_object_new (GTK_TYPE_TEXT, "buffer" , buffer, NULL);static GtkEntryBuffer *if (priv->buffer == NULL)0 );return priv->buffer;/** * gtk_text_get_buffer : * @ self : a text widget * * Get the entry buffer object which holds the text for * this widget . * * Returns : ( transfer none ) : the entry buffer object return get_buffer (self);/** * gtk_text_set_buffer : * @ self : a text widget * @ buffer : an entry buffer object * * Set the entry buffer object which holds the text for * this widget . void FALSE ;0 ;0 ;if (buffer)if (priv->buffer)TRUE ;if (priv->buffer)if (old_length != 0 || new_length != 0 )"text" );if (had_buffer)0 , 0 );static void if (is_editable != priv->editable)if (!is_editable)if (gtk_widget_has_focus (widget))0 ;0 ;0 ;"read-only" );else "read-only" );if (is_editable && gtk_widget_has_focus (widget))ller),1 );"editable" );static void const char *text)int tmp_pos;/* Actually setting the text will affect the cursor and selection; * if the contents don ' t actually change , this will look odd to the user . if (strcmp (gtk_entry_buffer_get_text (get_buffer (self)), text) == 0 )return ;0 , -1 );0 , G_MAXUINT);0 ;1 ));/** * gtk_text_set_visibility : * @ self : a text widget * @ visible : true if the contents of the text widget are displayed * as plain text * * Sets whether the contents of the text widget are visible or not . * * When visibility is set to false , characters are displayed * as the invisible char , and it will also appear that way when * the text in the widget is copied to the clipboard . * * By default , GTK picks the best invisible character available * in the current font , but it can be changed with * [ method @ Gtk . Text . set_invisible_char ] . * * Note that you probably want to set [ property @ Gtk . Text : input - purpose ] * to [ enum @ Gtk . InputPurpose . password ] or [ enum @ Gtk . InputPurpose . pin ] * to inform input methods about the purpose of this widget , in addition * to setting visibility to false . void FALSE ;if (priv->visible != visible)/* disable undo when invisible text is used */ /** * gtk_text_get_visibility : * @ self : a text widget * * Retrieves whether the text is visible . * * Returns : true if the text is visible FALSE );return priv->visible;/** * gtk_text_set_invisible_char : * @ self : a text widget * @ ch : a Unicode character * * Sets the character to use when in “ password mode ” . * * By default , GTK picks the best invisible char available in the * current font . If you set the invisible char to 0 , then the user * will get no feedback at all ; there will be no text on the screen * as they type . void if (!priv->invisible_char_set)TRUE ;if (ch == priv->invisible_char)return ;/** * gtk_text_get_invisible_char : * @ self : a text widget * * Retrieves the character displayed when visibility is set to false . * * Note that GTK does not compute this value unless it needs it , * so the value returned by this function is not very useful unless * it has been explicitly set with [ method @ Gtk . Text . set_invisible_char ] . * * Returns : the current invisible char , or 0 , if @ text does not * show invisible text at all 0 );return priv->invisible_char;/** * gtk_text_unset_invisible_char : * @ self : a text widget * * Unsets the invisible char . * * After calling this , the default invisible char is used again . void if (!priv->invisible_char_set)return ;FALSE ;if (priv->invisible_char != ch)/** * gtk_text_set_overwrite_mode : * @ self : a text widget * @ overwrite : new value * * Sets whether the text is overwritten when typing . void if (priv->overwrite_mode == overwrite)return ;/** * gtk_text_get_overwrite_mode : * @ self : a text widget * * Gets whether text is overwritten when typing . * * See [ method @ Gtk . Text . set_overwrite_mode ] . * * Returns : whether text is overwritten when typing FALSE );return priv->overwrite_mode;/** * gtk_text_set_max_length : * @ self : a text widget * @ length : the maximum length of the text , or 0 for no maximum . * ( other than the maximum length of entries . ) The value passed * in will be clamped to the range 0 - 65536 * * Sets the maximum allowed length of the contents . * * If the current contents are longer than the given length , * they will be truncated to fit . * * This is equivalent to getting @ self ' s ` GtkEntryBuffer ` and * calling [ method @ Gtk . EntryBuffer . set_max_length ] on it . void int length)/** * gtk_text_get_max_length : * @ self : a text widget * * Retrieves the maximum allowed length of the contents . * * See [ method @ Gtk . Text . set_max_length ] . * * This is equivalent to getting @ self ' s ` GtkEntryBuffer ` and * calling [ method @ Gtk . EntryBuffer . get_max_length ] on it . * * Returns : the maximum allowed number of characters , or 0 if * there is no limit int 0 );return gtk_entry_buffer_get_max_length (get_buffer (self));/** * gtk_text_get_text_length : * @ self : a text widget * * Retrieves the length of the contents . * * This is equivalent to getting @ self ' s ` GtkEntryBuffer ` * and calling [ method @ Gtk . EntryBuffer . get_length ] on it . * * Returns : the length of the contents , in characters 0 );return gtk_entry_buffer_get_length (get_buffer (self));/*< private > * gtk_text_get_complete_text_length : * * Retrieves the complete length of the contents . * * Unlike [ func @ Gtk . Text . get_text_length ] , this method also * includes the length of * pseudo - content * , such as the * preedit buffer . * * Returns : the length of the content & * pseudo - content * 0 );return gtk_entry_buffer_get_length (get_buffer (self)) + priv->preedit_length_c;/** * gtk_text_set_activates_default : * @ self : a text widget * @ activates : true to activate window ’ s default widget on * < kbd > Enter < / kbd > keypress * * Sets whether pressing < kbd > Enter < / kbd > will activate * the default widget . * * This usually means that the dialog containing @ self will * be closed , since the default widget is usually one of * the dialog buttons . void FALSE ;if (priv->activates_default != activates)/** * gtk_text_get_activates_default : * @ self : a text widget * * Returns whether pressing < kbd > Enter < / kbd > will activate * the default widget for the window containing the widget . * * See [ method @ Gtk . Text . set_activates_default ] . * * Returns : true if @ self will activate the default widget FALSE );return priv->activates_default;static void int n_chars)if (priv->width_chars != n_chars)"width-chars" );static void int n_chars)if (priv->max_width_chars != n_chars)"max-width-chars" );TRUE );return layout;void int *x,int *y)static void float xalign)if (xalign < 0 .0 )0 .0 ;else if (xalign > 1 .0 )1 .0 ;if (xalign != priv->xalign)if (priv->placeholder)"xalign" );static void if (priv->selection_bubble && gtk_widget_get_visible (priv->selection_bubble))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,static void const char *action_name,static void const char *action_name,0 , -1 );static void const char *action_name,static void const char *action_name,if (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL)else if (priv->cached_layout)static void ard), G_TYPE_STRING);0 );"clipboard.cut" ,"clipboard.copy" ,"clipboard.paste" ,"selection.delete" ,"selection.select-all" ,static void "misc.insert-emoji" ,0 );static void "text.clear" , 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" );"Select _All" ), "selection.select-all" );"touch-icon" , "s" , "edit-select-all-symbolic" );"Change di_rection" ), "misc.toggle-direction" );"hidden-when" , "s" , "action-disabled" );"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 gbooleanreturn GDK_EVENT_STOP;static void const char *action_name,1 , -1 );static void static void int index)const char *icon_name;const char *action_name;"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 (!gtk_action_muxer_query_action (muxer, action_name, &enabled,return ;FALSE );"image-button" );static gbooleanconst int text_width = gtk_widget_get_width (GTK_WIDGET (self));const int text_height = gtk_widget_get_height (GTK_WIDGET (self));int start_x, end_x;int i;if (!has_selection && !priv->editable)0 ;return G_SOURCE_REMOVE;"touch-selection" );FALSE );"notify::visible" ,5 );10 );10 );10 );10 );0 );"linked" );for (i = 0 ; i < g_menu_model_get_n_items (model); i++)if (!gtk_widget_compute_point (GTK_WIDGET (self), gtk_widget_get_parent (GTK_WIDGET (self)),0 , 0 ), &p))0 , 0 );0 , text_width);if (has_selection)0 , text_width);else 0 ;5 ;5 ;10 ;10 ;0 ;return G_SOURCE_REMOVE;static void if (priv->selection_bubble)FALSE );static void if (priv->selection_bubble_timeout_id)50 , gtk_text_selection_bubble_popup_show, self);"[gtk] gtk_text_selection_bubble_popup_cb" );static void 1 ;static gbooleanconst GValue *value,double x,double y,int drop_position;int length;const char *str;if (!priv->editable)return FALSE ;if (str == NULL)"" ;if (priv->truncate_multiline)else 1 ;if (priv->selection_bound == priv->current_pos ||else int pos;/* Replacing selection */ return TRUE ;static gbooleanif (!priv->editable)return FALSE ;if ((gdk_drop_get_actions (drop) & gtk_drop_target_get_actions (dest)) == GDK_ACTION_NONE)return FALSE ;return gdk_content_formats_match (gtk_drop_target_get_formats (dest), gdk_drop_get_formats (drop));static GdkDragActiondouble x,double y,int new_position, old_position;if (!priv->editable)return 0 ;if (priv->selection_bound == priv->current_pos ||else 1 ;if (priv->dnd_position != old_position)if (priv->drag)return GDK_ACTION_MOVE;else return GDK_ACTION_COPY;/* We display the cursor when * * - the selection is empty , AND * - the widget has focus #define CURSOR_ON_MULTIPLIER 2 #define CURSOR_OFF_MULTIPLIER 1 #define CURSOR_PEND_MULTIPLIER 3 #define CURSOR_DIVIDER 3 static gbooleanif (gtk_widget_get_mapped (GTK_WIDGET (self)) &&ller)) &&"gtk-cursor-blink" , &blink, NULL);return blink;else return FALSE ;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 timeout;"gtk-cursor-blink-timeout" , &timeout, NULL);return timeout;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 ;/* * Blink ! 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 (!gtk_widget_has_focus (GTK_WIDGET (self)))"GtkText - did not receive a focus-out event.\n" "If you handle this event, you must return\n" "GDK_EVENT_PROPAGATE so the default handler\n" "gets the event as well" );return G_SOURCE_REMOVE;if (priv->selection_bound != priv->current_pos)"GtkText - unexpected blinking selection. Removing" );return G_SOURCE_REMOVE;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 if (cursor_blinks (self))if (!priv->blink_tick)FALSE );else if (priv->blink_tick)static void if (cursor_blinks (self))TRUE );static void /** * gtk_text_set_placeholder_text : * @ self : a text widget * @ text : ( nullable ) : a string to be displayed when @ self * is empty and unfocused * * Sets the text to be displayed when the text widget is * empty and unfocused . * * This can be used to give a visual hint of the expected * contents of the text widget . void const char *text)if (priv->placeholder == NULL)"label" , text,"css-name" , "placeholder" ,"xalign" , priv->xalign,"ellipsize" , PANGO_ELLIPSIZE_END,"max-width-chars" , 3 ,else /** * gtk_text_get_placeholder_text : * @ self : a text widget * * Retrieves the text that will be displayed when the text widget * is empty and unfocused * * See [ method @ Gtk . Text . set_placeholder_text ] . * * Returns : ( nullable ) ( transfer none ) : the placeholder text const char *if (!priv->placeholder)return NULL;return gtk_label_get_text (GTK_LABEL (priv->placeholder));/** * gtk_text_set_input_purpose : * @ self : a text widget * @ purpose : the input purpose * * Sets the input purpose of the text widget . * * The input purpose can be used by on - screen keyboards * and other input methods to adjust their behaviour . void if (gtk_text_get_input_purpose (self) != purpose)"input-purpose" , purpose,/** * gtk_text_get_input_purpose : * @ self : a text widget * * Gets the input purpose of the text widget . * * Returns : the input purpose "input-purpose" , &purpose,return purpose;/** * gtk_text_set_input_hints : * @ self : a text widget * @ hints : input hints * * Sets hints that allow input methods to fine - tune their behaviour . void if (gtk_text_get_input_hints (self) != hints)"input-hints" , hints,/** * gtk_text_get_input_hints : * @ self : a text widget * * Gets the input hints of the text widget . * * Returns : the input hints "input-hints" , &hints,return hints;/** * gtk_text_set_attributes : * @ self : a text widget * @ attrs : ( nullable ) : a list of style attributes * * Apply attributes to the contents of the text widget . void if (attrs)if (priv->attrs)if (priv->placeholder)/** * gtk_text_get_attributes : * @ self : a text widget * * Gets the attribute list that was set on the text widget . * * See [ method @ Gtk . Text . set_attributes ] . * * Returns : ( transfer none ) ( nullable ) : the attribute list return priv->attrs;/** * gtk_text_set_tabs : * @ self : a text widget * @ tabs : ( nullable ) : tab stops * * Sets tab stops for the text widget . void if (priv->tabs)if (tabs)else /** * gtk_text_get_tabs : * @ self : a text widget * * Gets the tab stops for the text widget . * * See [ method @ Gtk . Text . set_tabs ] . * * Returns : ( nullable ) ( transfer none ) : the tab stops return priv->tabs;static void const char *text,int pos;if (priv->selection_bound != priv->current_pos)1 , &pos);1 ));static void if (gtk_widget_get_ancestor (GTK_WIDGET (self), GTK_TYPE_EMOJI_CHOOSER) != NULL)return ;"gtk-emoji-chooser" ));if (!chooser)"gtk-emoji-chooser" , chooser);"emoji-picked" , G_CALLBACK (emoji_picked), self);static void "text" );return priv->key_controller;/** * gtk_text_set_extra_menu : * @ self : a text widget * @ model : ( nullable ) : a menu model * * Sets a menu model to add to the context menu of the text widget . void if (g_set_object (&priv->extra_menu, model))/** * gtk_text_get_extra_menu : * @ self : a text widget * * Gets the extra menu model of the text widget . * * See [ method @ Gtk . Text . set_extra_menu ] . * * Returns : ( transfer none ) ( nullable ) : the menu model return priv->extra_menu;/** * gtk_text_set_enable_emoji_completion : * @ self : a text widget * @ enable_emoji_completion : true to enable Emoji completion * * Sets whether Emoji completion is enabled . * * If it is , typing ' : ' , followed by a recognized keyword , * will pop up a window with suggested Emojis matching the * keyword . void if (priv->enable_emoji_completion == enable_emoji_completion)return ;if (priv->enable_emoji_completion)else );/** * gtk_text_get_enable_emoji_completion : * @ self : a text widget * * Returns whether Emoji completion is enabled . * * Returns : true if Emoji completion is enabled FALSE );return priv->enable_emoji_completion;/** * gtk_text_set_propagate_text_width : * @ self : a text widget * @ propagate_text_width : true to propagate the text width * * Sets whether the text widget should grow and shrink with the content . void if (priv->propagate_text_width == propagate_text_width)return ;/** * gtk_text_get_propagate_text_width : * @ self : a text widget * * Returns whether the text widget will grow and shrink * with the content . * * Returns : true if @ self will propagate the text width FALSE );return priv->propagate_text_width;/** * gtk_text_set_truncate_multiline : * @ self : a text widget * @ truncate_multiline : true to truncate multi - line text * * Sets whether pasted text should be truncated to the first line . void if (priv->truncate_multiline == truncate_multiline)return ;/** * gtk_text_get_truncate_multiline : * @ self : a text widget * * Returns whether pasted text will be truncated to the first line . * * Returns : true if @ self will truncate pasted multi - line text FALSE );return priv->truncate_multiline;/** * gtk_text_compute_cursor_extents : * @ self : a text widget * @ position : the character position * @ strong : ( out ) ( optional ) : location to store the strong cursor position * @ weak : ( out ) ( optional ) : location to store the weak cursor position * * Determines the positions of the strong and weak cursors for a * given character position . * * 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 are inserted . * The weak cursor location is the location where characters of * the directionality opposite to the base direction are inserted . * * The rectangle positions are in widget coordinates . * * Since : 4 . 4 void int offset_x, offset_y, index;const char *text;TRUE );0 , g_utf8_strlen (text, -1 ));if (strong)0 ,if (weak)0 ,static void const char *action_name,static void const char *action_name,static void /* Do nothing */ static void const char *str,int location = begin;static void const char *expected_text,static void int selection_insert,int selection_bound)static void if (priv->enable_undo == enable_undo)return ;"enable-undo" );static void static void "input-intercepted" );static void if (priv->input_interceptor == widget)return ;if (priv->input_interceptor)if (widget)"gtk-text-key-capture" );"im-update" ,e),"input-interceptor" );static GtkWidget *return priv->input_interceptor;/* {{{ GtkAccessibleText implementation */ static GBytes *unsigned int start,unsigned int end)char *text = gtk_text_get_display_text (GTK_TEXT (self), 0 , -1 );int len = g_utf8_strlen (text, -1 );char *string;0 , len);0 , len);if (end <= start)"" );1 ;else const char *p, *q;1 ;return g_bytes_new_take (string, size);static GBytes *unsigned int offset,unsigned int *start,unsigned int *end)char *string = gtk_pango_get_string_at (layout, offset, granularity, start, end);return g_bytes_new_take (string, strlen (string));static unsigned int return gtk_editable_get_position (GTK_EDITABLE (self));static gbooleanint start, end;if (!gtk_editable_get_selection_bounds (GTK_EDITABLE (self), &start, &end))return FALSE ;1 ;1 );0 ].start = start;0 ].length = end - start;return TRUE ;static gbooleanunsigned int offset,char ***attribute_names,char ***attribute_values)unsigned int start, end;char **names, **values;for (unsigned i = 0 ; i < *n_ranges; i++)return TRUE ;static void char ***attribute_names,char ***attribute_values)char **names, **values;static gbooleanunsigned int start,unsigned int end,const char *text;int lx, ly;int range[2 ];0 ] = g_utf8_pointer_to_offset (text, text + start);1 ] = g_utf8_pointer_to_offset (text, text + end);1 );return TRUE ;static gbooleanconst graphene_point_t *point,unsigned int *offset)int lx;int index;const char *text;unsigned int ) g_utf8_pointer_to_offset (text, text + index);return TRUE ;static gbooleanunsigned int offset)return TRUE ;static gbooleanif (i != 0 )return FALSE ;h);return TRUE ;static void /* }}} */ /* vim:set foldmethod=marker: */
Messung V0.5 in Prozent C=98 H=96 G=96
¤ 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.327Bemerkung:
(vorverarbeitet am 2026-07-03)
¤ *Bot Zugriff
