------------------------------------------------------------------------------
-- --
-- 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 Glib; use Glib;
with Glib.Generic_Properties; use Glib.Generic_Properties;
with Glib.Object; use Glib.Object;
with Glib.Values; use Glib.Values;
with Gtk.Text_Attributes; use Gtk.Text_Attributes;
with Gtk.Text_Tag; use Gtk.Text_Tag;
with Interfaces.C.Strings; use Interfaces.C.Strings;
with Pango.Language; use Pango.Language;
package Gtk.Text_Iter is
type Gtk_Text_Search_Flags is mod 2 ** Integer'Size;
pragma Convention (C, Gtk_Text_Search_Flags);
Visible_Only : constant Gtk_Text_Search_Flags := 1;
Text_Only : constant Gtk_Text_Search_Flags := 2;
Case_Insensitive : constant Gtk_Text_Search_Flags := 4;
type Gtk_Text_Iter is private;
function From_Object_Free (B : access Gtk_Text_Iter) return Gtk_Text_Iter;
pragma Inline (From_Object_Free);
-- 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.
Null_Text_Iter : constant Gtk_Text_Iter;
----------------------------
-- Enumeration Properties --
----------------------------
package Gtk_Text_Search_Flags_Properties is
new Generic_Internal_Discrete_Property (Gtk_Text_Search_Flags);
type Property_Gtk_Text_Search_Flags is new Gtk_Text_Search_Flags_Properties.Property;
------------------
-- Constructors --
------------------
function Get_Type return Glib.GType;
pragma Import (C, Get_Type, "gtk_text_iter_get_type");
-------------
-- Methods --
-------------
procedure Assign (Iter : Gtk_Text_Iter; Other : Gtk_Text_Iter);
pragma Import (C, Assign, "gtk_text_iter_assign");
-- Assigns the value of Other to Iter. This function is not useful in
-- applications, because iterators can be assigned with 'GtkTextIter i =
-- j;'. The function is used by language bindings.
-- Since: gtk+ 3.2
-- "other": another Gtk.Text_Iter.Gtk_Text_Iter
procedure Backward_Char
(Iter : in out Gtk_Text_Iter;
Result : out Boolean);
-- Moves backward by one character offset. Returns True if movement was
-- possible; if Iter was the first in the buffer (character offset 0),
-- gtk_text_iter_backward_char () returns False for convenience when
-- writing loops.
procedure Backward_Chars
(Iter : in out Gtk_Text_Iter;
Count : Gint;
Result : out Boolean);
-- Moves Count characters backward, if possible (if Count would move past
-- the start or end of the buffer, moves to the start or end of the
-- buffer). The return value indicates whether the iterator moved onto a
-- dereferenceable position; if the iterator didn't move, or moved onto the
-- end iterator, then False is returned. If Count is 0, the function does
-- nothing and returns False.
-- "count": number of characters to move
procedure Backward_Cursor_Position
(Iter : in out Gtk_Text_Iter;
Result : out Boolean);
-- Like Gtk.Text_Iter.Forward_Cursor_Position, but moves backward.
procedure Backward_Cursor_Positions
(Iter : in out Gtk_Text_Iter;
Count : Gint;
Result : out Boolean);
-- Moves up to Count cursor positions. See
-- Gtk.Text_Iter.Forward_Cursor_Position for details.
-- "count": number of positions to move
procedure Backward_Line
(Iter : in out Gtk_Text_Iter;
Result : out Boolean);
-- Moves Iter to the start of the previous line. Returns True if Iter
-- could be moved; i.e. if Iter was at character offset 0, this function
-- returns False. Therefore if Iter was already on line 0, but not at the
-- start of the line, Iter is snapped to the start of the line and the
-- function returns True. (Note that this implies that in a loop calling
-- this function, the line number may not change on every iteration, if
-- your first iteration is on line 0.)
procedure Backward_Lines
(Iter : in out Gtk_Text_Iter;
Count : Gint;
Result : out Boolean);
-- Moves Count lines backward, if possible (if Count would move past the
-- start or end of the buffer, moves to the start or end of the buffer).
-- The return value indicates whether the iterator moved onto a
-- dereferenceable position; if the iterator didn't move, or moved onto the
-- end iterator, then False is returned. If Count is 0, the function does
-- nothing and returns False. If Count is negative, moves forward by 0 -
-- Count lines.
-- "count": number of lines to move backward
procedure Backward_Search
(Iter : in out Gtk_Text_Iter;
Str : UTF8_String;
Flags : Gtk_Text_Search_Flags;
Match_Start : out Gtk_Text_Iter;
Match_End : out Gtk_Text_Iter;
Limit : Gtk_Text_Iter := Null_Text_Iter;
Result : out Boolean);
-- Same as Gtk.Text_Iter.Forward_Search, but moves backward.
-- "str": search string
-- "flags": bitmask of flags affecting the search
-- "match_start": return location for start of match, or null
-- "match_end": return location for end of match, or null
-- "limit": location of last possible Match_Start, or null for start of
-- buffer
procedure Backward_Sentence_Start
(Iter : in out Gtk_Text_Iter;
Result : out Boolean);
-- Moves backward to the previous sentence start; if Iter is already at
-- the start of a sentence, moves backward to the next one. Sentence
-- boundaries are determined by Pango and should be correct for nearly any
-- language (if not, the correct fix would be to the Pango text boundary
-- algorithms).
procedure Backward_Sentence_Starts
(Iter : in out Gtk_Text_Iter;
Count : Gint;
Result : out Boolean);
-- Calls Gtk.Text_Iter.Backward_Sentence_Start up to Count times, or until
-- it returns False. If Count is negative, moves forward instead of
-- backward.
-- "count": number of sentences to move
procedure Backward_To_Tag_Toggle
(Iter : in out Gtk_Text_Iter;
Tag : Gtk.Text_Tag.Gtk_Text_Tag := null;
Result : out Boolean);
-- Moves backward to the next toggle (on or off) of the
-- Gtk.Text_Tag.Gtk_Text_Tag Tag, or to the next toggle of any tag if Tag
-- is null. If no matching tag toggles are found, returns False, otherwise
-- True. Does not return toggles located at Iter, only toggles before Iter.
-- Sets Iter to the location of the toggle, or the start of the buffer if
-- no toggle is found.
-- "tag": a Gtk.Text_Tag.Gtk_Text_Tag, or null
procedure Backward_Visible_Cursor_Position
(Iter : in out Gtk_Text_Iter;
Result : out Boolean);
-- Moves Iter forward to the previous visible cursor position. See
-- Gtk.Text_Iter.Backward_Cursor_Position for details.
-- Since: gtk+ 2.4
procedure Backward_Visible_Cursor_Positions
(Iter : in out Gtk_Text_Iter;
Count : Gint;
Result : out Boolean);
-- Moves up to Count visible cursor positions. See
-- Gtk.Text_Iter.Backward_Cursor_Position for details.
-- Since: gtk+ 2.4
-- "count": number of positions to move
procedure Backward_Visible_Line
(Iter : in out Gtk_Text_Iter;
Result : out Boolean);
-- Moves Iter to the start of the previous visible line. Returns True if
-- Iter could be moved; i.e. if Iter was at character offset 0, this
-- function returns False. Therefore if Iter was already on line 0, but not
-- at the start of the line, Iter is snapped to the start of the line and
-- the function returns True. (Note that this implies that in a loop
-- calling this function, the line number may not change on every
-- iteration, if your first iteration is on line 0.)
-- Since: gtk+ 2.8
procedure Backward_Visible_Lines
(Iter : in out Gtk_Text_Iter;
Count : Gint;
Result : out Boolean);
-- Moves Count visible lines backward, if possible (if Count would move
-- past the start or end of the buffer, moves to the start or end of the
-- buffer). The return value indicates whether the iterator moved onto a
-- dereferenceable position; if the iterator didn't move, or moved onto the
-- end iterator, then False is returned. If Count is 0, the function does
-- nothing and returns False. If Count is negative, moves forward by 0 -
-- Count lines.
-- Since: gtk+ 2.8
-- "count": number of lines to move backward
procedure Backward_Visible_Word_Start
(Iter : in out Gtk_Text_Iter;
Result : out Boolean);
-- Moves backward to the previous visible word start. (If Iter is
-- currently on a word start, moves backward to the next one after that.)
-- Word breaks are determined by Pango and should be correct for nearly any
-- language (if not, the correct fix would be to the Pango word break
-- algorithms).
-- Since: gtk+ 2.4
procedure Backward_Visible_Word_Starts
(Iter : in out Gtk_Text_Iter;
Count : Gint;
Result : out Boolean);
-- Calls Gtk.Text_Iter.Backward_Visible_Word_Start up to Count times.
-- Since: gtk+ 2.4
-- "count": number of times to move
procedure Backward_Word_Start
(Iter : in out Gtk_Text_Iter;
Result : out Boolean);
-- Moves backward to the previous word start. (If Iter is currently on a
-- word start, moves backward to the next one after that.) Word breaks are
-- determined by Pango and should be correct for nearly any language (if
-- not, the correct fix would be to the Pango word break algorithms).
procedure Backward_Word_Starts
(Iter : in out Gtk_Text_Iter;
Count : Gint;
Result : out Boolean);
-- Calls Gtk.Text_Iter.Backward_Word_Start up to Count times.
-- "count": number of times to move
function Begins_Tag
(Iter : Gtk_Text_Iter;
Tag : access Gtk.Text_Tag.Gtk_Text_Tag_Record'Class) return Boolean;
-- Returns True if Tag is toggled on at exactly this point. If Tag is
-- null, returns True if any tag is toggled on at this point. Note that the
-- gtk_text_iter_begins_tag () returns True if Iter is the *start* of the
-- tagged range; gtk_text_iter_has_tag () tells you whether an iterator is
-- *within* a tagged range.
-- "tag": a Gtk.Text_Tag.Gtk_Text_Tag, or null
function Can_Insert
(Iter : Gtk_Text_Iter;
Default_Editability : Boolean) return Boolean;
-- Considering the default editability of the buffer, and tags that affect
-- editability, determines whether text inserted at Iter would be editable.
-- If text inserted at Iter would be editable then the user should be
-- allowed to insert text at Iter. Gtk.Text_Buffer.Insert_Interactive uses
-- this function to decide whether insertions are allowed at a given
-- position.
-- "default_editability": True if text is editable by default
function Compare (Iter : Gtk_Text_Iter; Rhs : Gtk_Text_Iter) return Gint;
pragma Import (C, Compare, "gtk_text_iter_compare");
-- A qsort-style function that returns negative if Lhs is less than Rhs,
-- positive if Lhs is greater than Rhs, and 0 if they're equal. Ordering is
-- in character offset order, i.e. the first character in the buffer is
-- less than the second character in the buffer.
-- "rhs": another Gtk.Text_Iter.Gtk_Text_Iter
function Editable
(Iter : Gtk_Text_Iter;
Default_Setting : Boolean) return Boolean;
-- Returns whether the character at Iter is within an editable region of
-- text. Non-editable text is "locked" and can't be changed by the user via
-- Gtk.Text_View.Gtk_Text_View. This function is simply a convenience
-- wrapper around gtk_text_iter_get_attributes (). If no tags applied to
-- this text affect editability, Default_Setting will be returned.
-- You don't want to use this function to decide whether text can be
-- inserted at Iter, because for insertion you don't want to know whether
-- the char at Iter is inside an editable range, you want to know whether a
-- new character inserted at Iter would be inside an editable range. Use
-- Gtk.Text_Iter.Can_Insert to handle this case.
-- "default_setting": True if text is editable by default
function Ends_Line (Iter : Gtk_Text_Iter) return Boolean;
-- Returns True if Iter points to the start of the paragraph delimiter
-- characters for a line (delimiters will be either a newline, a carriage
-- return, a carriage return followed by a newline, or a Unicode paragraph
-- separator character). Note that an iterator pointing to the \n of a \r\n
-- pair will not be counted as the end of a line, the line ends before the
-- \r. The end iterator is considered to be at the end of a line, even
-- though there are no paragraph delimiter chars there.
function Ends_Sentence (Iter : Gtk_Text_Iter) return Boolean;
-- Determines whether Iter ends a sentence. Sentence boundaries are
-- determined by Pango and should be correct for nearly any language (if
-- not, the correct fix would be to the Pango text boundary algorithms).
function Ends_Tag
(Iter : Gtk_Text_Iter;
Tag : access Gtk.Text_Tag.Gtk_Text_Tag_Record'Class) return Boolean;
-- Returns True if Tag is toggled off at exactly this point. If Tag is
-- null, returns True if any tag is toggled off at this point. Note that
-- the gtk_text_iter_ends_tag () returns True if Iter is the *end* of the
-- tagged range; gtk_text_iter_has_tag () tells you whether an iterator is
-- *within* a tagged range.
-- "tag": a Gtk.Text_Tag.Gtk_Text_Tag, or null
function Ends_Word (Iter : Gtk_Text_Iter) return Boolean;
-- Determines whether Iter ends a natural-language word. Word breaks are
-- determined by Pango and should be correct for nearly any language (if
-- not, the correct fix would be to the Pango word break algorithms).
function Equal (Iter : Gtk_Text_Iter; Rhs : Gtk_Text_Iter) return Boolean;
-- Tests whether two iterators are equal, using the fastest possible
-- mechanism. This function is very fast; you can expect it to perform
-- better than e.g. getting the character offset for each iterator and
-- comparing the offsets yourself. Also, it's a bit faster than
-- Gtk.Text_Iter.Compare.
-- "rhs": another Gtk.Text_Iter.Gtk_Text_Iter
procedure Forward_Char
(Iter : in out Gtk_Text_Iter;
Result : out Boolean);
-- Moves Iter forward by one character offset. Note that images embedded
-- in the buffer occupy 1 character slot, so gtk_text_iter_forward_char ()
-- may actually move onto an image instead of a character, if you have
-- images in your buffer. If Iter is the end iterator or one character
-- before it, Iter will now point at the end iterator, and
-- gtk_text_iter_forward_char () returns False for convenience when writing
-- loops.
procedure Forward_Chars
(Iter : in out Gtk_Text_Iter;
Count : Gint;
Result : out Boolean);
-- Moves Count characters if possible (if Count would move past the start
-- or end of the buffer, moves to the start or end of the buffer). The
-- return value indicates whether the new position of Iter is different
-- from its original position, and dereferenceable (the last iterator in
-- the buffer is not dereferenceable). If Count is 0, the function does
-- nothing and returns False.
-- "count": number of characters to move, may be negative
procedure Forward_Cursor_Position
(Iter : in out Gtk_Text_Iter;
Result : out Boolean);
-- Moves Iter forward by a single cursor position. Cursor positions are
-- (unsurprisingly) positions where the cursor can appear. Perhaps
-- surprisingly, there may not be a cursor position between all characters.
-- The most common example for European languages would be a carriage
-- return/newline sequence. For some Unicode characters, the equivalent of
-- say the letter "a" with an accent mark will be represented as two
-- characters, first the letter then a "combining mark" that causes the
-- accent to be rendered; so the cursor can't go between those two
-- characters. See also the Pango_Log_Attr structure and pango_break
-- function.
procedure Forward_Cursor_Positions
(Iter : in out Gtk_Text_Iter;
Count : Gint;
Result : out Boolean);
-- Moves up to Count cursor positions. See
-- Gtk.Text_Iter.Forward_Cursor_Position for details.
-- "count": number of positions to move
procedure Forward_Line
(Iter : in out Gtk_Text_Iter;
Result : out Boolean);
-- Moves Iter to the start of the next line. If the iter is already on the
-- last line of the buffer, moves the iter to the end of the current line.
-- If after the operation, the iter is at the end of the buffer and not
-- dereferencable, returns False. Otherwise, returns True.
procedure Forward_Lines
(Iter : in out Gtk_Text_Iter;
Count : Gint;
Result : out Boolean);
-- Moves Count lines forward, if possible (if Count would move past the
-- start or end of the buffer, moves to the start or end of the buffer).
-- The return value indicates whether the iterator moved onto a
-- dereferenceable position; if the iterator didn't move, or moved onto the
-- end iterator, then False is returned. If Count is 0, the function does
-- nothing and returns False. If Count is negative, moves backward by 0 -
-- Count lines.
-- "count": number of lines to move forward
procedure Forward_Search
(Iter : in out Gtk_Text_Iter;
Str : UTF8_String;
Flags : Gtk_Text_Search_Flags;
Match_Start : out Gtk_Text_Iter;
Match_End : out Gtk_Text_Iter;
Limit : Gtk_Text_Iter := Null_Text_Iter;
Result : out Boolean);
-- Searches forward for Str. Any match is returned by setting Match_Start
-- to the first character of the match and Match_End to the first character
-- after the match. The search will not continue past Limit. Note that a
-- search is a linear or O(n) operation, so you may wish to use Limit to
-- avoid locking up your UI on large buffers.
-- If the GTK_TEXT_SEARCH_VISIBLE_ONLY flag is present, the match may have
-- invisible text interspersed in Str. i.e. Str will be a
-- possibly-noncontiguous subsequence of the matched range. similarly, if
-- you specify GTK_TEXT_SEARCH_TEXT_ONLY, the match may have pixbufs or
-- child widgets mixed inside the matched range. If these flags are not
-- given, the match must be exact; the special 0xFFFC character in Str will
-- match embedded pixbufs or child widgets. If you specify the
-- GTK_TEXT_SEARCH_CASE_INSENSITIVE flag, the text will be matched
-- regardless of what case it is in.
-- "str": a search string
-- "flags": flags affecting how the search is done
-- "match_start": return location for start of match, or null
-- "match_end": return location for end of match, or null
-- "limit": bound for the search, or null for the end of the buffer
procedure Forward_Sentence_End
(Iter : in out Gtk_Text_Iter;
Result : out Boolean);
-- Moves forward to the next sentence end. (If Iter is at the end of a
-- sentence, moves to the next end of sentence.) Sentence boundaries are
-- determined by Pango and should be correct for nearly any language (if
-- not, the correct fix would be to the Pango text boundary algorithms).
procedure Forward_Sentence_Ends
(Iter : in out Gtk_Text_Iter;
Count : Gint;
Result : out Boolean);
-- Calls Gtk.Text_Iter.Forward_Sentence_End Count times (or until
-- Gtk.Text_Iter.Forward_Sentence_End returns False). If Count is negative,
-- moves backward instead of forward.
-- "count": number of sentences to move
procedure Forward_To_End (Iter : in out Gtk_Text_Iter);
pragma Import (C, Forward_To_End, "gtk_text_iter_forward_to_end");
-- Moves Iter forward to the "end iterator," which points one past the
-- last valid character in the buffer. Gtk.Text_Iter.Get_Char called on the
-- end iterator returns 0, which is convenient for writing loops.
procedure Forward_To_Line_End
(Iter : in out Gtk_Text_Iter;
Result : out Boolean);
-- Moves the iterator to point to the paragraph delimiter characters,
-- which will be either a newline, a carriage return, a carriage
-- return/newline in sequence, or the Unicode paragraph separator
-- character. If the iterator is already at the paragraph delimiter
-- characters, moves to the paragraph delimiter characters for the next
-- line. If Iter is on the last line in the buffer, which does not end in
-- paragraph delimiters, moves to the end iterator (end of the last line),
-- and returns False.
procedure Forward_To_Tag_Toggle
(Iter : in out Gtk_Text_Iter;
Tag : Gtk.Text_Tag.Gtk_Text_Tag := null;
Result : out Boolean);
-- Moves forward to the next toggle (on or off) of the
-- Gtk.Text_Tag.Gtk_Text_Tag Tag, or to the next toggle of any tag if Tag
-- is null. If no matching tag toggles are found, returns False, otherwise
-- True. Does not return toggles located at Iter, only toggles after Iter.
-- Sets Iter to the location of the toggle, or to the end of the buffer if
-- no toggle is found.
-- "tag": a Gtk.Text_Tag.Gtk_Text_Tag, or null
procedure Forward_Visible_Cursor_Position
(Iter : in out Gtk_Text_Iter;
Result : out Boolean);
-- Moves Iter forward to the next visible cursor position. See
-- Gtk.Text_Iter.Forward_Cursor_Position for details.
-- Since: gtk+ 2.4
procedure Forward_Visible_Cursor_Positions
(Iter : in out Gtk_Text_Iter;
Count : Gint;
Result : out Boolean);
-- Moves up to Count visible cursor positions. See
-- Gtk.Text_Iter.Forward_Cursor_Position for details.
-- Since: gtk+ 2.4
-- "count": number of positions to move
procedure Forward_Visible_Line
(Iter : in out Gtk_Text_Iter;
Result : out Boolean);
-- Moves Iter to the start of the next visible line. Returns True if there
-- was a next line to move to, and False if Iter was simply moved to the
-- end of the buffer and is now not dereferenceable, or if Iter was already
-- at the end of the buffer.
-- Since: gtk+ 2.8
procedure Forward_Visible_Lines
(Iter : in out Gtk_Text_Iter;
Count : Gint;
Result : out Boolean);
-- Moves Count visible lines forward, if possible (if Count would move
-- past the start or end of the buffer, moves to the start or end of the
-- buffer). The return value indicates whether the iterator moved onto a
-- dereferenceable position; if the iterator didn't move, or moved onto the
-- end iterator, then False is returned. If Count is 0, the function does
-- nothing and returns False. If Count is negative, moves backward by 0 -
-- Count lines.
-- Since: gtk+ 2.8
-- "count": number of lines to move forward
procedure Forward_Visible_Word_End
(Iter : in out Gtk_Text_Iter;
Result : out Boolean);
-- Moves forward to the next visible word end. (If Iter is currently on a
-- word end, moves forward to the next one after that.) Word breaks are
-- determined by Pango and should be correct for nearly any language (if
-- not, the correct fix would be to the Pango word break algorithms).
-- Since: gtk+ 2.4
procedure Forward_Visible_Word_Ends
(Iter : in out Gtk_Text_Iter;
Count : Gint;
Result : out Boolean);
-- Calls Gtk.Text_Iter.Forward_Visible_Word_End up to Count times.
-- Since: gtk+ 2.4
-- "count": number of times to move
procedure Forward_Word_End
(Iter : in out Gtk_Text_Iter;
Result : out Boolean);
-- Moves forward to the next word end. (If Iter is currently on a word
-- end, moves forward to the next one after that.) Word breaks are
-- determined by Pango and should be correct for nearly any language (if
-- not, the correct fix would be to the Pango word break algorithms).
procedure Forward_Word_Ends
(Iter : in out Gtk_Text_Iter;
Count : Gint;
Result : out Boolean);
-- Calls Gtk.Text_Iter.Forward_Word_End up to Count times.
-- "count": number of times to move
procedure Free (Iter : Gtk_Text_Iter);
pragma Import (C, Free, "gtk_text_iter_free");
-- Free an iterator allocated on the heap. This function is intended for
-- use in language bindings, and is not especially useful for applications,
-- because iterators can simply be allocated on the stack.
function Get_Attributes
(Iter : Gtk_Text_Iter;
Values : access Gtk.Text_Attributes.Gtk_Text_Attributes)
return Boolean;
-- Computes the effect of any tags applied to this spot in the text. The
-- Values parameter should be initialized to the default settings you wish
-- to use if no tags are in effect. You'd typically obtain the defaults
-- from Gtk.Text_View.Get_Default_Attributes.
-- gtk_text_iter_get_attributes () will modify Values, applying the
-- effects of any tags present at Iter. If any tags affected Values, the
-- function returns True.
-- "values": a Gtk.Text_Attributes.Gtk_Text_Attributes to be filled in
function Get_Bytes_In_Line (Iter : Gtk_Text_Iter) return Gint;
pragma Import (C, Get_Bytes_In_Line, "gtk_text_iter_get_bytes_in_line");
-- Returns the number of bytes in the line containing Iter, including the
-- paragraph delimiters.
function Get_Char (Iter : Gtk_Text_Iter) return Gunichar;
pragma Import (C, Get_Char, "gtk_text_iter_get_char");
-- Returns the Unicode character at this iterator. (Equivalent to
-- operator* on a C++ iterator.) If the element at this iterator is a
-- non-character element, such as an image embedded in the buffer, the
-- Unicode "unknown" character 0xFFFC is returned. If invoked on the end
-- iterator, zero is returned; zero is not a valid Unicode character. So
-- you can write a loop which ends when gtk_text_iter_get_char () returns
-- 0.
function Get_Chars_In_Line (Iter : Gtk_Text_Iter) return Gint;
pragma Import (C, Get_Chars_In_Line, "gtk_text_iter_get_chars_in_line");
-- Returns the number of characters in the line containing Iter, including
-- the paragraph delimiters.
function Get_Language
(Iter : Gtk_Text_Iter) return Pango.Language.Pango_Language;
-- A convenience wrapper around gtk_text_iter_get_attributes (), which
-- returns the language in effect at Iter. If no tags affecting language
-- apply to Iter, the return value is identical to that of
-- gtk_get_default_language ().
function Get_Line (Iter : Gtk_Text_Iter) return Gint;
pragma Import (C, Get_Line, "gtk_text_iter_get_line");
-- Returns the line number containing the iterator. Lines in a
-- Gtk.Text_Buffer.Gtk_Text_Buffer are numbered beginning with 0 for the
-- first line in the buffer.
procedure Set_Line (Iter : in out Gtk_Text_Iter; Line_Number : Gint);
pragma Import (C, Set_Line, "gtk_text_iter_set_line");
-- Moves iterator Iter to the start of the line Line_Number. If
-- Line_Number is negative or larger than the number of lines in the
-- buffer, moves Iter to the start of the last line in the buffer.
-- "line_number": line number (counted from 0)
function Get_Line_Index (Iter : Gtk_Text_Iter) return Gint;
pragma Import (C, Get_Line_Index, "gtk_text_iter_get_line_index");
-- Returns the byte index of the iterator, counting from the start of a
-- newline-terminated line. Remember that Gtk.Text_Buffer.Gtk_Text_Buffer
-- encodes text in UTF-8, and that characters can require a variable number
-- of bytes to represent.
procedure Set_Line_Index
(Iter : in out Gtk_Text_Iter;
Byte_On_Line : Gint);
pragma Import (C, Set_Line_Index, "gtk_text_iter_set_line_index");
-- Same as Gtk.Text_Iter.Set_Line_Offset, but works with a *byte* index.
-- The given byte index must be at the start of a character, it can't be in
-- the middle of a UTF-8 encoded character.
-- "byte_on_line": a byte index relative to the start of Iter's current
-- line
function Get_Line_Offset (Iter : Gtk_Text_Iter) return Gint;
pragma Import (C, Get_Line_Offset, "gtk_text_iter_get_line_offset");
-- Returns the character offset of the iterator, counting from the start
-- of a newline-terminated line. The first character on the line has offset
-- 0.
procedure Set_Line_Offset
(Iter : in out Gtk_Text_Iter;
Char_On_Line : Gint);
pragma Import (C, Set_Line_Offset, "gtk_text_iter_set_line_offset");
-- Moves Iter within a line, to a new *character* (not byte) offset. The
-- given character offset must be less than or equal to the number of
-- characters in the line; if equal, Iter moves to the start of the next
-- line. See Gtk.Text_Iter.Set_Line_Index if you have a byte index rather
-- than a character offset.
-- "char_on_line": a character offset relative to the start of Iter's
-- current line
function Get_Marks
(Iter : Gtk_Text_Iter) return Glib.Object.Object_List.GSlist;
-- Returns a list of all Gtk.Text_Mark.Gtk_Text_Mark at this location.
-- Because marks are not iterable (they don't take up any "space" in the
-- buffer, they are just marks in between iterable locations), multiple
-- marks can exist in the same place. The returned list is not in any
-- meaningful order.
function Get_Offset (Iter : Gtk_Text_Iter) return Gint;
pragma Import (C, Get_Offset, "gtk_text_iter_get_offset");
-- Returns the character offset of an iterator. Each character in a
-- Gtk.Text_Buffer.Gtk_Text_Buffer has an offset, starting with 0 for the
-- first character in the buffer. Use gtk_text_buffer_get_iter_at_offset ()
-- to convert an offset back into an iterator.
procedure Set_Offset (Iter : in out Gtk_Text_Iter; Char_Offset : Gint);
pragma Import (C, Set_Offset, "gtk_text_iter_set_offset");
-- Sets Iter to point to Char_Offset. Char_Offset counts from the start of
-- the entire text buffer, starting with 0.
-- "char_offset": a character number
function Get_Pixbuf (Iter : Gtk_Text_Iter) return Gdk.Pixbuf.Gdk_Pixbuf;
-- If the element at Iter is a pixbuf, the pixbuf is returned (with no new
-- reference count added). Otherwise, null is returned.
function Get_Slice
(Iter : Gtk_Text_Iter;
The_End : Gtk_Text_Iter) return UTF8_String;
-- Returns the text in the given range. A "slice" is an array of
-- characters encoded in UTF-8 format, including the Unicode "unknown"
-- character 0xFFFC for iterable non-character elements in the buffer, such
-- as images. Because images are encoded in the slice, byte and character
-- offsets in the returned array will correspond to byte offsets in the
-- text buffer. 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.
-- "end": iterator at end of a range
function Get_Tags
(Iter : Gtk_Text_Iter) return Gtk.Text_Tag.Text_Tag_List.GSlist;
-- Returns a list of tags that apply to Iter, in ascending order of
-- priority (highest-priority tags are last). The Gtk.Text_Tag.Gtk_Text_Tag
-- in the list don't have a reference added, but you have to free the list
-- itself.
function Get_Text
(Iter : Gtk_Text_Iter;
The_End : Gtk_Text_Iter) return UTF8_String;
-- Returns *text* in the given range. If the range contains non-text
-- elements such as images, the character and byte offsets in the returned
-- string will not correspond to character and byte offsets in the buffer.
-- If you want offsets to correspond, see gtk_text_iter_get_slice ().
-- "end": iterator at end of a range
function Get_Toggled_Tags
(Iter : Gtk_Text_Iter;
Toggled_On : Boolean) return Gtk.Text_Tag.Text_Tag_List.GSlist;
-- Returns a list of Gtk.Text_Tag.Gtk_Text_Tag that are toggled on or off
-- at this point. (If Toggled_On is True, the list contains tags that are
-- toggled on.) If a tag is toggled on at Iter, then some non-empty range
-- of characters following Iter has that tag applied to it. If a tag is
-- toggled off, then some non-empty range following Iter does *not* have
-- the tag applied to it.
-- "toggled_on": True to get toggled-on tags
function Get_Visible_Line_Index (Iter : Gtk_Text_Iter) return Gint;
pragma Import (C, Get_Visible_Line_Index, "gtk_text_iter_get_visible_line_index");
-- Returns the number of bytes from the start of the line to the given
-- Iter, not counting bytes that are invisible due to tags with the
-- "invisible" flag toggled on.
procedure Set_Visible_Line_Index
(Iter : in out Gtk_Text_Iter;
Byte_On_Line : Gint);
pragma Import (C, Set_Visible_Line_Index, "gtk_text_iter_set_visible_line_index");
-- Like Gtk.Text_Iter.Set_Line_Index, but the index is in visible bytes,
-- i.e. text with a tag making it invisible is not counted in the index.
-- "byte_on_line": a byte index
function Get_Visible_Line_Offset (Iter : Gtk_Text_Iter) return Gint;
pragma Import (C, Get_Visible_Line_Offset, "gtk_text_iter_get_visible_line_offset");
-- Returns the offset in characters from the start of the line to the
-- given Iter, not counting characters that are invisible due to tags with
-- the "invisible" flag toggled on.
procedure Set_Visible_Line_Offset
(Iter : in out Gtk_Text_Iter;
Char_On_Line : Gint);
pragma Import (C, Set_Visible_Line_Offset, "gtk_text_iter_set_visible_line_offset");
-- Like Gtk.Text_Iter.Set_Line_Offset, but the offset is in visible
-- characters, i.e. text with a tag making it invisible is not counted in
-- the offset.
-- "char_on_line": a character offset
function Get_Visible_Slice
(Iter : Gtk_Text_Iter;
The_End : Gtk_Text_Iter) return UTF8_String;
-- Like gtk_text_iter_get_slice (), but invisible text is not included.
-- Invisible text is usually invisible because a Gtk.Text_Tag.Gtk_Text_Tag
-- with the "invisible" attribute turned on has been applied to it.
-- "end": iterator at end of range
function Get_Visible_Text
(Iter : Gtk_Text_Iter;
The_End : Gtk_Text_Iter) return UTF8_String;
-- Like gtk_text_iter_get_text (), but invisible text is not included.
-- Invisible text is usually invisible because a Gtk.Text_Tag.Gtk_Text_Tag
-- with the "invisible" attribute turned on has been applied to it.
-- "end": iterator at end of range
function Has_Tag
(Iter : Gtk_Text_Iter;
Tag : not null access Gtk.Text_Tag.Gtk_Text_Tag_Record'Class)
return Boolean;
-- Returns True if Iter is within a range tagged with Tag.
-- "tag": a Gtk.Text_Tag.Gtk_Text_Tag
function In_Range
(Iter : Gtk_Text_Iter;
Start : Gtk_Text_Iter;
The_End : Gtk_Text_Iter) return Boolean;
-- Checks whether Iter falls in the range [Start, End). Start and End must
-- be in ascending order.
-- "start": start of range
-- "end": end of range
function Inside_Sentence (Iter : Gtk_Text_Iter) return Boolean;
-- Determines whether Iter is inside a sentence (as opposed to in between
-- two sentences, e.g. after a period and before the first letter of the
-- next sentence). Sentence boundaries are determined by Pango and should
-- be correct for nearly any language (if not, the correct fix would be to
-- the Pango text boundary algorithms).
function Inside_Word (Iter : Gtk_Text_Iter) return Boolean;
-- Determines whether Iter is inside a natural-language word (as opposed
-- to say inside some whitespace). Word breaks are determined by Pango and
-- should be correct for nearly any language (if not, the correct fix would
-- be to the Pango word break algorithms).
function Is_Cursor_Position (Iter : Gtk_Text_Iter) return Boolean;
-- See Gtk.Text_Iter.Forward_Cursor_Position or Pango_Log_Attr or
-- pango_break for details on what a cursor position is.
function Is_End (Iter : Gtk_Text_Iter) return Boolean;
-- Returns True if Iter is the end iterator, i.e. one past the last
-- dereferenceable iterator in the buffer. gtk_text_iter_is_end () is the
-- most efficient way to check whether an iterator is the end iterator.
function Is_Start (Iter : Gtk_Text_Iter) return Boolean;
-- Returns True if Iter is the first iterator in the buffer, that is if
-- Iter has a character offset of 0.
procedure Order (Iter : Gtk_Text_Iter; Second : Gtk_Text_Iter);
pragma Import (C, Order, "gtk_text_iter_order");
-- Swaps the value of First and Second if Second comes before First in the
-- buffer. That is, ensures that First and Second are in sequence. Most
-- text buffer functions that take a range call this automatically on your
-- behalf, so there's no real reason to call it yourself in those cases.
-- There are some exceptions, such as Gtk.Text_Iter.In_Range, that expect a
-- pre-sorted range.
-- "second": another Gtk.Text_Iter.Gtk_Text_Iter
function Starts_Line (Iter : Gtk_Text_Iter) return Boolean;
-- Returns True if Iter begins a paragraph, i.e. if
-- gtk_text_iter_get_line_offset () would return 0. However this function
-- is potentially more efficient than gtk_text_iter_get_line_offset ()
-- because it doesn't have to compute the offset, it just has to see
-- whether it's 0.
function Starts_Sentence (Iter : Gtk_Text_Iter) return Boolean;
-- Determines whether Iter begins a sentence. Sentence boundaries are
-- determined by Pango and should be correct for nearly any language (if
-- not, the correct fix would be to the Pango text boundary algorithms).
function Starts_Word (Iter : Gtk_Text_Iter) return Boolean;
-- Determines whether Iter begins a natural-language word. Word breaks are
-- determined by Pango and should be correct for nearly any language (if
-- not, the correct fix would be to the Pango word break algorithms).
function Toggles_Tag
(Iter : Gtk_Text_Iter;
Tag : access Gtk.Text_Tag.Gtk_Text_Tag_Record'Class) return Boolean;
-- This is equivalent to (gtk_text_iter_begins_tag () ||
-- gtk_text_iter_ends_tag ()), i.e. it tells you whether a range with Tag
-- applied to it begins *or* ends at Iter.
-- "tag": a Gtk.Text_Tag.Gtk_Text_Tag, or null
----------------------
-- GtkAda additions --
----------------------
procedure Copy (Source : Gtk_Text_Iter; Dest : out Gtk_Text_Iter);
pragma Inline (Copy);
-- Create a copy of Source.
function Get_Char (Iter : Gtk_Text_Iter) return Character;
-- Return the character immediately following Iter. If Iter is at the
-- end of the buffer, then return ASCII.NUL.
-- Note that this function assumes that the text is encoded in ASCII
-- format. If this is not the case, use the Get_Char function that
-- returns a Gunichar instead.
function Iter_Or_Null (Iter : System.Address) return System.Address;
-- Internal function for GtkAda
-------------------------------
-- Converting to/from GValue --
-------------------------------
procedure Set_Text_Iter
(Val : in out Glib.Values.GValue;
Iter : Gtk_Text_Iter);
pragma Import (C, Set_Text_Iter, "g_value_set_pointer");
-- Set the value of the given GValue to Iter.
-- Note that Iter is stored by reference, which means no copy of Iter
-- is made. Iter should remain allocated as long as Val is being used.
procedure Get_Text_Iter
(Val : Glib.Values.GValue;
Iter : out Gtk_Text_Iter);
-- Extract the iterator from the given GValue.
-- Note that the iterator returned is a copy of the iterator referenced
-- by the give GValue. Modifying the iterator returned does not modify
-- the iterator referenced by the GValue.
function Get_Slice
(Start : Gtk_Text_Iter;
The_End : Gtk_Text_Iter) return Interfaces.C.Strings.chars_ptr;
-- Same as Get_Slice above, but returns the raw C string.
-- The caller is responsible for freeing the string returned.
private
type Gtk_Text_Iter is record
Dummy1 : System.Address;
Dummy2 : System.Address;
Dummy3 : Gint;
Dummy4 : Gint;
Dummy5 : Gint;
Dummy6 : Gint;
Dummy7 : Gint;
Dummy8 : Gint;
Dummy9 : System.Address;
Dummy10 : System.Address;
Dummy11 : Gint;
Dummy12 : Gint;
Dummy13 : Gint;
Dummy14 : System.Address;
end record;
pragma Convention (C, Gtk_Text_Iter);
Null_Text_Iter : constant Gtk_Text_Iter :=
(System.Null_Address, System.Null_Address, 0, 0, 0, 0, 0, 0,
System.Null_Address, System.Null_Address, 0, 0, 0,
System.Null_Address);
end Gtk.Text_Iter;