------------------------------------------------------------------------------
-- --
-- Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet --
-- Copyright (C) 2000-2014, AdaCore --
-- --
-- This library is free software; you can redistribute it and/or modify it --
-- under terms of the GNU General Public License as published by the Free --
-- Software Foundation; either version 3, 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 MERCHAN- --
-- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. --
-- --
-- As a special exception under Section 7 of GPL version 3, you are granted --
-- additional permissions described in the GCC Runtime Library Exception, --
-- version 3.1, as published by the Free Software Foundation. --
-- --
-- You should have received a copy of the GNU General Public License and --
-- a copy of the GCC Runtime Library Exception along with this program; --
-- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see --
-- <http://www.gnu.org/licenses/>. --
-- --
------------------------------------------------------------------------------
-- <description>
-- You may wish to begin by reading the <link linkend="TextWidget">text
-- widget conceptual overview</link> which gives an overview of all the
-- objects and data types related to the text widget and how they work
-- together.
--
-- </description>
pragma Ada_2005;
pragma Warnings (Off, "*is already use-visible*");
with Gdk; use Gdk;
with Gdk.Event; use Gdk.Event;
with Gdk.Rectangle; use Gdk.Rectangle;
with Glib; use Glib;
with Glib.Object; use Glib.Object;
with Glib.Properties; use Glib.Properties;
with Glib.Types; use Glib.Types;
with Gtk.Adjustment; use Gtk.Adjustment;
with Gtk.Buildable; use Gtk.Buildable;
with Gtk.Container; use Gtk.Container;
with Gtk.Enums; use Gtk.Enums;
with Gtk.Scrollable; use Gtk.Scrollable;
with Gtk.Text_Attributes; use Gtk.Text_Attributes;
with Gtk.Text_Buffer; use Gtk.Text_Buffer;
with Gtk.Text_Child_Anchor; use Gtk.Text_Child_Anchor;
with Gtk.Text_Iter; use Gtk.Text_Iter;
with Gtk.Text_Mark; use Gtk.Text_Mark;
with Gtk.Widget; use Gtk.Widget;
with Pango.Tabs; use Pango.Tabs;
package Gtk.Text_View is
type Gtk_Text_View_Record is new Gtk_Container_Record with null record;
type Gtk_Text_View is access all Gtk_Text_View_Record'Class;
------------------
-- Constructors --
------------------
procedure Gtk_New (View : out Gtk_Text_View);
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.
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.
procedure Gtk_New
(View : out Gtk_Text_View;
Buffer : not null access Gtk.Text_Buffer.Gtk_Text_Buffer_Record'Class);
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.
-- "buffer": a Gtk.Text_Buffer.Gtk_Text_Buffer
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.
-- "buffer": a Gtk.Text_Buffer.Gtk_Text_Buffer
function Get_Type return Glib.GType;
pragma Import (C, Get_Type, "gtk_text_view_get_type");
-------------
-- Methods --
-------------
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.
-- "child": a Gtk.Widget.Gtk_Widget
-- "anchor": 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 : Gint;
Ypos : 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 the Gdk.Gdk_Window in question, and that these
-- coordinates have no sane relationship 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), you'll need to
-- compute the child's correct position in buffer coordinates any time
-- scrolling occurs or buffer changes occur, and then call
-- Gtk.Text_View.Move_Child to update the child's position.
-- "child": a Gtk.Widget.Gtk_Widget
-- "which_window": which window the child should appear in
-- "xpos": X position of child in window coordinates
-- "ypos": 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.
-- "iter": a Gtk.Text_Iter.Gtk_Text_Iter
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.
-- "iter": a Gtk.Text_Iter.Gtk_Text_Iter
procedure Buffer_To_Window_Coords
(View : not null access Gtk_Text_View_Record;
Win : Gtk.Enums.Gtk_Text_Window_Type;
Buffer_X : Gint;
Buffer_Y : Gint;
Window_X : out Gint;
Window_Y : out 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).
-- "win": a Gtk.Enums.Gtk_Text_Window_Type except GTK_TEXT_WINDOW_PRIVATE
-- "buffer_x": buffer x coordinate
-- "buffer_y": buffer y coordinate
-- "window_x": window x coordinate return location or null
-- "window_y": window y coordinate return location or null
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.
-- "iter": a Gtk.Text_Iter.Gtk_Text_Iter
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.
-- "iter": a Gtk.Text_Iter.Gtk_Text_Iter
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
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
-- "accepts_tab": True if pressing the Tab key should insert a tab
-- character, False, if pressing the Tab key should move the keyboard
-- focus.
function Get_Border_Window_Size
(View : not null access Gtk_Text_View_Record;
The_Type : Gtk.Enums.Gtk_Text_Window_Type) return Gint;
-- Gets the width of the specified border window. See
-- Gtk.Text_View.Set_Border_Window_Size.
-- "type": window to return size from
procedure Set_Border_Window_Size
(View : not null access Gtk_Text_View_Record;
The_Type : Gtk.Enums.Gtk_Text_Window_Type;
Size : 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," it doesn't work with GTK_TEXT_WINDOW_WIDGET,
-- GTK_TEXT_WINDOW_TEXT, or GTK_TEXT_WINDOW_PRIVATE.
-- "type": window to affect
-- "size": width or height of the window
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.
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.
-- "buffer": 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
-- "iter": a Gtk.Text_Iter.Gtk_Text_Iter
-- "strong": location to store the strong cursor position (may be null)
-- "weak": 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 is being displayed.
procedure Set_Cursor_Visible
(View : not null access Gtk_Text_View_Record;
Setting : Boolean);
-- Toggles whether the insertion point is displayed. A buffer with no
-- editable text probably shouldn't have a visible cursor, so you may want
-- to turn the cursor off.
-- "setting": whether to show the insertion cursor
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.
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.
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.
-- "setting": whether it's editable
function Get_Indent
(View : not null access Gtk_Text_View_Record) return 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.
procedure Set_Indent
(View : not null access Gtk_Text_View_Record;
Indent : Gint);
-- Sets the default indentation for paragraphs in Text_View. Tags in the
-- buffer may override the default.
-- "indent": indentation in pixels
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
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
-- "hints": the hints
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
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
-- "purpose": the purpose
procedure Get_Iter_At_Location
(View : not null access Gtk_Text_View_Record;
Iter : out Gtk.Text_Iter.Gtk_Text_Iter;
X : Gint;
Y : Gint);
-- 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.
-- "iter": a Gtk.Text_Iter.Gtk_Text_Iter
-- "x": x position, in buffer coordinates
-- "y": y position, in buffer coordinates
procedure Get_Iter_At_Position
(View : not null access Gtk_Text_View_Record;
Iter : out Gtk.Text_Iter.Gtk_Text_Iter;
Trailing : out Gint;
X : Gint;
Y : Gint);
-- 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
-- "iter": a Gtk.Text_Iter.Gtk_Text_Iter
-- "trailing": if non-null, location to store an integer indicating where
-- in the grapheme the user clicked. It will either be zero, or the number
-- of characters in the grapheme. 0 represents the trailing edge of the
-- grapheme.
-- "x": x position, in buffer coordinates
-- "y": y position, in buffer coordinates
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.
-- "iter": a Gtk.Text_Iter.Gtk_Text_Iter
-- "location": 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.
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": justification
function Get_Left_Margin
(View : not null access Gtk_Text_View_Record) return Gint;
-- Gets the default left margin size of paragraphs in the Text_View. Tags
-- in the buffer may override the default.
procedure Set_Left_Margin
(View : not null access Gtk_Text_View_Record;
Left_Margin : Gint);
-- Sets the default left margin for text in Text_View. Tags in the buffer
-- may override the default.
-- "left_margin": 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 : Gint;
Line_Top : out 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.
-- "target_iter": a Gtk.Text_Iter.Gtk_Text_Iter
-- "y": a y coordinate
-- "line_top": 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 Gint;
Height : out 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.
-- "iter": a Gtk.Text_Iter.Gtk_Text_Iter
-- "y": return location for a y coordinate
-- "height": return location for a height
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
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
-- "overwrite": True to turn on overwrite mode, False to turn it off
function Get_Pixels_Above_Lines
(View : not null access Gtk_Text_View_Record) return Gint;
-- Gets the default number of pixels to put above paragraphs.
procedure Set_Pixels_Above_Lines
(View : not null access Gtk_Text_View_Record;
Pixels_Above_Lines : 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_lines": pixels above paragraphs
function Get_Pixels_Below_Lines
(View : not null access Gtk_Text_View_Record) return Gint;
-- Gets the value set by Gtk.Text_View.Set_Pixels_Below_Lines.
procedure Set_Pixels_Below_Lines
(View : not null access Gtk_Text_View_Record;
Pixels_Below_Lines : 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_lines": pixels below paragraphs
function Get_Pixels_Inside_Wrap
(View : not null access Gtk_Text_View_Record) return Gint;
-- Gets the value set by Gtk.Text_View.Set_Pixels_Inside_Wrap.
procedure Set_Pixels_Inside_Wrap
(View : not null access Gtk_Text_View_Record;
Pixels_Inside_Wrap : 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.
-- "pixels_inside_wrap": default number of pixels between wrapped lines
function Get_Right_Margin
(View : not null access Gtk_Text_View_Record) return Gint;
-- Gets the default right margin for text in Text_View. Tags in the buffer
-- may override the default.
procedure Set_Right_Margin
(View : not null access Gtk_Text_View_Record;
Right_Margin : Gint);
-- Sets the default right margin for text in the text view. Tags in the
-- buffer may override the default.
-- "right_margin": 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.
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": tabs as a Pango.Tabs.Pango_Tab_Array
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.
-- "visible_rect": rectangle to fill
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.
-- "win": window to get
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.
-- "window": a 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.
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.
-- "wrap_mode": a Gtk.Enums.Gtk_Wrap_Mode
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) { if ((key->keyval == GDK_KEY_Return || key->keyval
-- == GDK_KEY_KP_Enter)) { if (gtk_text_view_im_context_filter_keypress
-- (GTK_TEXT_VIEW (view), event)) return TRUE; }
-- /* Do some stuff */
-- return GTK_WIDGET_CLASS (gtk_foo_bar_parent_class)->key_press_event
-- (widget, event); } ]|
-- Since: gtk+ 2.22
-- "event": the key event
procedure Move_Child
(View : not null access Gtk_Text_View_Record;
Child : not null access Gtk.Widget.Gtk_Widget_Record'Class;
Xpos : Gint;
Ypos : Gint);
-- Updates the position of a child, as for
-- Gtk.Text_View.Add_Child_In_Window.
-- "child": child widget already added to the text view
-- "xpos": new X position in window coordinates
-- "ypos": 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.
-- "mark": a Gtk.Text_Mark.Gtk_Text_Mark
function Move_Visually
(View : not null access Gtk_Text_View_Record;
Iter : Gtk.Text_Iter.Gtk_Text_Iter;
Count : 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.
-- "iter": a Gtk.Text_Iter.Gtk_Text_Iter
-- "count": number of characters to move (negative moves left, positive
-- moves right)
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.
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
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.
-- "mark": 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.
-- "iter": a Gtk.Text_Iter.Gtk_Text_Iter
-- "within_margin": margin as a [0.0,0.5) fraction of screen size
-- "use_align": whether to use alignment arguments (if False, just get the
-- mark onscreen)
-- "xalign": horizontal alignment of mark within visible area
-- "yalign": vertical alignment of mark within visible area
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.
-- "mark": a Gtk.Text_Mark.Gtk_Text_Mark
-- "within_margin": margin as a [0.0,0.5) fraction of screen size
-- "use_align": whether to use alignment arguments (if False, just get the
-- mark onscreen)
-- "xalign": horizontal alignment of mark within visible area
-- "yalign": vertical alignment of mark within visible area
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.
-- "iter": a Gtk.Text_Iter.Gtk_Text_Iter
procedure Window_To_Buffer_Coords
(View : not null access Gtk_Text_View_Record;
Win : Gtk.Enums.Gtk_Text_Window_Type;
Window_X : Gint;
Window_Y : Gint;
Buffer_X : out Gint;
Buffer_Y : out 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).
-- "win": a Gtk.Enums.Gtk_Text_Window_Type except GTK_TEXT_WINDOW_PRIVATE
-- "window_x": window x coordinate
-- "window_y": window y coordinate
-- "buffer_x": buffer x coordinate return location or null
-- "buffer_y": buffer y coordinate return location or null
---------------------------------------------
-- Inherited subprograms (from interfaces) --
---------------------------------------------
-- Methods inherited from the Buildable interface are not duplicated here
-- since they are meant to be used by tools, mostly. If you need to call
-- them, use an explicit cast through the "-" operator below.
function Get_Hadjustment
(Self : not null access Gtk_Text_View_Record)
return Gtk.Adjustment.Gtk_Adjustment;
procedure Set_Hadjustment
(Self : not null access Gtk_Text_View_Record;
Hadjustment : access Gtk.Adjustment.Gtk_Adjustment_Record'Class);
function Get_Hscroll_Policy
(Self : not null access Gtk_Text_View_Record)
return Gtk.Enums.Gtk_Scrollable_Policy;
procedure Set_Hscroll_Policy
(Self : not null access Gtk_Text_View_Record;
Policy : Gtk.Enums.Gtk_Scrollable_Policy);
function Get_Vadjustment
(Self : not null access Gtk_Text_View_Record)
return Gtk.Adjustment.Gtk_Adjustment;
procedure Set_Vadjustment
(Self : not null access Gtk_Text_View_Record;
Vadjustment : access Gtk.Adjustment.Gtk_Adjustment_Record'Class);
function Get_Vscroll_Policy
(Self : not null access Gtk_Text_View_Record)
return Gtk.Enums.Gtk_Scrollable_Policy;
procedure Set_Vscroll_Policy
(Self : not null access Gtk_Text_View_Record;
Policy : Gtk.Enums.Gtk_Scrollable_Policy);
----------------
-- Properties --
----------------
-- The following properties are defined for this widget. See
-- Glib.Properties for more information on properties)
Accepts_Tab_Property : constant Glib.Properties.Property_Boolean;
Buffer_Property : constant Glib.Properties.Property_Object;
-- Type: Gtk.Text_Buffer.Gtk_Text_Buffer
Cursor_Visible_Property : constant Glib.Properties.Property_Boolean;
Editable_Property : constant Glib.Properties.Property_Boolean;
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.
Indent_Property : constant Glib.Properties.Property_Int;
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;
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;
Populate_All_Property : constant Glib.Properties.Property_Boolean;
Right_Margin_Property : constant Glib.Properties.Property_Int;
Tabs_Property : constant Glib.Properties.Property_Boxed;
-- Type: Pango.Tab_Array
Wrap_Mode_Property : constant Gtk.Enums.Property_Gtk_Wrap_Mode;
-------------
-- Signals --
-------------
type Cb_Gtk_Text_View_Void is not null access procedure (Self : access Gtk_Text_View_Record'Class);
type Cb_GObject_Void is not null access procedure
(Self : access Glib.Object.GObject_Record'Class);
Signal_Backspace : constant Glib.Signal_Name := "backspace";
procedure On_Backspace
(Self : not null access Gtk_Text_View_Record;
Call : Cb_Gtk_Text_View_Void;
After : Boolean := False);
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 <link
-- linkend="keybinding-signals">keybinding signal</link> which gets emitted
-- when the user asks for it.
--
-- The default bindings for this signal are Backspace and Shift-Backspace.
Signal_Copy_Clipboard : constant Glib.Signal_Name := "copy-clipboard";
procedure On_Copy_Clipboard
(Self : not null access Gtk_Text_View_Record;
Call : Cb_Gtk_Text_View_Void;
After : Boolean := False);
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 <link
-- linkend="keybinding-signals">keybinding signal</link> which gets emitted
-- to copy the selection to the clipboard.
--
-- The default bindings for this signal are Ctrl-c and Ctrl-Insert.
Signal_Cut_Clipboard : constant Glib.Signal_Name := "cut-clipboard";
procedure On_Cut_Clipboard
(Self : not null access Gtk_Text_View_Record;
Call : Cb_Gtk_Text_View_Void;
After : Boolean := False);
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 <link
-- linkend="keybinding-signals">keybinding signal</link> which gets emitted
-- to cut the selection to the clipboard.
--
-- The default bindings for this signal are Ctrl-x and Shift-Delete.
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 : Gint);
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 : Gint);
Signal_Delete_From_Cursor : constant Glib.Signal_Name := "delete-from-cursor";
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);
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 <link
-- linkend="keybinding-signals">keybinding signal</link> 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:
-- -- "type": the granularity of the deletion, as a Gtk.Enums.Gtk_Delete_Type
-- -- "count": the number of Type units to delete
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_GObject_UTF8_String_Void is not null access procedure
(Self : access Glib.Object.GObject_Record'Class;
String : UTF8_String);
Signal_Insert_At_Cursor : constant Glib.Signal_Name := "insert-at-cursor";
procedure On_Insert_At_Cursor
(Self : not null access Gtk_Text_View_Record;
Call : Cb_Gtk_Text_View_UTF8_String_Void;
After : Boolean := False);
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 <link
-- linkend="keybinding-signals">keybinding signal</link> which gets emitted
-- when the user initiates the insertion of a fixed string at the cursor.
--
-- This signal has no default bindings.
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 : Gint;
Extend_Selection : Boolean);
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 : Gint;
Extend_Selection : Boolean);
Signal_Move_Cursor : constant Glib.Signal_Name := "move-cursor";
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);
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 <link
-- linkend="keybinding-signals">keybinding signal</link> which gets emitted
-- when the user initiates a cursor movement. If the cursor is not visible
-- in Text_View, this signal causes the viewport to be moved instead.
--
-- Applications should not connect to it, but may emit it with
-- g_signal_emit_by_name if they need to control 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:
-- -- "step": the granularity of the move, as a Gtk.Enums.Gtk_Movement_Step
-- -- "count": the number of Step units to move
-- -- "extend_selection": True if the move should extend the selection
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 : Gint);
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 : Gint);
Signal_Move_Viewport : constant Glib.Signal_Name := "move-viewport";
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);
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 <link
-- linkend="keybinding-signals">keybinding signal</link> which can be bound
-- to key combinations to allow the user to move the viewport, i.e. change
-- what part of the text view is visible in a containing scrolled window.
--
-- There are no default bindings for this signal.
--
-- Callback parameters:
-- -- "step": the granularity of the move, as a Gtk.Enums.Gtk_Movement_Step
-- -- "count": the number of Step units to move
Signal_Paste_Clipboard : constant Glib.Signal_Name := "paste-clipboard";
procedure On_Paste_Clipboard
(Self : not null access Gtk_Text_View_Record;
Call : Cb_Gtk_Text_View_Void;
After : Boolean := False);
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 <link
-- linkend="keybinding-signals">keybinding signal</link> which gets emitted
-- to paste the contents of the clipboard into the text view.
--
-- The default bindings for this signal are Ctrl-v and Shift-Insert.
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_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);
Signal_Populate_Popup : constant Glib.Signal_Name := "populate-popup";
procedure On_Populate_Popup
(Self : not null access Gtk_Text_View_Record;
Call : Cb_Gtk_Text_View_Gtk_Widget_Void;
After : Boolean := False);
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.GEntry.Gtk_Entry::populate-toolbar 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";
procedure On_Preedit_Changed
(Self : not null access Gtk_Text_View_Record;
Call : Cb_Gtk_Text_View_UTF8_String_Void;
After : Boolean := False);
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.
type Cb_Gtk_Text_View_Boolean_Void is not null access procedure
(Self : access Gtk_Text_View_Record'Class;
Gtk_Select : Boolean);
type Cb_GObject_Boolean_Void is not null access procedure
(Self : access Glib.Object.GObject_Record'Class;
Gtk_Select : Boolean);
Signal_Select_All : constant Glib.Signal_Name := "select-all";
procedure On_Select_All
(Self : not null access Gtk_Text_View_Record;
Call : Cb_Gtk_Text_View_Boolean_Void;
After : Boolean := False);
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 <link
-- linkend="keybinding-signals">keybinding signal</link> which gets emitted
-- to select or unselect the complete contents of the text view.
--
-- The default bindings for this signal are Ctrl-a and Ctrl-/ for
-- selecting and Shift-Ctrl-a and Ctrl-\ for unselecting.
Signal_Set_Anchor : constant Glib.Signal_Name := "set-anchor";
procedure On_Set_Anchor
(Self : not null access Gtk_Text_View_Record;
Call : Cb_Gtk_Text_View_Void;
After : Boolean := False);
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 <link
-- linkend="keybinding-signals">keybinding signal</link> which gets emitted
-- when the user initiates setting the "anchor" mark. The "anchor" mark
-- gets placed at the same position as the "insert" mark.
--
-- This signal has no default bindings.
Signal_Toggle_Cursor_Visible : constant Glib.Signal_Name := "toggle-cursor-visible";
procedure On_Toggle_Cursor_Visible
(Self : not null access Gtk_Text_View_Record;
Call : Cb_Gtk_Text_View_Void;
After : Boolean := False);
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 <link
-- linkend="keybinding-signals">keybinding signal</link> which gets emitted
-- to toggle the visibility of the cursor.
--
-- The default binding for this signal is F7.
Signal_Toggle_Overwrite : constant Glib.Signal_Name := "toggle-overwrite";
procedure On_Toggle_Overwrite
(Self : not null access Gtk_Text_View_Record;
Call : Cb_Gtk_Text_View_Void;
After : Boolean := False);
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 <link
-- linkend="keybinding-signals">keybinding signal</link> which gets emitted
-- to toggle the overwrite mode of the text view.
--
-- The default bindings for this signal is Insert.
----------------
-- Interfaces --
----------------
-- This class implements several interfaces. See Glib.Types
--
-- - "Buildable"
--
-- - "Scrollable"
package Implements_Gtk_Buildable is new Glib.Types.Implements
(Gtk.Buildable.Gtk_Buildable, Gtk_Text_View_Record, Gtk_Text_View);
function "+"
(Widget : access Gtk_Text_View_Record'Class)
return Gtk.Buildable.Gtk_Buildable
renames Implements_Gtk_Buildable.To_Interface;
function "-"
(Interf : Gtk.Buildable.Gtk_Buildable)
return Gtk_Text_View
renames Implements_Gtk_Buildable.To_Object;
package Implements_Gtk_Scrollable is new Glib.Types.Implements
(Gtk.Scrollable.Gtk_Scrollable, Gtk_Text_View_Record, Gtk_Text_View);
function "+"
(Widget : access Gtk_Text_View_Record'Class)
return Gtk.Scrollable.Gtk_Scrollable
renames Implements_Gtk_Scrollable.To_Interface;
function "-"
(Interf : Gtk.Scrollable.Gtk_Scrollable)
return Gtk_Text_View
renames Implements_Gtk_Scrollable.To_Object;
private
Wrap_Mode_Property : constant Gtk.Enums.Property_Gtk_Wrap_Mode :=
Gtk.Enums.Build ("wrap-mode");
Tabs_Property : constant Glib.Properties.Property_Boxed :=
Glib.Properties.Build ("tabs");
Right_Margin_Property : constant Glib.Properties.Property_Int :=
Glib.Properties.Build ("right-margin");
Populate_All_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("populate-all");
Pixels_Inside_Wrap_Property : constant Glib.Properties.Property_Int :=
Glib.Properties.Build ("pixels-inside-wrap");
Pixels_Below_Lines_Property : constant Glib.Properties.Property_Int :=
Glib.Properties.Build ("pixels-below-lines");
Pixels_Above_Lines_Property : constant Glib.Properties.Property_Int :=
Glib.Properties.Build ("pixels-above-lines");
Overwrite_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("overwrite");
Left_Margin_Property : constant Glib.Properties.Property_Int :=
Glib.Properties.Build ("left-margin");
Justification_Property : constant Gtk.Enums.Property_Gtk_Justification :=
Gtk.Enums.Build ("justification");
Input_Purpose_Property : constant Gtk.Enums.Property_Gtk_Input_Purpose :=
Gtk.Enums.Build ("input-purpose");
Input_Hints_Property : constant Gtk.Enums.Property_Gtk_Input_Hints :=
Gtk.Enums.Build ("input-hints");
Indent_Property : constant Glib.Properties.Property_Int :=
Glib.Properties.Build ("indent");
Im_Module_Property : constant Glib.Properties.Property_String :=
Glib.Properties.Build ("im-module");
Editable_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("editable");
Cursor_Visible_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("cursor-visible");
Buffer_Property : constant Glib.Properties.Property_Object :=
Glib.Properties.Build ("buffer");
Accepts_Tab_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("accepts-tab");
end Gtk.Text_View;