You may wish to begin by reading the [text widget conceptual overview][TextWidget] which gives an overview of all the objects and data types related to the text widget and how they work together.
# CSS nodes
textview.view
âââ border.top
âââ border.left
âââ text
â â°ââ [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.
function "+"
(Widget : access Gtk_Text_View_Record'Class)
return Gtk.Buildable.Gtk_Buildable
function "+"
(Widget : access Gtk_Text_View_Record'Class)
return Gtk.Scrollable.Gtk_Scrollable
function "-"
(Interf : Gtk.Buildable.Gtk_Buildable)
return Gtk_Text_View
function "-"
(Interf : Gtk.Scrollable.Gtk_Scrollable)
return Gtk_Text_View
Accepts_Tab_Property : constant Glib.Properties.Property_Boolean;
procedure Add_Child_At_Anchor
(View : not null access Gtk_Text_View_Record;
Child : not null access Gtk.Widget.Gtk_Widget_Record'Class;
Anchor : not null access Gtk.Text_Child_Anchor.Gtk_Text_Child_Anchor_Record'Class)
Adds a child widget in the text buffer, at the given Anchor.
a Gtk.Widget.Gtk_Widget
a Gtk.Text_Child_Anchor.Gtk_Text_Child_Anchor in the Gtk.Text_Buffer.Gtk_Text_Buffer for Text_View
procedure Add_Child_In_Window
(View : not null access Gtk_Text_View_Record;
Child : not null access Gtk.Widget.Gtk_Widget_Record'Class;
Which_Window : Gtk.Enums.Gtk_Text_Window_Type;
Xpos : Glib.Gint;
Ypos : Glib.Gint)
Adds a child at fixed coordinates in one of the text widget's windows. The window must have nonzero size (see Gtk.Text_View.Set_Border_Window_Size). Note that the child coordinates are given relative to scrolling. When placing a child in GTK_TEXT_WINDOW_WIDGET, scrolling is irrelevant, the child floats above all scrollable areas. But when placing a child in one of the scrollable windows (border windows or text window) it will move with the scrolling as needed.
a Gtk.Widget.Gtk_Widget
which window the child should appear in
X position of child in window coordinates
Y position of child in window coordinates
function Backward_Display_Line
(View : not null access Gtk_Text_View_Record;
Iter : Gtk.Text_Iter.Gtk_Text_Iter) return Boolean
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 Gtk.Text_Buffer.Gtk_Text_Buffer.
a Gtk.Text_Iter.Gtk_Text_Iter
True if Iter was moved and is not on the end iterator
function Backward_Display_Line_Start
(View : not null access Gtk_Text_View_Record;
Iter : Gtk.Text_Iter.Gtk_Text_Iter) return Boolean
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 Gtk.Text_Buffer.Gtk_Text_Buffer.
a Gtk.Text_Iter.Gtk_Text_Iter
True if Iter was moved and is not on the end iterator
Bottom_Margin_Property : constant Glib.Properties.Property_Int;
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 Gtk.Widget.Gtk_Widget:margin-bottom.
Buffer_Property : constant Glib.Properties.Property_Object;
Type: Gtk.Text_Buffer.Gtk_Text_Buffer
procedure Buffer_To_Window_Coords
(View : not null access Gtk_Text_View_Record;
Win : Gtk.Enums.Gtk_Text_Window_Type;
Buffer_X : Glib.Gint;
Buffer_Y : Glib.Gint;
Window_X : out Glib.Gint;
Window_Y : out Glib.Gint)
Converts coordinate (Buffer_X, Buffer_Y) to coordinates for the window Win, and stores the result in (Window_X, Window_Y). Note that you can't convert coordinates for a nonexisting window (see Gtk.Text_View.Set_Border_Window_Size).
a Gtk.Enums.Gtk_Text_Window_Type, except Gtk.Enums.Text_Window_Private
buffer x coordinate
buffer y coordinate
window x coordinate return location or null
window y coordinate return location or null
type Cb_GObject_Boolean_Void is not null access procedure
(Self : access Glib.Object.GObject_Record'Class;
Gtk_Select : Boolean);
type Cb_GObject_Gtk_Delete_Type_Gint_Void is not null access procedure
(Self : access Glib.Object.GObject_Record'Class;
The_Type : Gtk.Enums.Gtk_Delete_Type;
Count : Glib.Gint);
type Cb_GObject_Gtk_Movement_Step_Gint_Boolean_Void is not null access procedure
(Self : access Glib.Object.GObject_Record'Class;
Step : Gtk.Enums.Gtk_Movement_Step;
Count : Glib.Gint;
Extend_Selection : Boolean);
type Cb_GObject_Gtk_Scroll_Step_Gint_Void is not null access procedure
(Self : access Glib.Object.GObject_Record'Class;
Step : Gtk.Enums.Gtk_Scroll_Step;
Count : Glib.Gint);
type Cb_GObject_Gtk_Text_Extend_Selection_Gtk_Text_Iter_Gtk_Text_Iter_Gtk_Text_Iter_Boolean is not null access function
(Self : access Glib.Object.GObject_Record'Class;
Granularity : Gtk_Text_Extend_Selection;
Location : Gtk.Text_Iter.Gtk_Text_Iter;
Start : Gtk.Text_Iter.Gtk_Text_Iter;
The_End : Gtk.Text_Iter.Gtk_Text_Iter) return Boolean;
type Cb_GObject_Gtk_Widget_Void is not null access procedure
(Self : access Glib.Object.GObject_Record'Class;
Popup : not null access Gtk.Widget.Gtk_Widget_Record'Class);
type Cb_GObject_UTF8_String_Void is not null access procedure
(Self : access Glib.Object.GObject_Record'Class;
String : UTF8_String);
type Cb_GObject_Void is not null access procedure
(Self : access Glib.Object.GObject_Record'Class);
type Cb_Gtk_Text_View_Boolean_Void is not null access procedure
(Self : access Gtk_Text_View_Record'Class;
Gtk_Select : Boolean);
type Cb_Gtk_Text_View_Gtk_Delete_Type_Gint_Void is not null access procedure
(Self : access Gtk_Text_View_Record'Class;
The_Type : Gtk.Enums.Gtk_Delete_Type;
Count : Glib.Gint);
type Cb_Gtk_Text_View_Gtk_Movement_Step_Gint_Boolean_Void is not null access procedure
(Self : access Gtk_Text_View_Record'Class;
Step : Gtk.Enums.Gtk_Movement_Step;
Count : Glib.Gint;
Extend_Selection : Boolean);
type Cb_Gtk_Text_View_Gtk_Scroll_Step_Gint_Void is not null access procedure
(Self : access Gtk_Text_View_Record'Class;
Step : Gtk.Enums.Gtk_Scroll_Step;
Count : Glib.Gint);
type Cb_Gtk_Text_View_Gtk_Text_Extend_Selection_Gtk_Text_Iter_Gtk_Text_Iter_Gtk_Text_Iter_Boolean is not null access function
(Self : access Gtk_Text_View_Record'Class;
Granularity : Gtk_Text_Extend_Selection;
Location : Gtk.Text_Iter.Gtk_Text_Iter;
Start : Gtk.Text_Iter.Gtk_Text_Iter;
The_End : Gtk.Text_Iter.Gtk_Text_Iter) return Boolean;
type Cb_Gtk_Text_View_Gtk_Widget_Void is not null access procedure
(Self : access Gtk_Text_View_Record'Class;
Popup : not null access Gtk.Widget.Gtk_Widget_Record'Class);
type Cb_Gtk_Text_View_UTF8_String_Void is not null access procedure
(Self : access Gtk_Text_View_Record'Class;
String : UTF8_String);
type Cb_Gtk_Text_View_Void is not null access procedure (Self : access Gtk_Text_View_Record'Class);
Cursor_Visible_Property : constant Glib.Properties.Property_Boolean;
Editable_Property : constant Glib.Properties.Property_Boolean;
function Forward_Display_Line
(View : not null access Gtk_Text_View_Record;
Iter : Gtk.Text_Iter.Gtk_Text_Iter) return Boolean
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 Gtk.Text_Buffer.Gtk_Text_Buffer.
a Gtk.Text_Iter.Gtk_Text_Iter
True if Iter was moved and is not on the end iterator
function Forward_Display_Line_End
(View : not null access Gtk_Text_View_Record;
Iter : Gtk.Text_Iter.Gtk_Text_Iter) return Boolean
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 Gtk.Text_Buffer.Gtk_Text_Buffer.
a Gtk.Text_Iter.Gtk_Text_Iter
True if Iter was moved and is not on the end iterator
function Get_Accepts_Tab
(View : not null access Gtk_Text_View_Record) return Boolean
Returns whether pressing the Tab key inserts a tab characters. Gtk.Text_View.Set_Accepts_Tab. Since: gtk+ 2.4
True if pressing the Tab key inserts a tab character, False if pressing the Tab key moves the keyboard focus.
function Get_Border
(Self : not null access Gtk_Text_View_Record;
Border : access Gtk.Style.Gtk_Border) return Boolean
function Get_Border_Window_Size
(View : not null access Gtk_Text_View_Record;
The_Type : Gtk.Enums.Gtk_Text_Window_Type) return Glib.Gint
Gets the width of the specified border window. See Gtk.Text_View.Set_Border_Window_Size.
window to return size from
width of window
function Get_Bottom_Margin
(View : not null access Gtk_Text_View_Record) return Glib.Gint
Gets the bottom margin for text in the Text_View. Since: gtk+ 3.18
bottom margin in pixels
function Get_Buffer
(View : not null access Gtk_Text_View_Record)
return Gtk.Text_Buffer.Gtk_Text_Buffer
Returns the Gtk.Text_Buffer.Gtk_Text_Buffer 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.
a Gtk.Text_Buffer.Gtk_Text_Buffer
procedure Get_Cursor_Locations
(View : not null access Gtk_Text_View_Record;
Iter : Gtk.Text_Iter.Gtk_Text_Iter;
Strong : out Gdk.Rectangle.Gdk_Rectangle;
Weak : out Gdk.Rectangle.Gdk_Rectangle)
Given an Iter within a text layout, determine the positions of the strong and weak cursors if the insertion point is at that iterator. 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 Gtk.Text_View.Buffer_To_Window_Coords to convert these coordinates to coordinates for one of the windows in the text view. Since: gtk+ 3.0
a Gtk.Text_Iter.Gtk_Text_Iter
location to store the strong cursor position (may be null)
location to store the weak cursor position (may be null)
function Get_Cursor_Visible
(View : not null access Gtk_Text_View_Record) return Boolean
Find out whether the cursor should be displayed.
whether the insertion mark is visible
function Get_Default_Attributes
(View : not null access Gtk_Text_View_Record)
return Gtk.Text_Attributes.Gtk_Text_Attributes
Obtains a copy of the default text attributes. These are the attributes used for text unless a tag overrides them. You'd typically pass the default attributes in to Gtk.Text_Iter.Get_Attributes in order to get the attributes in effect at a given text position. The return value is a copy owned by the caller of this function, and should be freed with Gtk.Text_Attributes.Unref.
a new Gtk.Text_Attributes.Gtk_Text_Attributes
function Get_Editable
(View : not null access Gtk_Text_View_Record) return Boolean
Returns the default editability of the Gtk.Text_View.Gtk_Text_View. Tags in the buffer may override this setting for some ranges of text.
whether text is editable by default
function Get_Hadjustment
(Self : not null access Gtk_Text_View_Record)
return Gtk.Adjustment.Gtk_Adjustment
function Get_Hscroll_Policy
(Self : not null access Gtk_Text_View_Record)
return Gtk.Enums.Gtk_Scrollable_Policy
function Get_Indent
(View : not null access Gtk_Text_View_Record) return Glib.Gint
Gets the default indentation of paragraphs in Text_View. Tags in the view's buffer may override the default. The indentation may be negative.
number of pixels of indentation
function Get_Input_Hints
(View : not null access Gtk_Text_View_Record)
return Gtk.Enums.Gtk_Input_Hints
Gets the value of the Gtk.Text_View.Gtk_Text_View:input-hints property. Since: gtk+ 3.6
function Get_Input_Purpose
(View : not null access Gtk_Text_View_Record)
return Gtk.Enums.Gtk_Input_Purpose
Gets the value of the Gtk.Text_View.Gtk_Text_View:input-purpose property. Since: gtk+ 3.6
function Get_Iter_At_Location
(View : not null access Gtk_Text_View_Record;
Iter : access Gtk.Text_Iter.Gtk_Text_Iter;
X : Glib.Gint;
Y : Glib.Gint) return Boolean
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 Gtk.Text_View.Window_To_Buffer_Coords.
a Gtk.Text_Iter.Gtk_Text_Iter
x position, in buffer coordinates
y position, in buffer coordinates
True if the position is over text
function Get_Iter_At_Position
(View : not null access Gtk_Text_View_Record;
Iter : access Gtk.Text_Iter.Gtk_Text_Iter;
Trailing : access Glib.Gint;
X : Glib.Gint;
Y : Glib.Gint) return Boolean
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 Gtk.Text_View.Window_To_Buffer_Coords. Note that this is different from Gtk.Text_View.Get_Iter_At_Location, which returns cursor locations, i.e. positions between characters. Since: gtk+ 2.6
a Gtk.Text_Iter.Gtk_Text_Iter
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 position, in buffer coordinates
y position, in buffer coordinates
True if the position is over text
procedure Get_Iter_Location
(View : not null access Gtk_Text_View_Record;
Iter : Gtk.Text_Iter.Gtk_Text_Iter;
Location : out Gdk.Rectangle.Gdk_Rectangle)
Gets a rectangle which roughly contains the character at Iter. The rectangle position is in buffer coordinates; use Gtk.Text_View.Buffer_To_Window_Coords to convert these coordinates to coordinates for one of the windows in the text view.
a Gtk.Text_Iter.Gtk_Text_Iter
bounds of the character at Iter
function Get_Justification
(View : not null access Gtk_Text_View_Record)
return Gtk.Enums.Gtk_Justification
Gets the default justification of paragraphs in Text_View. Tags in the buffer may override the default.
default justification
function Get_Left_Margin
(View : not null access Gtk_Text_View_Record) return Glib.Gint
Gets the default left margin size of paragraphs in the Text_View. Tags in the buffer may override the default.
left margin in pixels
procedure Get_Line_At_Y
(View : not null access Gtk_Text_View_Record;
Target_Iter : out Gtk.Text_Iter.Gtk_Text_Iter;
Y : Glib.Gint;
Line_Top : out Glib.Gint)
Gets the Gtk.Text_Iter.Gtk_Text_Iter at the start of the line containing the coordinate Y. Y is in buffer coordinates, convert from window coordinates with Gtk.Text_View.Window_To_Buffer_Coords. If non-null, Line_Top will be filled with the coordinate of the top edge of the line.
a Gtk.Text_Iter.Gtk_Text_Iter
a y coordinate
return location for top coordinate of the line
procedure Get_Line_Yrange
(View : not null access Gtk_Text_View_Record;
Iter : Gtk.Text_Iter.Gtk_Text_Iter;
Y : out Glib.Gint;
Height : out Glib.Gint)
Gets the y coordinate of the top of the line containing Iter, and the height of the line. The coordinate is a buffer coordinate; convert to window coordinates with Gtk.Text_View.Buffer_To_Window_Coords.
a Gtk.Text_Iter.Gtk_Text_Iter
return location for a y coordinate
return location for a height
function Get_Monospace
(View : not null access Gtk_Text_View_Record) return Boolean
Gets the value of the Gtk.Text_View.Gtk_Text_View:monospace property. Since: gtk+ 3.16
True if monospace fonts are desired
function Get_Overwrite
(View : not null access Gtk_Text_View_Record) return Boolean
Returns whether the Gtk.Text_View.Gtk_Text_View is in overwrite mode or not. Since: gtk+ 2.4
whether Text_View is in overwrite mode or not.
function Get_Pixels_Above_Lines
(View : not null access Gtk_Text_View_Record) return Glib.Gint
Gets the default number of pixels to put above paragraphs. Adding this function with Gtk.Text_View.Get_Pixels_Below_Lines is equal to the line space between each paragraph.
default number of pixels above paragraphs
function Get_Pixels_Below_Lines
(View : not null access Gtk_Text_View_Record) return Glib.Gint
Gets the value set by Gtk.Text_View.Set_Pixels_Below_Lines. The line space is the sum of the value returned by this function and the value returned by Gtk.Text_View.Get_Pixels_Above_Lines.
default number of blank pixels below paragraphs
function Get_Pixels_Inside_Wrap
(View : not null access Gtk_Text_View_Record) return Glib.Gint
Gets the value set by Gtk.Text_View.Set_Pixels_Inside_Wrap.
default number of pixels of blank space between wrapped lines
function Get_Right_Margin
(View : not null access Gtk_Text_View_Record) return Glib.Gint
Gets the default right margin for text in Text_View. Tags in the buffer may override the default.
right margin in pixels
function Get_Tabs
(View : not null access Gtk_Text_View_Record)
return Pango.Tabs.Pango_Tab_Array
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 Pango.Tabs.Free.
copy of default tab array, or null if "standard" tabs are used; must be freed with Pango.Tabs.Free.
function Get_Top_Margin
(View : not null access Gtk_Text_View_Record) return Glib.Gint
Gets the top margin for text in the Text_View. Since: gtk+ 3.18
top margin in pixels
function Get_Type return Glib.GType
function Get_Vadjustment
(Self : not null access Gtk_Text_View_Record)
return Gtk.Adjustment.Gtk_Adjustment
procedure Get_Visible_Rect
(View : not null access Gtk_Text_View_Record;
Visible_Rect : out Gdk.Rectangle.Gdk_Rectangle)
Fills Visible_Rect with the currently-visible region of the buffer, in buffer coordinates. Convert to window coordinates with Gtk.Text_View.Buffer_To_Window_Coords.
rectangle to fill
function Get_Vscroll_Policy
(Self : not null access Gtk_Text_View_Record)
return Gtk.Enums.Gtk_Scrollable_Policy
function Get_Window
(View : not null access Gtk_Text_View_Record;
Win : Gtk.Enums.Gtk_Text_Window_Type) return Gdk.Gdk_Window
Retrieves the Gdk.Gdk_Window corresponding to an area of the text view; possible windows include the overall widget window, child windows on the left, right, top, bottom, and the window that displays the text buffer. Windows are null and nonexistent if their width or height is 0, and are nonexistent before the widget has been realized.
window to get
a Gdk.Gdk_Window, or null
function Get_Window_Type
(View : not null access Gtk_Text_View_Record;
Window : Gdk.Gdk_Window) return Gtk.Enums.Gtk_Text_Window_Type
Usually used to find out which window an event corresponds to. If you connect to an event signal on Text_View, this function should be called on event->window to see which window it was.
a window type
the window type.
function Get_Wrap_Mode
(View : not null access Gtk_Text_View_Record)
return Gtk.Enums.Gtk_Wrap_Mode
Gets the line wrapping for the view.
the line wrap setting
procedure Gtk_New (View : out Gtk_Text_View)
Creates a new Gtk.Text_View.Gtk_Text_View. If you don't call Gtk.Text_View.Set_Buffer before using the text view, an empty default buffer will be created for you. Get the buffer with Gtk.Text_View.Get_Buffer. If you want to specify your own buffer, consider Gtk.Text_View.Gtk_New. Initialize does nothing if the object was already created with another call to Initialize* or G_New.
procedure Gtk_New
(View : out Gtk_Text_View;
Buffer : not null access Gtk.Text_Buffer.Gtk_Text_Buffer_Record'Class)
Creates a new Gtk.Text_View.Gtk_Text_View 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 Gtk.Text_View.Gtk_New. The text view adds its own reference count to the buffer; it does not take over an existing reference. Initialize does nothing if the object was already created with another call to Initialize* or G_New.
a Gtk.Text_Buffer.Gtk_Text_Buffer
type Gtk_Text_Extend_Selection is (
Text_Extend_Selection_Word,
Text_Extend_Selection_Line);
Granularity types that extend the text selection. Use the Gtk.Text_View.Gtk_Text_View::extend-selection signal to customize the selection.
package Gtk_Text_Extend_Selection_Properties is
new Generic_Internal_Discrete_Property (Gtk_Text_Extend_Selection);
type Gtk_Text_View is access all Gtk_Text_View_Record'Class;
type Gtk_Text_View_Layer is (
Text_View_Layer_Below,
Text_View_Layer_Above,
Text_View_Layer_Below_Text,
Text_View_Layer_Above_Text);
Used to reference the layers of Gtk.Text_View.Gtk_Text_View for the purpose of customized drawing with the ::draw_layer vfunc.
package Gtk_Text_View_Layer_Properties is
new Generic_Internal_Discrete_Property (Gtk_Text_View_Layer);
function Gtk_Text_View_New return Gtk_Text_View
Creates a new Gtk.Text_View.Gtk_Text_View. If you don't call Gtk.Text_View.Set_Buffer before using the text view, an empty default buffer will be created for you. Get the buffer with Gtk.Text_View.Get_Buffer. If you want to specify your own buffer, consider Gtk.Text_View.Gtk_New.
function Gtk_Text_View_New_With_Buffer
(Buffer : not null access Gtk.Text_Buffer.Gtk_Text_Buffer_Record'Class)
return Gtk_Text_View
Creates a new Gtk.Text_View.Gtk_Text_View 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 Gtk.Text_View.Gtk_New. The text view adds its own reference count to the buffer; it does not take over an existing reference.
a Gtk.Text_Buffer.Gtk_Text_Buffer
type Gtk_Text_View_Record is new Gtk_Container_Record with null record;
function Im_Context_Filter_Keypress
(View : not null access Gtk_Text_View_Record;
Event : Gdk.Event.Gdk_Event_Key) return Boolean
Allow the Gtk.Text_View.Gtk_Text_View input method to internally handle key press and release events. If this function returns True, then no further processing should be done for this key event. See Gtk.IM_Context.Filter_Keypress. Note that you are expected to call this function from your handler when overriding key event handling. This is needed in the case when you need to insert your own key handling between the input method and the default key event handling of the Gtk.Text_View.Gtk_Text_View.
static gboolean
gtk_foo_bar_key_press_event (GtkWidget *widget,
GdkEventKey *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);
}
Since: gtk+ 2.22
the key event
True if the input method handled the key event.
Im_Module_Property : constant Glib.Properties.Property_String;
Which IM (input method) module should be used for this text_view. See Gtk.IM_Context.Gtk_IM_Context.
Setting this to a non-null value overrides the system-wide IM module setting. See the GtkSettings Gtk.Settings.Gtk_Settings:gtk-im-module property.
package Implements_Gtk_Buildable is new Glib.Types.Implements
(Gtk.Buildable.Gtk_Buildable, Gtk_Text_View_Record, Gtk_Text_View);
package Implements_Gtk_Scrollable is new Glib.Types.Implements
(Gtk.Scrollable.Gtk_Scrollable, Gtk_Text_View_Record, Gtk_Text_View);
Indent_Property : constant Glib.Properties.Property_Int;
procedure Initialize (View : not null access Gtk_Text_View_Record'Class)
Creates a new Gtk.Text_View.Gtk_Text_View. If you don't call Gtk.Text_View.Set_Buffer before using the text view, an empty default buffer will be created for you. Get the buffer with Gtk.Text_View.Get_Buffer. If you want to specify your own buffer, consider Gtk.Text_View.Gtk_New. Initialize does nothing if the object was already created with another call to Initialize* or G_New.
procedure Initialize
(View : not null access Gtk_Text_View_Record'Class;
Buffer : not null access Gtk.Text_Buffer.Gtk_Text_Buffer_Record'Class)
Creates a new Gtk.Text_View.Gtk_Text_View 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 Gtk.Text_View.Gtk_New. The text view adds its own reference count to the buffer; it does not take over an existing reference. Initialize does nothing if the object was already created with another call to Initialize* or G_New.
a Gtk.Text_Buffer.Gtk_Text_Buffer
Input_Hints_Property : constant Gtk.Enums.Property_Gtk_Input_Hints;
Additional hints (beyond Gtk.Text_View.Gtk_Text_View:input-purpose) that allow input methods to fine-tune their behaviour.
Input_Purpose_Property : constant Gtk.Enums.Property_Gtk_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.
Justification_Property : constant Gtk.Enums.Property_Gtk_Justification;
Left_Margin_Property : constant Glib.Properties.Property_Int;
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.
Don't confuse this property with Gtk.Widget.Gtk_Widget:margin-left.
Monospace_Property : constant Glib.Properties.Property_Boolean;
procedure Move_Child
(View : not null access Gtk_Text_View_Record;
Child : not null access Gtk.Widget.Gtk_Widget_Record'Class;
Xpos : Glib.Gint;
Ypos : Glib.Gint)
Updates the position of a child, as for Gtk.Text_View.Add_Child_In_Window.
child widget already added to the text view
new X position in window coordinates
new Y position in window coordinates
function Move_Mark_Onscreen
(View : not null access Gtk_Text_View_Record;
Mark : not null access Gtk.Text_Mark.Gtk_Text_Mark_Record'Class)
return Boolean
Moves a mark within the buffer so that it's located within the currently-visible text area.
a Gtk.Text_Mark.Gtk_Text_Mark
True if the mark moved (wasn't already onscreen)
function Move_Visually
(View : not null access Gtk_Text_View_Record;
Iter : Gtk.Text_Iter.Gtk_Text_Iter;
Count : Glib.Gint) return Boolean
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.
a Gtk.Text_Iter.Gtk_Text_Iter
number of characters to move (negative moves left, positive moves right)
True if Iter moved and is not on the end iterator
procedure On_Backspace
(Self : not null access Gtk_Text_View_Record;
Call : Cb_GObject_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False)
The ::backspace signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user asks for it.
The default bindings for this signal are Backspace and Shift-Backspace.
procedure On_Backspace
(Self : not null access Gtk_Text_View_Record;
Call : Cb_Gtk_Text_View_Void;
After : Boolean := False)
The ::backspace signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user asks for it.
The default bindings for this signal are Backspace and Shift-Backspace.
procedure On_Copy_Clipboard
(Self : not null access Gtk_Text_View_Record;
Call : Cb_GObject_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False)
The ::copy-clipboard signal is a [keybinding signal][GtkBindingSignal] which gets emitted to copy the selection to the clipboard.
The default bindings for this signal are Ctrl-c and Ctrl-Insert.
procedure On_Copy_Clipboard
(Self : not null access Gtk_Text_View_Record;
Call : Cb_Gtk_Text_View_Void;
After : Boolean := False)
The ::copy-clipboard signal is a [keybinding signal][GtkBindingSignal] which gets emitted to copy the selection to the clipboard.
The default bindings for this signal are Ctrl-c and Ctrl-Insert.
procedure On_Cut_Clipboard
(Self : not null access Gtk_Text_View_Record;
Call : Cb_GObject_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False)
The ::cut-clipboard signal is a [keybinding signal][GtkBindingSignal] which gets emitted to cut the selection to the clipboard.
The default bindings for this signal are Ctrl-x and Shift-Delete.
procedure On_Cut_Clipboard
(Self : not null access Gtk_Text_View_Record;
Call : Cb_Gtk_Text_View_Void;
After : Boolean := False)
The ::cut-clipboard signal is a [keybinding signal][GtkBindingSignal] which gets emitted to cut the selection to the clipboard.
The default bindings for this signal are Ctrl-x and Shift-Delete.
procedure On_Delete_From_Cursor
(Self : not null access Gtk_Text_View_Record;
Call : Cb_GObject_Gtk_Delete_Type_Gint_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False)
The ::delete-from-cursor signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user initiates a text deletion.
If the Type is Gtk.Enums.Delete_Chars, GTK+ deletes the selection if there is one, otherwise it deletes the requested number of characters.
The default bindings for this signal are Delete for deleting a character, Ctrl-Delete for deleting a word and Ctrl-Backspace for deleting a word backwords.
Callback parameters: -- @param The_Type the granularity of the deletion, as a -- Gtk.Enums.Gtk_Delete_Type -- @param Count the number of Type units to delete
procedure On_Delete_From_Cursor
(Self : not null access Gtk_Text_View_Record;
Call : Cb_Gtk_Text_View_Gtk_Delete_Type_Gint_Void;
After : Boolean := False)
The ::delete-from-cursor signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user initiates a text deletion.
If the Type is Gtk.Enums.Delete_Chars, GTK+ deletes the selection if there is one, otherwise it deletes the requested number of characters.
The default bindings for this signal are Delete for deleting a character, Ctrl-Delete for deleting a word and Ctrl-Backspace for deleting a word backwords.
Callback parameters: -- @param The_Type the granularity of the deletion, as a -- Gtk.Enums.Gtk_Delete_Type -- @param Count the number of Type units to delete
procedure On_Extend_Selection
(Self : not null access Gtk_Text_View_Record;
Call : Cb_GObject_Gtk_Text_Extend_Selection_Gtk_Text_Iter_Gtk_Text_Iter_Gtk_Text_Iter_Boolean;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False)
The ::extend-selection signal is emitted when the selection needs to be extended at Location.
Callback parameters: -- @param Granularity the granularity type -- @param Location the location where to extend the selection -- @param Start where the selection should start -- @param The_End where the selection should end
procedure On_Extend_Selection
(Self : not null access Gtk_Text_View_Record;
Call : Cb_Gtk_Text_View_Gtk_Text_Extend_Selection_Gtk_Text_Iter_Gtk_Text_Iter_Gtk_Text_Iter_Boolean;
After : Boolean := False)
The ::extend-selection signal is emitted when the selection needs to be extended at Location.
Callback parameters: -- @param Granularity the granularity type -- @param Location the location where to extend the selection -- @param Start where the selection should start -- @param The_End where the selection should end
procedure On_Insert_At_Cursor
(Self : not null access Gtk_Text_View_Record;
Call : Cb_GObject_UTF8_String_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False)
The ::insert-at-cursor signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user initiates the insertion of a fixed string at the cursor.
This signal has no default bindings.
procedure On_Insert_At_Cursor
(Self : not null access Gtk_Text_View_Record;
Call : Cb_Gtk_Text_View_UTF8_String_Void;
After : Boolean := False)
The ::insert-at-cursor signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user initiates the insertion of a fixed string at the cursor.
This signal has no default bindings.
procedure On_Insert_Emoji
(Self : not null access Gtk_Text_View_Record;
Call : Cb_GObject_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False)
The ::insert-emoji signal is a [keybinding signal][GtkBindingSignal] which gets emitted to present the Emoji chooser for the Text_View.
The default bindings for this signal are Ctrl-. and Ctrl-;
procedure On_Insert_Emoji
(Self : not null access Gtk_Text_View_Record;
Call : Cb_Gtk_Text_View_Void;
After : Boolean := False)
The ::insert-emoji signal is a [keybinding signal][GtkBindingSignal] which gets emitted to present the Emoji chooser for the Text_View.
The default bindings for this signal are Ctrl-. and Ctrl-;
procedure On_Move_Cursor
(Self : not null access Gtk_Text_View_Record;
Call : Cb_GObject_Gtk_Movement_Step_Gint_Boolean_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False)
The ::move-cursor signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user initiates a cursor movement. If the cursor is not visible in Text_View, this signal causes the viewport to be moved instead.
Applications should not connect to it, but may emit it with g_signal_emit_by_name if they need to control the cursor programmatically.
The default bindings for this signal come in two variants, the variant with the Shift modifier extends the selection, the variant without the Shift modifer does not. There are too many key combinations to list them all here. - Arrow keys move by individual characters/lines - Ctrl-arrow key combinations move by words/paragraphs - Home/End keys move to the ends of the buffer - PageUp/PageDown keys move vertically by pages - Ctrl-PageUp/PageDown keys move horizontally by pages
Callback parameters: -- @param Step the granularity of the move, as a -- Gtk.Enums.Gtk_Movement_Step -- @param Count the number of Step units to move -- @param Extend_Selection True if the move should extend the selection
procedure On_Move_Cursor
(Self : not null access Gtk_Text_View_Record;
Call : Cb_Gtk_Text_View_Gtk_Movement_Step_Gint_Boolean_Void;
After : Boolean := False)
The ::move-cursor signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user initiates a cursor movement. If the cursor is not visible in Text_View, this signal causes the viewport to be moved instead.
Applications should not connect to it, but may emit it with g_signal_emit_by_name if they need to control the cursor programmatically.
The default bindings for this signal come in two variants, the variant with the Shift modifier extends the selection, the variant without the Shift modifer does not. There are too many key combinations to list them all here. - Arrow keys move by individual characters/lines - Ctrl-arrow key combinations move by words/paragraphs - Home/End keys move to the ends of the buffer - PageUp/PageDown keys move vertically by pages - Ctrl-PageUp/PageDown keys move horizontally by pages
Callback parameters: -- @param Step the granularity of the move, as a -- Gtk.Enums.Gtk_Movement_Step -- @param Count the number of Step units to move -- @param Extend_Selection True if the move should extend the selection
procedure On_Move_Viewport
(Self : not null access Gtk_Text_View_Record;
Call : Cb_GObject_Gtk_Scroll_Step_Gint_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False)
The ::move-viewport signal is a [keybinding signal][GtkBindingSignal] 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.
Callback parameters: -- @param Step the granularity of the movement, as a -- Gtk.Enums.Gtk_Scroll_Step -- @param Count the number of Step units to move
procedure On_Move_Viewport
(Self : not null access Gtk_Text_View_Record;
Call : Cb_Gtk_Text_View_Gtk_Scroll_Step_Gint_Void;
After : Boolean := False)
The ::move-viewport signal is a [keybinding signal][GtkBindingSignal] 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.
Callback parameters: -- @param Step the granularity of the movement, as a -- Gtk.Enums.Gtk_Scroll_Step -- @param Count the number of Step units to move
procedure On_Paste_Clipboard
(Self : not null access Gtk_Text_View_Record;
Call : Cb_GObject_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False)
The ::paste-clipboard signal is a [keybinding signal][GtkBindingSignal] which gets emitted to paste the contents of the clipboard into the text view.
The default bindings for this signal are Ctrl-v and Shift-Insert.
procedure On_Paste_Clipboard
(Self : not null access Gtk_Text_View_Record;
Call : Cb_Gtk_Text_View_Void;
After : Boolean := False)
The ::paste-clipboard signal is a [keybinding signal][GtkBindingSignal] which gets emitted to paste the contents of the clipboard into the text view.
The default bindings for this signal are Ctrl-v and Shift-Insert.
procedure On_Populate_Popup
(Self : not null access Gtk_Text_View_Record;
Call : Cb_GObject_Gtk_Widget_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False)
The ::populate-popup signal gets emitted before showing the context menu of the text view.
If you need to add items to the context menu, connect to this signal and append your items to the Popup, which will be a Gtk.Menu.Gtk_Menu in this case.
If Gtk.Text_View.Gtk_Text_View:populate-all is True, this signal will also be emitted to populate touch popups. In this case, Popup will be a different container, e.g. a Gtk.Toolbar.Gtk_Toolbar.
The signal handler should not make assumptions about the type of Widget, but check whether Popup is a Gtk.Menu.Gtk_Menu or Gtk.Toolbar.Gtk_Toolbar or another kind of container.
procedure On_Populate_Popup
(Self : not null access Gtk_Text_View_Record;
Call : Cb_Gtk_Text_View_Gtk_Widget_Void;
After : Boolean := False)
The ::populate-popup signal gets emitted before showing the context menu of the text view.
If you need to add items to the context menu, connect to this signal and append your items to the Popup, which will be a Gtk.Menu.Gtk_Menu in this case.
If Gtk.Text_View.Gtk_Text_View:populate-all is True, this signal will also be emitted to populate touch popups. In this case, Popup will be a different container, e.g. a Gtk.Toolbar.Gtk_Toolbar.
The signal handler should not make assumptions about the type of Widget, but check whether Popup is a Gtk.Menu.Gtk_Menu or Gtk.Toolbar.Gtk_Toolbar or another kind of container.
procedure On_Preedit_Changed
(Self : not null access Gtk_Text_View_Record;
Call : Cb_GObject_UTF8_String_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False)
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.
procedure On_Preedit_Changed
(Self : not null access Gtk_Text_View_Record;
Call : Cb_Gtk_Text_View_UTF8_String_Void;
After : Boolean := False)
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.
procedure On_Select_All
(Self : not null access Gtk_Text_View_Record;
Call : Cb_GObject_Boolean_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False)
The ::select-all signal is a [keybinding signal][GtkBindingSignal] which gets emitted to select or unselect the complete contents of the text view.
The default bindings for this signal are Ctrl-a and Ctrl-/ for selecting and Shift-Ctrl-a and Ctrl-\ for unselecting.
procedure On_Select_All
(Self : not null access Gtk_Text_View_Record;
Call : Cb_Gtk_Text_View_Boolean_Void;
After : Boolean := False)
The ::select-all signal is a [keybinding signal][GtkBindingSignal] which gets emitted to select or unselect the complete contents of the text view.
The default bindings for this signal are Ctrl-a and Ctrl-/ for selecting and Shift-Ctrl-a and Ctrl-\ for unselecting.
procedure On_Set_Anchor
(Self : not null access Gtk_Text_View_Record;
Call : Cb_GObject_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False)
The ::set-anchor signal is a [keybinding signal][GtkBindingSignal] 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.
procedure On_Set_Anchor
(Self : not null access Gtk_Text_View_Record;
Call : Cb_Gtk_Text_View_Void;
After : Boolean := False)
The ::set-anchor signal is a [keybinding signal][GtkBindingSignal] 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.
procedure On_Toggle_Cursor_Visible
(Self : not null access Gtk_Text_View_Record;
Call : Cb_GObject_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False)
The ::toggle-cursor-visible signal is a [keybinding signal][GtkBindingSignal] which gets emitted to toggle the Gtk.Text_View.Gtk_Text_View:cursor-visible property.
The default binding for this signal is F7.
procedure On_Toggle_Cursor_Visible
(Self : not null access Gtk_Text_View_Record;
Call : Cb_Gtk_Text_View_Void;
After : Boolean := False)
The ::toggle-cursor-visible signal is a [keybinding signal][GtkBindingSignal] which gets emitted to toggle the Gtk.Text_View.Gtk_Text_View:cursor-visible property.
The default binding for this signal is F7.
procedure On_Toggle_Overwrite
(Self : not null access Gtk_Text_View_Record;
Call : Cb_GObject_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False)
The ::toggle-overwrite signal is a [keybinding signal][GtkBindingSignal] which gets emitted to toggle the overwrite mode of the text view.
The default bindings for this signal is Insert.
procedure On_Toggle_Overwrite
(Self : not null access Gtk_Text_View_Record;
Call : Cb_Gtk_Text_View_Void;
After : Boolean := False)
The ::toggle-overwrite signal is a [keybinding signal][GtkBindingSignal] which gets emitted to toggle the overwrite mode of the text view.
The default bindings for this signal is Insert.
Overwrite_Property : constant Glib.Properties.Property_Boolean;
Pixels_Above_Lines_Property : constant Glib.Properties.Property_Int;
Pixels_Below_Lines_Property : constant Glib.Properties.Property_Int;
Pixels_Inside_Wrap_Property : constant Glib.Properties.Property_Int;
function Place_Cursor_Onscreen
(View : not null access Gtk_Text_View_Record) return Boolean
Moves the cursor to the currently visible region of the buffer, it it isn't there already.
True if the cursor had to be moved.
Populate_All_Property : constant Glib.Properties.Property_Boolean;
If :populate-all is True, the Gtk.Text_View.Gtk_Text_View::populate-popup signal is also emitted for touch popups.
type Property_Gtk_Text_Extend_Selection is new Gtk_Text_Extend_Selection_Properties.Property;
type Property_Gtk_Text_View_Layer is new Gtk_Text_View_Layer_Properties.Property;
procedure Reset_Cursor_Blink
(View : not null access Gtk_Text_View_Record)
Ensures that the cursor is shown (i.e. not in an 'off' blink interval) and 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 Gtk.Widget.Gtk_Widget::key-press-event handler). Since: gtk+ 3.20
procedure Reset_Im_Context (View : not null access Gtk_Text_View_Record)
Reset the input method context of the text view if needed. This can be necessary in the case where modifying the buffer would confuse on-going input method behavior. Since: gtk+ 2.22
Right_Margin_Property : constant Glib.Properties.Property_Int;
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.
Don't confuse this property with Gtk.Widget.Gtk_Widget:margin-right.
procedure Scroll_Mark_Onscreen
(View : not null access Gtk_Text_View_Record;
Mark : not null access Gtk.Text_Mark.Gtk_Text_Mark_Record'Class)
Scrolls Text_View the minimum distance such that Mark is contained within the visible area of the widget.
a mark in the buffer for Text_View
function Scroll_To_Iter
(View : not null access Gtk_Text_View_Record;
Iter : Gtk.Text_Iter.Gtk_Text_Iter;
Within_Margin : Gdouble;
Use_Align : Boolean;
Xalign : Gdouble;
Yalign : Gdouble) return Boolean
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 Gtk.Text_View.Scroll_To_Mark which saves a point to be scrolled to after line validation.
a Gtk.Text_Iter.Gtk_Text_Iter
margin as a [0.0,0.5) fraction of screen size
whether to use alignment arguments (if False, just get the mark onscreen)
horizontal alignment of mark within visible area
vertical alignment of mark within visible area
True if scrolling occurred
procedure Scroll_To_Mark
(View : not null access Gtk_Text_View_Record;
Mark : not null access Gtk.Text_Mark.Gtk_Text_Mark_Record'Class;
Within_Margin : Gdouble;
Use_Align : Boolean;
Xalign : Gdouble;
Yalign : Gdouble)
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.
a Gtk.Text_Mark.Gtk_Text_Mark
margin as a [0.0,0.5) fraction of screen size
whether to use alignment arguments (if False, just get the mark onscreen)
horizontal alignment of mark within visible area
vertical alignment of mark within visible area
procedure Set_Accepts_Tab
(View : not null access Gtk_Text_View_Record;
Accepts_Tab : Boolean)
Sets the behavior of the text widget when the Tab key is pressed. If Accepts_Tab is True, a tab character is inserted. If Accepts_Tab is False the keyboard focus is moved to the next widget in the focus chain. Since: gtk+ 2.4
True if pressing the Tab key should insert a tab character, False, if pressing the Tab key should move the keyboard focus.
procedure Set_Border_Window_Size
(View : not null access Gtk_Text_View_Record;
The_Type : Gtk.Enums.Gtk_Text_Window_Type;
Size : Glib.Gint)
Sets the width of Gtk.Enums.Text_Window_Left or Gtk.Enums.Text_Window_Right, or the height of Gtk.Enums.Text_Window_Top or Gtk.Enums.Text_Window_Bottom. Automatically destroys the corresponding window if the size is set to 0, and creates the window if the size is set to non-zero. This function can only be used for the "border windows", and it won't work with Gtk.Enums.Text_Window_Widget, Gtk.Enums.Text_Window_Text, or Gtk.Enums.Text_Window_Private.
window to affect
width or height of the window
procedure Set_Bottom_Margin
(View : not null access Gtk_Text_View_Record;
Bottom_Margin : Glib.Gint)
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. Since: gtk+ 3.18
bottom margin in pixels
procedure Set_Buffer
(View : not null access Gtk_Text_View_Record;
Buffer : access Gtk.Text_Buffer.Gtk_Text_Buffer_Record'Class)
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; Gtk.Text_View.Gtk_Text_View will not "adopt" it.
a Gtk.Text_Buffer.Gtk_Text_Buffer
procedure Set_Cursor_Visible
(View : not null access Gtk_Text_View_Record;
Setting : Boolean)
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 Gtk.Settings.Gtk_Settings:gtk-keynave-use-caret settings.
whether to show the insertion cursor
procedure Set_Draw_Layer
(Self : Glib.Object.GObject_Class;
Handler : Virtual_Draw_Layer)
See Glib.Object.Add_Interface
procedure Set_Editable
(View : not null access Gtk_Text_View_Record;
Setting : Boolean)
Sets the default editability of the Gtk.Text_View.Gtk_Text_View. You can override this default setting with tags in the buffer, using the "editable" attribute of tags.
whether it's editable
procedure Set_Hadjustment
(Self : not null access Gtk_Text_View_Record;
Hadjustment : access Gtk.Adjustment.Gtk_Adjustment_Record'Class)
procedure Set_Hscroll_Policy
(Self : not null access Gtk_Text_View_Record;
Policy : Gtk.Enums.Gtk_Scrollable_Policy)
procedure Set_Indent
(View : not null access Gtk_Text_View_Record;
Indent : Glib.Gint)
Sets the default indentation for paragraphs in Text_View. Tags in the buffer may override the default.
indentation in pixels
procedure Set_Input_Hints
(View : not null access Gtk_Text_View_Record;
Hints : Gtk.Enums.Gtk_Input_Hints)
Sets the Gtk.Text_View.Gtk_Text_View:input-hints property, which allows input methods to fine-tune their behaviour. Since: gtk+ 3.6
the hints
procedure Set_Input_Purpose
(View : not null access Gtk_Text_View_Record;
Purpose : Gtk.Enums.Gtk_Input_Purpose)
Sets the Gtk.Text_View.Gtk_Text_View:input-purpose property which can be used by on-screen keyboards and other input methods to adjust their behaviour. Since: gtk+ 3.6
the purpose
procedure Set_Justification
(View : not null access Gtk_Text_View_Record;
Justification : Gtk.Enums.Gtk_Justification)
Sets the default justification of text in Text_View. Tags in the view's buffer may override the default.
justification
procedure Set_Left_Margin
(View : not null access Gtk_Text_View_Record;
Left_Margin : Glib.Gint)
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.
left margin in pixels
procedure Set_Monospace
(View : not null access Gtk_Text_View_Record;
Monospace : Boolean)
Sets the Gtk.Text_View.Gtk_Text_View:monospace property, which indicates that the text view should use monospace fonts. Since: gtk+ 3.16
True to request monospace styling
procedure Set_Overwrite
(View : not null access Gtk_Text_View_Record;
Overwrite : Boolean)
Changes the Gtk.Text_View.Gtk_Text_View overwrite mode. Since: gtk+ 2.4
True to turn on overwrite mode, False to turn it off
procedure Set_Pixels_Above_Lines
(View : not null access Gtk_Text_View_Record;
Pixels_Above_Lines : Glib.Gint)
Sets the default number of blank pixels above paragraphs in Text_View. Tags in the buffer for Text_View may override the defaults.
pixels above paragraphs
procedure Set_Pixels_Below_Lines
(View : not null access Gtk_Text_View_Record;
Pixels_Below_Lines : Glib.Gint)
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.
pixels below paragraphs
procedure Set_Pixels_Inside_Wrap
(View : not null access Gtk_Text_View_Record;
Pixels_Inside_Wrap : Glib.Gint)
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.
default number of pixels between wrapped lines
procedure Set_Right_Margin
(View : not null access Gtk_Text_View_Record;
Right_Margin : Glib.Gint)
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.
right margin in pixels
procedure Set_Tabs
(View : not null access Gtk_Text_View_Record;
Tabs : Pango.Tabs.Pango_Tab_Array)
Sets the default tab stops for paragraphs in Text_View. Tags in the buffer may override the default.
tabs as a Pango.Tabs.Pango_Tab_Array
procedure Set_Top_Margin
(View : not null access Gtk_Text_View_Record;
Top_Margin : Glib.Gint)
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. Since: gtk+ 3.18
top margin in pixels
procedure Set_Vadjustment
(Self : not null access Gtk_Text_View_Record;
Vadjustment : access Gtk.Adjustment.Gtk_Adjustment_Record'Class)
procedure Set_Vscroll_Policy
(Self : not null access Gtk_Text_View_Record;
Policy : Gtk.Enums.Gtk_Scrollable_Policy)
procedure Set_Wrap_Mode
(View : not null access Gtk_Text_View_Record;
Wrap_Mode : Gtk.Enums.Gtk_Wrap_Mode)
Sets the line wrapping for the view.
a Gtk.Enums.Gtk_Wrap_Mode
Signal_Backspace : constant Glib.Signal_Name := "backspace";
The ::backspace signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user asks for it.
The default bindings for this signal are Backspace and Shift-Backspace.
Signal_Copy_Clipboard : constant Glib.Signal_Name := "copy-clipboard";
The ::copy-clipboard signal is a [keybinding signal][GtkBindingSignal] which gets emitted to copy the selection to the clipboard.
The default bindings for this signal are Ctrl-c and Ctrl-Insert.
Signal_Cut_Clipboard : constant Glib.Signal_Name := "cut-clipboard";
The ::cut-clipboard signal is a [keybinding signal][GtkBindingSignal] which gets emitted to cut the selection to the clipboard.
The default bindings for this signal are Ctrl-x and Shift-Delete.
Signal_Delete_From_Cursor : constant Glib.Signal_Name := "delete-from-cursor";
The ::delete-from-cursor signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user initiates a text deletion.
If the Type is Gtk.Enums.Delete_Chars, GTK+ deletes the selection if there is one, otherwise it deletes the requested number of characters.
The default bindings for this signal are Delete for deleting a character, Ctrl-Delete for deleting a word and Ctrl-Backspace for deleting a word backwords.
Callback parameters: -- @param The_Type the granularity of the deletion, as a -- Gtk.Enums.Gtk_Delete_Type -- @param Count the number of Type units to delete
Signal_Extend_Selection : constant Glib.Signal_Name := "extend-selection";
The ::extend-selection signal is emitted when the selection needs to be extended at Location.
Callback parameters: -- @param Granularity the granularity type -- @param Location the location where to extend the selection -- @param Start where the selection should start -- @param The_End where the selection should end
Signal_Insert_At_Cursor : constant Glib.Signal_Name := "insert-at-cursor";
The ::insert-at-cursor signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user initiates the insertion of a fixed string at the cursor.
This signal has no default bindings.
Signal_Insert_Emoji : constant Glib.Signal_Name := "insert-emoji";
The ::insert-emoji signal is a [keybinding signal][GtkBindingSignal] which gets emitted to present the Emoji chooser for the Text_View.
The default bindings for this signal are Ctrl-. and Ctrl-;
Signal_Move_Cursor : constant Glib.Signal_Name := "move-cursor";
The ::move-cursor signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user initiates a cursor movement. If the cursor is not visible in Text_View, this signal causes the viewport to be moved instead.
Applications should not connect to it, but may emit it with g_signal_emit_by_name if they need to control the cursor programmatically.
The default bindings for this signal come in two variants, the variant with the Shift modifier extends the selection, the variant without the Shift modifer does not. There are too many key combinations to list them all here. - Arrow keys move by individual characters/lines - Ctrl-arrow key combinations move by words/paragraphs - Home/End keys move to the ends of the buffer - PageUp/PageDown keys move vertically by pages - Ctrl-PageUp/PageDown keys move horizontally by pages
Callback parameters: -- @param Step the granularity of the move, as a -- Gtk.Enums.Gtk_Movement_Step -- @param Count the number of Step units to move -- @param Extend_Selection True if the move should extend the selection
Signal_Move_Viewport : constant Glib.Signal_Name := "move-viewport";
The ::move-viewport signal is a [keybinding signal][GtkBindingSignal] 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.
Callback parameters: -- @param Step the granularity of the movement, as a -- Gtk.Enums.Gtk_Scroll_Step -- @param Count the number of Step units to move
Signal_Paste_Clipboard : constant Glib.Signal_Name := "paste-clipboard";
The ::paste-clipboard signal is a [keybinding signal][GtkBindingSignal] which gets emitted to paste the contents of the clipboard into the text view.
The default bindings for this signal are Ctrl-v and Shift-Insert.
Signal_Populate_Popup : constant Glib.Signal_Name := "populate-popup";
The ::populate-popup signal gets emitted before showing the context menu of the text view.
If you need to add items to the context menu, connect to this signal and append your items to the Popup, which will be a Gtk.Menu.Gtk_Menu in this case.
If Gtk.Text_View.Gtk_Text_View:populate-all is True, this signal will also be emitted to populate touch popups. In this case, Popup will be a different container, e.g. a Gtk.Toolbar.Gtk_Toolbar.
The signal handler should not make assumptions about the type of Widget, but check whether Popup is a Gtk.Menu.Gtk_Menu or Gtk.Toolbar.Gtk_Toolbar or another kind of container.
Signal_Preedit_Changed : constant Glib.Signal_Name := "preedit-changed";
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.
Signal_Select_All : constant Glib.Signal_Name := "select-all";
The ::select-all signal is a [keybinding signal][GtkBindingSignal] which gets emitted to select or unselect the complete contents of the text view.
The default bindings for this signal are Ctrl-a and Ctrl-/ for selecting and Shift-Ctrl-a and Ctrl-\ for unselecting.
Signal_Set_Anchor : constant Glib.Signal_Name := "set-anchor";
The ::set-anchor signal is a [keybinding signal][GtkBindingSignal] 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.
Signal_Toggle_Cursor_Visible : constant Glib.Signal_Name := "toggle-cursor-visible";
The ::toggle-cursor-visible signal is a [keybinding signal][GtkBindingSignal] which gets emitted to toggle the Gtk.Text_View.Gtk_Text_View:cursor-visible property.
The default binding for this signal is F7.
Signal_Toggle_Overwrite : constant Glib.Signal_Name := "toggle-overwrite";
The ::toggle-overwrite signal is a [keybinding signal][GtkBindingSignal] which gets emitted to toggle the overwrite mode of the text view.
The default bindings for this signal is Insert.
function Starts_Display_Line
(View : not null access Gtk_Text_View_Record;
Iter : Gtk.Text_Iter.Gtk_Text_Iter) return Boolean
Determines whether Iter is at the start of a display line. See Gtk.Text_View.Forward_Display_Line for an explanation of display lines vs. paragraphs.
a Gtk.Text_Iter.Gtk_Text_Iter
True if Iter begins a wrapped line
Tabs_Property : constant Glib.Properties.Property_Boxed;
Type: Pango.Tab_Array
subtype Text_View_Interface_Descr is Glib.Object.Interface_Description;
Top_Margin_Property : constant Glib.Properties.Property_Int;
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 Gtk.Widget.Gtk_Widget:margin-top.
type Virtual_Draw_Layer is access procedure
(View : System.Address;
Layer : Gtk_Text_View_Layer;
Cr : Cairo.Cairo_Context);
The draw_layer virtual function is called before and after the text view is drawing its own text. Applications can override this vfunc in a subclass to draw customized content underneath or above the text. Since: 3.14
procedure Window_To_Buffer_Coords
(View : not null access Gtk_Text_View_Record;
Win : Gtk.Enums.Gtk_Text_Window_Type;
Window_X : Glib.Gint;
Window_Y : Glib.Gint;
Buffer_X : out Glib.Gint;
Buffer_Y : out Glib.Gint)
Converts coordinates on the window identified by Win to buffer coordinates, storing the result in (Buffer_X,Buffer_Y). Note that you can't convert coordinates for a nonexisting window (see Gtk.Text_View.Set_Border_Window_Size).
a Gtk.Enums.Gtk_Text_Window_Type except Gtk.Enums.Text_Window_Private
window x coordinate
window y coordinate
buffer x coordinate return location or null
buffer y coordinate return location or null
Wrap_Mode_Property : constant Gtk.Enums.Property_Gtk_Wrap_Mode;