------------------------------------------------------------------------------
-- --
-- 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/>. --
-- --
------------------------------------------------------------------------------
pragma Ada_2005;
pragma Warnings (Off, "*is already use-visible*");
with Glib; use Glib;
with Glib.Generic_Properties; use Glib.Generic_Properties;
with Glib.Object; use Glib.Object;
with Gtkada.Types; use Gtkada.Types;
with Pango.Attributes; use Pango.Attributes;
with Pango.Context; use Pango.Context;
with Pango.Enums; use Pango.Enums;
with Pango.Font; use Pango.Font;
with Pango.Tabs; use Pango.Tabs;
package Pango.Layout is
type Pango_Layout_Record is new GObject_Record with null record;
type Pango_Layout is access all Pango_Layout_Record'Class;
type Pango_Ellipsize_Mode is (
Ellipsize_None,
Ellipsize_Start,
Ellipsize_Middle,
Ellipsize_End);
pragma Convention (C, Pango_Ellipsize_Mode);
-- The Pango.Layout.Pango_Ellipsize_Mode type describes what sort of (if
-- any) ellipsization should be applied to a line of text. In the
-- ellipsization process characters are removed from the text in order to
-- make it fit to a given width and replaced with an ellipsis.
type Pango_Layout_Iter is new Glib.C_Boxed with null record;
Null_Pango_Layout_Iter : constant Pango_Layout_Iter;
function From_Object (Object : System.Address) return Pango_Layout_Iter;
function From_Object_Free (B : access Pango_Layout_Iter'Class) return Pango_Layout_Iter;
pragma Inline (From_Object_Free, From_Object);
type Pango_Layout_Line is private;
function From_Object_Free (B : access Pango_Layout_Line) return Pango_Layout_Line;
pragma Inline (From_Object_Free);
----------------------------
-- Enumeration Properties --
----------------------------
package Pango_Ellipsize_Mode_Properties is
new Generic_Internal_Discrete_Property (Pango_Ellipsize_Mode);
type Property_Pango_Ellipsize_Mode is new Pango_Ellipsize_Mode_Properties.Property;
------------------
-- Constructors --
------------------
procedure Gdk_New
(Layout : out Pango_Layout;
Context : not null access Pango.Context.Pango_Context_Record'Class);
-- Create a new Pango.Layout.Pango_Layout object with attributes
-- initialized to default values for a particular
-- Pango.Context.Pango_Context.
-- "context": a Pango.Context.Pango_Context
procedure Initialize
(Layout : not null access Pango_Layout_Record'Class;
Context : not null access Pango.Context.Pango_Context_Record'Class);
-- Create a new Pango.Layout.Pango_Layout object with attributes
-- initialized to default values for a particular
-- Pango.Context.Pango_Context.
-- "context": a Pango.Context.Pango_Context
function Pango_Layout_New
(Context : not null access Pango.Context.Pango_Context_Record'Class)
return Pango_Layout;
-- Create a new Pango.Layout.Pango_Layout object with attributes
-- initialized to default values for a particular
-- Pango.Context.Pango_Context.
-- "context": a Pango.Context.Pango_Context
function Get_Type return Glib.GType;
pragma Import (C, Get_Type, "pango_layout_get_type");
function Get_Type_Layout_Iter return Glib.GType;
pragma Import (C, Get_Type_Layout_Iter, "pango_layout_iter_get_type");
function Get_Type_Layout_Line return Glib.GType;
pragma Import (C, Get_Type_Layout_Line, "pango_layout_line_get_type");
-------------
-- Methods --
-------------
procedure Context_Changed (Layout : not null access Pango_Layout_Record);
-- Forces recomputation of any state in the Pango.Layout.Pango_Layout that
-- might depend on the layout's context. This function should be called if
-- you make changes to the context subsequent to creating the layout.
function Copy
(Layout : not null access Pango_Layout_Record) return Pango_Layout;
-- Does a deep copy-by-value of the Src layout. The attribute list, tab
-- array, and text from the original layout are all copied by value.
function Copy (Self : Pango_Layout_Iter) return Pango_Layout_Iter;
-- Copies a Pango.Layout.Pango_Layout_Iter.
-- Since: gtk+ 1.20
function Get_Alignment
(Layout : not null access Pango_Layout_Record)
return Pango.Enums.Alignment;
-- Gets the alignment for the layout: how partial lines are positioned
-- within the horizontal space available.
procedure Set_Alignment
(Layout : not null access Pango_Layout_Record;
Alignment : Pango.Enums.Alignment);
-- Sets the alignment for the layout: how partial lines are positioned
-- within the horizontal space available.
-- "alignment": the alignment
function Get_Attributes
(Layout : not null access Pango_Layout_Record)
return Pango.Attributes.Pango_Attr_List;
-- Gets the attribute list for the layout, if any.
procedure Set_Attributes
(Layout : not null access Pango_Layout_Record;
Attrs : Pango.Attributes.Pango_Attr_List);
-- Sets the text attributes for a layout object. References Attrs, so the
-- caller can unref its reference.
-- "attrs": a Pango.Attributes.Pango_Attr_List, can be null
function Get_Auto_Dir
(Layout : not null access Pango_Layout_Record) return Boolean;
-- Gets whether to calculate the bidirectional base direction for the
-- layout according to the contents of the layout. See
-- Pango.Layout.Set_Auto_Dir.
-- Since: gtk+ 1.4
procedure Set_Auto_Dir
(Layout : not null access Pango_Layout_Record;
Auto_Dir : Boolean);
-- Sets whether to calculate the bidirectional base direction for the
-- layout according to the contents of the layout; when this flag is on
-- (the default), then paragraphs in Layout that begin with strong
-- right-to-left characters (Arabic and Hebrew principally), will have
-- right-to-left layout, paragraphs with letters from other scripts will
-- have left-to-right layout. Paragraphs with only neutral characters get
-- their direction from the surrounding paragraphs.
-- When False, the choice between left-to-right and right-to-left layout
-- is done according to the base direction of the layout's
-- Pango.Context.Pango_Context. (See Pango.Context.Set_Base_Dir).
-- When the auto-computed direction of a paragraph differs from the base
-- direction of the context, the interpretation of
-- Pango.Enums.Pango_Align_Left and Pango.Enums.Pango_Align_Right are
-- swapped.
-- Since: gtk+ 1.4
-- "auto_dir": if True, compute the bidirectional base direction from the
-- layout's contents.
function Get_Baseline
(Layout : not null access Pango_Layout_Record) return Gint;
-- Gets the Y position of baseline of the first line in Layout.
-- Since: gtk+ 1.22
function Get_Baseline (Self : Pango_Layout_Iter) return Gint;
-- Gets the Y position of the current line's baseline, in layout
-- coordinates (origin at top left of the entire layout).
function Get_Character_Count
(Layout : not null access Pango_Layout_Record) return Gint;
-- Returns the number of Unicode characters in the the text of Layout.
-- Since: gtk+ 1.30
function Get_Context
(Layout : not null access Pango_Layout_Record)
return Pango.Context.Pango_Context;
-- Retrieves the Pango.Context.Pango_Context used for this layout.
procedure Get_Cursor_Pos
(Layout : not null access Pango_Layout_Record;
Index : Gint;
Strong_Pos : out Pango_Rectangle;
Weak_Pos : out Pango_Rectangle);
-- Given an index within a layout, determines the positions that of the
-- strong and weak cursors if the insertion point is at that index. The
-- position of each cursor is stored as a zero-width rectangle. The strong
-- cursor location is the location where characters of the directionality
-- equal to the base direction of the layout are inserted. The weak cursor
-- location is the location where characters of the directionality opposite
-- to the base direction of the layout are inserted.
-- "index_": the byte index of the cursor
-- "strong_pos": location to store the strong cursor position (may be
-- null)
-- "weak_pos": location to store the weak cursor position (may be null)
function Get_Ellipsize
(Layout : not null access Pango_Layout_Record)
return Pango_Ellipsize_Mode;
-- Gets the type of ellipsization being performed for Layout. See
-- Pango.Layout.Set_Ellipsize
-- Since: gtk+ 1.6
procedure Set_Ellipsize
(Layout : not null access Pango_Layout_Record;
Ellipsize : Pango_Ellipsize_Mode);
-- Sets the type of ellipsization being performed for Layout. Depending on
-- the ellipsization mode Ellipsize text is removed from the start, middle,
-- or end of text so they fit within the width and height of layout set
-- with Pango.Layout.Set_Width and Pango.Layout.Set_Height.
-- If the layout contains characters such as newlines that force it to be
-- layed out in multiple paragraphs, then whether each paragraph is
-- ellipsized separately or the entire layout is ellipsized as a whole
-- depends on the set height of the layout. See Pango.Layout.Set_Height for
-- details.
-- Since: gtk+ 1.6
-- "ellipsize": the new ellipsization mode for Layout
procedure Get_Extents
(Layout : not null access Pango_Layout_Record;
Ink_Rect : out Pango_Rectangle;
Logical_Rect : out Pango_Rectangle);
-- Computes the logical and ink extents of Layout. Logical extents are
-- usually what you want for positioning things. Note that both extents may
-- have non-zero x and y. You may want to use those to offset where you
-- render the layout. Not doing that is a very typical bug that shows up as
-- right-to-left layouts not being correctly positioned in a layout with a
-- set width.
-- The extents are given in layout coordinates and in Pango units; layout
-- coordinates begin at the top left corner of the layout.
-- "ink_rect": rectangle used to store the extents of the layout as drawn
-- or null to indicate that the result is not needed.
-- "logical_rect": rectangle used to store the logical extents of the
-- layout or null to indicate that the result is not needed.
function Get_Font_Description
(Layout : not null access Pango_Layout_Record)
return Pango.Font.Pango_Font_Description;
-- Gets the font description for the layout, if any.
-- Since: gtk+ 1.8
procedure Set_Font_Description
(Layout : not null access Pango_Layout_Record;
Desc : Pango.Font.Pango_Font_Description);
-- Sets the default font description for the layout. If no font
-- description is set on the layout, the font description from the layout's
-- context is used.
-- "desc": the new Pango.Font.Pango_Font_Description, or null to unset the
-- current font description
function Get_Height
(Layout : not null access Pango_Layout_Record) return Gint;
-- Gets the height of layout used for ellipsization. See
-- Pango.Layout.Set_Height for details.
-- Since: gtk+ 1.20
procedure Set_Height
(Layout : not null access Pango_Layout_Record;
Height : Gint);
-- Sets the height to which the Pango.Layout.Pango_Layout should be
-- ellipsized at. There are two different behaviors, based on whether
-- Height is positive or negative.
-- If Height is positive, it will be the maximum height of the layout.
-- Only lines would be shown that would fit, and if there is any text
-- omitted, an ellipsis added. At least one line is included in each
-- paragraph regardless of how small the height value is. A value of zero
-- will render exactly one line for the entire layout.
-- If Height is negative, it will be the (negative of) maximum number of
-- lines per paragraph. That is, the total number of lines shown may well
-- be more than this value if the layout contains multiple paragraphs of
-- text. The default value of -1 means that first line of each paragraph is
-- ellipsized. This behvaior may be changed in the future to act per layout
-- instead of per paragraph. File a bug against pango at <ulink
-- url="http://bugzilla.gnome.org/">http://bugzilla.gnome.org/</ulink> if
-- your code relies on this behavior.
-- Height setting only has effect if a positive width is set on Layout and
-- ellipsization mode of Layout is not Pango.Layout.Ellipsize_None. The
-- behavior is undefined if a height other than -1 is set and ellipsization
-- mode is set to Pango.Layout.Ellipsize_None, and may change in the
-- future.
-- Since: gtk+ 1.20
-- "height": the desired height of the layout in Pango units if positive,
-- or desired number of lines if negative.
function Get_Indent
(Layout : not null access Pango_Layout_Record) return Gint;
-- Gets the paragraph indent width in Pango units. A negative value
-- indicates a hanging indentation.
procedure Set_Indent
(Layout : not null access Pango_Layout_Record;
Indent : Gint);
-- Sets the width in Pango units to indent each paragraph. A negative
-- value of Indent will produce a hanging indentation. That is, the first
-- line will have the full width, and subsequent lines will be indented by
-- the absolute value of Indent.
-- The indent setting is ignored if layout alignment is set to
-- Pango.Enums.Pango_Align_Center.
-- "indent": the amount by which to indent.
function Get_Iter
(Layout : not null access Pango_Layout_Record'Class)
return Pango_Layout_Iter;
-- Returns an iterator to iterate over the visual extents of the layout.
function Get_Justify
(Layout : not null access Pango_Layout_Record) return Boolean;
-- Gets whether each complete line should be stretched to fill the entire
-- width of the layout.
procedure Set_Justify
(Layout : not null access Pango_Layout_Record;
Justify : Boolean);
-- Sets whether each complete line should be stretched to fill the entire
-- width of the layout. This stretching is typically done by adding
-- whitespace, but for some scripts (such as Arabic), the justification may
-- be done in more complex ways, like extending the characters.
-- Note that this setting is not implemented and so is ignored in Pango
-- older than 1.18.
-- "justify": whether the lines in the layout should be justified.
function Get_Line
(Layout : not null access Pango_Layout_Record;
Line : Gint) return Pango_Layout_Line;
-- Retrieves a particular line from a Pango.Layout.Pango_Layout.
-- Use the faster Pango.Layout.Get_Line_Readonly if you do not plan to
-- modify the contents of the line (glyphs, glyph widths, etc.).
-- "line": the index of a line, which must be between 0 and
-- 'pango_layout_get_line_count(layout) - 1', inclusive.
function Get_Line (Self : Pango_Layout_Iter) return Pango_Layout_Line;
-- Gets the current line.
-- Use the faster Pango.Layout.Get_Line_Readonly if you do not plan to
-- modify the contents of the line (glyphs, glyph widths, etc.).
function Get_Line_Count
(Layout : not null access Pango_Layout_Record) return Gint;
-- Retrieves the count of lines for the Layout.
function Get_Line_Readonly
(Layout : not null access Pango_Layout_Record;
Line : Gint) return Pango_Layout_Line;
-- Retrieves a particular line from a Pango.Layout.Pango_Layout.
-- This is a faster alternative to Pango.Layout.Get_Line, but the user is
-- not expected to modify the contents of the line (glyphs, glyph widths,
-- etc.).
-- Since: gtk+ 1.16
-- "line": the index of a line, which must be between 0 and
-- 'pango_layout_get_line_count(layout) - 1', inclusive.
function Get_Line_Readonly
(Self : Pango_Layout_Iter) return Pango_Layout_Line;
-- Gets the current line for read-only access.
-- This is a faster alternative to Pango.Layout.Get_Line, but the user is
-- not expected to modify the contents of the line (glyphs, glyph widths,
-- etc.).
-- Since: gtk+ 1.16
procedure Get_Pixel_Extents
(Layout : not null access Pango_Layout_Record;
Ink_Rect : out Pango_Rectangle;
Logical_Rect : out Pango_Rectangle);
-- Computes the logical and ink extents of Layout in device units. This
-- function just calls Pango.Layout.Get_Extents followed by two
-- pango_extents_to_pixels calls, rounding Ink_Rect and Logical_Rect such
-- that the rounded rectangles fully contain the unrounded one (that is,
-- passes them as first argument to pango_extents_to_pixels).
-- "ink_rect": rectangle used to store the extents of the layout as drawn
-- or null to indicate that the result is not needed.
-- "logical_rect": rectangle used to store the logical extents of the
-- layout or null to indicate that the result is not needed.
procedure Get_Pixel_Size
(Layout : not null access Pango_Layout_Record;
Width : out Gint;
Height : out Gint);
-- Determines the logical width and height of a Pango.Layout.Pango_Layout
-- in device units. (pango_layout_get_size returns the width and height
-- scaled by PANGO_SCALE.) This is simply a convenience function around
-- Pango.Layout.Get_Pixel_Extents.
-- "width": location to store the logical width, or null
-- "height": location to store the logical height, or null
function Get_Serial
(Layout : not null access Pango_Layout_Record) return Guint;
-- Returns the current serial number of Layout. The serial number is
-- initialized to an small number larger than zero when a new layout is
-- created and is increased whenever the layout is changed using any of the
-- setter functions, or the Pango.Context.Pango_Context it uses has
-- changed. The serial may wrap, but will never have the value 0. Since it
-- can wrap, never compare it with "less than", always use "not equals".
-- This can be used to automatically detect changes to a
-- Pango.Layout.Pango_Layout, and is useful for example to decide whether a
-- layout needs redrawing. To force the serial to be increased, use
-- Pango.Layout.Context_Changed.
-- Since: gtk+ 1.32.4
function Get_Single_Paragraph_Mode
(Layout : not null access Pango_Layout_Record) return Boolean;
-- Obtains the value set by Pango.Layout.Set_Single_Paragraph_Mode.
procedure Set_Single_Paragraph_Mode
(Layout : not null access Pango_Layout_Record;
Setting : Boolean);
-- If Setting is True, do not treat newlines and similar characters as
-- paragraph separators; instead, keep all text in a single paragraph, and
-- display a glyph for paragraph separator characters. Used when you want
-- to allow editing of newlines on a single text line.
-- "setting": new setting
procedure Get_Size
(Layout : not null access Pango_Layout_Record;
Width : out Gint;
Height : out Gint);
-- Determines the logical width and height of a Pango.Layout.Pango_Layout
-- in Pango units (device units scaled by PANGO_SCALE). This is simply a
-- convenience function around Pango.Layout.Get_Extents.
-- "width": location to store the logical width, or null
-- "height": location to store the logical height, or null
function Get_Spacing
(Layout : not null access Pango_Layout_Record) return Gint;
-- Gets the amount of spacing between the lines of the layout.
procedure Set_Spacing
(Layout : not null access Pango_Layout_Record;
Spacing : Gint);
-- Sets the amount of spacing in Pango unit between the lines of the
-- layout.
-- "spacing": the amount of spacing
function Get_Tabs
(Layout : not null access Pango_Layout_Record)
return Pango.Tabs.Pango_Tab_Array;
-- Gets the current Pango.Tabs.Pango_Tab_Array used by this layout. If no
-- Pango.Tabs.Pango_Tab_Array has been set, then the default tabs are in
-- use and null is returned. Default tabs are every 8 spaces. The return
-- value should be freed with Pango.Tabs.Free.
procedure Set_Tabs
(Layout : not null access Pango_Layout_Record;
Tabs : Pango.Tabs.Pango_Tab_Array);
-- Sets the tabs to use for Layout, overriding the default tabs (by
-- default, tabs are every 8 spaces). If Tabs is null, the default tabs are
-- reinstated. Tabs is copied into the layout; you must free your copy of
-- Tabs yourself.
-- "tabs": a Pango.Tabs.Pango_Tab_Array, or null
function Get_Text
(Layout : not null access Pango_Layout_Record) return UTF8_String;
-- Gets the text in the layout. The returned text should not be freed or
-- modified.
procedure Set_Text
(Layout : not null access Pango_Layout_Record;
Text : UTF8_String);
-- Sets the text of the layout.
-- Note that if you have used Pango.Layout.Set_Markup or
-- Pango.Layout.Set_Markup_With_Accel on Layout before, you may want to
-- call Pango.Layout.Set_Attributes to clear the attributes set on the
-- layout from the markup as this function does not clear attributes.
-- "text": a valid UTF-8 string
function Get_Unknown_Glyphs_Count
(Layout : not null access Pango_Layout_Record) return Gint;
-- Counts the number unknown glyphs in Layout. That is, zero if glyphs for
-- all characters in the layout text were found, or more than zero
-- otherwise.
-- This function can be used to determine if there are any fonts available
-- to render all characters in a certain string, or when used in
-- combination with Pango.Enums.Pango_Attr_Fallback, to check if a certain
-- font supports all the characters in the string.
-- Since: gtk+ 1.16
function Get_Width
(Layout : not null access Pango_Layout_Record) return Gint;
-- Gets the width to which the lines of the Pango.Layout.Pango_Layout
-- should wrap.
procedure Set_Width
(Layout : not null access Pango_Layout_Record;
Width : Gint);
-- Sets the width to which the lines of the Pango.Layout.Pango_Layout
-- should wrap or ellipsized. The default value is -1: no width set.
-- "width": the desired width in Pango units, or -1 to indicate that no
-- wrapping or ellipsization should be performed.
function Get_Wrap
(Layout : not null access Pango_Layout_Record)
return Pango.Enums.Wrap_Mode;
-- Gets the wrap mode for the layout.
-- Use Pango.Layout.Is_Wrapped to query whether any paragraphs were
-- actually wrapped.
procedure Set_Wrap
(Layout : not null access Pango_Layout_Record;
Wrap : Pango.Enums.Wrap_Mode);
-- Sets the wrap mode; the wrap mode only has effect if a width is set on
-- the layout with Pango.Layout.Set_Width. To turn off wrapping, set the
-- width to -1.
-- "wrap": the wrap mode
procedure Index_To_Line_X
(Layout : not null access Pango_Layout_Record;
Index : Gint;
Trailing : Boolean;
Line : out Gint;
X_Pos : out Gint);
-- Converts from byte Index_ within the Layout to line and X position. (X
-- position is measured from the left edge of the line)
-- "index_": the byte index of a grapheme within the layout.
-- "trailing": an integer indicating the edge of the grapheme to retrieve
-- the position of. If 0, the trailing edge of the grapheme, if > 0, the
-- leading of the grapheme.
-- "line": location to store resulting line index. (which will between 0
-- and pango_layout_get_line_count(layout) - 1), or null
-- "x_pos": location to store resulting position within line (PANGO_SCALE
-- units per device unit), or null
procedure Index_To_Pos
(Layout : not null access Pango_Layout_Record;
Index : Gint;
Pos : out Pango_Rectangle);
-- Converts from an index within a Pango.Layout.Pango_Layout to the
-- onscreen position corresponding to the grapheme at that index, which is
-- represented as rectangle. Note that 'pos->x' is always the leading edge
-- of the grapheme and 'pos->x + pos->width' the trailing edge of the
-- grapheme. If the directionality of the grapheme is right-to-left, then
-- 'pos->width' will be negative.
-- "index_": byte index within Layout
-- "pos": rectangle in which to store the position of the grapheme
function Is_Ellipsized
(Layout : not null access Pango_Layout_Record) return Boolean;
-- Queries whether the layout had to ellipsize any paragraphs.
-- This returns True if the ellipsization mode for Layout is not
-- Pango.Layout.Ellipsize_None, a positive width is set on Layout, and
-- there are paragraphs exceeding that width that have to be ellipsized.
-- Since: gtk+ 1.16
function Is_Wrapped
(Layout : not null access Pango_Layout_Record) return Boolean;
-- Queries whether the layout had to wrap any paragraphs.
-- This returns True if a positive width is set on Layout, ellipsization
-- mode of Layout is set to Pango.Layout.Ellipsize_None, and there are
-- paragraphs exceeding the layout width that have to be wrapped.
-- Since: gtk+ 1.16
procedure Move_Cursor_Visually
(Layout : not null access Pango_Layout_Record;
Strong : Boolean;
Old_Index : Gint;
Old_Trailing : Gint;
Direction : Gint;
New_Index : out Gint;
New_Trailing : out Gint);
-- Computes a new cursor position from an old position and a count of
-- positions to move visually. If Direction is positive, then the new
-- strong cursor position will be one position to the right of the old
-- cursor position. If Direction is negative, then the new strong cursor
-- position will be one position to the left of the old cursor position.
-- In the presence of bidirectional text, the correspondence between
-- logical and visual order will depend on the direction of the current
-- run, and there may be jumps when the cursor is moved off of the end of a
-- run.
-- Motion here is in cursor positions, not in characters, so a single call
-- to Pango.Layout.Move_Cursor_Visually may move the cursor over multiple
-- characters when multiple characters combine to form a single grapheme.
-- "strong": whether the moving cursor is the strong cursor or the weak
-- cursor. The strong cursor is the cursor corresponding to text insertion
-- in the base direction for the layout.
-- "old_index": the byte index of the grapheme for the old index
-- "old_trailing": if 0, the cursor was at the trailing edge of the
-- grapheme indicated by Old_Index, if > 0, the cursor was at the leading
-- edge.
-- "direction": direction to move cursor. A negative value indicates
-- motion to the left.
-- "new_index": location to store the new cursor byte index. A value of -1
-- indicates that the cursor has been moved off the beginning of the
-- layout. A value of G_MAXINT indicates that the cursor has been moved off
-- the end of the layout.
-- "new_trailing": number of characters to move forward from the location
-- returned for New_Index to get the position where the cursor should be
-- displayed. This allows distinguishing the position at the beginning of
-- one line from the position at the end of the preceding line. New_Index
-- is always on the line where the cursor should be displayed.
procedure Set_Markup
(Layout : not null access Pango_Layout_Record;
Markup : UTF8_String);
-- Same as Pango.Layout.Set_Markup_With_Accel, but the markup text isn't
-- scanned for accelerators.
-- "markup": marked-up text
procedure Set_Markup_With_Accel
(Layout : not null access Pango_Layout_Record;
Markup : UTF8_String;
Length : Gint;
Accel_Marker : Gunichar;
Accel_Char : out Gunichar);
-- Sets the layout text and attribute list from marked-up text (see <link
-- linkend="PangoMarkupFormat">markup format</link>). Replaces the current
-- text and attribute list.
-- If Accel_Marker is nonzero, the given character will mark the character
-- following it as an accelerator. For example, Accel_Marker might be an
-- ampersand or underscore. All characters marked as an accelerator will
-- receive a Pango.Enums.Pango_Underline_Low attribute, and the first
-- character so marked will be returned in Accel_Char. Two Accel_Marker
-- characters following each other produce a single literal Accel_Marker
-- character.
-- "markup": marked-up text (see <link linkend="PangoMarkupFormat">markup
-- format</link>)
-- "length": length of marked-up text in bytes, or -1 if Markup is
-- null-terminated
-- "accel_marker": marker for accelerators in the text
-- "accel_char": return location for first located accelerator, or null
procedure Xy_To_Index
(Layout : not null access Pango_Layout_Record;
X : Gint;
Y : Gint;
Index : out Gint;
Trailing : out Gint;
Exact : out Boolean);
-- Converts from X and Y position within a layout to the byte index to the
-- character at that logical position. If the Y position is not inside the
-- layout, the closest position is chosen (the position will be clamped
-- inside the layout). If the X position is not within the layout, then the
-- start or the end of the line is chosen as described for
-- pango_layout_x_to_index. If either the X or Y positions were not inside
-- the layout, then the function returns False; on an exact hit, it returns
-- True.
-- "x": the X offset (in Pango units) from the left edge of the layout.
-- "y": the Y offset (in Pango units) from the top edge of the layout
-- "index_": location to store calculated byte index
-- "trailing": location to store a integer indicating where in the
-- grapheme the user clicked. It will either be zero, or the number of
-- characters in the grapheme. 0 represents the trailing edge of the
-- grapheme.
function At_Last_Line (Self : Pango_Layout_Iter) return Boolean;
-- Determines whether Iter is on the last line of the layout.
procedure Free (Self : Pango_Layout_Iter);
-- Frees an iterator that's no longer in use.
procedure Get_Char_Extents
(Self : Pango_Layout_Iter;
Logical_Rect : out Pango_Rectangle);
-- Gets the extents of the current character, in layout coordinates
-- (origin is the top left of the entire layout). Only logical extents can
-- sensibly be obtained for characters; ink extents make sense only down to
-- the level of clusters.
-- "logical_rect": rectangle to fill with logical extents
procedure Get_Cluster_Extents
(Self : Pango_Layout_Iter;
Ink_Rect : out Pango_Rectangle;
Logical_Rect : out Pango_Rectangle);
-- Gets the extents of the current cluster, in layout coordinates (origin
-- is the top left of the entire layout).
-- "ink_rect": rectangle to fill with ink extents, or null
-- "logical_rect": rectangle to fill with logical extents, or null
function Get_Index (Self : Pango_Layout_Iter) return Gint;
-- Gets the current byte index. Note that iterating forward by char moves
-- in visual order, not logical order, so indexes may not be sequential.
-- Also, the index may be equal to the length of the text in the layout, if
-- on the null run (see pango_layout_iter_get_run).
function Get_Layout (Self : Pango_Layout_Iter) return Pango_Layout;
-- Gets the layout associated with a Pango.Layout.Pango_Layout_Iter.
-- Since: gtk+ 1.20
procedure Get_Layout_Extents
(Self : Pango_Layout_Iter;
Ink_Rect : out Pango_Rectangle;
Logical_Rect : out Pango_Rectangle);
-- Obtains the extents of the Pango.Layout.Pango_Layout being iterated
-- over. Ink_Rect or Logical_Rect can be null if you aren't interested in
-- them.
-- "ink_rect": rectangle to fill with ink extents, or null
-- "logical_rect": rectangle to fill with logical extents, or null
procedure Get_Line_Extents
(Self : Pango_Layout_Iter;
Ink_Rect : out Pango_Rectangle;
Logical_Rect : out Pango_Rectangle);
-- Obtains the extents of the current line. Ink_Rect or Logical_Rect can
-- be null if you aren't interested in them. Extents are in layout
-- coordinates (origin is the top-left corner of the entire
-- Pango.Layout.Pango_Layout). Thus the extents returned by this function
-- will be the same width/height but not at the same x/y as the extents
-- returned from pango_layout_line_get_extents.
-- "ink_rect": rectangle to fill with ink extents, or null
-- "logical_rect": rectangle to fill with logical extents, or null
procedure Get_Line_Yrange
(Self : Pango_Layout_Iter;
Y0 : out Gint;
Y1 : out Gint);
-- Divides the vertical space in the Pango.Layout.Pango_Layout being
-- iterated over between the lines in the layout, and returns the space
-- belonging to the current line. A line's range includes the line's
-- logical extents, plus half of the spacing above and below the line, if
-- Pango.Layout.Set_Spacing has been called to set layout spacing. The Y
-- positions are in layout coordinates (origin at top left of the entire
-- layout).
-- "y0_": start of line, or null
-- "y1_": end of line, or null
procedure Get_Run_Extents
(Self : Pango_Layout_Iter;
Ink_Rect : out Pango_Rectangle;
Logical_Rect : out Pango_Rectangle);
-- Gets the extents of the current run in layout coordinates (origin is
-- the top left of the entire layout).
-- "ink_rect": rectangle to fill with ink extents, or null
-- "logical_rect": rectangle to fill with logical extents, or null
function Next_Char (Self : Pango_Layout_Iter) return Boolean;
-- Moves Iter forward to the next character in visual order. If Iter was
-- already at the end of the layout, returns False.
function Next_Cluster (Self : Pango_Layout_Iter) return Boolean;
-- Moves Iter forward to the next cluster in visual order. If Iter was
-- already at the end of the layout, returns False.
function Next_Line (Self : Pango_Layout_Iter) return Boolean;
-- Moves Iter forward to the start of the next line. If Iter is already on
-- the last line, returns False.
function Next_Run (Self : Pango_Layout_Iter) return Boolean;
-- Moves Iter forward to the next run in visual order. If Iter was already
-- at the end of the layout, returns False.
----------------------
-- GtkAda additions --
----------------------
function Get_Text (Layout : access Pango_Layout_Record)
return Gtkada.Types.Chars_Ptr;
-- Same a Get_Text, but return directly the C string, which is more
-- efficient. The returned value should not be freed or modified.
private
type Pango_Layout_Line is record
Layout : System.Address;
Start_Index : Gint;
Length : Gint;
Runs : System.Address;
Is_Paragraph_Start : Guint;
Resolved_Dir : Guint;
end record;
pragma Convention (C, Pango_Layout_Line);
Null_Pango_Layout_Iter : constant Pango_Layout_Iter := (Glib.C_Boxed with null record);
end Pango.Layout;