------------------------------------------------------------------------------
-- --
-- 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.Pixbuf; use Gdk.Pixbuf;
with Gdk.Types; use Gdk.Types;
with Glib; use Glib;
with Glib.Object; use Glib.Object;
with Glib.Properties; use Glib.Properties;
with Gtk.Clipboard; use Gtk.Clipboard;
with Gtk.Target_List; use Gtk.Target_List;
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.Text_Tag; use Gtk.Text_Tag;
with Gtk.Text_Tag_Table; use Gtk.Text_Tag_Table;
with Gtkada.Types; use Gtkada.Types;
package Gtk.Text_Buffer is
type Gtk_Text_Buffer_Record is new GObject_Record with null record;
type Gtk_Text_Buffer is access all Gtk_Text_Buffer_Record'Class;
------------------
-- Constructors --
------------------
procedure Gtk_New
(Buffer : out Gtk_Text_Buffer;
Table : Gtk.Text_Tag_Table.Gtk_Text_Tag_Table := null);
procedure Initialize
(Buffer : not null access Gtk_Text_Buffer_Record'Class;
Table : Gtk.Text_Tag_Table.Gtk_Text_Tag_Table := null);
-- Creates a new text buffer.
-- "table": a tag table, or null to create a new one
function Gtk_Text_Buffer_New
(Table : Gtk.Text_Tag_Table.Gtk_Text_Tag_Table := null)
return Gtk_Text_Buffer;
-- Creates a new text buffer.
-- "table": a tag table, or null to create a new one
function Get_Type return Glib.GType;
pragma Import (C, Get_Type, "gtk_text_buffer_get_type");
-------------
-- Methods --
-------------
procedure Add_Mark
(Buffer : not null access Gtk_Text_Buffer_Record;
Mark : not null access Gtk.Text_Mark.Gtk_Text_Mark_Record'Class;
Where : Gtk.Text_Iter.Gtk_Text_Iter);
-- Adds the mark at position Where. The mark must not be added to another
-- buffer, and if its name is not null then there must not be another mark
-- in the buffer with the same name.
-- Emits the "mark-set" signal as notification of the mark's initial
-- placement.
-- Since: gtk+ 2.12
-- "mark": the mark to add
-- "where": location to place mark
procedure Add_Selection_Clipboard
(Buffer : not null access Gtk_Text_Buffer_Record;
Clipboard : not null access Gtk.Clipboard.Gtk_Clipboard_Record'Class);
-- Adds Clipboard to the list of clipboards in which the selection
-- contents of Buffer are available. In most cases, Clipboard will be the
-- Gtk.Clipboard.Gtk_Clipboard of type GDK_SELECTION_PRIMARY for a view of
-- Buffer.
-- "clipboard": a Gtk.Clipboard.Gtk_Clipboard
procedure Apply_Tag
(Buffer : not null access Gtk_Text_Buffer_Record;
Tag : not null access Gtk.Text_Tag.Gtk_Text_Tag_Record'Class;
Start : Gtk.Text_Iter.Gtk_Text_Iter;
The_End : Gtk.Text_Iter.Gtk_Text_Iter);
-- Emits the "apply-tag" signal on Buffer. The default handler for the
-- signal applies Tag to the given range. Start and End do not have to be
-- in order.
-- "tag": a Gtk.Text_Tag.Gtk_Text_Tag
-- "start": one bound of range to be tagged
-- "end": other bound of range to be tagged
procedure Apply_Tag_By_Name
(Buffer : not null access Gtk_Text_Buffer_Record;
Name : UTF8_String;
Start : Gtk.Text_Iter.Gtk_Text_Iter;
The_End : Gtk.Text_Iter.Gtk_Text_Iter);
-- Calls Gtk.Text_Tag_Table.Lookup on the buffer's tag table to get a
-- Gtk.Text_Tag.Gtk_Text_Tag, then calls Gtk.Text_Buffer.Apply_Tag.
-- "name": name of a named Gtk.Text_Tag.Gtk_Text_Tag
-- "start": one bound of range to be tagged
-- "end": other bound of range to be tagged
function Backspace
(Buffer : not null access Gtk_Text_Buffer_Record;
Iter : Gtk.Text_Iter.Gtk_Text_Iter;
Interactive : Boolean;
Default_Editable : Boolean) return Boolean;
-- Performs the appropriate action as if the user hit the delete key with
-- the cursor at the position specified by Iter. In the normal case a
-- single character will be deleted, but when combining accents are
-- involved, more than one character can be deleted, and when precomposed
-- character and accent combinations are involved, less than one character
-- will be deleted.
-- Because the buffer is modified, all outstanding iterators become
-- invalid after calling this function; however, the Iter will be
-- re-initialized to point to the location where text was deleted.
-- Since: gtk+ 2.6
-- "iter": a position in Buffer
-- "interactive": whether the deletion is caused by user interaction
-- "default_editable": whether the buffer is editable by default
procedure Begin_User_Action
(Buffer : not null access Gtk_Text_Buffer_Record);
-- Called to indicate that the buffer operations between here and a call
-- to Gtk.Text_Buffer.End_User_Action are part of a single user-visible
-- operation. The operations between Gtk.Text_Buffer.Begin_User_Action and
-- Gtk.Text_Buffer.End_User_Action can then be grouped when creating an
-- undo stack. Gtk.Text_Buffer.Gtk_Text_Buffer maintains a count of calls
-- to Gtk.Text_Buffer.Begin_User_Action that have not been closed with a
-- call to Gtk.Text_Buffer.End_User_Action, and emits the
-- "begin-user-action" and "end-user-action" signals only for the outermost
-- pair of calls. This allows you to build user actions from other user
-- actions.
-- The "interactive" buffer mutation functions, such as
-- Gtk.Text_Buffer.Insert_Interactive, automatically call begin/end user
-- action around the buffer operations they perform, so there's no need to
-- add extra calls if you user action consists solely of a single call to
-- one of those functions.
procedure Copy_Clipboard
(Buffer : not null access Gtk_Text_Buffer_Record;
Clipboard : not null access Gtk.Clipboard.Gtk_Clipboard_Record'Class);
-- Copies the currently-selected text to a clipboard.
-- "clipboard": the Gtk.Clipboard.Gtk_Clipboard object to copy to
function Create_Child_Anchor
(Buffer : not null access Gtk_Text_Buffer_Record;
Iter : Gtk.Text_Iter.Gtk_Text_Iter)
return Gtk.Text_Child_Anchor.Gtk_Text_Child_Anchor;
-- This is a convenience function which simply creates a child anchor with
-- Gtk.Text_Child_Anchor.Gtk_New and inserts it into the buffer with
-- Gtk.Text_Buffer.Insert_Child_Anchor. The new anchor is owned by the
-- buffer; no reference count is returned to the caller of
-- Gtk.Text_Buffer.Create_Child_Anchor.
-- "iter": location in the buffer
function Create_Mark
(Buffer : not null access Gtk_Text_Buffer_Record;
Mark_Name : UTF8_String := "";
Where : Gtk.Text_Iter.Gtk_Text_Iter;
Left_Gravity : Boolean := True) return Gtk.Text_Mark.Gtk_Text_Mark;
-- Creates a mark at position Where. If Mark_Name is null, the mark is
-- anonymous; otherwise, the mark can be retrieved by name using
-- Gtk.Text_Buffer.Get_Mark. If a mark has left gravity, and text is
-- inserted at the mark's current location, the mark will be moved to the
-- left of the newly-inserted text. If the mark has right gravity
-- (Left_Gravity = False), the mark will end up on the right of
-- newly-inserted text. The standard left-to-right cursor is a mark with
-- right gravity (when you type, the cursor stays on the right side of the
-- text you're typing).
-- The caller of this function does *not* own a reference to the returned
-- Gtk.Text_Mark.Gtk_Text_Mark, so you can ignore the return value if you
-- like. Marks are owned by the buffer and go away when the buffer does.
-- Emits the "mark-set" signal as notification of the mark's initial
-- placement.
-- "mark_name": name for mark, or null
-- "where": location to place mark
-- "left_gravity": whether the mark has left gravity
procedure Cut_Clipboard
(Buffer : not null access Gtk_Text_Buffer_Record;
Clipboard : not null access Gtk.Clipboard.Gtk_Clipboard_Record'Class;
Default_Editable : Boolean);
-- Copies the currently-selected text to a clipboard, then deletes said
-- text if it's editable.
-- "clipboard": the Gtk.Clipboard.Gtk_Clipboard object to cut to
-- "default_editable": default editability of the buffer
procedure Delete
(Buffer : not null access Gtk_Text_Buffer_Record;
Start : in out Gtk.Text_Iter.Gtk_Text_Iter;
The_End : in out Gtk.Text_Iter.Gtk_Text_Iter);
-- Deletes text between Start and End. The order of Start and End is not
-- actually relevant; Gtk.Text_Buffer.Delete will reorder them. This
-- function actually emits the "delete-range" signal, and the default
-- handler of that signal deletes the text. Because the buffer is modified,
-- all outstanding iterators become invalid after calling this function;
-- however, the Start and End will be re-initialized to point to the
-- location where text was deleted.
-- "start": a position in Buffer
-- "end": another position in Buffer
procedure Delete_Interactive
(Buffer : not null access Gtk_Text_Buffer_Record;
Start_Iter : Gtk.Text_Iter.Gtk_Text_Iter;
End_Iter : Gtk.Text_Iter.Gtk_Text_Iter;
Default_Editable : Boolean;
Result : out Boolean);
-- Deletes all *editable* text in the given range. Calls
-- Gtk.Text_Buffer.Delete for each editable sub-range of [Start,End). Start
-- and End are revalidated to point to the location of the last deleted
-- range, or left untouched if no text was deleted.
-- "start_iter": start of range to delete
-- "end_iter": end of range
-- "default_editable": whether the buffer is editable by default
procedure Delete_Mark
(Buffer : not null access Gtk_Text_Buffer_Record;
Mark : not null access Gtk.Text_Mark.Gtk_Text_Mark_Record'Class);
-- Deletes Mark, so that it's no longer located anywhere in the buffer.
-- Removes the reference the buffer holds to the mark, so if you haven't
-- called g_object_ref on the mark, it will be freed. Even if the mark
-- isn't freed, most operations on Mark become invalid, until it gets added
-- to a buffer again with Gtk.Text_Buffer.Add_Mark. Use
-- Gtk.Text_Mark.Get_Deleted to find out if a mark has been removed from
-- its buffer. The "mark-deleted" signal will be emitted as notification
-- after the mark is deleted.
-- "mark": a Gtk.Text_Mark.Gtk_Text_Mark in Buffer
procedure Delete_Mark_By_Name
(Buffer : not null access Gtk_Text_Buffer_Record;
Name : UTF8_String);
-- Deletes the mark named Name; the mark must exist. See
-- Gtk.Text_Buffer.Delete_Mark for details.
-- "name": name of a mark in Buffer
function Delete_Selection
(Buffer : not null access Gtk_Text_Buffer_Record;
Interactive : Boolean;
Default_Editable : Boolean) return Boolean;
-- Deletes the range between the "insert" and "selection_bound" marks,
-- that is, the currently-selected text. If Interactive is True, the
-- editability of the selection will be considered (users can't delete
-- uneditable text).
-- "interactive": whether the deletion is caused by user interaction
-- "default_editable": whether the buffer is editable by default
function Deserialize_Get_Can_Create_Tags
(Buffer : not null access Gtk_Text_Buffer_Record;
Format : Gdk.Types.Gdk_Atom) return Boolean;
-- This functions returns the value set with
-- Gtk.Text_Buffer.Deserialize_Set_Can_Create_Tags
-- Since: gtk+ 2.10
-- "format": a Gdk.Types.Gdk_Atom representing a registered rich text
-- format
procedure Deserialize_Set_Can_Create_Tags
(Buffer : not null access Gtk_Text_Buffer_Record;
Format : Gdk.Types.Gdk_Atom;
Can_Create_Tags : Boolean);
-- Use this function to allow a rich text deserialization function to
-- create new tags in the receiving buffer. Note that using this function
-- is almost always a bad idea, because the rich text functions you
-- register should know how to map the rich text format they handler to
-- your text buffers set of tags.
-- The ability of creating new (arbitrary!) tags in the receiving buffer
-- is meant for special rich text formats like the internal one that is
-- registered using Gtk.Text_Buffer.Register_Deserialize_Tagset, because
-- that format is essentially a dump of the internal structure of the
-- source buffer, including its tag names.
-- You should allow creation of tags only if you know what you are doing,
-- e.g. if you defined a tagset name for your application suite's text
-- buffers and you know that it's fine to receive new tags from these
-- buffers, because you know that your application can handle the newly
-- created tags.
-- Since: gtk+ 2.10
-- "format": a Gdk.Types.Gdk_Atom representing a registered rich text
-- format
-- "can_create_tags": whether deserializing this format may create tags
procedure End_User_Action
(Buffer : not null access Gtk_Text_Buffer_Record);
-- Should be paired with a call to Gtk.Text_Buffer.Begin_User_Action. See
-- that function for a full explanation.
procedure Get_Bounds
(Buffer : not null access Gtk_Text_Buffer_Record;
Start : out Gtk.Text_Iter.Gtk_Text_Iter;
The_End : out Gtk.Text_Iter.Gtk_Text_Iter);
-- Retrieves the first and last iterators in the buffer, i.e. the entire
-- buffer lies within the range [Start,End).
-- "start": iterator to initialize with first position in the buffer
-- "end": iterator to initialize with the end iterator
function Get_Char_Count
(Buffer : not null access Gtk_Text_Buffer_Record) return Gint;
-- Gets the number of characters in the buffer; note that characters and
-- bytes are not the same, you can't e.g. expect the contents of the buffer
-- in string form to be this many bytes long. The character count is
-- cached, so this function is very fast.
function Get_Copy_Target_List
(Buffer : not null access Gtk_Text_Buffer_Record)
return Gtk.Target_List.Gtk_Target_List;
-- This function returns the list of targets this text buffer can provide
-- for copying and as DND source. The targets in the list are added with
-- %info values from the Gtk_Text_Buffer_Target_Info enum, using
-- gtk_target_list_add_rich_text_targets and
-- Gtk.Target_List.Add_Text_Targets.
-- Since: gtk+ 2.10
procedure Get_End_Iter
(Buffer : not null access Gtk_Text_Buffer_Record;
Iter : out Gtk.Text_Iter.Gtk_Text_Iter);
-- Initializes Iter with the "end iterator," one past the last valid
-- character in the text buffer. If dereferenced with
-- Gtk.Text_Iter.Get_Char, the end iterator has a character value of 0. The
-- entire buffer lies in the range from the first position in the buffer
-- (call Gtk.Text_Buffer.Get_Start_Iter to get character position 0) to the
-- end iterator.
-- "iter": iterator to initialize
function Get_Has_Selection
(Buffer : not null access Gtk_Text_Buffer_Record) return Boolean;
-- Indicates whether the buffer has some text currently selected.
-- Since: gtk+ 2.10
function Get_Insert
(Buffer : not null access Gtk_Text_Buffer_Record)
return Gtk.Text_Mark.Gtk_Text_Mark;
-- Returns the mark that represents the cursor (insertion point).
-- Equivalent to calling Gtk.Text_Buffer.Get_Mark to get the mark named
-- "insert", but very slightly more efficient, and involves less typing.
procedure Insert
(Buffer : not null access Gtk_Text_Buffer_Record;
Iter : in out Gtk.Text_Iter.Gtk_Text_Iter;
Text : UTF8_String);
-- Inserts Len bytes of Text at position Iter. If Len is -1, Text must be
-- nul-terminated and will be inserted in its entirety. Emits the
-- "insert-text" signal; insertion actually occurs in the default handler
-- for the signal. Iter is invalidated when insertion occurs (because the
-- buffer contents change), but the default signal handler revalidates it
-- to point to the end of the inserted text.
-- "iter": a position in the buffer
-- "text": text in UTF-8 format
procedure Get_Iter_At_Child_Anchor
(Buffer : not null access Gtk_Text_Buffer_Record;
Iter : out Gtk.Text_Iter.Gtk_Text_Iter;
Anchor : not null access Gtk.Text_Child_Anchor.Gtk_Text_Child_Anchor_Record'Class);
-- Obtains the location of Anchor within Buffer.
-- "iter": an iterator to be initialized
-- "anchor": a child anchor that appears in Buffer
procedure Get_Iter_At_Line
(Buffer : not null access Gtk_Text_Buffer_Record;
Iter : out Gtk.Text_Iter.Gtk_Text_Iter;
Line_Number : Gint);
-- Initializes Iter to the start of the given line.
-- "iter": iterator to initialize
-- "line_number": line number counting from 0
procedure Get_Iter_At_Line_Index
(Buffer : not null access Gtk_Text_Buffer_Record;
Iter : out Gtk.Text_Iter.Gtk_Text_Iter;
Line_Number : Gint;
Byte_Index : Gint);
-- Obtains an iterator pointing to Byte_Index within the given line.
-- Byte_Index must be the start of a UTF-8 character, and must not be
-- beyond the end of the line. Note *bytes*, not characters; UTF-8 may
-- encode one character as multiple bytes.
-- "iter": iterator to initialize
-- "line_number": line number counting from 0
-- "byte_index": byte index from start of line
procedure Get_Iter_At_Line_Offset
(Buffer : not null access Gtk_Text_Buffer_Record;
Iter : out Gtk.Text_Iter.Gtk_Text_Iter;
Line_Number : Gint;
Char_Offset : Gint);
-- Obtains an iterator pointing to Char_Offset within the given line. The
-- Char_Offset must exist, offsets off the end of the line are not allowed.
-- Note *characters*, not bytes; UTF-8 may encode one character as multiple
-- bytes.
-- "iter": iterator to initialize
-- "line_number": line number counting from 0
-- "char_offset": char offset from start of line
procedure Get_Iter_At_Mark
(Buffer : not null access Gtk_Text_Buffer_Record;
Iter : out Gtk.Text_Iter.Gtk_Text_Iter;
Mark : not null access Gtk.Text_Mark.Gtk_Text_Mark_Record'Class);
-- Initializes Iter with the current position of Mark.
-- "iter": iterator to initialize
-- "mark": a Gtk.Text_Mark.Gtk_Text_Mark in Buffer
procedure Get_Iter_At_Offset
(Buffer : not null access Gtk_Text_Buffer_Record;
Iter : out Gtk.Text_Iter.Gtk_Text_Iter;
Char_Offset : Gint);
-- Initializes Iter to a position Char_Offset chars from the start of the
-- entire buffer. If Char_Offset is -1 or greater than the number of
-- characters in the buffer, Iter is initialized to the end iterator, the
-- iterator one past the last valid character in the buffer.
-- "iter": iterator to initialize
-- "char_offset": char offset from start of buffer, counting from 0, or -1
function Get_Line_Count
(Buffer : not null access Gtk_Text_Buffer_Record) return Gint;
-- Obtains the number of lines in the buffer. This value is cached, so the
-- function is very fast.
function Get_Mark
(Buffer : not null access Gtk_Text_Buffer_Record;
Name : UTF8_String) return Gtk.Text_Mark.Gtk_Text_Mark;
-- Returns the mark named Name in buffer Buffer, or null if no such mark
-- exists in the buffer.
-- "name": a mark name
function Get_Modified
(Buffer : not null access Gtk_Text_Buffer_Record) return Boolean;
-- Indicates whether the buffer has been modified since the last call to
-- Gtk.Text_Buffer.Set_Modified set the modification flag to False. Used
-- for example to enable a "save" function in a text editor.
procedure Set_Modified
(Buffer : not null access Gtk_Text_Buffer_Record;
Setting : Boolean);
-- Used to keep track of whether the buffer has been modified since the
-- last time it was saved. Whenever the buffer is saved to disk, call
-- gtk_text_buffer_set_modified (Buffer, FALSE). When the buffer is
-- modified, it will automatically toggled on the modified bit again. When
-- the modified bit flips, the buffer emits a "modified-changed" signal.
-- "setting": modification flag setting
function Get_Paste_Target_List
(Buffer : not null access Gtk_Text_Buffer_Record)
return Gtk.Target_List.Gtk_Target_List;
-- This function returns the list of targets this text buffer supports for
-- pasting and as DND destination. The targets in the list are added with
-- %info values from the Gtk_Text_Buffer_Target_Info enum, using
-- gtk_target_list_add_rich_text_targets and
-- Gtk.Target_List.Add_Text_Targets.
-- Since: gtk+ 2.10
function Get_Selection_Bound
(Buffer : not null access Gtk_Text_Buffer_Record)
return Gtk.Text_Mark.Gtk_Text_Mark;
-- Returns the mark that represents the selection bound. Equivalent to
-- calling Gtk.Text_Buffer.Get_Mark to get the mark named
-- "selection_bound", but very slightly more efficient, and involves less
-- typing.
-- The currently-selected text in Buffer is the region between the
-- "selection_bound" and "insert" marks. If "selection_bound" and "insert"
-- are in the same place, then there is no current selection.
-- Gtk.Text_Buffer.Get_Selection_Bounds is another convenient function for
-- handling the selection, if you just want to know whether there's a
-- selection and what its bounds are.
procedure Get_Selection_Bounds
(Buffer : not null access Gtk_Text_Buffer_Record;
Start : out Gtk.Text_Iter.Gtk_Text_Iter;
The_End : out Gtk.Text_Iter.Gtk_Text_Iter;
Result : out Boolean);
-- Returns True if some text is selected; places the bounds of the
-- selection in Start and End (if the selection has length 0, then Start
-- and End are filled in with the same value). Start and End will be in
-- ascending order. If Start and End are NULL, then they are not filled in,
-- but the return value still indicates whether text is selected.
-- "start": iterator to initialize with selection start
-- "end": iterator to initialize with selection end
function Get_Slice
(Buffer : not null access Gtk_Text_Buffer_Record;
Start : Gtk.Text_Iter.Gtk_Text_Iter;
The_End : Gtk.Text_Iter.Gtk_Text_Iter;
Include_Hidden_Chars : Boolean := False) return UTF8_String;
-- Returns the text in the range [Start,End). Excludes undisplayed text
-- (text marked with tags that set the invisibility attribute) if
-- Include_Hidden_Chars is False. The returned string includes a 0xFFFC
-- character whenever the buffer contains embedded images, so byte and
-- character indexes into the returned string *do* correspond to byte and
-- character indexes into the buffer. Contrast with
-- Gtk.Text_Buffer.Get_Text. Note that 0xFFFC can occur in normal text as
-- well, so it is not a reliable indicator that a pixbuf or widget is in
-- the buffer.
-- "start": start of a range
-- "end": end of a range
-- "include_hidden_chars": whether to include invisible text
procedure Get_Start_Iter
(Buffer : not null access Gtk_Text_Buffer_Record;
Iter : out Gtk.Text_Iter.Gtk_Text_Iter);
-- Initialized Iter with the first position in the text buffer. This is
-- the same as using Gtk.Text_Buffer.Get_Iter_At_Offset to get the iter at
-- character offset 0.
-- "iter": iterator to initialize
function Get_Tag_Table
(Buffer : not null access Gtk_Text_Buffer_Record)
return Gtk.Text_Tag_Table.Gtk_Text_Tag_Table;
-- Get the Gtk.Text_Tag_Table.Gtk_Text_Tag_Table associated with this
-- buffer.
function Get_Text
(Buffer : not null access Gtk_Text_Buffer_Record;
Start : Gtk.Text_Iter.Gtk_Text_Iter;
The_End : Gtk.Text_Iter.Gtk_Text_Iter;
Include_Hidden_Chars : Boolean := False) return UTF8_String;
-- Returns the text in the range [Start,End). Excludes undisplayed text
-- (text marked with tags that set the invisibility attribute) if
-- Include_Hidden_Chars is False. Does not include characters representing
-- embedded images, so byte and character indexes into the returned string
-- do *not* correspond to byte and character indexes into the buffer.
-- Contrast with Gtk.Text_Buffer.Get_Slice.
-- "start": start of a range
-- "end": end of a range
-- "include_hidden_chars": whether to include invisible text
procedure Set_Text
(Buffer : not null access Gtk_Text_Buffer_Record;
Text : UTF8_String);
-- Deletes current contents of Buffer, and inserts Text instead. If Len is
-- -1, Text must be nul-terminated. Text must be valid UTF-8.
-- "text": UTF-8 text to insert
procedure Insert_At_Cursor
(Buffer : not null access Gtk_Text_Buffer_Record;
Text : UTF8_String);
-- Simply calls Gtk.Text_Buffer.Insert, using the current cursor position
-- as the insertion point.
-- "text": text in UTF-8 format
procedure Insert_Child_Anchor
(Buffer : not null access Gtk_Text_Buffer_Record;
Iter : Gtk.Text_Iter.Gtk_Text_Iter;
Anchor : not null access Gtk.Text_Child_Anchor.Gtk_Text_Child_Anchor_Record'Class);
-- Inserts a child widget anchor into the text buffer at Iter. The anchor
-- will be counted as one character in character counts, and when obtaining
-- the buffer contents as a string, will be represented by the Unicode
-- "object replacement character" 0xFFFC. Note that the "slice" variants
-- for obtaining portions of the buffer as a string include this character
-- for child anchors, but the "text" variants do not. E.g. see
-- Gtk.Text_Buffer.Get_Slice and Gtk.Text_Buffer.Get_Text. Consider
-- Gtk.Text_Buffer.Create_Child_Anchor as a more convenient alternative to
-- this function. The buffer will add a reference to the anchor, so you can
-- unref it after insertion.
-- "iter": location to insert the anchor
-- "anchor": a Gtk.Text_Child_Anchor.Gtk_Text_Child_Anchor
function Insert_Interactive
(Buffer : not null access Gtk_Text_Buffer_Record;
Iter : access Gtk.Text_Iter.Gtk_Text_Iter;
Text : UTF8_String;
Default_Editable : Boolean) return Boolean;
-- Like Gtk.Text_Buffer.Insert, but the insertion will not occur if Iter
-- is at a non-editable location in the buffer. Usually you want to prevent
-- insertions at ineditable locations if the insertion results from a user
-- action (is interactive).
-- Default_Editable indicates the editability of text that doesn't have a
-- tag affecting editability applied to it. Typically the result of
-- Gtk.Text_View.Get_Editable is appropriate here.
-- "iter": a position in Buffer
-- "text": some UTF-8 text
-- "default_editable": default editability of buffer
function Insert_Interactive_At_Cursor
(Buffer : not null access Gtk_Text_Buffer_Record;
Text : UTF8_String;
Default_Editable : Boolean) return Boolean;
-- Calls Gtk.Text_Buffer.Insert_Interactive at the cursor position.
-- Default_Editable indicates the editability of text that doesn't have a
-- tag affecting editability applied to it. Typically the result of
-- Gtk.Text_View.Get_Editable is appropriate here.
-- "text": text in UTF-8 format
-- "default_editable": default editability of buffer
procedure Insert_Pixbuf
(Buffer : not null access Gtk_Text_Buffer_Record;
Iter : Gtk.Text_Iter.Gtk_Text_Iter;
Pixbuf : not null access Gdk.Pixbuf.Gdk_Pixbuf_Record'Class);
-- Inserts an image into the text buffer at Iter. The image will be
-- counted as one character in character counts, and when obtaining the
-- buffer contents as a string, will be represented by the Unicode "object
-- replacement character" 0xFFFC. Note that the "slice" variants for
-- obtaining portions of the buffer as a string include this character for
-- pixbufs, but the "text" variants do not. e.g. see
-- Gtk.Text_Buffer.Get_Slice and Gtk.Text_Buffer.Get_Text.
-- "iter": location to insert the pixbuf
-- "pixbuf": a Gdk.Pixbuf.Gdk_Pixbuf
procedure Insert_Range
(Buffer : not null access Gtk_Text_Buffer_Record;
Iter : Gtk.Text_Iter.Gtk_Text_Iter;
Start : Gtk.Text_Iter.Gtk_Text_Iter;
The_End : Gtk.Text_Iter.Gtk_Text_Iter);
-- Copies text, tags, and pixbufs between Start and End (the order of
-- Start and End doesn't matter) and inserts the copy at Iter. Used instead
-- of simply getting/inserting text because it preserves images and tags.
-- If Start and End are in a different buffer from Buffer, the two buffers
-- must share the same tag table.
-- Implemented via emissions of the insert_text and apply_tag signals, so
-- expect those.
-- "iter": a position in Buffer
-- "start": a position in a Gtk.Text_Buffer.Gtk_Text_Buffer
-- "end": another position in the same buffer as Start
function Insert_Range_Interactive
(Buffer : not null access Gtk_Text_Buffer_Record;
Iter : Gtk.Text_Iter.Gtk_Text_Iter;
Start : Gtk.Text_Iter.Gtk_Text_Iter;
The_End : Gtk.Text_Iter.Gtk_Text_Iter;
Default_Editable : Boolean) return Boolean;
-- Same as Gtk.Text_Buffer.Insert_Range, but does nothing if the insertion
-- point isn't editable. The Default_Editable parameter indicates whether
-- the text is editable at Iter if no tags enclosing Iter affect
-- editability. Typically the result of Gtk.Text_View.Get_Editable is
-- appropriate here.
-- "iter": a position in Buffer
-- "start": a position in a Gtk.Text_Buffer.Gtk_Text_Buffer
-- "end": another position in the same buffer as Start
-- "default_editable": default editability of the buffer
procedure Move_Mark
(Buffer : not null access Gtk_Text_Buffer_Record;
Mark : not null access Gtk.Text_Mark.Gtk_Text_Mark_Record'Class;
Where : Gtk.Text_Iter.Gtk_Text_Iter);
-- Moves Mark to the new location Where. Emits the "mark-set" signal as
-- notification of the move.
-- "mark": a Gtk.Text_Mark.Gtk_Text_Mark
-- "where": new location for Mark in Buffer
procedure Move_Mark_By_Name
(Buffer : not null access Gtk_Text_Buffer_Record;
Name : UTF8_String;
Where : Gtk.Text_Iter.Gtk_Text_Iter);
-- Moves the mark named Name (which must exist) to location Where. See
-- Gtk.Text_Buffer.Move_Mark for details.
-- "name": name of a mark
-- "where": new location for mark
procedure Paste_Clipboard
(Buffer : not null access Gtk_Text_Buffer_Record;
Clipboard : not null access Gtk.Clipboard.Gtk_Clipboard_Record'Class;
Default_Editable : Boolean := True);
-- Pastes the contents of a clipboard at the insertion point, or at
-- Override_Location. (Note: pasting is asynchronous, that is, we'll ask
-- for the paste data and return, and at some point later after the main
-- loop runs, the paste data will be inserted.)
-- "clipboard": the Gtk.Clipboard.Gtk_Clipboard to paste from
-- "default_editable": whether the buffer is editable by default
procedure Place_Cursor
(Buffer : not null access Gtk_Text_Buffer_Record;
Where : Gtk.Text_Iter.Gtk_Text_Iter);
-- This function moves the "insert" and "selection_bound" marks
-- simultaneously. If you move them to the same place in two steps with
-- Gtk.Text_Buffer.Move_Mark, you will temporarily select a region in
-- between their old and new locations, which can be pretty inefficient
-- since the temporarily-selected region will force stuff to be
-- recalculated. This function moves them as a unit, which can be
-- optimized.
-- "where": where to put the cursor
function Register_Deserialize_Tagset
(Buffer : not null access Gtk_Text_Buffer_Record;
Tagset_Name : UTF8_String := "") return Gdk.Types.Gdk_Atom;
-- This function registers GTK+'s internal rich text serialization format
-- with the passed Buffer. See Gtk.Text_Buffer.Register_Serialize_Tagset
-- for details.
-- Since: gtk+ 2.10
-- "tagset_name": an optional tagset name, on null
function Register_Serialize_Tagset
(Buffer : not null access Gtk_Text_Buffer_Record;
Tagset_Name : UTF8_String := "") return Gdk.Types.Gdk_Atom;
-- This function registers GTK+'s internal rich text serialization format
-- with the passed Buffer. The internal format does not comply to any
-- standard rich text format and only works between
-- Gtk.Text_Buffer.Gtk_Text_Buffer instances. It is capable of serializing
-- all of a text buffer's tags and embedded pixbufs.
-- This function is just a wrapper around
-- gtk_text_buffer_register_serialize_format. The mime type used for
-- registering is "application/x-gtk-text-buffer-rich-text", or
-- "application/x-gtk-text-buffer-rich-text;format=Tagset_Name" if a
-- Tagset_Name was passed.
-- The Tagset_Name can be used to restrict the transfer of rich text to
-- buffers with compatible sets of tags, in order to avoid unknown tags
-- from being pasted. It is probably the common case to pass an identifier
-- != null here, since the null tagset requires the receiving buffer to
-- deal with with pasting of arbitrary tags.
-- Since: gtk+ 2.10
-- "tagset_name": an optional tagset name, on null
procedure Remove_All_Tags
(Buffer : not null access Gtk_Text_Buffer_Record;
Start : Gtk.Text_Iter.Gtk_Text_Iter;
The_End : Gtk.Text_Iter.Gtk_Text_Iter);
-- Removes all tags in the range between Start and End. Be careful with
-- this function; it could remove tags added in code unrelated to the code
-- you're currently writing. That is, using this function is probably a bad
-- idea if you have two or more unrelated code sections that add tags.
-- "start": one bound of range to be untagged
-- "end": other bound of range to be untagged
procedure Remove_Selection_Clipboard
(Buffer : not null access Gtk_Text_Buffer_Record;
Clipboard : not null access Gtk.Clipboard.Gtk_Clipboard_Record'Class);
-- Removes a Gtk.Clipboard.Gtk_Clipboard added with
-- Gtk.Text_Buffer.Add_Selection_Clipboard.
-- "clipboard": a Gtk.Clipboard.Gtk_Clipboard added to Buffer by
-- Gtk.Text_Buffer.Add_Selection_Clipboard
procedure Remove_Tag
(Buffer : not null access Gtk_Text_Buffer_Record;
Tag : not null access Gtk.Text_Tag.Gtk_Text_Tag_Record'Class;
Start : Gtk.Text_Iter.Gtk_Text_Iter;
The_End : Gtk.Text_Iter.Gtk_Text_Iter);
-- Emits the "remove-tag" signal. The default handler for the signal
-- removes all occurrences of Tag from the given range. Start and End don't
-- have to be in order.
-- "tag": a Gtk.Text_Tag.Gtk_Text_Tag
-- "start": one bound of range to be untagged
-- "end": other bound of range to be untagged
procedure Remove_Tag_By_Name
(Buffer : not null access Gtk_Text_Buffer_Record;
Name : UTF8_String;
Start : Gtk.Text_Iter.Gtk_Text_Iter;
The_End : Gtk.Text_Iter.Gtk_Text_Iter);
-- Calls Gtk.Text_Tag_Table.Lookup on the buffer's tag table to get a
-- Gtk.Text_Tag.Gtk_Text_Tag, then calls Gtk.Text_Buffer.Remove_Tag.
-- "name": name of a Gtk.Text_Tag.Gtk_Text_Tag
-- "start": one bound of range to be untagged
-- "end": other bound of range to be untagged
procedure Select_Range
(Buffer : not null access Gtk_Text_Buffer_Record;
Ins : Gtk.Text_Iter.Gtk_Text_Iter;
Bound : Gtk.Text_Iter.Gtk_Text_Iter);
-- This function moves the "insert" and "selection_bound" marks
-- simultaneously. If you move them in two steps with
-- Gtk.Text_Buffer.Move_Mark, you will temporarily select a region in
-- between their old and new locations, which can be pretty inefficient
-- since the temporarily-selected region will force stuff to be
-- recalculated. This function moves them as a unit, which can be
-- optimized.
-- Since: gtk+ 2.4
-- "ins": where to put the "insert" mark
-- "bound": where to put the "selection_bound" mark
procedure Unregister_Deserialize_Format
(Buffer : not null access Gtk_Text_Buffer_Record;
Format : Gdk.Types.Gdk_Atom);
-- This function unregisters a rich text format that was previously
-- registered using gtk_text_buffer_register_deserialize_format or
-- Gtk.Text_Buffer.Register_Deserialize_Tagset.
-- Since: gtk+ 2.10
-- "format": a Gdk.Types.Gdk_Atom representing a registered rich text
-- format.
procedure Unregister_Serialize_Format
(Buffer : not null access Gtk_Text_Buffer_Record;
Format : Gdk.Types.Gdk_Atom);
-- This function unregisters a rich text format that was previously
-- registered using gtk_text_buffer_register_serialize_format or
-- Gtk.Text_Buffer.Register_Serialize_Tagset
-- Since: gtk+ 2.10
-- "format": a Gdk.Types.Gdk_Atom representing a registered rich text
-- format.
----------------------
-- GtkAda additions --
----------------------
procedure Insert
(Buffer : access Gtk_Text_Buffer_Record;
Iter : in out Gtk.Text_Iter.Gtk_Text_Iter;
Text : Gtkada.Types.Chars_Ptr);
-- More efficient version of Insert, which doesn't require a string copy.
procedure Insert_At_Cursor
(Buffer : access Gtk_Text_Buffer_Record;
Text : Gtkada.Types.Chars_Ptr;
Len : Gint := -1);
-- Call Buffer_Insert, using the current cursor position
-- as the insertion point.
-- Text: UTF-8 format C string to insert.
function Get_Text
(Buffer : access Gtk_Text_Buffer_Record;
Start : Gtk.Text_Iter.Gtk_Text_Iter;
The_End : Gtk.Text_Iter.Gtk_Text_Iter;
Include_Hidden_Chars : Boolean := False) return Gtkada.Types.Chars_Ptr;
-- Same as Get_Text above, but return a pointer to a C string, for
-- efficiency.
-- The caller is responsible for freeing (using Gtkada.Types.g_free) the
-- returned pointer.
function Selection_Exists
(Buffer : access Gtk_Text_Buffer_Record) return Boolean;
-- Return True if some text in the buffer is currently selected.
procedure Insert_With_Tags
(Buffer : access Gtk_Text_Buffer_Record;
Iter : in out Gtk.Text_Iter.Gtk_Text_Iter;
Text : UTF8_String;
Tag : Gtk_Text_Tag);
procedure Insert_With_Tags
(Buffer : access Gtk_Text_Buffer_Record;
Iter : in out Gtk.Text_Iter.Gtk_Text_Iter;
Text : Gtkada.Types.Chars_Ptr;
Tag : Gtk.Text_Tag.Gtk_Text_Tag);
-- Same as Insert, but specifies the tag to apply to the range.
function Get_Buffer
(Iter : Gtk_Text_Iter) return Gtk.Text_Buffer.Gtk_Text_Buffer;
-- Returns the Gtk.Text_Buffer.Gtk_Text_Buffer this iterator is associated
-- with.
function Get_Buffer
(Mark : Gtk_Text_Mark)
return Gtk.Text_Buffer.Gtk_Text_Buffer;
-- Gets the buffer this mark is located inside, or null if the mark is
-- deleted.
function Create_Tag
(Buffer : access Gtk_Text_Buffer_Record;
Tag_Name : String := "")
return Gtk.Text_Tag.Gtk_Text_Tag;
-- Creates a tag and adds it to the tag table for Buffer. Equivalent to
-- calling gtk.text_tag.gtk_new and then adding the tag to the buffer's tag
-- table. The returned tag is owned by the buffer's tag table, so the ref
-- count will be equal to one.
--
-- If Tag_Name is NULL, the tag is anonymous, otherwise a tag called
-- Tag_Name must not already exist in the tag table for this buffer.
----------------
-- Properties --
----------------
-- The following properties are defined for this widget. See
-- Glib.Properties for more information on properties)
Copy_Target_List_Property : constant Glib.Properties.Property_Object;
-- Type: Gtk.Target_List.Gtk_Target_List
-- The list of targets this buffer supports for clipboard copying and as
-- DND source.
Cursor_Position_Property : constant Glib.Properties.Property_Int;
-- The position of the insert mark (as offset from the beginning of the
-- buffer). It is useful for getting notified when the cursor moves.
Has_Selection_Property : constant Glib.Properties.Property_Boolean;
-- Whether the buffer has some text currently selected.
Paste_Target_List_Property : constant Glib.Properties.Property_Object;
-- Type: Gtk.Target_List.Gtk_Target_List
-- The list of targets this buffer supports for clipboard pasting and as
-- DND destination.
Tag_Table_Property : constant Glib.Properties.Property_Object;
-- Type: Gtk.Text_Tag_Table.Gtk_Text_Tag_Table
Text_Property : constant Glib.Properties.Property_String;
-- The text content of the buffer. Without child widgets and images, see
-- Gtk.Text_Buffer.Get_Text for more information.
-------------
-- Signals --
-------------
type Cb_Gtk_Text_Buffer_Gtk_Text_Tag_Gtk_Text_Iter_Gtk_Text_Iter_Void is not null access procedure
(Self : access Gtk_Text_Buffer_Record'Class;
Tag : not null access Gtk.Text_Tag.Gtk_Text_Tag_Record'Class;
Start : Gtk.Text_Iter.Gtk_Text_Iter;
The_End : Gtk.Text_Iter.Gtk_Text_Iter);
type Cb_GObject_Gtk_Text_Tag_Gtk_Text_Iter_Gtk_Text_Iter_Void is not null access procedure
(Self : access Glib.Object.GObject_Record'Class;
Tag : not null access Gtk.Text_Tag.Gtk_Text_Tag_Record'Class;
Start : Gtk.Text_Iter.Gtk_Text_Iter;
The_End : Gtk.Text_Iter.Gtk_Text_Iter);
Signal_Apply_Tag : constant Glib.Signal_Name := "apply-tag";
procedure On_Apply_Tag
(Self : not null access Gtk_Text_Buffer_Record;
Call : Cb_Gtk_Text_Buffer_Gtk_Text_Tag_Gtk_Text_Iter_Gtk_Text_Iter_Void;
After : Boolean := False);
procedure On_Apply_Tag
(Self : not null access Gtk_Text_Buffer_Record;
Call : Cb_GObject_Gtk_Text_Tag_Gtk_Text_Iter_Gtk_Text_Iter_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
-- The ::apply-tag signal is emitted to apply a tag to a range of text in
-- a Gtk.Text_Buffer.Gtk_Text_Buffer. Applying actually occurs in the
-- default handler.
--
-- Note that if your handler runs before the default handler it must not
-- invalidate the Start and End iters (or has to revalidate them).
--
-- See also: Gtk.Text_Buffer.Apply_Tag, gtk_text_buffer_insert_with_tags,
-- Gtk.Text_Buffer.Insert_Range.
--
-- Callback parameters:
-- -- "tag": the applied tag
-- -- "start": the start of the range the tag is applied to
-- -- "end": the end of the range the tag is applied to
type Cb_Gtk_Text_Buffer_Void is not null access procedure
(Self : access Gtk_Text_Buffer_Record'Class);
type Cb_GObject_Void is not null access procedure
(Self : access Glib.Object.GObject_Record'Class);
Signal_Begin_User_Action : constant Glib.Signal_Name := "begin-user-action";
procedure On_Begin_User_Action
(Self : not null access Gtk_Text_Buffer_Record;
Call : Cb_Gtk_Text_Buffer_Void;
After : Boolean := False);
procedure On_Begin_User_Action
(Self : not null access Gtk_Text_Buffer_Record;
Call : Cb_GObject_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
-- The ::begin-user-action signal is emitted at the beginning of a single
-- user-visible operation on a Gtk.Text_Buffer.Gtk_Text_Buffer.
--
-- See also: Gtk.Text_Buffer.Begin_User_Action,
-- Gtk.Text_Buffer.Insert_Interactive,
-- Gtk.Text_Buffer.Insert_Range_Interactive,
-- Gtk.Text_Buffer.Delete_Interactive, Gtk.Text_Buffer.Backspace,
-- Gtk.Text_Buffer.Delete_Selection.
Signal_Changed : constant Glib.Signal_Name := "changed";
procedure On_Changed
(Self : not null access Gtk_Text_Buffer_Record;
Call : Cb_Gtk_Text_Buffer_Void;
After : Boolean := False);
procedure On_Changed
(Self : not null access Gtk_Text_Buffer_Record;
Call : Cb_GObject_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
-- The ::changed signal is emitted when the content of a
-- Gtk.Text_Buffer.Gtk_Text_Buffer has changed.
type Cb_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Iter_Void is not null access procedure
(Self : access Gtk_Text_Buffer_Record'Class;
Start : Gtk.Text_Iter.Gtk_Text_Iter;
The_End : Gtk.Text_Iter.Gtk_Text_Iter);
type Cb_GObject_Gtk_Text_Iter_Gtk_Text_Iter_Void is not null access procedure
(Self : access Glib.Object.GObject_Record'Class;
Start : Gtk.Text_Iter.Gtk_Text_Iter;
The_End : Gtk.Text_Iter.Gtk_Text_Iter);
Signal_Delete_Range : constant Glib.Signal_Name := "delete-range";
procedure On_Delete_Range
(Self : not null access Gtk_Text_Buffer_Record;
Call : Cb_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Iter_Void;
After : Boolean := False);
procedure On_Delete_Range
(Self : not null access Gtk_Text_Buffer_Record;
Call : Cb_GObject_Gtk_Text_Iter_Gtk_Text_Iter_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
-- The ::delete-range signal is emitted to delete a range from a
-- Gtk.Text_Buffer.Gtk_Text_Buffer.
--
-- Note that if your handler runs before the default handler it must not
-- invalidate the Start and End iters (or has to revalidate them). The
-- default signal handler revalidates the Start and End iters to both point
-- point to the location where text was deleted. Handlers which run after
-- the default handler (see g_signal_connect_after) do not have access to
-- the deleted text.
--
-- See also: Gtk.Text_Buffer.Delete.
--
-- Callback parameters:
-- -- "start": the start of the range to be deleted
-- -- "end": the end of the range to be deleted
Signal_End_User_Action : constant Glib.Signal_Name := "end-user-action";
procedure On_End_User_Action
(Self : not null access Gtk_Text_Buffer_Record;
Call : Cb_Gtk_Text_Buffer_Void;
After : Boolean := False);
procedure On_End_User_Action
(Self : not null access Gtk_Text_Buffer_Record;
Call : Cb_GObject_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
-- The ::end-user-action signal is emitted at the end of a single
-- user-visible operation on the Gtk.Text_Buffer.Gtk_Text_Buffer.
--
-- See also: Gtk.Text_Buffer.End_User_Action,
-- Gtk.Text_Buffer.Insert_Interactive,
-- Gtk.Text_Buffer.Insert_Range_Interactive,
-- Gtk.Text_Buffer.Delete_Interactive, Gtk.Text_Buffer.Backspace,
-- Gtk.Text_Buffer.Delete_Selection, Gtk.Text_Buffer.Backspace.
type Cb_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Child_Anchor_Void is not null access procedure
(Self : access Gtk_Text_Buffer_Record'Class;
Location : Gtk.Text_Iter.Gtk_Text_Iter;
Anchor : not null access Gtk.Text_Child_Anchor.Gtk_Text_Child_Anchor_Record'Class);
type Cb_GObject_Gtk_Text_Iter_Gtk_Text_Child_Anchor_Void is not null access procedure
(Self : access Glib.Object.GObject_Record'Class;
Location : Gtk.Text_Iter.Gtk_Text_Iter;
Anchor : not null access Gtk.Text_Child_Anchor.Gtk_Text_Child_Anchor_Record'Class);
Signal_Insert_Child_Anchor : constant Glib.Signal_Name := "insert-child-anchor";
procedure On_Insert_Child_Anchor
(Self : not null access Gtk_Text_Buffer_Record;
Call : Cb_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Child_Anchor_Void;
After : Boolean := False);
procedure On_Insert_Child_Anchor
(Self : not null access Gtk_Text_Buffer_Record;
Call : Cb_GObject_Gtk_Text_Iter_Gtk_Text_Child_Anchor_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
-- The ::insert-child-anchor signal is emitted to insert a
-- Gtk.Text_Child_Anchor.Gtk_Text_Child_Anchor in a
-- Gtk.Text_Buffer.Gtk_Text_Buffer. Insertion actually occurs in the
-- default handler.
--
-- Note that if your handler runs before the default handler it must not
-- invalidate the Location iter (or has to revalidate it). The default
-- signal handler revalidates it to be placed after the inserted Anchor.
--
-- See also: Gtk.Text_Buffer.Insert_Child_Anchor.
--
-- Callback parameters:
-- -- "location": position to insert Anchor in Textbuffer
-- -- "anchor": the Gtk.Text_Child_Anchor.Gtk_Text_Child_Anchor to be
-- -- inserted
type Cb_Gtk_Text_Buffer_Gtk_Text_Iter_Gdk_Pixbuf_Void is not null access procedure
(Self : access Gtk_Text_Buffer_Record'Class;
Location : Gtk.Text_Iter.Gtk_Text_Iter;
Pixbuf : not null access Gdk.Pixbuf.Gdk_Pixbuf_Record'Class);
type Cb_GObject_Gtk_Text_Iter_Gdk_Pixbuf_Void is not null access procedure
(Self : access Glib.Object.GObject_Record'Class;
Location : Gtk.Text_Iter.Gtk_Text_Iter;
Pixbuf : not null access Gdk.Pixbuf.Gdk_Pixbuf_Record'Class);
Signal_Insert_Pixbuf : constant Glib.Signal_Name := "insert-pixbuf";
procedure On_Insert_Pixbuf
(Self : not null access Gtk_Text_Buffer_Record;
Call : Cb_Gtk_Text_Buffer_Gtk_Text_Iter_Gdk_Pixbuf_Void;
After : Boolean := False);
procedure On_Insert_Pixbuf
(Self : not null access Gtk_Text_Buffer_Record;
Call : Cb_GObject_Gtk_Text_Iter_Gdk_Pixbuf_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
-- The ::insert-pixbuf signal is emitted to insert a Gdk.Pixbuf.Gdk_Pixbuf
-- in a Gtk.Text_Buffer.Gtk_Text_Buffer. Insertion actually occurs in the
-- default handler.
--
-- Note that if your handler runs before the default handler it must not
-- invalidate the Location iter (or has to revalidate it). The default
-- signal handler revalidates it to be placed after the inserted Pixbuf.
--
-- See also: Gtk.Text_Buffer.Insert_Pixbuf.
--
-- Callback parameters:
-- -- "location": position to insert Pixbuf in Textbuffer
-- -- "pixbuf": the Gdk.Pixbuf.Gdk_Pixbuf to be inserted
type Cb_Gtk_Text_Buffer_Gtk_Text_Iter_UTF8_String_Gint_Void is not null access procedure
(Self : access Gtk_Text_Buffer_Record'Class;
Location : Gtk.Text_Iter.Gtk_Text_Iter;
Text : UTF8_String;
Len : Gint);
type Cb_GObject_Gtk_Text_Iter_UTF8_String_Gint_Void is not null access procedure
(Self : access Glib.Object.GObject_Record'Class;
Location : Gtk.Text_Iter.Gtk_Text_Iter;
Text : UTF8_String;
Len : Gint);
Signal_Insert_Text : constant Glib.Signal_Name := "insert-text";
procedure On_Insert_Text
(Self : not null access Gtk_Text_Buffer_Record;
Call : Cb_Gtk_Text_Buffer_Gtk_Text_Iter_UTF8_String_Gint_Void;
After : Boolean := False);
procedure On_Insert_Text
(Self : not null access Gtk_Text_Buffer_Record;
Call : Cb_GObject_Gtk_Text_Iter_UTF8_String_Gint_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
-- The ::insert-text signal is emitted to insert text in a
-- Gtk.Text_Buffer.Gtk_Text_Buffer. Insertion actually occurs in the
-- default handler.
--
-- Note that if your handler runs before the default handler it must not
-- invalidate the Location iter (or has to revalidate it). The default
-- signal handler revalidates it to point to the end of the inserted text.
--
-- See also: Gtk.Text_Buffer.Insert, Gtk.Text_Buffer.Insert_Range.
--
-- Callback parameters:
-- -- "location": position to insert Text in Textbuffer
-- -- "text": the UTF-8 text to be inserted
-- -- "len": length of the inserted text in bytes
type Cb_Gtk_Text_Buffer_Gtk_Text_Mark_Void is not null access procedure
(Self : access Gtk_Text_Buffer_Record'Class;
Mark : not null access Gtk.Text_Mark.Gtk_Text_Mark_Record'Class);
type Cb_GObject_Gtk_Text_Mark_Void is not null access procedure
(Self : access Glib.Object.GObject_Record'Class;
Mark : not null access Gtk.Text_Mark.Gtk_Text_Mark_Record'Class);
Signal_Mark_Deleted : constant Glib.Signal_Name := "mark-deleted";
procedure On_Mark_Deleted
(Self : not null access Gtk_Text_Buffer_Record;
Call : Cb_Gtk_Text_Buffer_Gtk_Text_Mark_Void;
After : Boolean := False);
procedure On_Mark_Deleted
(Self : not null access Gtk_Text_Buffer_Record;
Call : Cb_GObject_Gtk_Text_Mark_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
-- The ::mark-deleted signal is emitted as notification after a
-- Gtk.Text_Mark.Gtk_Text_Mark is deleted.
--
-- See also: Gtk.Text_Buffer.Delete_Mark.
type Cb_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Mark_Void is not null access procedure
(Self : access Gtk_Text_Buffer_Record'Class;
Location : Gtk.Text_Iter.Gtk_Text_Iter;
Mark : not null access Gtk.Text_Mark.Gtk_Text_Mark_Record'Class);
type Cb_GObject_Gtk_Text_Iter_Gtk_Text_Mark_Void is not null access procedure
(Self : access Glib.Object.GObject_Record'Class;
Location : Gtk.Text_Iter.Gtk_Text_Iter;
Mark : not null access Gtk.Text_Mark.Gtk_Text_Mark_Record'Class);
Signal_Mark_Set : constant Glib.Signal_Name := "mark-set";
procedure On_Mark_Set
(Self : not null access Gtk_Text_Buffer_Record;
Call : Cb_Gtk_Text_Buffer_Gtk_Text_Iter_Gtk_Text_Mark_Void;
After : Boolean := False);
procedure On_Mark_Set
(Self : not null access Gtk_Text_Buffer_Record;
Call : Cb_GObject_Gtk_Text_Iter_Gtk_Text_Mark_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
-- The ::mark-set signal is emitted as notification after a
-- Gtk.Text_Mark.Gtk_Text_Mark is set.
--
-- See also: Gtk.Text_Buffer.Create_Mark, Gtk.Text_Buffer.Move_Mark.
--
-- Callback parameters:
-- -- "location": The location of Mark in Textbuffer
-- -- "mark": The mark that is set
Signal_Modified_Changed : constant Glib.Signal_Name := "modified-changed";
procedure On_Modified_Changed
(Self : not null access Gtk_Text_Buffer_Record;
Call : Cb_Gtk_Text_Buffer_Void;
After : Boolean := False);
procedure On_Modified_Changed
(Self : not null access Gtk_Text_Buffer_Record;
Call : Cb_GObject_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
-- The ::modified-changed signal is emitted when the modified bit of a
-- Gtk.Text_Buffer.Gtk_Text_Buffer flips.
--
-- See also: Gtk.Text_Buffer.Set_Modified.
type Cb_Gtk_Text_Buffer_Gtk_Clipboard_Void is not null access procedure
(Self : access Gtk_Text_Buffer_Record'Class;
Object : not null access Gtk.Clipboard.Gtk_Clipboard_Record'Class);
type Cb_GObject_Gtk_Clipboard_Void is not null access procedure
(Self : access Glib.Object.GObject_Record'Class;
Object : not null access Gtk.Clipboard.Gtk_Clipboard_Record'Class);
Signal_Paste_Done : constant Glib.Signal_Name := "paste-done";
procedure On_Paste_Done
(Self : not null access Gtk_Text_Buffer_Record;
Call : Cb_Gtk_Text_Buffer_Gtk_Clipboard_Void;
After : Boolean := False);
procedure On_Paste_Done
(Self : not null access Gtk_Text_Buffer_Record;
Call : Cb_GObject_Gtk_Clipboard_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
-- The paste-done signal is emitted after paste operation has been
-- completed. This is useful to properly scroll the view to the end of the
-- pasted text. See Gtk.Text_Buffer.Paste_Clipboard for more details.
Signal_Remove_Tag : constant Glib.Signal_Name := "remove-tag";
procedure On_Remove_Tag
(Self : not null access Gtk_Text_Buffer_Record;
Call : Cb_Gtk_Text_Buffer_Gtk_Text_Tag_Gtk_Text_Iter_Gtk_Text_Iter_Void;
After : Boolean := False);
procedure On_Remove_Tag
(Self : not null access Gtk_Text_Buffer_Record;
Call : Cb_GObject_Gtk_Text_Tag_Gtk_Text_Iter_Gtk_Text_Iter_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
-- The ::remove-tag signal is emitted to remove all occurrences of Tag
-- from a range of text in a Gtk.Text_Buffer.Gtk_Text_Buffer. Removal
-- actually occurs in the default handler.
--
-- Note that if your handler runs before the default handler it must not
-- invalidate the Start and End iters (or has to revalidate them).
--
-- See also: Gtk.Text_Buffer.Remove_Tag.
--
-- Callback parameters:
-- -- "tag": the tag to be removed
-- -- "start": the start of the range the tag is removed from
-- -- "end": the end of the range the tag is removed from
private
Text_Property : constant Glib.Properties.Property_String :=
Glib.Properties.Build ("text");
Tag_Table_Property : constant Glib.Properties.Property_Object :=
Glib.Properties.Build ("tag-table");
Paste_Target_List_Property : constant Glib.Properties.Property_Object :=
Glib.Properties.Build ("paste-target-list");
Has_Selection_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("has-selection");
Cursor_Position_Property : constant Glib.Properties.Property_Int :=
Glib.Properties.Build ("cursor-position");
Copy_Target_List_Property : constant Glib.Properties.Property_Object :=
Glib.Properties.Build ("copy-target-list");
end Gtk.Text_Buffer;