------------------------------------------------------------------------------
-- --
-- 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>
-- Widget that displays any object that implements the
-- Gtk.Tree_Model.Gtk_Tree_Model interface.
--
-- Please refer to the <link linkend="TreeWidget">tree widget conceptual
-- overview</link> for an overview of all the objects and data types related
-- to the tree widget and how they work together.
--
-- Several different coordinate systems are exposed in the GtkTreeView API.
-- These are:
--
-- <inlinegraphic fileref="tree-view-coordinates.png"
-- format="PNG"></inlinegraphic>
-- == Coordinate systems in GtkTreeView API ==
--
-- 'Widget coordinates'
--
-- * Coordinates relative to the widget (usually 'widget->window').
--
-- 'Bin window coordinates'
--
-- * Coordinates relative to the window that GtkTreeView renders to.
--
-- 'Tree coordinates'
--
-- * Coordinates relative to the entire scrollable area of GtkTreeView.
-- These coordinates start at (0, 0) for row 0 of the tree.
--
-- Several functions are available for converting between the different
-- coordinate systems. The most common translations are between widget and bin
-- window coordinates and between bin window and tree coordinates. For the
-- former you can use Gtk.Tree_View.Convert_Widget_To_Bin_Window_Coords (and
-- vice versa), for the latter Gtk.Tree_View.Convert_Bin_Window_To_Tree_Coords
-- (and vice versa).
--
-- == GtkTreeView as GtkBuildable ==
--
-- The GtkTreeView implementation of the GtkBuildable interface accepts
-- Gtk.Tree_View_Column.Gtk_Tree_View_Column objects as <child> elements and
-- exposes the internal Gtk.Tree_Selection.Gtk_Tree_Selection in UI
-- definitions.
--
-- == A UI definition fragment with GtkTreeView ==
--
-- <object class="GtkTreeView" id="treeview">
-- <property name="model">liststore1</property>
-- <child>
-- <object class="GtkTreeViewColumn" id="test-column">
-- <property name="title">Test</property>
-- <child>
-- <object class="GtkCellRendererText" id="test-renderer"/>
-- <attributes>
-- <attribute name="text">1</attribute>
-- </attributes>
-- </child>
-- </object>
-- </child>
-- <child internal-child="selection">
-- <object class="GtkTreeSelection" id="selection">
-- <signal name="changed" handler="on_treeview_selection_changed"/>
-- </object>
-- </child>
-- </object>
-- </description>
pragma Ada_2005;
pragma Warnings (Off, "*is already use-visible*");
with Cairo; use Cairo;
with Gdk; use Gdk;
with Gdk.Drag_Contexts; use Gdk.Drag_Contexts;
with Gdk.Rectangle; use Gdk.Rectangle;
with Gdk.Types; use Gdk.Types;
with Glib; use Glib;
with Glib.Generic_Properties; use Glib.Generic_Properties;
with Glib.Object; use Glib.Object;
with Glib.Properties; use Glib.Properties;
with Glib.Types; use Glib.Types;
with Gtk.Adjustment; use Gtk.Adjustment;
with Gtk.Buildable; use Gtk.Buildable;
with Gtk.Cell_Renderer; use Gtk.Cell_Renderer;
with Gtk.Container; use Gtk.Container;
with Gtk.Enums; use Gtk.Enums;
with Gtk.GEntry; use Gtk.GEntry;
with Gtk.Scrollable; use Gtk.Scrollable;
with Gtk.Target_List; use Gtk.Target_List;
with Gtk.Tooltip; use Gtk.Tooltip;
with Gtk.Tree_Model; use Gtk.Tree_Model;
with Gtk.Tree_Selection; use Gtk.Tree_Selection;
with Gtk.Tree_View_Column; use Gtk.Tree_View_Column;
with Gtk.Widget; use Gtk.Widget;
package Gtk.Tree_View is
type Gtk_Tree_View_Record is new Gtk_Container_Record with null record;
type Gtk_Tree_View is access all Gtk_Tree_View_Record'Class;
type Gtk_Tree_View_Drop_Position is (
Tree_View_Drop_Before,
Tree_View_Drop_After,
Tree_View_Drop_Into_Or_Before,
Tree_View_Drop_Into_Or_After);
pragma Convention (C, Gtk_Tree_View_Drop_Position);
-- An enum for determining where a dropped row goes.
---------------
-- Callbacks --
---------------
type Gtk_Tree_Cell_Data_Func is access procedure
(Tree_Column : not null access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class;
Cell : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class;
Tree_Model : Gtk.Tree_Model.Gtk_Tree_Model;
Iter : Gtk.Tree_Model.Gtk_Tree_Iter);
-- A function to set the properties of a cell instead of just using the
-- straight mapping between the cell and the model. This is useful for
-- customizing the cell renderer. For example, a function might get an
-- integer from the Tree_Model, and render it to the "text" attribute of
-- "cell" by converting it to its written equivilent. This is set by
-- calling gtk_tree_view_column_set_cell_data_func
-- "tree_column": A Gtk.Tree_View_Column.Gtk_Tree_View_Column
-- "cell": The Gtk.Cell_Renderer.Gtk_Cell_Renderer that is being rendered
-- by Tree_Column
-- "tree_model": The Gtk.Tree_Model.Gtk_Tree_Model being rendered
-- "iter": A Gtk.Tree_Model.Gtk_Tree_Iter of the current row rendered
type Gtk_Tree_View_Mapping_Func is access procedure
(Tree_View : not null access Gtk_Tree_View_Record'Class;
Path : Gtk.Tree_Model.Gtk_Tree_Path);
-- Function used for Gtk.Tree_View.Map_Expanded_Rows.
-- "tree_view": A Gtk.Tree_View.Gtk_Tree_View
-- "path": The path that's expanded
type Gtk_Tree_View_Column_Drop_Func is access function
(Tree_View : not null access Gtk_Tree_View_Record'Class;
Column : not null access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class;
Prev_Column : not null access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class;
Next_Column : not null access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class)
return Boolean;
-- Function type for determining whether Column can be dropped in a
-- particular spot (as determined by Prev_Column and Next_Column). In left
-- to right locales, Prev_Column is on the left of the potential drop spot,
-- and Next_Column is on the right. In right to left mode, this is
-- reversed. This function should return True if the spot is a valid drop
-- spot. Please note that returning True does not actually indicate that
-- the column drop was made, but is meant only to indicate a possible drop
-- spot to the user.
-- "tree_view": A Gtk.Tree_View.Gtk_Tree_View
-- "column": The Gtk.Tree_View_Column.Gtk_Tree_View_Column being dragged
-- "prev_column": A Gtk.Tree_View_Column.Gtk_Tree_View_Column on one side
-- of Column
-- "next_column": A Gtk.Tree_View_Column.Gtk_Tree_View_Column on the other
-- side of Column
type Gtk_Tree_Destroy_Count_Func is access procedure
(Tree_View : not null access Gtk_Tree_View_Record'Class;
Path : Gtk.Tree_Model.Gtk_Tree_Path;
Children : Gint);
type Gtk_Tree_View_Row_Separator_Func is access function
(Model : Gtk.Tree_Model.Gtk_Tree_Model;
Iter : Gtk.Tree_Model.Gtk_Tree_Iter) return Boolean;
-- Function type for determining whether the row pointed to by Iter should
-- be rendered as a separator. A common way to implement this is to have a
-- boolean column in the model, whose values the
-- Gtk.Tree_View.Gtk_Tree_View_Row_Separator_Func returns.
-- "model": the Gtk.Tree_Model.Gtk_Tree_Model
-- "iter": a Gtk.Tree_Model.Gtk_Tree_Iter pointing at a row in Model
type Gtk_Tree_View_Search_Equal_Func is access function
(Model : Gtk.Tree_Model.Gtk_Tree_Model;
Column : Gint;
Key : UTF8_String;
Iter : Gtk.Tree_Model.Gtk_Tree_Iter) return Boolean;
-- A function used for checking whether a row in Model matches a search
-- key string entered by the user. Note the return value is reversed from
-- what you would normally expect, though it has some similarity to strcmp
-- returning 0 for equal strings.
-- "model": the Gtk.Tree_Model.Gtk_Tree_Model being searched
-- "column": the search column set by Gtk.Tree_View.Set_Search_Column
-- "key": the key string to compare with
-- "iter": a Gtk.Tree_Model.Gtk_Tree_Iter pointing the row of Model that
-- should be compared with Key.
type Gtk_Tree_View_Search_Position_Func is access procedure
(Tree_View : not null access Gtk_Tree_View_Record'Class;
Search_Dialog : not null access Gtk.Widget.Gtk_Widget_Record'Class);
----------------------------
-- Enumeration Properties --
----------------------------
package Gtk_Tree_View_Drop_Position_Properties is
new Generic_Internal_Discrete_Property (Gtk_Tree_View_Drop_Position);
type Property_Gtk_Tree_View_Drop_Position is new Gtk_Tree_View_Drop_Position_Properties.Property;
------------------
-- Constructors --
------------------
procedure Gtk_New (Tree_View : out Gtk_Tree_View);
procedure Initialize
(Tree_View : not null access Gtk_Tree_View_Record'Class);
-- Creates a new Gtk.Tree_View.Gtk_Tree_View widget.
function Gtk_Tree_View_New return Gtk_Tree_View;
-- Creates a new Gtk.Tree_View.Gtk_Tree_View widget.
procedure Gtk_New
(Tree_View : out Gtk_Tree_View;
Model : Gtk.Tree_Model.Gtk_Tree_Model);
procedure Initialize
(Tree_View : not null access Gtk_Tree_View_Record'Class;
Model : Gtk.Tree_Model.Gtk_Tree_Model);
-- Creates a new Gtk.Tree_View.Gtk_Tree_View widget with the model
-- initialized to Model.
-- "model": the model.
function Gtk_Tree_View_New_With_Model
(Model : Gtk.Tree_Model.Gtk_Tree_Model) return Gtk_Tree_View;
-- Creates a new Gtk.Tree_View.Gtk_Tree_View widget with the model
-- initialized to Model.
-- "model": the model.
function Get_Type return Glib.GType;
pragma Import (C, Get_Type, "gtk_tree_view_get_type");
-------------
-- Methods --
-------------
function Append_Column
(Tree_View : not null access Gtk_Tree_View_Record;
Column : not null access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class)
return Gint;
-- Appends Column to the list of columns. If Tree_View has "fixed_height"
-- mode enabled, then Column must have its "sizing" property set to be
-- GTK_TREE_VIEW_COLUMN_FIXED.
-- "column": The Gtk.Tree_View_Column.Gtk_Tree_View_Column to add.
procedure Collapse_All (Tree_View : not null access Gtk_Tree_View_Record);
-- Recursively collapses all visible, expanded nodes in Tree_View.
function Collapse_Row
(Tree_View : not null access Gtk_Tree_View_Record;
Path : Gtk.Tree_Model.Gtk_Tree_Path) return Boolean;
-- Collapses a row (hides its child rows, if they exist).
-- "path": path to a row in the Tree_View
procedure Columns_Autosize
(Tree_View : not null access Gtk_Tree_View_Record);
-- Resizes all columns to their optimal width. Only works after the
-- treeview has been realized.
procedure Convert_Bin_Window_To_Tree_Coords
(Tree_View : not null access Gtk_Tree_View_Record;
Bx : Gint;
By : Gint;
Tx : out Gint;
Ty : out Gint);
-- Converts bin_window coordinates to coordinates for the tree (the full
-- scrollable area of the tree).
-- Since: gtk+ 2.12
-- "bx": X coordinate relative to bin_window
-- "by": Y coordinate relative to bin_window
-- "tx": return location for tree X coordinate
-- "ty": return location for tree Y coordinate
procedure Convert_Bin_Window_To_Widget_Coords
(Tree_View : not null access Gtk_Tree_View_Record;
Bx : Gint;
By : Gint;
Wx : out Gint;
Wy : out Gint);
-- Converts bin_window coordinates (see Gtk.Tree_View.Get_Bin_Window) to
-- widget relative coordinates.
-- Since: gtk+ 2.12
-- "bx": bin_window X coordinate
-- "by": bin_window Y coordinate
-- "wx": return location for widget X coordinate
-- "wy": return location for widget Y coordinate
procedure Convert_Tree_To_Bin_Window_Coords
(Tree_View : not null access Gtk_Tree_View_Record;
Tx : Gint;
Ty : Gint;
Bx : out Gint;
By : out Gint);
-- Converts tree coordinates (coordinates in full scrollable area of the
-- tree) to bin_window coordinates.
-- Since: gtk+ 2.12
-- "tx": tree X coordinate
-- "ty": tree Y coordinate
-- "bx": return location for X coordinate relative to bin_window
-- "by": return location for Y coordinate relative to bin_window
procedure Convert_Tree_To_Widget_Coords
(Tree_View : not null access Gtk_Tree_View_Record;
Tx : Gint;
Ty : Gint;
Wx : out Gint;
Wy : out Gint);
-- Converts tree coordinates (coordinates in full scrollable area of the
-- tree) to widget coordinates.
-- Since: gtk+ 2.12
-- "tx": X coordinate relative to the tree
-- "ty": Y coordinate relative to the tree
-- "wx": return location for widget X coordinate
-- "wy": return location for widget Y coordinate
procedure Convert_Widget_To_Bin_Window_Coords
(Tree_View : not null access Gtk_Tree_View_Record;
Wx : Gint;
Wy : Gint;
Bx : out Gint;
By : out Gint);
-- Converts widget coordinates to coordinates for the bin_window (see
-- Gtk.Tree_View.Get_Bin_Window).
-- Since: gtk+ 2.12
-- "wx": X coordinate relative to the widget
-- "wy": Y coordinate relative to the widget
-- "bx": return location for bin_window X coordinate
-- "by": return location for bin_window Y coordinate
procedure Convert_Widget_To_Tree_Coords
(Tree_View : not null access Gtk_Tree_View_Record;
Wx : Gint;
Wy : Gint;
Tx : out Gint;
Ty : out Gint);
-- Converts widget coordinates to coordinates for the tree (the full
-- scrollable area of the tree).
-- Since: gtk+ 2.12
-- "wx": X coordinate relative to the widget
-- "wy": Y coordinate relative to the widget
-- "tx": return location for tree X coordinate
-- "ty": return location for tree Y coordinate
function Create_Row_Drag_Icon
(Tree_View : not null access Gtk_Tree_View_Record;
Path : Gtk.Tree_Model.Gtk_Tree_Path) return Cairo.Cairo_Surface;
-- Creates a cairo_surface_t representation of the row at Path. This image
-- is used for a drag icon.
-- "path": a Gtk.Tree_Model.Gtk_Tree_Path in Tree_View
procedure Enable_Model_Drag_Dest
(Tree_View : not null access Gtk_Tree_View_Record;
Targets : Gtk.Target_List.Target_Entry_Array;
Actions : Gdk.Drag_Contexts.Gdk_Drag_Action);
-- Turns Tree_View into a drop destination for automatic DND. Calling this
-- method sets Gtk.Tree_View.Gtk_Tree_View:reorderable to False.
-- "targets": the table of targets that the drag will support
-- "actions": the bitmask of possible actions for a drag from this widget
procedure Enable_Model_Drag_Source
(Tree_View : not null access Gtk_Tree_View_Record;
Start_Button_Mask : Gdk.Types.Gdk_Modifier_Type;
Targets : Gtk.Target_List.Target_Entry_Array;
Actions : Gdk.Drag_Contexts.Gdk_Drag_Action);
-- Turns Tree_View into a drag source for automatic DND. Calling this
-- method sets Gtk.Tree_View.Gtk_Tree_View:reorderable to False.
-- "start_button_mask": Mask of allowed buttons to start drag
-- "targets": the table of targets that the drag will support
-- "actions": the bitmask of possible actions for a drag from this widget
procedure Expand_All (Tree_View : not null access Gtk_Tree_View_Record);
-- Recursively expands all nodes in the Tree_View.
function Expand_Row
(Tree_View : not null access Gtk_Tree_View_Record;
Path : Gtk.Tree_Model.Gtk_Tree_Path;
Open_All : Boolean) return Boolean;
-- Opens the row so its children are visible.
-- "path": path to a row
-- "open_all": whether to recursively expand, or just expand immediate
-- children
procedure Expand_To_Path
(Tree_View : not null access Gtk_Tree_View_Record;
Path : Gtk.Tree_Model.Gtk_Tree_Path);
-- Expands the row at Path. This will also expand all parent rows of Path
-- as necessary.
-- Since: gtk+ 2.2
-- "path": path to a row.
function Get_Activate_On_Single_Click
(Tree_View : not null access Gtk_Tree_View_Record) return Boolean;
-- Gets the setting set by Gtk.Tree_View.Set_Activate_On_Single_Click.
-- Since: gtk+ 3.8
procedure Set_Activate_On_Single_Click
(Tree_View : not null access Gtk_Tree_View_Record;
Single : Boolean);
-- Cause the Gtk.Tree_View.Gtk_Tree_View::row-activated signal to be
-- emitted on a single click instead of a double click.
-- Since: gtk+ 3.8
-- "single": True to emit row-activated on a single click
procedure Get_Background_Area
(Tree_View : not null access Gtk_Tree_View_Record;
Path : Gtk.Tree_Model.Gtk_Tree_Path;
Column : access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class;
Rect : out Gdk.Rectangle.Gdk_Rectangle);
-- Fills the bounding rectangle in bin_window coordinates for the cell at
-- the row specified by Path and the column specified by Column. If Path is
-- null, or points to a node not found in the tree, the Y and Height fields
-- of the rectangle will be filled with 0. If Column is null, the X and
-- Width fields will be filled with 0. The returned rectangle is equivalent
-- to the Background_Area passed to Gtk.Cell_Renderer.Render. These
-- background areas tile to cover the entire bin window. Contrast with the
-- Cell_Area, returned by Gtk.Tree_View.Get_Cell_Area, which returns only
-- the cell itself, excluding surrounding borders and the tree expander
-- area.
-- "path": a Gtk.Tree_Model.Gtk_Tree_Path for the row, or null to get only
-- horizontal coordinates
-- "column": a Gtk.Tree_View_Column.Gtk_Tree_View_Column for the column,
-- or null to get only vertical coordiantes
-- "rect": rectangle to fill with cell background rect
function Get_Bin_Window
(Tree_View : not null access Gtk_Tree_View_Record)
return Gdk.Gdk_Window;
-- Returns the window that Tree_View renders to. This is used primarily to
-- compare to 'event->window' to confirm that the event on Tree_View is on
-- the right window.
procedure Get_Cell_Area
(Tree_View : not null access Gtk_Tree_View_Record;
Path : Gtk.Tree_Model.Gtk_Tree_Path;
Column : access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class;
Rect : out Gdk.Rectangle.Gdk_Rectangle);
-- Fills the bounding rectangle in bin_window coordinates for the cell at
-- the row specified by Path and the column specified by Column. If Path is
-- null, or points to a path not currently displayed, the Y and Height
-- fields of the rectangle will be filled with 0. If Column is null, the X
-- and Width fields will be filled with 0. The sum of all cell rects does
-- not cover the entire tree; there are extra pixels in between rows, for
-- example. The returned rectangle is equivalent to the Cell_Area passed to
-- Gtk.Cell_Renderer.Render. This function is only valid if Tree_View is
-- realized.
-- "path": a Gtk.Tree_Model.Gtk_Tree_Path for the row, or null to get only
-- horizontal coordinates
-- "column": a Gtk.Tree_View_Column.Gtk_Tree_View_Column for the column,
-- or null to get only vertical coordinates
-- "rect": rectangle to fill with cell rect
function Get_Column
(Tree_View : not null access Gtk_Tree_View_Record;
N : Gint) return Gtk.Tree_View_Column.Gtk_Tree_View_Column;
-- Gets the Gtk.Tree_View_Column.Gtk_Tree_View_Column at the given
-- position in the tree_view.
-- "n": The position of the column, counting from 0.
function Get_Columns
(Tree_View : not null access Gtk_Tree_View_Record)
return Gtk.Tree_View_Column.Column_List.Glist;
-- Returns a GList of all the Gtk.Tree_View_Column.Gtk_Tree_View_Column s
-- currently in Tree_View. The returned list must be freed with g_list_free
-- ().
procedure Get_Cursor
(Tree_View : not null access Gtk_Tree_View_Record;
Path : out Gtk.Tree_Model.Gtk_Tree_Path;
Focus_Column : out Gtk.Tree_View_Column.Gtk_Tree_View_Column);
-- Fills in Path and Focus_Column with the current path and focus column.
-- If the cursor isn't currently set, then *Path will be null. If no column
-- currently has focus, then *Focus_Column will be null.
-- The returned Gtk.Tree_Model.Gtk_Tree_Path must be freed with
-- Gtk.Tree_Model.Path_Free when you are done with it.
-- "path": A pointer to be filled with the current cursor path, or null
-- "focus_column": A pointer to be filled with the current focus column,
-- or null
procedure Set_Cursor
(Tree_View : not null access Gtk_Tree_View_Record;
Path : Gtk.Tree_Model.Gtk_Tree_Path;
Focus_Column : access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class;
Start_Editing : Boolean);
-- Sets the current keyboard focus to be at Path, and selects it. This is
-- useful when you want to focus the user's attention on a particular row.
-- If Focus_Column is not null, then focus is given to the column specified
-- by it. Additionally, if Focus_Column is specified, and Start_Editing is
-- True, then editing should be started in the specified cell. This
-- function is often followed by Gtk_Widget_Grab_Focus (Tree_View) in order
-- to give keyboard focus to the widget. Please note that editing can only
-- happen when the widget is realized.
-- If Path is invalid for Model, the current cursor (if any) will be unset
-- and the function will return without failing.
-- "path": A Gtk.Tree_Model.Gtk_Tree_Path
-- "focus_column": A Gtk.Tree_View_Column.Gtk_Tree_View_Column, or null
-- "start_editing": True if the specified cell should start being edited.
function Get_Dest_Row_At_Pos
(Tree_View : not null access Gtk_Tree_View_Record;
Drag_X : Gint;
Drag_Y : Gint;
Path : access Gtk.Tree_Model.Gtk_Tree_Path;
Pos : access Gtk_Tree_View_Drop_Position) return Boolean;
-- Determines the destination row for a given position. Drag_X and Drag_Y
-- are expected to be in widget coordinates. This function is only
-- meaningful if Tree_View is realized. Therefore this function will always
-- return False if Tree_View is not realized or does not have a model.
-- "drag_x": the position to determine the destination row for
-- "drag_y": the position to determine the destination row for
-- "path": Return location for the path of the highlighted row, or null.
-- "pos": Return location for the drop position, or null
procedure Get_Drag_Dest_Row
(Tree_View : not null access Gtk_Tree_View_Record;
Path : out Gtk.Tree_Model.Gtk_Tree_Path;
Pos : out Gtk_Tree_View_Drop_Position);
-- Gets information about the row that is highlighted for feedback.
-- "path": Return location for the path of the highlighted row, or null.
-- "pos": Return location for the drop position, or null
procedure Set_Drag_Dest_Row
(Tree_View : not null access Gtk_Tree_View_Record;
Path : Gtk.Tree_Model.Gtk_Tree_Path;
Pos : Gtk_Tree_View_Drop_Position);
-- Sets the row that is highlighted for feedback. If Path is null, an
-- existing highlight is removed.
-- "path": The path of the row to highlight, or null
-- "pos": Specifies whether to drop before, after or into the row
function Get_Enable_Search
(Tree_View : not null access Gtk_Tree_View_Record) return Boolean;
-- Returns whether or not the tree allows to start interactive searching
-- by typing in text.
procedure Set_Enable_Search
(Tree_View : not null access Gtk_Tree_View_Record;
Enable_Search : Boolean);
-- If Enable_Search is set, then the user can type in text to search
-- through the tree interactively (this is sometimes called "typeahead
-- find").
-- Note that even if this is False, the user can still initiate a search
-- using the "start-interactive-search" key binding.
-- "enable_search": True, if the user can search interactively
function Get_Enable_Tree_Lines
(Tree_View : not null access Gtk_Tree_View_Record) return Boolean;
-- Returns whether or not tree lines are drawn in Tree_View.
-- Since: gtk+ 2.10
procedure Set_Enable_Tree_Lines
(Tree_View : not null access Gtk_Tree_View_Record;
Enabled : Boolean);
-- Sets whether to draw lines interconnecting the expanders in Tree_View.
-- This does not have any visible effects for lists.
-- Since: gtk+ 2.10
-- "enabled": True to enable tree line drawing, False otherwise.
function Get_Expander_Column
(Tree_View : not null access Gtk_Tree_View_Record)
return Gtk.Tree_View_Column.Gtk_Tree_View_Column;
-- Returns the column that is the current expander column. This column has
-- the expander arrow drawn next to it.
procedure Set_Expander_Column
(Tree_View : not null access Gtk_Tree_View_Record;
Column : access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class);
-- Sets the column to draw the expander arrow at. It must be in Tree_View.
-- If Column is null, then the expander arrow is always at the first
-- visible column.
-- If you do not want expander arrow to appear in your tree, set the
-- expander column to a hidden column.
-- "column": null, or the column to draw the expander arrow at.
function Get_Fixed_Height_Mode
(Tree_View : not null access Gtk_Tree_View_Record) return Boolean;
-- Returns whether fixed height mode is turned on for Tree_View.
-- Since: gtk+ 2.6
procedure Set_Fixed_Height_Mode
(Tree_View : not null access Gtk_Tree_View_Record;
Enable : Boolean);
-- Enables or disables the fixed height mode of Tree_View. Fixed height
-- mode speeds up Gtk.Tree_View.Gtk_Tree_View by assuming that all rows
-- have the same height. Only enable this option if all rows are the same
-- height and all columns are of type
-- Gtk.Tree_View_Column.Tree_View_Column_Fixed.
-- Since: gtk+ 2.6
-- "enable": True to enable fixed height mode
function Get_Grid_Lines
(Tree_View : not null access Gtk_Tree_View_Record)
return Gtk.Enums.Gtk_Tree_View_Grid_Lines;
-- Returns which grid lines are enabled in Tree_View.
-- Since: gtk+ 2.10
procedure Set_Grid_Lines
(Tree_View : not null access Gtk_Tree_View_Record;
Grid_Lines : Gtk.Enums.Gtk_Tree_View_Grid_Lines);
-- Sets which grid lines to draw in Tree_View.
-- Since: gtk+ 2.10
-- "grid_lines": a Gtk.Enums.Gtk_Tree_View_Grid_Lines value indicating
-- which grid lines to enable.
function Get_Headers_Clickable
(Tree_View : not null access Gtk_Tree_View_Record) return Boolean;
-- Returns whether all header columns are clickable.
-- Since: gtk+ 2.10
procedure Set_Headers_Clickable
(Tree_View : not null access Gtk_Tree_View_Record;
Setting : Boolean);
-- Allow the column title buttons to be clicked.
-- "setting": True if the columns are clickable.
function Get_Headers_Visible
(Tree_View : not null access Gtk_Tree_View_Record) return Boolean;
-- Returns True if the headers on the Tree_View are visible.
procedure Set_Headers_Visible
(Tree_View : not null access Gtk_Tree_View_Record;
Headers_Visible : Boolean);
-- Sets the visibility state of the headers.
-- "headers_visible": True if the headers are visible
function Get_Hover_Expand
(Tree_View : not null access Gtk_Tree_View_Record) return Boolean;
-- Returns whether hover expansion mode is turned on for Tree_View.
-- Since: gtk+ 2.6
procedure Set_Hover_Expand
(Tree_View : not null access Gtk_Tree_View_Record;
Expand : Boolean);
-- Enables or disables the hover expansion mode of Tree_View. Hover
-- expansion makes rows expand or collapse if the pointer moves over them.
-- Since: gtk+ 2.6
-- "expand": True to enable hover selection mode
function Get_Hover_Selection
(Tree_View : not null access Gtk_Tree_View_Record) return Boolean;
-- Returns whether hover selection mode is turned on for Tree_View.
-- Since: gtk+ 2.6
procedure Set_Hover_Selection
(Tree_View : not null access Gtk_Tree_View_Record;
Hover : Boolean);
-- Enables or disables the hover selection mode of Tree_View. Hover
-- selection makes the selected row follow the pointer. Currently, this
-- works only for the selection modes Gtk.Enums.Selection_Single and
-- Gtk.Enums.Selection_Browse.
-- Since: gtk+ 2.6
-- "hover": True to enable hover selection mode
function Get_Level_Indentation
(Tree_View : not null access Gtk_Tree_View_Record) return Gint;
-- Returns the amount, in pixels, of extra indentation for child levels in
-- Tree_View.
-- Since: gtk+ 2.12
procedure Set_Level_Indentation
(Tree_View : not null access Gtk_Tree_View_Record;
Indentation : Gint);
-- Sets the amount of extra indentation for child levels to use in
-- Tree_View in addition to the default indentation. The value should be
-- specified in pixels, a value of 0 disables this feature and in this case
-- only the default indentation will be used. This does not have any
-- visible effects for lists.
-- Since: gtk+ 2.12
-- "indentation": the amount, in pixels, of extra indentation in
-- Tree_View.
function Get_Model
(Tree_View : not null access Gtk_Tree_View_Record)
return Gtk.Tree_Model.Gtk_Tree_Model;
-- Returns the model the Gtk.Tree_View.Gtk_Tree_View is based on. Returns
-- null if the model is unset.
procedure Set_Model
(Tree_View : not null access Gtk_Tree_View_Record;
Model : Gtk.Tree_Model.Gtk_Tree_Model);
-- Sets the model for a Gtk.Tree_View.Gtk_Tree_View. If the Tree_View
-- already has a model set, it will remove it before setting the new model.
-- If Model is null, then it will unset the old model.
-- "model": The model.
function Get_N_Columns
(Tree_View : not null access Gtk_Tree_View_Record) return Guint;
-- Queries the number of columns in the given Tree_View.
-- Since: gtk+ 3.4
procedure Get_Path_At_Pos
(Tree_View : not null access Gtk_Tree_View_Record;
X : Gint;
Y : Gint;
Path : out Gtk.Tree_Model.Gtk_Tree_Path;
Column : out Gtk.Tree_View_Column.Gtk_Tree_View_Column;
Cell_X : out Gint;
Cell_Y : out Gint;
Row_Found : out Boolean);
-- Finds the path at the point (X, Y), relative to bin_window coordinates
-- (please see Gtk.Tree_View.Get_Bin_Window). That is, X and Y are relative
-- to an events coordinates. X and Y must come from an event on the
-- Tree_View only where 'event->window == gtk_tree_view_get_bin_window
-- (<!-- -->)'. It is primarily for things like popup menus. If Path is
-- non-null, then it will be filled with the Gtk.Tree_Model.Gtk_Tree_Path
-- at that point. This path should be freed with Gtk.Tree_Model.Path_Free.
-- If Column is non-null, then it will be filled with the column at that
-- point. Cell_X and Cell_Y return the coordinates relative to the cell
-- background (i.e. the Background_Area passed to
-- Gtk.Cell_Renderer.Render). This function is only meaningful if Tree_View
-- is realized. Therefore this function will always return False if
-- Tree_View is not realized or does not have a model.
-- For converting widget coordinates (eg. the ones you get from
-- GtkWidget::query-tooltip), please see
-- Gtk.Tree_View.Convert_Widget_To_Bin_Window_Coords.
-- "x": The x position to be identified (relative to bin_window).
-- "y": The y position to be identified (relative to bin_window).
-- "path": A pointer to a Gtk.Tree_Model.Gtk_Tree_Path pointer to be
-- filled in, or null
-- "column": A pointer to a Gtk.Tree_View_Column.Gtk_Tree_View_Column
-- pointer to be filled in, or null
-- "cell_x": A pointer where the X coordinate relative to the cell can be
-- placed, or null
-- "cell_y": A pointer where the Y coordinate relative to the cell can be
-- placed, or null
function Get_Reorderable
(Tree_View : not null access Gtk_Tree_View_Record) return Boolean;
-- Retrieves whether the user can reorder the tree via drag-and-drop. See
-- Gtk.Tree_View.Set_Reorderable.
procedure Set_Reorderable
(Tree_View : not null access Gtk_Tree_View_Record;
Reorderable : Boolean);
-- This function is a convenience function to allow you to reorder models
-- that support the Gtk_Tree_Drag_Source_Iface and the
-- Gtk_Tree_Drag_Dest_Iface. Both Gtk.Tree_Store.Gtk_Tree_Store and
-- Gtk.List_Store.Gtk_List_Store support these. If Reorderable is True,
-- then the user can reorder the model by dragging and dropping rows. The
-- developer can listen to these changes by connecting to the model's
-- row_inserted and row_deleted signals. The reordering is implemented by
-- setting up the tree view as a drag source and destination. Therefore,
-- drag and drop can not be used in a reorderable view for any other
-- purpose.
-- This function does not give you any degree of control over the order --
-- any reordering is allowed. If more control is needed, you should
-- probably handle drag and drop manually.
-- "reorderable": True, if the tree can be reordered.
procedure Get_Row_Separator_Func
(Tree_View : not null access Gtk_Tree_View_Record);
-- Returns the current row separator function.
-- Since: gtk+ 2.6
procedure Set_Row_Separator_Func
(Tree_View : not null access Gtk_Tree_View_Record;
Func : Gtk_Tree_View_Row_Separator_Func);
-- Sets the row separator function, which is used to determine whether a
-- row should be drawn as a separator. If the row separator function is
-- null, no separators are drawn. This is the default value.
-- Since: gtk+ 2.6
-- "func": a Gtk.Tree_View.Gtk_Tree_View_Row_Separator_Func
function Get_Rubber_Banding
(Tree_View : not null access Gtk_Tree_View_Record) return Boolean;
-- Returns whether rubber banding is turned on for Tree_View. If the
-- selection mode is GTK_SELECTION_MULTIPLE, rubber banding will allow the
-- user to select multiple rows by dragging the mouse.
-- Since: gtk+ 2.10
procedure Set_Rubber_Banding
(Tree_View : not null access Gtk_Tree_View_Record;
Enable : Boolean);
-- Enables or disables rubber banding in Tree_View. If the selection mode
-- is GTK_SELECTION_MULTIPLE, rubber banding will allow the user to select
-- multiple rows by dragging the mouse.
-- Since: gtk+ 2.10
-- "enable": True to enable rubber banding
function Get_Rules_Hint
(Tree_View : not null access Gtk_Tree_View_Record) return Boolean;
-- Gets the setting set by Gtk.Tree_View.Set_Rules_Hint.
procedure Set_Rules_Hint
(Tree_View : not null access Gtk_Tree_View_Record;
Setting : Boolean);
-- This function tells GTK+ that the user interface for your application
-- requires users to read across tree rows and associate cells with one
-- another. By default, GTK+ will then render the tree with alternating row
-- colors. Do *not* use it just because you prefer the appearance of the
-- ruled tree; that's a question for the theme. Some themes will draw tree
-- rows in alternating colors even when rules are turned off, and users who
-- prefer that appearance all the time can choose those themes. You should
-- call this function only as a *semantic* hint to the theme engine that
-- your tree makes alternating colors useful from a functional standpoint
-- (since it has lots of columns, generally).
-- "setting": True if the tree requires reading across rows
function Get_Search_Column
(Tree_View : not null access Gtk_Tree_View_Record) return Gint;
-- Gets the column searched on by the interactive search code.
procedure Set_Search_Column
(Tree_View : not null access Gtk_Tree_View_Record;
Column : Gint);
-- Sets Column as the column where the interactive search code should
-- search in for the current model.
-- If the search column is set, users can use the
-- "start-interactive-search" key binding to bring up search popup. The
-- enable-search property controls whether simply typing text will also
-- start an interactive search.
-- Note that Column refers to a column of the current model. The search
-- column is reset to -1 when the model is changed.
-- "column": the column of the model to search in, or -1 to disable
-- searching
function Get_Search_Entry
(Tree_View : not null access Gtk_Tree_View_Record)
return Gtk.GEntry.Gtk_Entry;
-- Returns the Gtk.GEntry.Gtk_Entry which is currently in use as
-- interactive search entry for Tree_View. In case the built-in entry is
-- being used, null will be returned.
-- Since: gtk+ 2.10
procedure Set_Search_Entry
(Tree_View : not null access Gtk_Tree_View_Record;
GEntry : access Gtk.GEntry.Gtk_Entry_Record'Class);
-- Sets the entry which the interactive search code will use for this
-- Tree_View. This is useful when you want to provide a search entry in our
-- interface at all time at a fixed position. Passing null for Entry will
-- make the interactive search code use the built-in popup entry again.
-- Since: gtk+ 2.10
-- "entry": the entry the interactive search code of Tree_View should use
-- or null
procedure Get_Search_Equal_Func
(Tree_View : not null access Gtk_Tree_View_Record);
-- Returns the compare function currently in use.
procedure Set_Search_Equal_Func
(Tree_View : not null access Gtk_Tree_View_Record;
Search_Equal_Func : Gtk_Tree_View_Search_Equal_Func;
Search_Destroy : Glib.G_Destroy_Notify_Address);
-- Sets the compare function for the interactive search capabilities; note
-- that somewhat like strcmp returning 0 for equality
-- Gtk_Tree_View_Search_Equal_Func returns False on matches.
-- "search_equal_func": the compare function to use during the search
-- "search_destroy": Destroy notifier for Search_User_Data, or null
procedure Get_Search_Position_Func
(Tree_View : not null access Gtk_Tree_View_Record);
-- Returns the positioning function currently in use.
-- Since: gtk+ 2.10
procedure Set_Search_Position_Func
(Tree_View : not null access Gtk_Tree_View_Record;
Func : Gtk_Tree_View_Search_Position_Func);
-- Sets the function to use when positioning the search dialog.
-- Since: gtk+ 2.10
-- "func": the function to use to position the search dialog, or null to
-- use the default search position function
function Get_Selection
(Tree_View : not null access Gtk_Tree_View_Record)
return Gtk.Tree_Selection.Gtk_Tree_Selection;
-- Gets the Gtk.Tree_Selection.Gtk_Tree_Selection associated with
-- Tree_View.
function Get_Show_Expanders
(Tree_View : not null access Gtk_Tree_View_Record) return Boolean;
-- Returns whether or not expanders are drawn in Tree_View.
-- Since: gtk+ 2.12
procedure Set_Show_Expanders
(Tree_View : not null access Gtk_Tree_View_Record;
Enabled : Boolean);
-- Sets whether to draw and enable expanders and indent child rows in
-- Tree_View. When disabled there will be no expanders visible in trees and
-- there will be no way to expand and collapse rows by default. Also note
-- that hiding the expanders will disable the default indentation. You can
-- set a custom indentation in this case using
-- Gtk.Tree_View.Set_Level_Indentation. This does not have any visible
-- effects for lists.
-- Since: gtk+ 2.12
-- "enabled": True to enable expander drawing, False otherwise.
function Get_Tooltip_Column
(Tree_View : not null access Gtk_Tree_View_Record) return Gint;
-- Returns the column of Tree_View's model which is being used for
-- displaying tooltips on Tree_View's rows.
-- Since: gtk+ 2.12
procedure Set_Tooltip_Column
(Tree_View : not null access Gtk_Tree_View_Record;
Column : Gint);
-- If you only plan to have simple (text-only) tooltips on full rows, you
-- can use this function to have Gtk.Tree_View.Gtk_Tree_View handle these
-- automatically for you. Column should be set to the column in Tree_View's
-- model containing the tooltip texts, or -1 to disable this feature.
-- When enabled, Gtk.Widget.Gtk_Widget:has-tooltip will be set to True and
-- Tree_View will connect a Gtk.Widget.Gtk_Widget::query-tooltip signal
-- handler.
-- Note that the signal handler sets the text with Gtk.Tooltip.Set_Markup,
-- so &, <, etc have to be escaped in the text.
-- Since: gtk+ 2.12
-- "column": an integer, which is a valid column number for Tree_View's
-- model
procedure Get_Tooltip_Context
(Tree_View : not null access Gtk_Tree_View_Record;
X : in out Gint;
Y : in out Gint;
Keyboard_Tip : Boolean;
Model : out Gtk.Tree_Model.Gtk_Tree_Model;
Path : out Gtk.Tree_Model.Gtk_Tree_Path;
Iter : out Gtk.Tree_Model.Gtk_Tree_Iter;
Success : out Boolean);
-- This function is supposed to be used in a
-- Gtk.Widget.Gtk_Widget::query-tooltip signal handler for
-- Gtk.Tree_View.Gtk_Tree_View. The X, Y and Keyboard_Tip values which are
-- received in the signal handler, should be passed to this function
-- without modification.
-- The return value indicates whether there is a tree view row at the
-- given coordinates (True) or not (False) for mouse tooltips. For keyboard
-- tooltips the row returned will be the cursor row. When True, then any of
-- Model, Path and Iter which have been provided will be set to point to
-- that row and the corresponding model. X and Y will always be converted
-- to be relative to Tree_View's bin_window if Keyboard_Tooltip is False.
-- Since: gtk+ 2.12
-- "x": the x coordinate (relative to widget coordinates)
-- "y": the y coordinate (relative to widget coordinates)
-- "keyboard_tip": whether this is a keyboard tooltip or not
-- "model": a pointer to receive a Gtk.Tree_Model.Gtk_Tree_Model or null
-- "path": a pointer to receive a Gtk.Tree_Model.Gtk_Tree_Path or null
-- "iter": a pointer to receive a Gtk.Tree_Model.Gtk_Tree_Iter or null
procedure Get_Visible_Range
(Tree_View : not null access Gtk_Tree_View_Record;
Start_Path : out Gtk.Tree_Model.Gtk_Tree_Path;
End_Path : out Gtk.Tree_Model.Gtk_Tree_Path;
Success : out Boolean);
-- Sets Start_Path and End_Path to be the first and last visible path.
-- Note that there may be invisible paths in between.
-- The paths should be freed with Gtk.Tree_Model.Path_Free after use.
-- Since: gtk+ 2.8
-- "start_path": Return location for start of region, or null.
-- "end_path": Return location for end of region, or null.
procedure Get_Visible_Rect
(Tree_View : not null access Gtk_Tree_View_Record;
Visible_Rect : out Gdk.Rectangle.Gdk_Rectangle);
-- Fills Visible_Rect with the currently-visible region of the buffer, in
-- tree coordinates. Convert to bin_window coordinates with
-- Gtk.Tree_View.Convert_Tree_To_Bin_Window_Coords. Tree coordinates start
-- at 0,0 for row 0 of the tree, and cover the entire scrollable area of
-- the tree.
-- "visible_rect": rectangle to fill
function Insert_Column
(Tree_View : not null access Gtk_Tree_View_Record;
Column : not null access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class;
Position : Gint := -1) return Gint;
-- This inserts the Column into the Tree_View at Position. If Position is
-- -1, then the column is inserted at the end. If Tree_View has
-- "fixed_height" mode enabled, then Column must have its "sizing" property
-- set to be GTK_TREE_VIEW_COLUMN_FIXED.
-- "column": The Gtk.Tree_View_Column.Gtk_Tree_View_Column to be inserted.
-- "position": The position to insert Column in.
function Insert_Column_With_Data_Func
(Tree_View : not null access Gtk_Tree_View_Record;
Position : Gint;
Title : UTF8_String;
Cell : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class;
Func : Gtk_Tree_Cell_Data_Func;
Dnotify : Glib.G_Destroy_Notify_Address) return Gint;
-- Convenience function that inserts a new column into the
-- Gtk.Tree_View.Gtk_Tree_View with the given cell renderer and a
-- Gtk_Tree_Cell_Data_Func to set cell renderer attributes (normally using
-- data from the model). See also gtk_tree_view_column_set_cell_data_func,
-- gtk_tree_view_column_pack_start. If Tree_View has "fixed_height" mode
-- enabled, then the new column will have its "sizing" property set to be
-- GTK_TREE_VIEW_COLUMN_FIXED.
-- "position": Position to insert, -1 for append
-- "title": column title
-- "cell": cell renderer for column
-- "func": function to set attributes of cell renderer
-- "dnotify": destroy notifier for Data
generic
type User_Data_Type (<>) is private;
with procedure Destroy (Data : in out User_Data_Type) is null;
package Insert_Column_With_Data_Func_User_Data is
type Gtk_Tree_Cell_Data_Func is access procedure
(Tree_Column : not null access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class;
Cell : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class;
Tree_Model : Gtk.Tree_Model.Gtk_Tree_Model;
Iter : Gtk.Tree_Model.Gtk_Tree_Iter;
Data : User_Data_Type);
-- A function to set the properties of a cell instead of just using the
-- straight mapping between the cell and the model. This is useful for
-- customizing the cell renderer. For example, a function might get an
-- integer from the Tree_Model, and render it to the "text" attribute of
-- "cell" by converting it to its written equivilent. This is set by
-- calling gtk_tree_view_column_set_cell_data_func
-- "tree_column": A Gtk.Tree_View_Column.Gtk_Tree_View_Column
-- "cell": The Gtk.Cell_Renderer.Gtk_Cell_Renderer that is being rendered
-- by Tree_Column
-- "tree_model": The Gtk.Tree_Model.Gtk_Tree_Model being rendered
-- "iter": A Gtk.Tree_Model.Gtk_Tree_Iter of the current row rendered
-- "data": user data
function Insert_Column_With_Data_Func
(Tree_View : not null access Gtk.Tree_View.Gtk_Tree_View_Record'Class;
Position : Gint;
Title : UTF8_String;
Cell : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class;
Func : Gtk_Tree_Cell_Data_Func;
Data : User_Data_Type;
Dnotify : Glib.G_Destroy_Notify_Address) return Gint;
-- Convenience function that inserts a new column into the
-- Gtk.Tree_View.Gtk_Tree_View with the given cell renderer and a
-- Gtk_Tree_Cell_Data_Func to set cell renderer attributes (normally
-- using data from the model). See also
-- gtk_tree_view_column_set_cell_data_func,
-- gtk_tree_view_column_pack_start. If Tree_View has "fixed_height" mode
-- enabled, then the new column will have its "sizing" property set to
-- be GTK_TREE_VIEW_COLUMN_FIXED.
-- "position": Position to insert, -1 for append
-- "title": column title
-- "cell": cell renderer for column
-- "func": function to set attributes of cell renderer
-- "data": data for Func
-- "dnotify": destroy notifier for Data
end Insert_Column_With_Data_Func_User_Data;
function Is_Blank_At_Pos
(Tree_View : not null access Gtk_Tree_View_Record;
X : Gint;
Y : Gint;
Path : access Gtk.Tree_Model.Gtk_Tree_Path;
Column : access Gtk.Tree_View_Column.Gtk_Tree_View_Column;
Cell_X : access Gint;
Cell_Y : access Gint) return Boolean;
-- Determine whether the point (X, Y) in Tree_View is blank, that is no
-- cell content nor an expander arrow is drawn at the location. If so, the
-- location can be considered as the background. You might wish to take
-- special action on clicks on the background, such as clearing a current
-- selection, having a custom context menu or starting rubber banding.
-- The X and Y coordinate that are provided must be relative to bin_window
-- coordinates. That is, X and Y must come from an event on Tree_View where
-- 'event->window == gtk_tree_view_get_bin_window (<!-- -->)'.
-- For converting widget coordinates (eg. the ones you get from
-- GtkWidget::query-tooltip), please see
-- Gtk.Tree_View.Convert_Widget_To_Bin_Window_Coords.
-- The Path, Column, Cell_X and Cell_Y arguments will be filled in
-- likewise as for Gtk.Tree_View.Get_Path_At_Pos. Please see
-- Gtk.Tree_View.Get_Path_At_Pos for more information.
-- Since: gtk+ 3.0
-- "x": The x position to be identified (relative to bin_window)
-- "y": The y position to be identified (relative to bin_window)
-- "path": A pointer to a Gtk.Tree_Model.Gtk_Tree_Path pointer to be
-- filled in, or null
-- "column": A pointer to a Gtk.Tree_View_Column.Gtk_Tree_View_Column
-- pointer to be filled in, or null
-- "cell_x": A pointer where the X coordinate relative to the cell can be
-- placed, or null
-- "cell_y": A pointer where the Y coordinate relative to the cell can be
-- placed, or null
function Is_Rubber_Banding_Active
(Tree_View : not null access Gtk_Tree_View_Record) return Boolean;
-- Returns whether a rubber banding operation is currently being done in
-- Tree_View.
-- Since: gtk+ 2.12
procedure Map_Expanded_Rows
(Tree_View : not null access Gtk_Tree_View_Record;
Func : Gtk_Tree_View_Mapping_Func);
-- Calls Func on all expanded rows.
-- "func": A function to be called
generic
type User_Data_Type (<>) is private;
with procedure Destroy (Data : in out User_Data_Type) is null;
package Map_Expanded_Rows_User_Data is
type Gtk_Tree_View_Mapping_Func is access procedure
(Tree_View : not null access Gtk.Tree_View.Gtk_Tree_View_Record'Class;
Path : Gtk.Tree_Model.Gtk_Tree_Path;
User_Data : User_Data_Type);
-- Function used for Gtk.Tree_View.Map_Expanded_Rows.
-- "tree_view": A Gtk.Tree_View.Gtk_Tree_View
-- "path": The path that's expanded
-- "user_data": user data
procedure Map_Expanded_Rows
(Tree_View : not null access Gtk.Tree_View.Gtk_Tree_View_Record'Class;
Func : Gtk_Tree_View_Mapping_Func;
Data : User_Data_Type);
-- Calls Func on all expanded rows.
-- "func": A function to be called
-- "data": User data to be passed to the function.
end Map_Expanded_Rows_User_Data;
procedure Move_Column_After
(Tree_View : not null access Gtk_Tree_View_Record;
Column : not null access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class;
Base_Column : access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class);
-- Moves Column to be after to Base_Column. If Base_Column is null, then
-- Column is placed in the first position.
-- "column": The Gtk.Tree_View_Column.Gtk_Tree_View_Column to be moved.
-- "base_column": The Gtk.Tree_View_Column.Gtk_Tree_View_Column to be
-- moved relative to, or null.
function Remove_Column
(Tree_View : not null access Gtk_Tree_View_Record;
Column : not null access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class)
return Gint;
-- Removes Column from Tree_View.
-- "column": The Gtk.Tree_View_Column.Gtk_Tree_View_Column to remove.
procedure Row_Activated
(Tree_View : not null access Gtk_Tree_View_Record;
Path : Gtk.Tree_Model.Gtk_Tree_Path;
Column : not null access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class);
-- Activates the cell determined by Path and Column.
-- "path": The Gtk.Tree_Model.Gtk_Tree_Path to be activated.
-- "column": The Gtk.Tree_View_Column.Gtk_Tree_View_Column to be
-- activated.
function Row_Expanded
(Tree_View : not null access Gtk_Tree_View_Record;
Path : Gtk.Tree_Model.Gtk_Tree_Path) return Boolean;
-- Returns True if the node pointed to by Path is expanded in Tree_View.
-- "path": A Gtk.Tree_Model.Gtk_Tree_Path to test expansion state.
procedure Scroll_To_Cell
(Tree_View : not null access Gtk_Tree_View_Record;
Path : Gtk.Tree_Model.Gtk_Tree_Path;
Column : access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class;
Use_Align : Boolean;
Row_Align : Gfloat;
Col_Align : Gfloat);
-- Moves the alignments of Tree_View to the position specified by Column
-- and Path. If Column is null, then no horizontal scrolling occurs.
-- Likewise, if Path is null no vertical scrolling occurs. At a minimum,
-- one of Column or Path need to be non-null. Row_Align determines where
-- the row is placed, and Col_Align determines where Column is placed. Both
-- are expected to be between 0.0 and 1.0. 0.0 means left/top alignment,
-- 1.0 means right/bottom alignment, 0.5 means center.
-- If Use_Align is False, then the alignment arguments are ignored, and
-- the tree does the minimum amount of work to scroll the cell onto the
-- screen. This means that the cell will be scrolled to the edge closest to
-- its current position. If the cell is currently visible on the screen,
-- nothing is done.
-- This function only works if the model is set, and Path is a valid row
-- on the model. If the model changes before the Tree_View is realized, the
-- centered path will be modified to reflect this change.
-- "path": The path of the row to move to, or null.
-- "column": The Gtk.Tree_View_Column.Gtk_Tree_View_Column to move
-- horizontally to, or null.
-- "use_align": whether to use alignment arguments, or False.
-- "row_align": The vertical alignment of the row specified by Path.
-- "col_align": The horizontal alignment of the column specified by
-- Column.
procedure Scroll_To_Point
(Tree_View : not null access Gtk_Tree_View_Record;
Tree_X : Gint;
Tree_Y : Gint);
-- Scrolls the tree view such that the top-left corner of the visible area
-- is Tree_X, Tree_Y, where Tree_X and Tree_Y are specified in tree
-- coordinates. The Tree_View must be realized before this function is
-- called. If it isn't, you probably want to be using
-- Gtk.Tree_View.Scroll_To_Cell.
-- If either Tree_X or Tree_Y are -1, then that direction isn't scrolled.
-- "tree_x": X coordinate of new top-left pixel of visible area, or -1
-- "tree_y": Y coordinate of new top-left pixel of visible area, or -1
procedure Set_Column_Drag_Function
(Tree_View : not null access Gtk_Tree_View_Record;
Func : Gtk_Tree_View_Column_Drop_Func);
-- Sets a user function for determining where a column may be dropped when
-- dragged. This function is called on every column pair in turn at the
-- beginning of a column drag to determine where a drop can take place. The
-- arguments passed to Func are: the Tree_View, the
-- Gtk.Tree_View_Column.Gtk_Tree_View_Column being dragged, the two
-- Gtk.Tree_View_Column.Gtk_Tree_View_Column s determining the drop spot,
-- and User_Data. If either of the
-- Gtk.Tree_View_Column.Gtk_Tree_View_Column arguments for the drop spot
-- are null, then they indicate an edge. If Func is set to be null, then
-- Tree_View reverts to the default behavior of allowing all columns to be
-- dropped everywhere.
-- "func": A function to determine which columns are reorderable, or null.
generic
type User_Data_Type (<>) is private;
with procedure Destroy (Data : in out User_Data_Type) is null;
package Set_Column_Drag_Function_User_Data is
type Gtk_Tree_View_Column_Drop_Func is access function
(Tree_View : not null access Gtk.Tree_View.Gtk_Tree_View_Record'Class;
Column : not null access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class;
Prev_Column : not null access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class;
Next_Column : not null access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class;
Data : User_Data_Type) return Boolean;
-- Function type for determining whether Column can be dropped in a
-- particular spot (as determined by Prev_Column and Next_Column). In left
-- to right locales, Prev_Column is on the left of the potential drop spot,
-- and Next_Column is on the right. In right to left mode, this is
-- reversed. This function should return True if the spot is a valid drop
-- spot. Please note that returning True does not actually indicate that
-- the column drop was made, but is meant only to indicate a possible drop
-- spot to the user.
-- "tree_view": A Gtk.Tree_View.Gtk_Tree_View
-- "column": The Gtk.Tree_View_Column.Gtk_Tree_View_Column being dragged
-- "prev_column": A Gtk.Tree_View_Column.Gtk_Tree_View_Column on one side
-- of Column
-- "next_column": A Gtk.Tree_View_Column.Gtk_Tree_View_Column on the other
-- side of Column
-- "data": user data
procedure Set_Column_Drag_Function
(Tree_View : not null access Gtk.Tree_View.Gtk_Tree_View_Record'Class;
Func : Gtk_Tree_View_Column_Drop_Func;
User_Data : User_Data_Type);
-- Sets a user function for determining where a column may be dropped
-- when dragged. This function is called on every column pair in turn at
-- the beginning of a column drag to determine where a drop can take
-- place. The arguments passed to Func are: the Tree_View, the
-- Gtk.Tree_View_Column.Gtk_Tree_View_Column being dragged, the two
-- Gtk.Tree_View_Column.Gtk_Tree_View_Column s determining the drop
-- spot, and User_Data. If either of the
-- Gtk.Tree_View_Column.Gtk_Tree_View_Column arguments for the drop spot
-- are null, then they indicate an edge. If Func is set to be null, then
-- Tree_View reverts to the default behavior of allowing all columns to
-- be dropped everywhere.
-- "func": A function to determine which columns are reorderable, or
-- null.
-- "user_data": User data to be passed to Func, or null
end Set_Column_Drag_Function_User_Data;
procedure Set_Cursor_On_Cell
(Tree_View : not null access Gtk_Tree_View_Record;
Path : Gtk.Tree_Model.Gtk_Tree_Path;
Focus_Column : access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class;
Focus_Cell : access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class;
Start_Editing : Boolean);
-- Sets the current keyboard focus to be at Path, and selects it. This is
-- useful when you want to focus the user's attention on a particular row.
-- If Focus_Column is not null, then focus is given to the column specified
-- by it. If Focus_Column and Focus_Cell are not null, and Focus_Column
-- contains 2 or more editable or activatable cells, then focus is given to
-- the cell specified by Focus_Cell. Additionally, if Focus_Column is
-- specified, and Start_Editing is True, then editing should be started in
-- the specified cell. This function is often followed by
-- Gtk_Widget_Grab_Focus (Tree_View) in order to give keyboard focus to the
-- widget. Please note that editing can only happen when the widget is
-- realized.
-- If Path is invalid for Model, the current cursor (if any) will be unset
-- and the function will return without failing.
-- Since: gtk+ 2.2
-- "path": A Gtk.Tree_Model.Gtk_Tree_Path
-- "focus_column": A Gtk.Tree_View_Column.Gtk_Tree_View_Column, or null
-- "focus_cell": A Gtk.Cell_Renderer.Gtk_Cell_Renderer, or null
-- "start_editing": True if the specified cell should start being edited.
procedure Set_Destroy_Count_Func
(Tree_View : not null access Gtk_Tree_View_Record;
Func : Gtk_Tree_Destroy_Count_Func);
pragma Obsolescent (Set_Destroy_Count_Func);
-- This function should almost never be used. It is meant for private use
-- by ATK for determining the number of visible children that are removed
-- when the user collapses a row, or a row is deleted.
-- Deprecated since 3.4, Accessibility does not need the function anymore.
-- "func": Function to be called when a view row is destroyed, or null
generic
type User_Data_Type (<>) is private;
with procedure Destroy (Data : in out User_Data_Type) is null;
package Set_Destroy_Count_Func_User_Data is
type Gtk_Tree_Destroy_Count_Func is access procedure
(Tree_View : not null access Gtk.Tree_View.Gtk_Tree_View_Record'Class;
Path : Gtk.Tree_Model.Gtk_Tree_Path;
Children : Gint;
User_Data : User_Data_Type);
procedure Set_Destroy_Count_Func
(Tree_View : not null access Gtk.Tree_View.Gtk_Tree_View_Record'Class;
Func : Gtk_Tree_Destroy_Count_Func;
Data : User_Data_Type);
pragma Obsolescent (Set_Destroy_Count_Func);
-- This function should almost never be used. It is meant for private
-- use by ATK for determining the number of visible children that are
-- removed when the user collapses a row, or a row is deleted.
-- Deprecated since 3.4, Accessibility does not need the function
-- anymore.
-- "func": Function to be called when a view row is destroyed, or null
-- "data": User data to be passed to Func, or null
end Set_Destroy_Count_Func_User_Data;
generic
type User_Data_Type (<>) is private;
with procedure Destroy (Data : in out User_Data_Type) is null;
package Set_Row_Separator_Func_User_Data is
type Gtk_Tree_View_Row_Separator_Func is access function
(Model : Gtk.Tree_Model.Gtk_Tree_Model;
Iter : Gtk.Tree_Model.Gtk_Tree_Iter;
Data : User_Data_Type) return Boolean;
-- Function type for determining whether the row pointed to by Iter should
-- be rendered as a separator. A common way to implement this is to have a
-- boolean column in the model, whose values the
-- Gtk.Tree_View.Gtk_Tree_View_Row_Separator_Func returns.
-- "model": the Gtk.Tree_Model.Gtk_Tree_Model
-- "iter": a Gtk.Tree_Model.Gtk_Tree_Iter pointing at a row in Model
-- "data": user data
procedure Set_Row_Separator_Func
(Tree_View : not null access Gtk.Tree_View.Gtk_Tree_View_Record'Class;
Func : Gtk_Tree_View_Row_Separator_Func;
Data : User_Data_Type);
-- Sets the row separator function, which is used to determine whether
-- a row should be drawn as a separator. If the row separator function
-- is null, no separators are drawn. This is the default value.
-- Since: gtk+ 2.6
-- "func": a Gtk.Tree_View.Gtk_Tree_View_Row_Separator_Func
-- "data": user data to pass to Func, or null
end Set_Row_Separator_Func_User_Data;
generic
type User_Data_Type (<>) is private;
with procedure Destroy (Data : in out User_Data_Type) is null;
package Set_Search_Equal_Func_User_Data is
type Gtk_Tree_View_Search_Equal_Func is access function
(Model : Gtk.Tree_Model.Gtk_Tree_Model;
Column : Gint;
Key : UTF8_String;
Iter : Gtk.Tree_Model.Gtk_Tree_Iter;
Search_Data : User_Data_Type) return Boolean;
-- A function used for checking whether a row in Model matches a search
-- key string entered by the user. Note the return value is reversed from
-- what you would normally expect, though it has some similarity to strcmp
-- returning 0 for equal strings.
-- "model": the Gtk.Tree_Model.Gtk_Tree_Model being searched
-- "column": the search column set by Gtk.Tree_View.Set_Search_Column
-- "key": the key string to compare with
-- "iter": a Gtk.Tree_Model.Gtk_Tree_Iter pointing the row of Model that
-- should be compared with Key.
-- "search_data": user data from Gtk.Tree_View.Set_Search_Equal_Func
procedure Set_Search_Equal_Func
(Tree_View : not null access Gtk.Tree_View.Gtk_Tree_View_Record'Class;
Search_Equal_Func : Gtk_Tree_View_Search_Equal_Func;
Search_User_Data : User_Data_Type;
Search_Destroy : Glib.G_Destroy_Notify_Address);
-- Sets the compare function for the interactive search capabilities;
-- note that somewhat like strcmp returning 0 for equality
-- Gtk_Tree_View_Search_Equal_Func returns False on matches.
-- "search_equal_func": the compare function to use during the search
-- "search_user_data": user data to pass to Search_Equal_Func, or null
-- "search_destroy": Destroy notifier for Search_User_Data, or null
end Set_Search_Equal_Func_User_Data;
generic
type User_Data_Type (<>) is private;
with procedure Destroy (Data : in out User_Data_Type) is null;
package Set_Search_Position_Func_User_Data is
type Gtk_Tree_View_Search_Position_Func is access procedure
(Tree_View : not null access Gtk.Tree_View.Gtk_Tree_View_Record'Class;
Search_Dialog : not null access Gtk.Widget.Gtk_Widget_Record'Class;
User_Data : User_Data_Type);
procedure Set_Search_Position_Func
(Tree_View : not null access Gtk.Tree_View.Gtk_Tree_View_Record'Class;
Func : Gtk_Tree_View_Search_Position_Func;
Data : User_Data_Type);
-- Sets the function to use when positioning the search dialog.
-- Since: gtk+ 2.10
-- "func": the function to use to position the search dialog, or null
-- to use the default search position function
-- "data": user data to pass to Func, or null
end Set_Search_Position_Func_User_Data;
procedure Set_Tooltip_Cell
(Tree_View : not null access Gtk_Tree_View_Record;
Tooltip : not null access Gtk.Tooltip.Gtk_Tooltip_Record'Class;
Path : Gtk.Tree_Model.Gtk_Tree_Path;
Column : access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class;
Cell : access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class);
-- Sets the tip area of Tooltip to the area Path, Column and Cell have in
-- common. For example if Path is null and Column is set, the tip area will
-- be set to the full area covered by Column. See also
-- Gtk.Tooltip.Set_Tip_Area.
-- Note that if Path is not specified and Cell is set and part of a column
-- containing the expander, the tooltip might not show and hide at the
-- correct position. In such cases Path must be set to the current node
-- under the mouse cursor for this function to operate correctly.
-- See also Gtk.Tree_View.Set_Tooltip_Column for a simpler alternative.
-- Since: gtk+ 2.12
-- "tooltip": a Gtk.Tooltip.Gtk_Tooltip
-- "path": a Gtk.Tree_Model.Gtk_Tree_Path or null
-- "column": a Gtk.Tree_View_Column.Gtk_Tree_View_Column or null
-- "cell": a Gtk.Cell_Renderer.Gtk_Cell_Renderer or null
procedure Set_Tooltip_Row
(Tree_View : not null access Gtk_Tree_View_Record;
Tooltip : not null access Gtk.Tooltip.Gtk_Tooltip_Record'Class;
Path : Gtk.Tree_Model.Gtk_Tree_Path);
-- Sets the tip area of Tooltip to be the area covered by the row at Path.
-- See also Gtk.Tree_View.Set_Tooltip_Column for a simpler alternative. See
-- also Gtk.Tooltip.Set_Tip_Area.
-- Since: gtk+ 2.12
-- "tooltip": a Gtk.Tooltip.Gtk_Tooltip
-- "path": a Gtk.Tree_Model.Gtk_Tree_Path
procedure Unset_Rows_Drag_Dest
(Tree_View : not null access Gtk_Tree_View_Record);
-- Undoes the effect of Gtk.Tree_View.Enable_Model_Drag_Dest. Calling this
-- method sets Gtk.Tree_View.Gtk_Tree_View:reorderable to False.
procedure Unset_Rows_Drag_Source
(Tree_View : not null access Gtk_Tree_View_Record);
-- Undoes the effect of Gtk.Tree_View.Enable_Model_Drag_Source. Calling
-- this method sets Gtk.Tree_View.Gtk_Tree_View:reorderable to False.
----------------------
-- GtkAda additions --
----------------------
procedure Gtk_New
(Tree_View : out Gtk_Tree_View;
Model : access Gtk.Tree_Model.Gtk_Root_Tree_Model_Record'Class);
-- A convenience function so that one can directly pass a model, without
-- converting to a Gtk_Tree_Model via the "+" operator.
---------------------------------------------
-- Inherited subprograms (from interfaces) --
---------------------------------------------
-- Methods inherited from the Buildable interface are not duplicated here
-- since they are meant to be used by tools, mostly. If you need to call
-- them, use an explicit cast through the "-" operator below.
function Get_Hadjustment
(Self : not null access Gtk_Tree_View_Record)
return Gtk.Adjustment.Gtk_Adjustment;
procedure Set_Hadjustment
(Self : not null access Gtk_Tree_View_Record;
Hadjustment : access Gtk.Adjustment.Gtk_Adjustment_Record'Class);
function Get_Hscroll_Policy
(Self : not null access Gtk_Tree_View_Record)
return Gtk.Enums.Gtk_Scrollable_Policy;
procedure Set_Hscroll_Policy
(Self : not null access Gtk_Tree_View_Record;
Policy : Gtk.Enums.Gtk_Scrollable_Policy);
function Get_Vadjustment
(Self : not null access Gtk_Tree_View_Record)
return Gtk.Adjustment.Gtk_Adjustment;
procedure Set_Vadjustment
(Self : not null access Gtk_Tree_View_Record;
Vadjustment : access Gtk.Adjustment.Gtk_Adjustment_Record'Class);
function Get_Vscroll_Policy
(Self : not null access Gtk_Tree_View_Record)
return Gtk.Enums.Gtk_Scrollable_Policy;
procedure Set_Vscroll_Policy
(Self : not null access Gtk_Tree_View_Record;
Policy : Gtk.Enums.Gtk_Scrollable_Policy);
----------------
-- Properties --
----------------
-- The following properties are defined for this widget. See
-- Glib.Properties for more information on properties)
Activate_On_Single_Click_Property : constant Glib.Properties.Property_Boolean;
-- The activate-on-single-click property specifies whether the
-- "row-activated" signal will be emitted after a single click.
Enable_Grid_Lines_Property : constant Gtk.Enums.Property_Gtk_Tree_View_Grid_Lines;
Enable_Search_Property : constant Glib.Properties.Property_Boolean;
Enable_Tree_Lines_Property : constant Glib.Properties.Property_Boolean;
Expander_Column_Property : constant Glib.Properties.Property_Object;
-- Type: Gtk.Tree_View_Column.Gtk_Tree_View_Column
Fixed_Height_Mode_Property : constant Glib.Properties.Property_Boolean;
-- Setting the ::fixed-height-mode property to True speeds up
-- Gtk.Tree_View.Gtk_Tree_View by assuming that all rows have the same
-- height. Only enable this option if all rows are the same height. Please
-- see Gtk.Tree_View.Set_Fixed_Height_Mode for more information on this
-- option.
Headers_Clickable_Property : constant Glib.Properties.Property_Boolean;
Headers_Visible_Property : constant Glib.Properties.Property_Boolean;
Hover_Expand_Property : constant Glib.Properties.Property_Boolean;
-- Enables or disables the hover expansion mode of Tree_View. Hover
-- expansion makes rows expand or collapse if the pointer moves over them.
--
-- This mode is primarily intended for treeviews in popups, e.g. in
-- Gtk.Combo_Box.Gtk_Combo_Box or
-- Gtk.Entry_Completion.Gtk_Entry_Completion.
Hover_Selection_Property : constant Glib.Properties.Property_Boolean;
-- Enables or disables the hover selection mode of Tree_View. Hover
-- selection makes the selected row follow the pointer. Currently, this
-- works only for the selection modes Gtk.Enums.Selection_Single and
-- Gtk.Enums.Selection_Browse.
--
-- This mode is primarily intended for treeviews in popups, e.g. in
-- Gtk.Combo_Box.Gtk_Combo_Box or
-- Gtk.Entry_Completion.Gtk_Entry_Completion.
Level_Indentation_Property : constant Glib.Properties.Property_Int;
-- Extra indentation for each level.
Model_Property : constant Glib.Properties.Property_Interface;
-- Type: Gtk.Tree_Model.Gtk_Tree_Model
Reorderable_Property : constant Glib.Properties.Property_Boolean;
Rubber_Banding_Property : constant Glib.Properties.Property_Boolean;
Rules_Hint_Property : constant Glib.Properties.Property_Boolean;
Search_Column_Property : constant Glib.Properties.Property_Int;
Show_Expanders_Property : constant Glib.Properties.Property_Boolean;
-- True if the view has expanders.
Tooltip_Column_Property : constant Glib.Properties.Property_Int;
-------------
-- Signals --
-------------
type Cb_Gtk_Tree_View_Void is not null access procedure (Self : access Gtk_Tree_View_Record'Class);
type Cb_GObject_Void is not null access procedure
(Self : access Glib.Object.GObject_Record'Class);
Signal_Columns_Changed : constant Glib.Signal_Name := "columns-changed";
procedure On_Columns_Changed
(Self : not null access Gtk_Tree_View_Record;
Call : Cb_Gtk_Tree_View_Void;
After : Boolean := False);
procedure On_Columns_Changed
(Self : not null access Gtk_Tree_View_Record;
Call : Cb_GObject_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
-- The number of columns of the treeview has changed.
Signal_Cursor_Changed : constant Glib.Signal_Name := "cursor-changed";
procedure On_Cursor_Changed
(Self : not null access Gtk_Tree_View_Record;
Call : Cb_Gtk_Tree_View_Void;
After : Boolean := False);
procedure On_Cursor_Changed
(Self : not null access Gtk_Tree_View_Record;
Call : Cb_GObject_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
-- The position of the cursor (focused cell) has changed.
type Cb_Gtk_Tree_View_Boolean_Boolean_Boolean_Boolean is not null access function
(Self : access Gtk_Tree_View_Record'Class;
Object : Boolean;
P0 : Boolean;
P1 : Boolean) return Boolean;
type Cb_GObject_Boolean_Boolean_Boolean_Boolean is not null access function
(Self : access Glib.Object.GObject_Record'Class;
Object : Boolean;
P0 : Boolean;
P1 : Boolean) return Boolean;
Signal_Expand_Collapse_Cursor_Row : constant Glib.Signal_Name := "expand-collapse-cursor-row";
procedure On_Expand_Collapse_Cursor_Row
(Self : not null access Gtk_Tree_View_Record;
Call : Cb_Gtk_Tree_View_Boolean_Boolean_Boolean_Boolean;
After : Boolean := False);
procedure On_Expand_Collapse_Cursor_Row
(Self : not null access Gtk_Tree_View_Record;
Call : Cb_GObject_Boolean_Boolean_Boolean_Boolean;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
--
-- Callback parameters:
type Cb_Gtk_Tree_View_Gtk_Movement_Step_Gint_Boolean is not null access function
(Self : access Gtk_Tree_View_Record'Class;
Object : Gtk.Enums.Gtk_Movement_Step;
P0 : Gint) return Boolean;
type Cb_GObject_Gtk_Movement_Step_Gint_Boolean is not null access function
(Self : access Glib.Object.GObject_Record'Class;
Object : Gtk.Enums.Gtk_Movement_Step;
P0 : Gint) return Boolean;
Signal_Move_Cursor : constant Glib.Signal_Name := "move-cursor";
procedure On_Move_Cursor
(Self : not null access Gtk_Tree_View_Record;
Call : Cb_Gtk_Tree_View_Gtk_Movement_Step_Gint_Boolean;
After : Boolean := False);
procedure On_Move_Cursor
(Self : not null access Gtk_Tree_View_Record;
Call : Cb_GObject_Gtk_Movement_Step_Gint_Boolean;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
--
-- Callback parameters:
type Cb_Gtk_Tree_View_Gtk_Tree_Path_Gtk_Tree_View_Column_Void is not null access procedure
(Self : access Gtk_Tree_View_Record'Class;
Path : Gtk.Tree_Model.Gtk_Tree_Path;
Column : not null access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class);
type Cb_GObject_Gtk_Tree_Path_Gtk_Tree_View_Column_Void is not null access procedure
(Self : access Glib.Object.GObject_Record'Class;
Path : Gtk.Tree_Model.Gtk_Tree_Path;
Column : not null access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class);
Signal_Row_Activated : constant Glib.Signal_Name := "row-activated";
procedure On_Row_Activated
(Self : not null access Gtk_Tree_View_Record;
Call : Cb_Gtk_Tree_View_Gtk_Tree_Path_Gtk_Tree_View_Column_Void;
After : Boolean := False);
procedure On_Row_Activated
(Self : not null access Gtk_Tree_View_Record;
Call : Cb_GObject_Gtk_Tree_Path_Gtk_Tree_View_Column_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
-- The "row-activated" signal is emitted when the method
-- Gtk.Tree_View.Row_Activated is called, when the user double clicks a
-- treeview row with the "activate-on-single-click" property set to False,
-- or when the user single clicks a row when the "activate-on-single-click"
-- property set to True. It is also emitted when a non-editable row is
-- selected and one of the keys: Space, Shift+Space, Return or Enter is
-- pressed.
--
-- For selection handling refer to the <link linkend="TreeWidget">tree
-- widget conceptual overview</link> as well as
-- Gtk.Tree_Selection.Gtk_Tree_Selection.
--
-- Callback parameters:
-- -- "path": the Gtk.Tree_Model.Gtk_Tree_Path for the activated row
-- -- "column": the Gtk.Tree_View_Column.Gtk_Tree_View_Column in which the
-- -- activation occurred
type Cb_Gtk_Tree_View_Gtk_Tree_Iter_Gtk_Tree_Path_Void is not null access procedure
(Self : access Gtk_Tree_View_Record'Class;
Iter : Gtk.Tree_Model.Gtk_Tree_Iter;
Path : Gtk.Tree_Model.Gtk_Tree_Path);
type Cb_GObject_Gtk_Tree_Iter_Gtk_Tree_Path_Void is not null access procedure
(Self : access Glib.Object.GObject_Record'Class;
Iter : Gtk.Tree_Model.Gtk_Tree_Iter;
Path : Gtk.Tree_Model.Gtk_Tree_Path);
Signal_Row_Collapsed : constant Glib.Signal_Name := "row-collapsed";
procedure On_Row_Collapsed
(Self : not null access Gtk_Tree_View_Record;
Call : Cb_Gtk_Tree_View_Gtk_Tree_Iter_Gtk_Tree_Path_Void;
After : Boolean := False);
procedure On_Row_Collapsed
(Self : not null access Gtk_Tree_View_Record;
Call : Cb_GObject_Gtk_Tree_Iter_Gtk_Tree_Path_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
-- The given row has been collapsed (child nodes are hidden).
--
-- Callback parameters:
-- -- "iter": the tree iter of the collapsed row
-- -- "path": a tree path that points to the row
Signal_Row_Expanded : constant Glib.Signal_Name := "row-expanded";
procedure On_Row_Expanded
(Self : not null access Gtk_Tree_View_Record;
Call : Cb_Gtk_Tree_View_Gtk_Tree_Iter_Gtk_Tree_Path_Void;
After : Boolean := False);
procedure On_Row_Expanded
(Self : not null access Gtk_Tree_View_Record;
Call : Cb_GObject_Gtk_Tree_Iter_Gtk_Tree_Path_Void;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
-- The given row has been expanded (child nodes are shown).
--
-- Callback parameters:
-- -- "iter": the tree iter of the expanded row
-- -- "path": a tree path that points to the row
type Cb_Gtk_Tree_View_Boolean is not null access function
(Self : access Gtk_Tree_View_Record'Class) return Boolean;
type Cb_GObject_Boolean is not null access function
(Self : access Glib.Object.GObject_Record'Class)
return Boolean;
Signal_Select_All : constant Glib.Signal_Name := "select-all";
procedure On_Select_All
(Self : not null access Gtk_Tree_View_Record;
Call : Cb_Gtk_Tree_View_Boolean;
After : Boolean := False);
procedure On_Select_All
(Self : not null access Gtk_Tree_View_Record;
Call : Cb_GObject_Boolean;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
Signal_Select_Cursor_Parent : constant Glib.Signal_Name := "select-cursor-parent";
procedure On_Select_Cursor_Parent
(Self : not null access Gtk_Tree_View_Record;
Call : Cb_Gtk_Tree_View_Boolean;
After : Boolean := False);
procedure On_Select_Cursor_Parent
(Self : not null access Gtk_Tree_View_Record;
Call : Cb_GObject_Boolean;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
type Cb_Gtk_Tree_View_Boolean_Boolean is not null access function
(Self : access Gtk_Tree_View_Record'Class;
Object : Boolean) return Boolean;
type Cb_GObject_Boolean_Boolean is not null access function
(Self : access Glib.Object.GObject_Record'Class;
Object : Boolean) return Boolean;
Signal_Select_Cursor_Row : constant Glib.Signal_Name := "select-cursor-row";
procedure On_Select_Cursor_Row
(Self : not null access Gtk_Tree_View_Record;
Call : Cb_Gtk_Tree_View_Boolean_Boolean;
After : Boolean := False);
procedure On_Select_Cursor_Row
(Self : not null access Gtk_Tree_View_Record;
Call : Cb_GObject_Boolean_Boolean;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
Signal_Start_Interactive_Search : constant Glib.Signal_Name := "start-interactive-search";
procedure On_Start_Interactive_Search
(Self : not null access Gtk_Tree_View_Record;
Call : Cb_Gtk_Tree_View_Boolean;
After : Boolean := False);
procedure On_Start_Interactive_Search
(Self : not null access Gtk_Tree_View_Record;
Call : Cb_GObject_Boolean;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
type Cb_Gtk_Tree_View_Gtk_Tree_Iter_Gtk_Tree_Path_Boolean is not null access function
(Self : access Gtk_Tree_View_Record'Class;
Iter : Gtk.Tree_Model.Gtk_Tree_Iter;
Path : Gtk.Tree_Model.Gtk_Tree_Path) return Boolean;
type Cb_GObject_Gtk_Tree_Iter_Gtk_Tree_Path_Boolean is not null access function
(Self : access Glib.Object.GObject_Record'Class;
Iter : Gtk.Tree_Model.Gtk_Tree_Iter;
Path : Gtk.Tree_Model.Gtk_Tree_Path) return Boolean;
Signal_Test_Collapse_Row : constant Glib.Signal_Name := "test-collapse-row";
procedure On_Test_Collapse_Row
(Self : not null access Gtk_Tree_View_Record;
Call : Cb_Gtk_Tree_View_Gtk_Tree_Iter_Gtk_Tree_Path_Boolean;
After : Boolean := False);
procedure On_Test_Collapse_Row
(Self : not null access Gtk_Tree_View_Record;
Call : Cb_GObject_Gtk_Tree_Iter_Gtk_Tree_Path_Boolean;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
-- The given row is about to be collapsed (hide its children nodes). Use
-- this signal if you need to control the collapsibility of individual
-- rows.
--
-- Callback parameters:
-- -- "iter": the tree iter of the row to collapse
-- -- "path": a tree path that points to the row
-- -- Returns False to allow collapsing, True to reject
Signal_Test_Expand_Row : constant Glib.Signal_Name := "test-expand-row";
procedure On_Test_Expand_Row
(Self : not null access Gtk_Tree_View_Record;
Call : Cb_Gtk_Tree_View_Gtk_Tree_Iter_Gtk_Tree_Path_Boolean;
After : Boolean := False);
procedure On_Test_Expand_Row
(Self : not null access Gtk_Tree_View_Record;
Call : Cb_GObject_Gtk_Tree_Iter_Gtk_Tree_Path_Boolean;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
-- The given row is about to be expanded (show its children nodes). Use
-- this signal if you need to control the expandability of individual rows.
--
-- Callback parameters:
-- -- "iter": the tree iter of the row to expand
-- -- "path": a tree path that points to the row
-- -- Returns False to allow expansion, True to reject
Signal_Toggle_Cursor_Row : constant Glib.Signal_Name := "toggle-cursor-row";
procedure On_Toggle_Cursor_Row
(Self : not null access Gtk_Tree_View_Record;
Call : Cb_Gtk_Tree_View_Boolean;
After : Boolean := False);
procedure On_Toggle_Cursor_Row
(Self : not null access Gtk_Tree_View_Record;
Call : Cb_GObject_Boolean;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
Signal_Unselect_All : constant Glib.Signal_Name := "unselect-all";
procedure On_Unselect_All
(Self : not null access Gtk_Tree_View_Record;
Call : Cb_Gtk_Tree_View_Boolean;
After : Boolean := False);
procedure On_Unselect_All
(Self : not null access Gtk_Tree_View_Record;
Call : Cb_GObject_Boolean;
Slot : not null access Glib.Object.GObject_Record'Class;
After : Boolean := False);
----------------
-- Interfaces --
----------------
-- This class implements several interfaces. See Glib.Types
--
-- - "Buildable"
--
-- - "Scrollable"
package Implements_Gtk_Buildable is new Glib.Types.Implements
(Gtk.Buildable.Gtk_Buildable, Gtk_Tree_View_Record, Gtk_Tree_View);
function "+"
(Widget : access Gtk_Tree_View_Record'Class)
return Gtk.Buildable.Gtk_Buildable
renames Implements_Gtk_Buildable.To_Interface;
function "-"
(Interf : Gtk.Buildable.Gtk_Buildable)
return Gtk_Tree_View
renames Implements_Gtk_Buildable.To_Object;
package Implements_Gtk_Scrollable is new Glib.Types.Implements
(Gtk.Scrollable.Gtk_Scrollable, Gtk_Tree_View_Record, Gtk_Tree_View);
function "+"
(Widget : access Gtk_Tree_View_Record'Class)
return Gtk.Scrollable.Gtk_Scrollable
renames Implements_Gtk_Scrollable.To_Interface;
function "-"
(Interf : Gtk.Scrollable.Gtk_Scrollable)
return Gtk_Tree_View
renames Implements_Gtk_Scrollable.To_Object;
private
Tooltip_Column_Property : constant Glib.Properties.Property_Int :=
Glib.Properties.Build ("tooltip-column");
Show_Expanders_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("show-expanders");
Search_Column_Property : constant Glib.Properties.Property_Int :=
Glib.Properties.Build ("search-column");
Rules_Hint_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("rules-hint");
Rubber_Banding_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("rubber-banding");
Reorderable_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("reorderable");
Model_Property : constant Glib.Properties.Property_Interface :=
Glib.Properties.Build ("model");
Level_Indentation_Property : constant Glib.Properties.Property_Int :=
Glib.Properties.Build ("level-indentation");
Hover_Selection_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("hover-selection");
Hover_Expand_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("hover-expand");
Headers_Visible_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("headers-visible");
Headers_Clickable_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("headers-clickable");
Fixed_Height_Mode_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("fixed-height-mode");
Expander_Column_Property : constant Glib.Properties.Property_Object :=
Glib.Properties.Build ("expander-column");
Enable_Tree_Lines_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("enable-tree-lines");
Enable_Search_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("enable-search");
Enable_Grid_Lines_Property : constant Gtk.Enums.Property_Gtk_Tree_View_Grid_Lines :=
Gtk.Enums.Build ("enable-grid-lines");
Activate_On_Single_Click_Property : constant Glib.Properties.Property_Boolean :=
Glib.Properties.Build ("activate-on-single-click");
end Gtk.Tree_View;