1. ------------------------------------------------------------------------------ 
  2. --                                                                          -- 
  3. --      Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet       -- 
  4. --                     Copyright (C) 2000-2014, AdaCore                     -- 
  5. --                                                                          -- 
  6. -- This library is free software;  you can redistribute it and/or modify it -- 
  7. -- under terms of the  GNU General Public License  as published by the Free -- 
  8. -- Software  Foundation;  either version 3,  or (at your  option) any later -- 
  9. -- version. This library is distributed in the hope that it will be useful, -- 
  10. -- but WITHOUT ANY WARRANTY;  without even the implied warranty of MERCHAN- -- 
  11. -- TABILITY or FITNESS FOR A PARTICULAR PURPOSE.                            -- 
  12. --                                                                          -- 
  13. -- As a special exception under Section 7 of GPL version 3, you are granted -- 
  14. -- additional permissions described in the GCC Runtime Library Exception,   -- 
  15. -- version 3.1, as published by the Free Software Foundation.               -- 
  16. --                                                                          -- 
  17. -- You should have received a copy of the GNU General Public License and    -- 
  18. -- a copy of the GCC Runtime Library Exception along with this program;     -- 
  19. -- see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see    -- 
  20. -- <http://www.gnu.org/licenses/>.                                          -- 
  21. --                                                                          -- 
  22. ------------------------------------------------------------------------------ 
  23.  
  24. --  <description> 
  25. --  Widget that displays any object that implements the 
  26. --  Gtk.Tree_Model.Gtk_Tree_Model interface. 
  27. -- 
  28. --  Please refer to the <link linkend="TreeWidget">tree widget conceptual 
  29. --  overview</link> for an overview of all the objects and data types related 
  30. --  to the tree widget and how they work together. 
  31. -- 
  32. --  Several different coordinate systems are exposed in the GtkTreeView API. 
  33. --  These are: 
  34. -- 
  35. --  <inlinegraphic fileref="tree-view-coordinates.png" 
  36. --  format="PNG"></inlinegraphic> 
  37. --  == Coordinate systems in GtkTreeView API == 
  38. -- 
  39. --  'Widget coordinates' 
  40. -- 
  41. --     * Coordinates relative to the widget (usually 'widget->window'). 
  42. -- 
  43. --  'Bin window coordinates' 
  44. -- 
  45. --     * Coordinates relative to the window that GtkTreeView renders to. 
  46. -- 
  47. --  'Tree coordinates' 
  48. -- 
  49. --     * Coordinates relative to the entire scrollable area of GtkTreeView. 
  50. --  These coordinates start at (0, 0) for row 0 of the tree. 
  51. -- 
  52. --  Several functions are available for converting between the different 
  53. --  coordinate systems. The most common translations are between widget and bin 
  54. --  window coordinates and between bin window and tree coordinates. For the 
  55. --  former you can use Gtk.Tree_View.Convert_Widget_To_Bin_Window_Coords (and 
  56. --  vice versa), for the latter Gtk.Tree_View.Convert_Bin_Window_To_Tree_Coords 
  57. --  (and vice versa). 
  58. -- 
  59. --  == GtkTreeView as GtkBuildable == 
  60. -- 
  61. --  The GtkTreeView implementation of the GtkBuildable interface accepts 
  62. --  Gtk.Tree_View_Column.Gtk_Tree_View_Column objects as <child> elements and 
  63. --  exposes the internal Gtk.Tree_Selection.Gtk_Tree_Selection in UI 
  64. --  definitions. 
  65. -- 
  66. --  == A UI definition fragment with GtkTreeView == 
  67. -- 
  68. --    <object class="GtkTreeView" id="treeview"> 
  69. --    <property name="model">liststore1</property> 
  70. --    <child> 
  71. --    <object class="GtkTreeViewColumn" id="test-column"> 
  72. --    <property name="title">Test</property> 
  73. --    <child> 
  74. --    <object class="GtkCellRendererText" id="test-renderer"/> 
  75. --    <attributes> 
  76. --    <attribute name="text">1</attribute> 
  77. --    </attributes> 
  78. --    </child> 
  79. --    </object> 
  80. --    </child> 
  81. --    <child internal-child="selection"> 
  82. --    <object class="GtkTreeSelection" id="selection"> 
  83. --    <signal name="changed" handler="on_treeview_selection_changed"/> 
  84. --    </object> 
  85. --    </child> 
  86. --    </object> 
  87. --  </description> 
  88. pragma Ada_2005; 
  89.  
  90. pragma Warnings (Off, "*is already use-visible*"); 
  91. with Cairo;                   use Cairo; 
  92. with Gdk;                     use Gdk; 
  93. with Gdk.Drag_Contexts;       use Gdk.Drag_Contexts; 
  94. with Gdk.Rectangle;           use Gdk.Rectangle; 
  95. with Gdk.Types;               use Gdk.Types; 
  96. with Glib;                    use Glib; 
  97. with Glib.Generic_Properties; use Glib.Generic_Properties; 
  98. with Glib.Object;             use Glib.Object; 
  99. with Glib.Properties;         use Glib.Properties; 
  100. with Glib.Types;              use Glib.Types; 
  101. with Gtk.Adjustment;          use Gtk.Adjustment; 
  102. with Gtk.Buildable;           use Gtk.Buildable; 
  103. with Gtk.Cell_Renderer;       use Gtk.Cell_Renderer; 
  104. with Gtk.Container;           use Gtk.Container; 
  105. with Gtk.Enums;               use Gtk.Enums; 
  106. with Gtk.GEntry;              use Gtk.GEntry; 
  107. with Gtk.Scrollable;          use Gtk.Scrollable; 
  108. with Gtk.Target_List;         use Gtk.Target_List; 
  109. with Gtk.Tooltip;             use Gtk.Tooltip; 
  110. with Gtk.Tree_Model;          use Gtk.Tree_Model; 
  111. with Gtk.Tree_Selection;      use Gtk.Tree_Selection; 
  112. with Gtk.Tree_View_Column;    use Gtk.Tree_View_Column; 
  113. with Gtk.Widget;              use Gtk.Widget; 
  114.  
  115. package Gtk.Tree_View is 
  116.  
  117.    type Gtk_Tree_View_Record is new Gtk_Container_Record with null record; 
  118.    type Gtk_Tree_View is access all Gtk_Tree_View_Record'Class; 
  119.  
  120.    type Gtk_Tree_View_Drop_Position is ( 
  121.       Tree_View_Drop_Before, 
  122.       Tree_View_Drop_After, 
  123.       Tree_View_Drop_Into_Or_Before, 
  124.       Tree_View_Drop_Into_Or_After); 
  125.    pragma Convention (C, Gtk_Tree_View_Drop_Position); 
  126.    --  An enum for determining where a dropped row goes. 
  127.  
  128.    --------------- 
  129.    -- Callbacks -- 
  130.    --------------- 
  131.  
  132.    type Gtk_Tree_Cell_Data_Func is access procedure 
  133.      (Tree_Column : not null access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class; 
  134.       Cell        : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  135.       Tree_Model  : Gtk.Tree_Model.Gtk_Tree_Model; 
  136.       Iter        : Gtk.Tree_Model.Gtk_Tree_Iter); 
  137.    --  A function to set the properties of a cell instead of just using the 
  138.    --  straight mapping between the cell and the model. This is useful for 
  139.    --  customizing the cell renderer. For example, a function might get an 
  140.    --  integer from the Tree_Model, and render it to the "text" attribute of 
  141.    --  "cell" by converting it to its written equivilent. This is set by 
  142.    --  calling gtk_tree_view_column_set_cell_data_func 
  143.    --  "tree_column": A Gtk.Tree_View_Column.Gtk_Tree_View_Column 
  144.    --  "cell": The Gtk.Cell_Renderer.Gtk_Cell_Renderer that is being rendered 
  145.    --  by Tree_Column 
  146.    --  "tree_model": The Gtk.Tree_Model.Gtk_Tree_Model being rendered 
  147.    --  "iter": A Gtk.Tree_Model.Gtk_Tree_Iter of the current row rendered 
  148.  
  149.    type Gtk_Tree_View_Mapping_Func is access procedure 
  150.      (Tree_View : not null access Gtk_Tree_View_Record'Class; 
  151.       Path      : Gtk.Tree_Model.Gtk_Tree_Path); 
  152.    --  Function used for Gtk.Tree_View.Map_Expanded_Rows. 
  153.    --  "tree_view": A Gtk.Tree_View.Gtk_Tree_View 
  154.    --  "path": The path that's expanded 
  155.  
  156.    type Gtk_Tree_View_Column_Drop_Func is access function 
  157.      (Tree_View   : not null access Gtk_Tree_View_Record'Class; 
  158.       Column      : not null access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class; 
  159.       Prev_Column : not null access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class; 
  160.       Next_Column : not null access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class) 
  161.    return Boolean; 
  162.    --  Function type for determining whether Column can be dropped in a 
  163.    --  particular spot (as determined by Prev_Column and Next_Column). In left 
  164.    --  to right locales, Prev_Column is on the left of the potential drop spot, 
  165.    --  and Next_Column is on the right. In right to left mode, this is 
  166.    --  reversed. This function should return True if the spot is a valid drop 
  167.    --  spot. Please note that returning True does not actually indicate that 
  168.    --  the column drop was made, but is meant only to indicate a possible drop 
  169.    --  spot to the user. 
  170.    --  "tree_view": A Gtk.Tree_View.Gtk_Tree_View 
  171.    --  "column": The Gtk.Tree_View_Column.Gtk_Tree_View_Column being dragged 
  172.    --  "prev_column": A Gtk.Tree_View_Column.Gtk_Tree_View_Column on one side 
  173.    --  of Column 
  174.    --  "next_column": A Gtk.Tree_View_Column.Gtk_Tree_View_Column on the other 
  175.    --  side of Column 
  176.  
  177.    type Gtk_Tree_Destroy_Count_Func is access procedure 
  178.      (Tree_View : not null access Gtk_Tree_View_Record'Class; 
  179.       Path      : Gtk.Tree_Model.Gtk_Tree_Path; 
  180.       Children  : Gint); 
  181.  
  182.    type Gtk_Tree_View_Row_Separator_Func is access function 
  183.      (Model : Gtk.Tree_Model.Gtk_Tree_Model; 
  184.       Iter  : Gtk.Tree_Model.Gtk_Tree_Iter) return Boolean; 
  185.    --  Function type for determining whether the row pointed to by Iter should 
  186.    --  be rendered as a separator. A common way to implement this is to have a 
  187.    --  boolean column in the model, whose values the 
  188.    --  Gtk.Tree_View.Gtk_Tree_View_Row_Separator_Func returns. 
  189.    --  "model": the Gtk.Tree_Model.Gtk_Tree_Model 
  190.    --  "iter": a Gtk.Tree_Model.Gtk_Tree_Iter pointing at a row in Model 
  191.  
  192.    type Gtk_Tree_View_Search_Equal_Func is access function 
  193.      (Model  : Gtk.Tree_Model.Gtk_Tree_Model; 
  194.       Column : Gint; 
  195.       Key    : UTF8_String; 
  196.       Iter   : Gtk.Tree_Model.Gtk_Tree_Iter) return Boolean; 
  197.    --  A function used for checking whether a row in Model matches a search 
  198.    --  key string entered by the user. Note the return value is reversed from 
  199.    --  what you would normally expect, though it has some similarity to strcmp 
  200.    --  returning 0 for equal strings. 
  201.    --  "model": the Gtk.Tree_Model.Gtk_Tree_Model being searched 
  202.    --  "column": the search column set by Gtk.Tree_View.Set_Search_Column 
  203.    --  "key": the key string to compare with 
  204.    --  "iter": a Gtk.Tree_Model.Gtk_Tree_Iter pointing the row of Model that 
  205.    --  should be compared with Key. 
  206.  
  207.    type Gtk_Tree_View_Search_Position_Func is access procedure 
  208.      (Tree_View     : not null access Gtk_Tree_View_Record'Class; 
  209.       Search_Dialog : not null access Gtk.Widget.Gtk_Widget_Record'Class); 
  210.  
  211.    ---------------------------- 
  212.    -- Enumeration Properties -- 
  213.    ---------------------------- 
  214.  
  215.    package Gtk_Tree_View_Drop_Position_Properties is 
  216.       new Generic_Internal_Discrete_Property (Gtk_Tree_View_Drop_Position); 
  217.    type Property_Gtk_Tree_View_Drop_Position is new Gtk_Tree_View_Drop_Position_Properties.Property; 
  218.  
  219.    ------------------ 
  220.    -- Constructors -- 
  221.    ------------------ 
  222.  
  223.    procedure Gtk_New (Tree_View : out Gtk_Tree_View); 
  224.    procedure Initialize 
  225.       (Tree_View : not null access Gtk_Tree_View_Record'Class); 
  226.    --  Creates a new Gtk.Tree_View.Gtk_Tree_View widget. 
  227.  
  228.    function Gtk_Tree_View_New return Gtk_Tree_View; 
  229.    --  Creates a new Gtk.Tree_View.Gtk_Tree_View widget. 
  230.  
  231.    procedure Gtk_New 
  232.       (Tree_View : out Gtk_Tree_View; 
  233.        Model     : Gtk.Tree_Model.Gtk_Tree_Model); 
  234.    procedure Initialize 
  235.       (Tree_View : not null access Gtk_Tree_View_Record'Class; 
  236.        Model     : Gtk.Tree_Model.Gtk_Tree_Model); 
  237.    --  Creates a new Gtk.Tree_View.Gtk_Tree_View widget with the model 
  238.    --  initialized to Model. 
  239.    --  "model": the model. 
  240.  
  241.    function Gtk_Tree_View_New_With_Model 
  242.       (Model : Gtk.Tree_Model.Gtk_Tree_Model) return Gtk_Tree_View; 
  243.    --  Creates a new Gtk.Tree_View.Gtk_Tree_View widget with the model 
  244.    --  initialized to Model. 
  245.    --  "model": the model. 
  246.  
  247.    function Get_Type return Glib.GType; 
  248.    pragma Import (C, Get_Type, "gtk_tree_view_get_type"); 
  249.  
  250.    ------------- 
  251.    -- Methods -- 
  252.    ------------- 
  253.  
  254.    function Append_Column 
  255.       (Tree_View : not null access Gtk_Tree_View_Record; 
  256.        Column    : not null access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class) 
  257.        return Gint; 
  258.    --  Appends Column to the list of columns. If Tree_View has "fixed_height" 
  259.    --  mode enabled, then Column must have its "sizing" property set to be 
  260.    --  GTK_TREE_VIEW_COLUMN_FIXED. 
  261.    --  "column": The Gtk.Tree_View_Column.Gtk_Tree_View_Column to add. 
  262.  
  263.    procedure Collapse_All (Tree_View : not null access Gtk_Tree_View_Record); 
  264.    --  Recursively collapses all visible, expanded nodes in Tree_View. 
  265.  
  266.    function Collapse_Row 
  267.       (Tree_View : not null access Gtk_Tree_View_Record; 
  268.        Path      : Gtk.Tree_Model.Gtk_Tree_Path) return Boolean; 
  269.    --  Collapses a row (hides its child rows, if they exist). 
  270.    --  "path": path to a row in the Tree_View 
  271.  
  272.    procedure Columns_Autosize 
  273.       (Tree_View : not null access Gtk_Tree_View_Record); 
  274.    --  Resizes all columns to their optimal width. Only works after the 
  275.    --  treeview has been realized. 
  276.  
  277.    procedure Convert_Bin_Window_To_Tree_Coords 
  278.       (Tree_View : not null access Gtk_Tree_View_Record; 
  279.        Bx        : Gint; 
  280.        By        : Gint; 
  281.        Tx        : out Gint; 
  282.        Ty        : out Gint); 
  283.    --  Converts bin_window coordinates to coordinates for the tree (the full 
  284.    --  scrollable area of the tree). 
  285.    --  Since: gtk+ 2.12 
  286.    --  "bx": X coordinate relative to bin_window 
  287.    --  "by": Y coordinate relative to bin_window 
  288.    --  "tx": return location for tree X coordinate 
  289.    --  "ty": return location for tree Y coordinate 
  290.  
  291.    procedure Convert_Bin_Window_To_Widget_Coords 
  292.       (Tree_View : not null access Gtk_Tree_View_Record; 
  293.        Bx        : Gint; 
  294.        By        : Gint; 
  295.        Wx        : out Gint; 
  296.        Wy        : out Gint); 
  297.    --  Converts bin_window coordinates (see Gtk.Tree_View.Get_Bin_Window) to 
  298.    --  widget relative coordinates. 
  299.    --  Since: gtk+ 2.12 
  300.    --  "bx": bin_window X coordinate 
  301.    --  "by": bin_window Y coordinate 
  302.    --  "wx": return location for widget X coordinate 
  303.    --  "wy": return location for widget Y coordinate 
  304.  
  305.    procedure Convert_Tree_To_Bin_Window_Coords 
  306.       (Tree_View : not null access Gtk_Tree_View_Record; 
  307.        Tx        : Gint; 
  308.        Ty        : Gint; 
  309.        Bx        : out Gint; 
  310.        By        : out Gint); 
  311.    --  Converts tree coordinates (coordinates in full scrollable area of the 
  312.    --  tree) to bin_window coordinates. 
  313.    --  Since: gtk+ 2.12 
  314.    --  "tx": tree X coordinate 
  315.    --  "ty": tree Y coordinate 
  316.    --  "bx": return location for X coordinate relative to bin_window 
  317.    --  "by": return location for Y coordinate relative to bin_window 
  318.  
  319.    procedure Convert_Tree_To_Widget_Coords 
  320.       (Tree_View : not null access Gtk_Tree_View_Record; 
  321.        Tx        : Gint; 
  322.        Ty        : Gint; 
  323.        Wx        : out Gint; 
  324.        Wy        : out Gint); 
  325.    --  Converts tree coordinates (coordinates in full scrollable area of the 
  326.    --  tree) to widget coordinates. 
  327.    --  Since: gtk+ 2.12 
  328.    --  "tx": X coordinate relative to the tree 
  329.    --  "ty": Y coordinate relative to the tree 
  330.    --  "wx": return location for widget X coordinate 
  331.    --  "wy": return location for widget Y coordinate 
  332.  
  333.    procedure Convert_Widget_To_Bin_Window_Coords 
  334.       (Tree_View : not null access Gtk_Tree_View_Record; 
  335.        Wx        : Gint; 
  336.        Wy        : Gint; 
  337.        Bx        : out Gint; 
  338.        By        : out Gint); 
  339.    --  Converts widget coordinates to coordinates for the bin_window (see 
  340.    --  Gtk.Tree_View.Get_Bin_Window). 
  341.    --  Since: gtk+ 2.12 
  342.    --  "wx": X coordinate relative to the widget 
  343.    --  "wy": Y coordinate relative to the widget 
  344.    --  "bx": return location for bin_window X coordinate 
  345.    --  "by": return location for bin_window Y coordinate 
  346.  
  347.    procedure Convert_Widget_To_Tree_Coords 
  348.       (Tree_View : not null access Gtk_Tree_View_Record; 
  349.        Wx        : Gint; 
  350.        Wy        : Gint; 
  351.        Tx        : out Gint; 
  352.        Ty        : out Gint); 
  353.    --  Converts widget coordinates to coordinates for the tree (the full 
  354.    --  scrollable area of the tree). 
  355.    --  Since: gtk+ 2.12 
  356.    --  "wx": X coordinate relative to the widget 
  357.    --  "wy": Y coordinate relative to the widget 
  358.    --  "tx": return location for tree X coordinate 
  359.    --  "ty": return location for tree Y coordinate 
  360.  
  361.    function Create_Row_Drag_Icon 
  362.       (Tree_View : not null access Gtk_Tree_View_Record; 
  363.        Path      : Gtk.Tree_Model.Gtk_Tree_Path) return Cairo.Cairo_Surface; 
  364.    --  Creates a cairo_surface_t representation of the row at Path. This image 
  365.    --  is used for a drag icon. 
  366.    --  "path": a Gtk.Tree_Model.Gtk_Tree_Path in Tree_View 
  367.  
  368.    procedure Enable_Model_Drag_Dest 
  369.       (Tree_View : not null access Gtk_Tree_View_Record; 
  370.        Targets   : Gtk.Target_List.Target_Entry_Array; 
  371.        Actions   : Gdk.Drag_Contexts.Gdk_Drag_Action); 
  372.    --  Turns Tree_View into a drop destination for automatic DND. Calling this 
  373.    --  method sets Gtk.Tree_View.Gtk_Tree_View:reorderable to False. 
  374.    --  "targets": the table of targets that the drag will support 
  375.    --  "actions": the bitmask of possible actions for a drag from this widget 
  376.  
  377.    procedure Enable_Model_Drag_Source 
  378.       (Tree_View         : not null access Gtk_Tree_View_Record; 
  379.        Start_Button_Mask : Gdk.Types.Gdk_Modifier_Type; 
  380.        Targets           : Gtk.Target_List.Target_Entry_Array; 
  381.        Actions           : Gdk.Drag_Contexts.Gdk_Drag_Action); 
  382.    --  Turns Tree_View into a drag source for automatic DND. Calling this 
  383.    --  method sets Gtk.Tree_View.Gtk_Tree_View:reorderable to False. 
  384.    --  "start_button_mask": Mask of allowed buttons to start drag 
  385.    --  "targets": the table of targets that the drag will support 
  386.    --  "actions": the bitmask of possible actions for a drag from this widget 
  387.  
  388.    procedure Expand_All (Tree_View : not null access Gtk_Tree_View_Record); 
  389.    --  Recursively expands all nodes in the Tree_View. 
  390.  
  391.    function Expand_Row 
  392.       (Tree_View : not null access Gtk_Tree_View_Record; 
  393.        Path      : Gtk.Tree_Model.Gtk_Tree_Path; 
  394.        Open_All  : Boolean) return Boolean; 
  395.    --  Opens the row so its children are visible. 
  396.    --  "path": path to a row 
  397.    --  "open_all": whether to recursively expand, or just expand immediate 
  398.    --  children 
  399.  
  400.    procedure Expand_To_Path 
  401.       (Tree_View : not null access Gtk_Tree_View_Record; 
  402.        Path      : Gtk.Tree_Model.Gtk_Tree_Path); 
  403.    --  Expands the row at Path. This will also expand all parent rows of Path 
  404.    --  as necessary. 
  405.    --  Since: gtk+ 2.2 
  406.    --  "path": path to a row. 
  407.  
  408.    function Get_Activate_On_Single_Click 
  409.       (Tree_View : not null access Gtk_Tree_View_Record) return Boolean; 
  410.    --  Gets the setting set by Gtk.Tree_View.Set_Activate_On_Single_Click. 
  411.    --  Since: gtk+ 3.8 
  412.  
  413.    procedure Set_Activate_On_Single_Click 
  414.       (Tree_View : not null access Gtk_Tree_View_Record; 
  415.        Single    : Boolean); 
  416.    --  Cause the Gtk.Tree_View.Gtk_Tree_View::row-activated signal to be 
  417.    --  emitted on a single click instead of a double click. 
  418.    --  Since: gtk+ 3.8 
  419.    --  "single": True to emit row-activated on a single click 
  420.  
  421.    procedure Get_Background_Area 
  422.       (Tree_View : not null access Gtk_Tree_View_Record; 
  423.        Path      : Gtk.Tree_Model.Gtk_Tree_Path; 
  424.        Column    : access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class; 
  425.        Rect      : out Gdk.Rectangle.Gdk_Rectangle); 
  426.    --  Fills the bounding rectangle in bin_window coordinates for the cell at 
  427.    --  the row specified by Path and the column specified by Column. If Path is 
  428.    --  null, or points to a node not found in the tree, the Y and Height fields 
  429.    --  of the rectangle will be filled with 0. If Column is null, the X and 
  430.    --  Width fields will be filled with 0. The returned rectangle is equivalent 
  431.    --  to the Background_Area passed to Gtk.Cell_Renderer.Render. These 
  432.    --  background areas tile to cover the entire bin window. Contrast with the 
  433.    --  Cell_Area, returned by Gtk.Tree_View.Get_Cell_Area, which returns only 
  434.    --  the cell itself, excluding surrounding borders and the tree expander 
  435.    --  area. 
  436.    --  "path": a Gtk.Tree_Model.Gtk_Tree_Path for the row, or null to get only 
  437.    --  horizontal coordinates 
  438.    --  "column": a Gtk.Tree_View_Column.Gtk_Tree_View_Column for the column, 
  439.    --  or null to get only vertical coordiantes 
  440.    --  "rect": rectangle to fill with cell background rect 
  441.  
  442.    function Get_Bin_Window 
  443.       (Tree_View : not null access Gtk_Tree_View_Record) 
  444.        return Gdk.Gdk_Window; 
  445.    --  Returns the window that Tree_View renders to. This is used primarily to 
  446.    --  compare to 'event->window' to confirm that the event on Tree_View is on 
  447.    --  the right window. 
  448.  
  449.    procedure Get_Cell_Area 
  450.       (Tree_View : not null access Gtk_Tree_View_Record; 
  451.        Path      : Gtk.Tree_Model.Gtk_Tree_Path; 
  452.        Column    : access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class; 
  453.        Rect      : out Gdk.Rectangle.Gdk_Rectangle); 
  454.    --  Fills the bounding rectangle in bin_window coordinates for the cell at 
  455.    --  the row specified by Path and the column specified by Column. If Path is 
  456.    --  null, or points to a path not currently displayed, the Y and Height 
  457.    --  fields of the rectangle will be filled with 0. If Column is null, the X 
  458.    --  and Width fields will be filled with 0. The sum of all cell rects does 
  459.    --  not cover the entire tree; there are extra pixels in between rows, for 
  460.    --  example. The returned rectangle is equivalent to the Cell_Area passed to 
  461.    --  Gtk.Cell_Renderer.Render. This function is only valid if Tree_View is 
  462.    --  realized. 
  463.    --  "path": a Gtk.Tree_Model.Gtk_Tree_Path for the row, or null to get only 
  464.    --  horizontal coordinates 
  465.    --  "column": a Gtk.Tree_View_Column.Gtk_Tree_View_Column for the column, 
  466.    --  or null to get only vertical coordinates 
  467.    --  "rect": rectangle to fill with cell rect 
  468.  
  469.    function Get_Column 
  470.       (Tree_View : not null access Gtk_Tree_View_Record; 
  471.        N         : Gint) return Gtk.Tree_View_Column.Gtk_Tree_View_Column; 
  472.    --  Gets the Gtk.Tree_View_Column.Gtk_Tree_View_Column at the given 
  473.    --  position in the tree_view. 
  474.    --  "n": The position of the column, counting from 0. 
  475.  
  476.    function Get_Columns 
  477.       (Tree_View : not null access Gtk_Tree_View_Record) 
  478.        return Gtk.Tree_View_Column.Column_List.Glist; 
  479.    --  Returns a GList of all the Gtk.Tree_View_Column.Gtk_Tree_View_Column s 
  480.    --  currently in Tree_View. The returned list must be freed with g_list_free 
  481.    --  (). 
  482.  
  483.    procedure Get_Cursor 
  484.       (Tree_View    : not null access Gtk_Tree_View_Record; 
  485.        Path         : out Gtk.Tree_Model.Gtk_Tree_Path; 
  486.        Focus_Column : out Gtk.Tree_View_Column.Gtk_Tree_View_Column); 
  487.    --  Fills in Path and Focus_Column with the current path and focus column. 
  488.    --  If the cursor isn't currently set, then *Path will be null. If no column 
  489.    --  currently has focus, then *Focus_Column will be null. 
  490.    --  The returned Gtk.Tree_Model.Gtk_Tree_Path must be freed with 
  491.    --  Gtk.Tree_Model.Path_Free when you are done with it. 
  492.    --  "path": A pointer to be filled with the current cursor path, or null 
  493.    --  "focus_column": A pointer to be filled with the current focus column, 
  494.    --  or null 
  495.  
  496.    procedure Set_Cursor 
  497.       (Tree_View     : not null access Gtk_Tree_View_Record; 
  498.        Path          : Gtk.Tree_Model.Gtk_Tree_Path; 
  499.        Focus_Column  : access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class; 
  500.        Start_Editing : Boolean); 
  501.    --  Sets the current keyboard focus to be at Path, and selects it. This is 
  502.    --  useful when you want to focus the user's attention on a particular row. 
  503.    --  If Focus_Column is not null, then focus is given to the column specified 
  504.    --  by it. Additionally, if Focus_Column is specified, and Start_Editing is 
  505.    --  True, then editing should be started in the specified cell. This 
  506.    --  function is often followed by Gtk_Widget_Grab_Focus (Tree_View) in order 
  507.    --  to give keyboard focus to the widget. Please note that editing can only 
  508.    --  happen when the widget is realized. 
  509.    --  If Path is invalid for Model, the current cursor (if any) will be unset 
  510.    --  and the function will return without failing. 
  511.    --  "path": A Gtk.Tree_Model.Gtk_Tree_Path 
  512.    --  "focus_column": A Gtk.Tree_View_Column.Gtk_Tree_View_Column, or null 
  513.    --  "start_editing": True if the specified cell should start being edited. 
  514.  
  515.    function Get_Dest_Row_At_Pos 
  516.       (Tree_View : not null access Gtk_Tree_View_Record; 
  517.        Drag_X    : Gint; 
  518.        Drag_Y    : Gint; 
  519.        Path      : access Gtk.Tree_Model.Gtk_Tree_Path; 
  520.        Pos       : access Gtk_Tree_View_Drop_Position) return Boolean; 
  521.    --  Determines the destination row for a given position. Drag_X and Drag_Y 
  522.    --  are expected to be in widget coordinates. This function is only 
  523.    --  meaningful if Tree_View is realized. Therefore this function will always 
  524.    --  return False if Tree_View is not realized or does not have a model. 
  525.    --  "drag_x": the position to determine the destination row for 
  526.    --  "drag_y": the position to determine the destination row for 
  527.    --  "path": Return location for the path of the highlighted row, or null. 
  528.    --  "pos": Return location for the drop position, or null 
  529.  
  530.    procedure Get_Drag_Dest_Row 
  531.       (Tree_View : not null access Gtk_Tree_View_Record; 
  532.        Path      : out Gtk.Tree_Model.Gtk_Tree_Path; 
  533.        Pos       : out Gtk_Tree_View_Drop_Position); 
  534.    --  Gets information about the row that is highlighted for feedback. 
  535.    --  "path": Return location for the path of the highlighted row, or null. 
  536.    --  "pos": Return location for the drop position, or null 
  537.  
  538.    procedure Set_Drag_Dest_Row 
  539.       (Tree_View : not null access Gtk_Tree_View_Record; 
  540.        Path      : Gtk.Tree_Model.Gtk_Tree_Path; 
  541.        Pos       : Gtk_Tree_View_Drop_Position); 
  542.    --  Sets the row that is highlighted for feedback. If Path is null, an 
  543.    --  existing highlight is removed. 
  544.    --  "path": The path of the row to highlight, or null 
  545.    --  "pos": Specifies whether to drop before, after or into the row 
  546.  
  547.    function Get_Enable_Search 
  548.       (Tree_View : not null access Gtk_Tree_View_Record) return Boolean; 
  549.    --  Returns whether or not the tree allows to start interactive searching 
  550.    --  by typing in text. 
  551.  
  552.    procedure Set_Enable_Search 
  553.       (Tree_View     : not null access Gtk_Tree_View_Record; 
  554.        Enable_Search : Boolean); 
  555.    --  If Enable_Search is set, then the user can type in text to search 
  556.    --  through the tree interactively (this is sometimes called "typeahead 
  557.    --  find"). 
  558.    --  Note that even if this is False, the user can still initiate a search 
  559.    --  using the "start-interactive-search" key binding. 
  560.    --  "enable_search": True, if the user can search interactively 
  561.  
  562.    function Get_Enable_Tree_Lines 
  563.       (Tree_View : not null access Gtk_Tree_View_Record) return Boolean; 
  564.    --  Returns whether or not tree lines are drawn in Tree_View. 
  565.    --  Since: gtk+ 2.10 
  566.  
  567.    procedure Set_Enable_Tree_Lines 
  568.       (Tree_View : not null access Gtk_Tree_View_Record; 
  569.        Enabled   : Boolean); 
  570.    --  Sets whether to draw lines interconnecting the expanders in Tree_View. 
  571.    --  This does not have any visible effects for lists. 
  572.    --  Since: gtk+ 2.10 
  573.    --  "enabled": True to enable tree line drawing, False otherwise. 
  574.  
  575.    function Get_Expander_Column 
  576.       (Tree_View : not null access Gtk_Tree_View_Record) 
  577.        return Gtk.Tree_View_Column.Gtk_Tree_View_Column; 
  578.    --  Returns the column that is the current expander column. This column has 
  579.    --  the expander arrow drawn next to it. 
  580.  
  581.    procedure Set_Expander_Column 
  582.       (Tree_View : not null access Gtk_Tree_View_Record; 
  583.        Column    : access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class); 
  584.    --  Sets the column to draw the expander arrow at. It must be in Tree_View. 
  585.    --  If Column is null, then the expander arrow is always at the first 
  586.    --  visible column. 
  587.    --  If you do not want expander arrow to appear in your tree, set the 
  588.    --  expander column to a hidden column. 
  589.    --  "column": null, or the column to draw the expander arrow at. 
  590.  
  591.    function Get_Fixed_Height_Mode 
  592.       (Tree_View : not null access Gtk_Tree_View_Record) return Boolean; 
  593.    --  Returns whether fixed height mode is turned on for Tree_View. 
  594.    --  Since: gtk+ 2.6 
  595.  
  596.    procedure Set_Fixed_Height_Mode 
  597.       (Tree_View : not null access Gtk_Tree_View_Record; 
  598.        Enable    : Boolean); 
  599.    --  Enables or disables the fixed height mode of Tree_View. Fixed height 
  600.    --  mode speeds up Gtk.Tree_View.Gtk_Tree_View by assuming that all rows 
  601.    --  have the same height. Only enable this option if all rows are the same 
  602.    --  height and all columns are of type 
  603.    --  Gtk.Tree_View_Column.Tree_View_Column_Fixed. 
  604.    --  Since: gtk+ 2.6 
  605.    --  "enable": True to enable fixed height mode 
  606.  
  607.    function Get_Grid_Lines 
  608.       (Tree_View : not null access Gtk_Tree_View_Record) 
  609.        return Gtk.Enums.Gtk_Tree_View_Grid_Lines; 
  610.    --  Returns which grid lines are enabled in Tree_View. 
  611.    --  Since: gtk+ 2.10 
  612.  
  613.    procedure Set_Grid_Lines 
  614.       (Tree_View  : not null access Gtk_Tree_View_Record; 
  615.        Grid_Lines : Gtk.Enums.Gtk_Tree_View_Grid_Lines); 
  616.    --  Sets which grid lines to draw in Tree_View. 
  617.    --  Since: gtk+ 2.10 
  618.    --  "grid_lines": a Gtk.Enums.Gtk_Tree_View_Grid_Lines value indicating 
  619.    --  which grid lines to enable. 
  620.  
  621.    function Get_Headers_Clickable 
  622.       (Tree_View : not null access Gtk_Tree_View_Record) return Boolean; 
  623.    --  Returns whether all header columns are clickable. 
  624.    --  Since: gtk+ 2.10 
  625.  
  626.    procedure Set_Headers_Clickable 
  627.       (Tree_View : not null access Gtk_Tree_View_Record; 
  628.        Setting   : Boolean); 
  629.    --  Allow the column title buttons to be clicked. 
  630.    --  "setting": True if the columns are clickable. 
  631.  
  632.    function Get_Headers_Visible 
  633.       (Tree_View : not null access Gtk_Tree_View_Record) return Boolean; 
  634.    --  Returns True if the headers on the Tree_View are visible. 
  635.  
  636.    procedure Set_Headers_Visible 
  637.       (Tree_View       : not null access Gtk_Tree_View_Record; 
  638.        Headers_Visible : Boolean); 
  639.    --  Sets the visibility state of the headers. 
  640.    --  "headers_visible": True if the headers are visible 
  641.  
  642.    function Get_Hover_Expand 
  643.       (Tree_View : not null access Gtk_Tree_View_Record) return Boolean; 
  644.    --  Returns whether hover expansion mode is turned on for Tree_View. 
  645.    --  Since: gtk+ 2.6 
  646.  
  647.    procedure Set_Hover_Expand 
  648.       (Tree_View : not null access Gtk_Tree_View_Record; 
  649.        Expand    : Boolean); 
  650.    --  Enables or disables the hover expansion mode of Tree_View. Hover 
  651.    --  expansion makes rows expand or collapse if the pointer moves over them. 
  652.    --  Since: gtk+ 2.6 
  653.    --  "expand": True to enable hover selection mode 
  654.  
  655.    function Get_Hover_Selection 
  656.       (Tree_View : not null access Gtk_Tree_View_Record) return Boolean; 
  657.    --  Returns whether hover selection mode is turned on for Tree_View. 
  658.    --  Since: gtk+ 2.6 
  659.  
  660.    procedure Set_Hover_Selection 
  661.       (Tree_View : not null access Gtk_Tree_View_Record; 
  662.        Hover     : Boolean); 
  663.    --  Enables or disables the hover selection mode of Tree_View. Hover 
  664.    --  selection makes the selected row follow the pointer. Currently, this 
  665.    --  works only for the selection modes Gtk.Enums.Selection_Single and 
  666.    --  Gtk.Enums.Selection_Browse. 
  667.    --  Since: gtk+ 2.6 
  668.    --  "hover": True to enable hover selection mode 
  669.  
  670.    function Get_Level_Indentation 
  671.       (Tree_View : not null access Gtk_Tree_View_Record) return Gint; 
  672.    --  Returns the amount, in pixels, of extra indentation for child levels in 
  673.    --  Tree_View. 
  674.    --  Since: gtk+ 2.12 
  675.  
  676.    procedure Set_Level_Indentation 
  677.       (Tree_View   : not null access Gtk_Tree_View_Record; 
  678.        Indentation : Gint); 
  679.    --  Sets the amount of extra indentation for child levels to use in 
  680.    --  Tree_View in addition to the default indentation. The value should be 
  681.    --  specified in pixels, a value of 0 disables this feature and in this case 
  682.    --  only the default indentation will be used. This does not have any 
  683.    --  visible effects for lists. 
  684.    --  Since: gtk+ 2.12 
  685.    --  "indentation": the amount, in pixels, of extra indentation in 
  686.    --  Tree_View. 
  687.  
  688.    function Get_Model 
  689.       (Tree_View : not null access Gtk_Tree_View_Record) 
  690.        return Gtk.Tree_Model.Gtk_Tree_Model; 
  691.    --  Returns the model the Gtk.Tree_View.Gtk_Tree_View is based on. Returns 
  692.    --  null if the model is unset. 
  693.  
  694.    procedure Set_Model 
  695.       (Tree_View : not null access Gtk_Tree_View_Record; 
  696.        Model     : Gtk.Tree_Model.Gtk_Tree_Model); 
  697.    --  Sets the model for a Gtk.Tree_View.Gtk_Tree_View. If the Tree_View 
  698.    --  already has a model set, it will remove it before setting the new model. 
  699.    --  If Model is null, then it will unset the old model. 
  700.    --  "model": The model. 
  701.  
  702.    function Get_N_Columns 
  703.       (Tree_View : not null access Gtk_Tree_View_Record) return Guint; 
  704.    --  Queries the number of columns in the given Tree_View. 
  705.    --  Since: gtk+ 3.4 
  706.  
  707.    procedure Get_Path_At_Pos 
  708.       (Tree_View : not null access Gtk_Tree_View_Record; 
  709.        X         : Gint; 
  710.        Y         : Gint; 
  711.        Path      : out Gtk.Tree_Model.Gtk_Tree_Path; 
  712.        Column    : out Gtk.Tree_View_Column.Gtk_Tree_View_Column; 
  713.        Cell_X    : out Gint; 
  714.        Cell_Y    : out Gint; 
  715.        Row_Found : out Boolean); 
  716.    --  Finds the path at the point (X, Y), relative to bin_window coordinates 
  717.    --  (please see Gtk.Tree_View.Get_Bin_Window). That is, X and Y are relative 
  718.    --  to an events coordinates. X and Y must come from an event on the 
  719.    --  Tree_View only where 'event->window == gtk_tree_view_get_bin_window 
  720.    --  (<!-- -->)'. It is primarily for things like popup menus. If Path is 
  721.    --  non-null, then it will be filled with the Gtk.Tree_Model.Gtk_Tree_Path 
  722.    --  at that point. This path should be freed with Gtk.Tree_Model.Path_Free. 
  723.    --  If Column is non-null, then it will be filled with the column at that 
  724.    --  point. Cell_X and Cell_Y return the coordinates relative to the cell 
  725.    --  background (i.e. the Background_Area passed to 
  726.    --  Gtk.Cell_Renderer.Render). This function is only meaningful if Tree_View 
  727.    --  is realized. Therefore this function will always return False if 
  728.    --  Tree_View is not realized or does not have a model. 
  729.    --  For converting widget coordinates (eg. the ones you get from 
  730.    --  GtkWidget::query-tooltip), please see 
  731.    --  Gtk.Tree_View.Convert_Widget_To_Bin_Window_Coords. 
  732.    --  "x": The x position to be identified (relative to bin_window). 
  733.    --  "y": The y position to be identified (relative to bin_window). 
  734.    --  "path": A pointer to a Gtk.Tree_Model.Gtk_Tree_Path pointer to be 
  735.    --  filled in, or null 
  736.    --  "column": A pointer to a Gtk.Tree_View_Column.Gtk_Tree_View_Column 
  737.    --  pointer to be filled in, or null 
  738.    --  "cell_x": A pointer where the X coordinate relative to the cell can be 
  739.    --  placed, or null 
  740.    --  "cell_y": A pointer where the Y coordinate relative to the cell can be 
  741.    --  placed, or null 
  742.  
  743.    function Get_Reorderable 
  744.       (Tree_View : not null access Gtk_Tree_View_Record) return Boolean; 
  745.    --  Retrieves whether the user can reorder the tree via drag-and-drop. See 
  746.    --  Gtk.Tree_View.Set_Reorderable. 
  747.  
  748.    procedure Set_Reorderable 
  749.       (Tree_View   : not null access Gtk_Tree_View_Record; 
  750.        Reorderable : Boolean); 
  751.    --  This function is a convenience function to allow you to reorder models 
  752.    --  that support the Gtk_Tree_Drag_Source_Iface and the 
  753.    --  Gtk_Tree_Drag_Dest_Iface. Both Gtk.Tree_Store.Gtk_Tree_Store and 
  754.    --  Gtk.List_Store.Gtk_List_Store support these. If Reorderable is True, 
  755.    --  then the user can reorder the model by dragging and dropping rows. The 
  756.    --  developer can listen to these changes by connecting to the model's 
  757.    --  row_inserted and row_deleted signals. The reordering is implemented by 
  758.    --  setting up the tree view as a drag source and destination. Therefore, 
  759.    --  drag and drop can not be used in a reorderable view for any other 
  760.    --  purpose. 
  761.    --  This function does not give you any degree of control over the order -- 
  762.    --  any reordering is allowed. If more control is needed, you should 
  763.    --  probably handle drag and drop manually. 
  764.    --  "reorderable": True, if the tree can be reordered. 
  765.  
  766.    procedure Get_Row_Separator_Func 
  767.       (Tree_View : not null access Gtk_Tree_View_Record); 
  768.    --  Returns the current row separator function. 
  769.    --  Since: gtk+ 2.6 
  770.  
  771.    procedure Set_Row_Separator_Func 
  772.       (Tree_View : not null access Gtk_Tree_View_Record; 
  773.        Func      : Gtk_Tree_View_Row_Separator_Func); 
  774.    --  Sets the row separator function, which is used to determine whether a 
  775.    --  row should be drawn as a separator. If the row separator function is 
  776.    --  null, no separators are drawn. This is the default value. 
  777.    --  Since: gtk+ 2.6 
  778.    --  "func": a Gtk.Tree_View.Gtk_Tree_View_Row_Separator_Func 
  779.  
  780.    function Get_Rubber_Banding 
  781.       (Tree_View : not null access Gtk_Tree_View_Record) return Boolean; 
  782.    --  Returns whether rubber banding is turned on for Tree_View. If the 
  783.    --  selection mode is GTK_SELECTION_MULTIPLE, rubber banding will allow the 
  784.    --  user to select multiple rows by dragging the mouse. 
  785.    --  Since: gtk+ 2.10 
  786.  
  787.    procedure Set_Rubber_Banding 
  788.       (Tree_View : not null access Gtk_Tree_View_Record; 
  789.        Enable    : Boolean); 
  790.    --  Enables or disables rubber banding in Tree_View. If the selection mode 
  791.    --  is GTK_SELECTION_MULTIPLE, rubber banding will allow the user to select 
  792.    --  multiple rows by dragging the mouse. 
  793.    --  Since: gtk+ 2.10 
  794.    --  "enable": True to enable rubber banding 
  795.  
  796.    function Get_Rules_Hint 
  797.       (Tree_View : not null access Gtk_Tree_View_Record) return Boolean; 
  798.    --  Gets the setting set by Gtk.Tree_View.Set_Rules_Hint. 
  799.  
  800.    procedure Set_Rules_Hint 
  801.       (Tree_View : not null access Gtk_Tree_View_Record; 
  802.        Setting   : Boolean); 
  803.    --  This function tells GTK+ that the user interface for your application 
  804.    --  requires users to read across tree rows and associate cells with one 
  805.    --  another. By default, GTK+ will then render the tree with alternating row 
  806.    --  colors. Do *not* use it just because you prefer the appearance of the 
  807.    --  ruled tree; that's a question for the theme. Some themes will draw tree 
  808.    --  rows in alternating colors even when rules are turned off, and users who 
  809.    --  prefer that appearance all the time can choose those themes. You should 
  810.    --  call this function only as a *semantic* hint to the theme engine that 
  811.    --  your tree makes alternating colors useful from a functional standpoint 
  812.    --  (since it has lots of columns, generally). 
  813.    --  "setting": True if the tree requires reading across rows 
  814.  
  815.    function Get_Search_Column 
  816.       (Tree_View : not null access Gtk_Tree_View_Record) return Gint; 
  817.    --  Gets the column searched on by the interactive search code. 
  818.  
  819.    procedure Set_Search_Column 
  820.       (Tree_View : not null access Gtk_Tree_View_Record; 
  821.        Column    : Gint); 
  822.    --  Sets Column as the column where the interactive search code should 
  823.    --  search in for the current model. 
  824.    --  If the search column is set, users can use the 
  825.    --  "start-interactive-search" key binding to bring up search popup. The 
  826.    --  enable-search property controls whether simply typing text will also 
  827.    --  start an interactive search. 
  828.    --  Note that Column refers to a column of the current model. The search 
  829.    --  column is reset to -1 when the model is changed. 
  830.    --  "column": the column of the model to search in, or -1 to disable 
  831.    --  searching 
  832.  
  833.    function Get_Search_Entry 
  834.       (Tree_View : not null access Gtk_Tree_View_Record) 
  835.        return Gtk.GEntry.Gtk_Entry; 
  836.    --  Returns the Gtk.GEntry.Gtk_Entry which is currently in use as 
  837.    --  interactive search entry for Tree_View. In case the built-in entry is 
  838.    --  being used, null will be returned. 
  839.    --  Since: gtk+ 2.10 
  840.  
  841.    procedure Set_Search_Entry 
  842.       (Tree_View : not null access Gtk_Tree_View_Record; 
  843.        GEntry    : access Gtk.GEntry.Gtk_Entry_Record'Class); 
  844.    --  Sets the entry which the interactive search code will use for this 
  845.    --  Tree_View. This is useful when you want to provide a search entry in our 
  846.    --  interface at all time at a fixed position. Passing null for Entry will 
  847.    --  make the interactive search code use the built-in popup entry again. 
  848.    --  Since: gtk+ 2.10 
  849.    --  "entry": the entry the interactive search code of Tree_View should use 
  850.    --  or null 
  851.  
  852.    procedure Get_Search_Equal_Func 
  853.       (Tree_View : not null access Gtk_Tree_View_Record); 
  854.    --  Returns the compare function currently in use. 
  855.  
  856.    procedure Set_Search_Equal_Func 
  857.       (Tree_View         : not null access Gtk_Tree_View_Record; 
  858.        Search_Equal_Func : Gtk_Tree_View_Search_Equal_Func; 
  859.        Search_Destroy    : Glib.G_Destroy_Notify_Address); 
  860.    --  Sets the compare function for the interactive search capabilities; note 
  861.    --  that somewhat like strcmp returning 0 for equality 
  862.    --  Gtk_Tree_View_Search_Equal_Func returns False on matches. 
  863.    --  "search_equal_func": the compare function to use during the search 
  864.    --  "search_destroy": Destroy notifier for Search_User_Data, or null 
  865.  
  866.    procedure Get_Search_Position_Func 
  867.       (Tree_View : not null access Gtk_Tree_View_Record); 
  868.    --  Returns the positioning function currently in use. 
  869.    --  Since: gtk+ 2.10 
  870.  
  871.    procedure Set_Search_Position_Func 
  872.       (Tree_View : not null access Gtk_Tree_View_Record; 
  873.        Func      : Gtk_Tree_View_Search_Position_Func); 
  874.    --  Sets the function to use when positioning the search dialog. 
  875.    --  Since: gtk+ 2.10 
  876.    --  "func": the function to use to position the search dialog, or null to 
  877.    --  use the default search position function 
  878.  
  879.    function Get_Selection 
  880.       (Tree_View : not null access Gtk_Tree_View_Record) 
  881.        return Gtk.Tree_Selection.Gtk_Tree_Selection; 
  882.    --  Gets the Gtk.Tree_Selection.Gtk_Tree_Selection associated with 
  883.    --  Tree_View. 
  884.  
  885.    function Get_Show_Expanders 
  886.       (Tree_View : not null access Gtk_Tree_View_Record) return Boolean; 
  887.    --  Returns whether or not expanders are drawn in Tree_View. 
  888.    --  Since: gtk+ 2.12 
  889.  
  890.    procedure Set_Show_Expanders 
  891.       (Tree_View : not null access Gtk_Tree_View_Record; 
  892.        Enabled   : Boolean); 
  893.    --  Sets whether to draw and enable expanders and indent child rows in 
  894.    --  Tree_View. When disabled there will be no expanders visible in trees and 
  895.    --  there will be no way to expand and collapse rows by default. Also note 
  896.    --  that hiding the expanders will disable the default indentation. You can 
  897.    --  set a custom indentation in this case using 
  898.    --  Gtk.Tree_View.Set_Level_Indentation. This does not have any visible 
  899.    --  effects for lists. 
  900.    --  Since: gtk+ 2.12 
  901.    --  "enabled": True to enable expander drawing, False otherwise. 
  902.  
  903.    function Get_Tooltip_Column 
  904.       (Tree_View : not null access Gtk_Tree_View_Record) return Gint; 
  905.    --  Returns the column of Tree_View's model which is being used for 
  906.    --  displaying tooltips on Tree_View's rows. 
  907.    --  Since: gtk+ 2.12 
  908.  
  909.    procedure Set_Tooltip_Column 
  910.       (Tree_View : not null access Gtk_Tree_View_Record; 
  911.        Column    : Gint); 
  912.    --  If you only plan to have simple (text-only) tooltips on full rows, you 
  913.    --  can use this function to have Gtk.Tree_View.Gtk_Tree_View handle these 
  914.    --  automatically for you. Column should be set to the column in Tree_View's 
  915.    --  model containing the tooltip texts, or -1 to disable this feature. 
  916.    --  When enabled, Gtk.Widget.Gtk_Widget:has-tooltip will be set to True and 
  917.    --  Tree_View will connect a Gtk.Widget.Gtk_Widget::query-tooltip signal 
  918.    --  handler. 
  919.    --  Note that the signal handler sets the text with Gtk.Tooltip.Set_Markup, 
  920.    --  so &amp;, <, etc have to be escaped in the text. 
  921.    --  Since: gtk+ 2.12 
  922.    --  "column": an integer, which is a valid column number for Tree_View's 
  923.    --  model 
  924.  
  925.    procedure Get_Tooltip_Context 
  926.       (Tree_View    : not null access Gtk_Tree_View_Record; 
  927.        X            : in out Gint; 
  928.        Y            : in out Gint; 
  929.        Keyboard_Tip : Boolean; 
  930.        Model        : out Gtk.Tree_Model.Gtk_Tree_Model; 
  931.        Path         : out Gtk.Tree_Model.Gtk_Tree_Path; 
  932.        Iter         : out Gtk.Tree_Model.Gtk_Tree_Iter; 
  933.        Success      : out Boolean); 
  934.    --  This function is supposed to be used in a 
  935.    --  Gtk.Widget.Gtk_Widget::query-tooltip signal handler for 
  936.    --  Gtk.Tree_View.Gtk_Tree_View. The X, Y and Keyboard_Tip values which are 
  937.    --  received in the signal handler, should be passed to this function 
  938.    --  without modification. 
  939.    --  The return value indicates whether there is a tree view row at the 
  940.    --  given coordinates (True) or not (False) for mouse tooltips. For keyboard 
  941.    --  tooltips the row returned will be the cursor row. When True, then any of 
  942.    --  Model, Path and Iter which have been provided will be set to point to 
  943.    --  that row and the corresponding model. X and Y will always be converted 
  944.    --  to be relative to Tree_View's bin_window if Keyboard_Tooltip is False. 
  945.    --  Since: gtk+ 2.12 
  946.    --  "x": the x coordinate (relative to widget coordinates) 
  947.    --  "y": the y coordinate (relative to widget coordinates) 
  948.    --  "keyboard_tip": whether this is a keyboard tooltip or not 
  949.    --  "model": a pointer to receive a Gtk.Tree_Model.Gtk_Tree_Model or null 
  950.    --  "path": a pointer to receive a Gtk.Tree_Model.Gtk_Tree_Path or null 
  951.    --  "iter": a pointer to receive a Gtk.Tree_Model.Gtk_Tree_Iter or null 
  952.  
  953.    procedure Get_Visible_Range 
  954.       (Tree_View  : not null access Gtk_Tree_View_Record; 
  955.        Start_Path : out Gtk.Tree_Model.Gtk_Tree_Path; 
  956.        End_Path   : out Gtk.Tree_Model.Gtk_Tree_Path; 
  957.        Success    : out Boolean); 
  958.    --  Sets Start_Path and End_Path to be the first and last visible path. 
  959.    --  Note that there may be invisible paths in between. 
  960.    --  The paths should be freed with Gtk.Tree_Model.Path_Free after use. 
  961.    --  Since: gtk+ 2.8 
  962.    --  "start_path": Return location for start of region, or null. 
  963.    --  "end_path": Return location for end of region, or null. 
  964.  
  965.    procedure Get_Visible_Rect 
  966.       (Tree_View    : not null access Gtk_Tree_View_Record; 
  967.        Visible_Rect : out Gdk.Rectangle.Gdk_Rectangle); 
  968.    --  Fills Visible_Rect with the currently-visible region of the buffer, in 
  969.    --  tree coordinates. Convert to bin_window coordinates with 
  970.    --  Gtk.Tree_View.Convert_Tree_To_Bin_Window_Coords. Tree coordinates start 
  971.    --  at 0,0 for row 0 of the tree, and cover the entire scrollable area of 
  972.    --  the tree. 
  973.    --  "visible_rect": rectangle to fill 
  974.  
  975.    function Insert_Column 
  976.       (Tree_View : not null access Gtk_Tree_View_Record; 
  977.        Column    : not null access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class; 
  978.        Position  : Gint := -1) return Gint; 
  979.    --  This inserts the Column into the Tree_View at Position. If Position is 
  980.    --  -1, then the column is inserted at the end. If Tree_View has 
  981.    --  "fixed_height" mode enabled, then Column must have its "sizing" property 
  982.    --  set to be GTK_TREE_VIEW_COLUMN_FIXED. 
  983.    --  "column": The Gtk.Tree_View_Column.Gtk_Tree_View_Column to be inserted. 
  984.    --  "position": The position to insert Column in. 
  985.  
  986.    function Insert_Column_With_Data_Func 
  987.       (Tree_View : not null access Gtk_Tree_View_Record; 
  988.        Position  : Gint; 
  989.        Title     : UTF8_String; 
  990.        Cell      : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  991.        Func      : Gtk_Tree_Cell_Data_Func; 
  992.        Dnotify   : Glib.G_Destroy_Notify_Address) return Gint; 
  993.    --  Convenience function that inserts a new column into the 
  994.    --  Gtk.Tree_View.Gtk_Tree_View with the given cell renderer and a 
  995.    --  Gtk_Tree_Cell_Data_Func to set cell renderer attributes (normally using 
  996.    --  data from the model). See also gtk_tree_view_column_set_cell_data_func, 
  997.    --  gtk_tree_view_column_pack_start. If Tree_View has "fixed_height" mode 
  998.    --  enabled, then the new column will have its "sizing" property set to be 
  999.    --  GTK_TREE_VIEW_COLUMN_FIXED. 
  1000.    --  "position": Position to insert, -1 for append 
  1001.    --  "title": column title 
  1002.    --  "cell": cell renderer for column 
  1003.    --  "func": function to set attributes of cell renderer 
  1004.    --  "dnotify": destroy notifier for Data 
  1005.  
  1006.    generic 
  1007.       type User_Data_Type (<>) is private; 
  1008.       with procedure Destroy (Data : in out User_Data_Type) is null; 
  1009.    package Insert_Column_With_Data_Func_User_Data is 
  1010.  
  1011.       type Gtk_Tree_Cell_Data_Func is access procedure 
  1012.         (Tree_Column : not null access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class; 
  1013.          Cell        : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  1014.          Tree_Model  : Gtk.Tree_Model.Gtk_Tree_Model; 
  1015.          Iter        : Gtk.Tree_Model.Gtk_Tree_Iter; 
  1016.          Data        : User_Data_Type); 
  1017.       --  A function to set the properties of a cell instead of just using the 
  1018.       --  straight mapping between the cell and the model. This is useful for 
  1019.       --  customizing the cell renderer. For example, a function might get an 
  1020.       --  integer from the Tree_Model, and render it to the "text" attribute of 
  1021.       --  "cell" by converting it to its written equivilent. This is set by 
  1022.       --  calling gtk_tree_view_column_set_cell_data_func 
  1023.       --  "tree_column": A Gtk.Tree_View_Column.Gtk_Tree_View_Column 
  1024.       --  "cell": The Gtk.Cell_Renderer.Gtk_Cell_Renderer that is being rendered 
  1025.       --  by Tree_Column 
  1026.       --  "tree_model": The Gtk.Tree_Model.Gtk_Tree_Model being rendered 
  1027.       --  "iter": A Gtk.Tree_Model.Gtk_Tree_Iter of the current row rendered 
  1028.       --  "data": user data 
  1029.  
  1030.       function Insert_Column_With_Data_Func 
  1031.          (Tree_View : not null access Gtk.Tree_View.Gtk_Tree_View_Record'Class; 
  1032.           Position  : Gint; 
  1033.           Title     : UTF8_String; 
  1034.           Cell      : not null access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  1035.           Func      : Gtk_Tree_Cell_Data_Func; 
  1036.           Data      : User_Data_Type; 
  1037.           Dnotify   : Glib.G_Destroy_Notify_Address) return Gint; 
  1038.       --  Convenience function that inserts a new column into the 
  1039.       --  Gtk.Tree_View.Gtk_Tree_View with the given cell renderer and a 
  1040.       --  Gtk_Tree_Cell_Data_Func to set cell renderer attributes (normally 
  1041.       --  using data from the model). See also 
  1042.       --  gtk_tree_view_column_set_cell_data_func, 
  1043.       --  gtk_tree_view_column_pack_start. If Tree_View has "fixed_height" mode 
  1044.       --  enabled, then the new column will have its "sizing" property set to 
  1045.       --  be GTK_TREE_VIEW_COLUMN_FIXED. 
  1046.       --  "position": Position to insert, -1 for append 
  1047.       --  "title": column title 
  1048.       --  "cell": cell renderer for column 
  1049.       --  "func": function to set attributes of cell renderer 
  1050.       --  "data": data for Func 
  1051.       --  "dnotify": destroy notifier for Data 
  1052.  
  1053.    end Insert_Column_With_Data_Func_User_Data; 
  1054.  
  1055.    function Is_Blank_At_Pos 
  1056.       (Tree_View : not null access Gtk_Tree_View_Record; 
  1057.        X         : Gint; 
  1058.        Y         : Gint; 
  1059.        Path      : access Gtk.Tree_Model.Gtk_Tree_Path; 
  1060.        Column    : access Gtk.Tree_View_Column.Gtk_Tree_View_Column; 
  1061.        Cell_X    : access Gint; 
  1062.        Cell_Y    : access Gint) return Boolean; 
  1063.    --  Determine whether the point (X, Y) in Tree_View is blank, that is no 
  1064.    --  cell content nor an expander arrow is drawn at the location. If so, the 
  1065.    --  location can be considered as the background. You might wish to take 
  1066.    --  special action on clicks on the background, such as clearing a current 
  1067.    --  selection, having a custom context menu or starting rubber banding. 
  1068.    --  The X and Y coordinate that are provided must be relative to bin_window 
  1069.    --  coordinates. That is, X and Y must come from an event on Tree_View where 
  1070.    --  'event->window == gtk_tree_view_get_bin_window (<!-- -->)'. 
  1071.    --  For converting widget coordinates (eg. the ones you get from 
  1072.    --  GtkWidget::query-tooltip), please see 
  1073.    --  Gtk.Tree_View.Convert_Widget_To_Bin_Window_Coords. 
  1074.    --  The Path, Column, Cell_X and Cell_Y arguments will be filled in 
  1075.    --  likewise as for Gtk.Tree_View.Get_Path_At_Pos. Please see 
  1076.    --  Gtk.Tree_View.Get_Path_At_Pos for more information. 
  1077.    --  Since: gtk+ 3.0 
  1078.    --  "x": The x position to be identified (relative to bin_window) 
  1079.    --  "y": The y position to be identified (relative to bin_window) 
  1080.    --  "path": A pointer to a Gtk.Tree_Model.Gtk_Tree_Path pointer to be 
  1081.    --  filled in, or null 
  1082.    --  "column": A pointer to a Gtk.Tree_View_Column.Gtk_Tree_View_Column 
  1083.    --  pointer to be filled in, or null 
  1084.    --  "cell_x": A pointer where the X coordinate relative to the cell can be 
  1085.    --  placed, or null 
  1086.    --  "cell_y": A pointer where the Y coordinate relative to the cell can be 
  1087.    --  placed, or null 
  1088.  
  1089.    function Is_Rubber_Banding_Active 
  1090.       (Tree_View : not null access Gtk_Tree_View_Record) return Boolean; 
  1091.    --  Returns whether a rubber banding operation is currently being done in 
  1092.    --  Tree_View. 
  1093.    --  Since: gtk+ 2.12 
  1094.  
  1095.    procedure Map_Expanded_Rows 
  1096.       (Tree_View : not null access Gtk_Tree_View_Record; 
  1097.        Func      : Gtk_Tree_View_Mapping_Func); 
  1098.    --  Calls Func on all expanded rows. 
  1099.    --  "func": A function to be called 
  1100.  
  1101.    generic 
  1102.       type User_Data_Type (<>) is private; 
  1103.       with procedure Destroy (Data : in out User_Data_Type) is null; 
  1104.    package Map_Expanded_Rows_User_Data is 
  1105.  
  1106.       type Gtk_Tree_View_Mapping_Func is access procedure 
  1107.         (Tree_View : not null access Gtk.Tree_View.Gtk_Tree_View_Record'Class; 
  1108.          Path      : Gtk.Tree_Model.Gtk_Tree_Path; 
  1109.          User_Data : User_Data_Type); 
  1110.       --  Function used for Gtk.Tree_View.Map_Expanded_Rows. 
  1111.       --  "tree_view": A Gtk.Tree_View.Gtk_Tree_View 
  1112.       --  "path": The path that's expanded 
  1113.       --  "user_data": user data 
  1114.  
  1115.       procedure Map_Expanded_Rows 
  1116.          (Tree_View : not null access Gtk.Tree_View.Gtk_Tree_View_Record'Class; 
  1117.           Func      : Gtk_Tree_View_Mapping_Func; 
  1118.           Data      : User_Data_Type); 
  1119.       --  Calls Func on all expanded rows. 
  1120.       --  "func": A function to be called 
  1121.       --  "data": User data to be passed to the function. 
  1122.  
  1123.    end Map_Expanded_Rows_User_Data; 
  1124.  
  1125.    procedure Move_Column_After 
  1126.       (Tree_View   : not null access Gtk_Tree_View_Record; 
  1127.        Column      : not null access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class; 
  1128.        Base_Column : access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class); 
  1129.    --  Moves Column to be after to Base_Column. If Base_Column is null, then 
  1130.    --  Column is placed in the first position. 
  1131.    --  "column": The Gtk.Tree_View_Column.Gtk_Tree_View_Column to be moved. 
  1132.    --  "base_column": The Gtk.Tree_View_Column.Gtk_Tree_View_Column to be 
  1133.    --  moved relative to, or null. 
  1134.  
  1135.    function Remove_Column 
  1136.       (Tree_View : not null access Gtk_Tree_View_Record; 
  1137.        Column    : not null access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class) 
  1138.        return Gint; 
  1139.    --  Removes Column from Tree_View. 
  1140.    --  "column": The Gtk.Tree_View_Column.Gtk_Tree_View_Column to remove. 
  1141.  
  1142.    procedure Row_Activated 
  1143.       (Tree_View : not null access Gtk_Tree_View_Record; 
  1144.        Path      : Gtk.Tree_Model.Gtk_Tree_Path; 
  1145.        Column    : not null access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class); 
  1146.    --  Activates the cell determined by Path and Column. 
  1147.    --  "path": The Gtk.Tree_Model.Gtk_Tree_Path to be activated. 
  1148.    --  "column": The Gtk.Tree_View_Column.Gtk_Tree_View_Column to be 
  1149.    --  activated. 
  1150.  
  1151.    function Row_Expanded 
  1152.       (Tree_View : not null access Gtk_Tree_View_Record; 
  1153.        Path      : Gtk.Tree_Model.Gtk_Tree_Path) return Boolean; 
  1154.    --  Returns True if the node pointed to by Path is expanded in Tree_View. 
  1155.    --  "path": A Gtk.Tree_Model.Gtk_Tree_Path to test expansion state. 
  1156.  
  1157.    procedure Scroll_To_Cell 
  1158.       (Tree_View : not null access Gtk_Tree_View_Record; 
  1159.        Path      : Gtk.Tree_Model.Gtk_Tree_Path; 
  1160.        Column    : access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class; 
  1161.        Use_Align : Boolean; 
  1162.        Row_Align : Gfloat; 
  1163.        Col_Align : Gfloat); 
  1164.    --  Moves the alignments of Tree_View to the position specified by Column 
  1165.    --  and Path. If Column is null, then no horizontal scrolling occurs. 
  1166.    --  Likewise, if Path is null no vertical scrolling occurs. At a minimum, 
  1167.    --  one of Column or Path need to be non-null. Row_Align determines where 
  1168.    --  the row is placed, and Col_Align determines where Column is placed. Both 
  1169.    --  are expected to be between 0.0 and 1.0. 0.0 means left/top alignment, 
  1170.    --  1.0 means right/bottom alignment, 0.5 means center. 
  1171.    --  If Use_Align is False, then the alignment arguments are ignored, and 
  1172.    --  the tree does the minimum amount of work to scroll the cell onto the 
  1173.    --  screen. This means that the cell will be scrolled to the edge closest to 
  1174.    --  its current position. If the cell is currently visible on the screen, 
  1175.    --  nothing is done. 
  1176.    --  This function only works if the model is set, and Path is a valid row 
  1177.    --  on the model. If the model changes before the Tree_View is realized, the 
  1178.    --  centered path will be modified to reflect this change. 
  1179.    --  "path": The path of the row to move to, or null. 
  1180.    --  "column": The Gtk.Tree_View_Column.Gtk_Tree_View_Column to move 
  1181.    --  horizontally to, or null. 
  1182.    --  "use_align": whether to use alignment arguments, or False. 
  1183.    --  "row_align": The vertical alignment of the row specified by Path. 
  1184.    --  "col_align": The horizontal alignment of the column specified by 
  1185.    --  Column. 
  1186.  
  1187.    procedure Scroll_To_Point 
  1188.       (Tree_View : not null access Gtk_Tree_View_Record; 
  1189.        Tree_X    : Gint; 
  1190.        Tree_Y    : Gint); 
  1191.    --  Scrolls the tree view such that the top-left corner of the visible area 
  1192.    --  is Tree_X, Tree_Y, where Tree_X and Tree_Y are specified in tree 
  1193.    --  coordinates. The Tree_View must be realized before this function is 
  1194.    --  called. If it isn't, you probably want to be using 
  1195.    --  Gtk.Tree_View.Scroll_To_Cell. 
  1196.    --  If either Tree_X or Tree_Y are -1, then that direction isn't scrolled. 
  1197.    --  "tree_x": X coordinate of new top-left pixel of visible area, or -1 
  1198.    --  "tree_y": Y coordinate of new top-left pixel of visible area, or -1 
  1199.  
  1200.    procedure Set_Column_Drag_Function 
  1201.       (Tree_View : not null access Gtk_Tree_View_Record; 
  1202.        Func      : Gtk_Tree_View_Column_Drop_Func); 
  1203.    --  Sets a user function for determining where a column may be dropped when 
  1204.    --  dragged. This function is called on every column pair in turn at the 
  1205.    --  beginning of a column drag to determine where a drop can take place. The 
  1206.    --  arguments passed to Func are: the Tree_View, the 
  1207.    --  Gtk.Tree_View_Column.Gtk_Tree_View_Column being dragged, the two 
  1208.    --  Gtk.Tree_View_Column.Gtk_Tree_View_Column s determining the drop spot, 
  1209.    --  and User_Data. If either of the 
  1210.    --  Gtk.Tree_View_Column.Gtk_Tree_View_Column arguments for the drop spot 
  1211.    --  are null, then they indicate an edge. If Func is set to be null, then 
  1212.    --  Tree_View reverts to the default behavior of allowing all columns to be 
  1213.    --  dropped everywhere. 
  1214.    --  "func": A function to determine which columns are reorderable, or null. 
  1215.  
  1216.    generic 
  1217.       type User_Data_Type (<>) is private; 
  1218.       with procedure Destroy (Data : in out User_Data_Type) is null; 
  1219.    package Set_Column_Drag_Function_User_Data is 
  1220.  
  1221.       type Gtk_Tree_View_Column_Drop_Func is access function 
  1222.         (Tree_View   : not null access Gtk.Tree_View.Gtk_Tree_View_Record'Class; 
  1223.          Column      : not null access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class; 
  1224.          Prev_Column : not null access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class; 
  1225.          Next_Column : not null access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class; 
  1226.          Data        : User_Data_Type) return Boolean; 
  1227.       --  Function type for determining whether Column can be dropped in a 
  1228.       --  particular spot (as determined by Prev_Column and Next_Column). In left 
  1229.       --  to right locales, Prev_Column is on the left of the potential drop spot, 
  1230.       --  and Next_Column is on the right. In right to left mode, this is 
  1231.       --  reversed. This function should return True if the spot is a valid drop 
  1232.       --  spot. Please note that returning True does not actually indicate that 
  1233.       --  the column drop was made, but is meant only to indicate a possible drop 
  1234.       --  spot to the user. 
  1235.       --  "tree_view": A Gtk.Tree_View.Gtk_Tree_View 
  1236.       --  "column": The Gtk.Tree_View_Column.Gtk_Tree_View_Column being dragged 
  1237.       --  "prev_column": A Gtk.Tree_View_Column.Gtk_Tree_View_Column on one side 
  1238.       --  of Column 
  1239.       --  "next_column": A Gtk.Tree_View_Column.Gtk_Tree_View_Column on the other 
  1240.       --  side of Column 
  1241.       --  "data": user data 
  1242.  
  1243.       procedure Set_Column_Drag_Function 
  1244.          (Tree_View : not null access Gtk.Tree_View.Gtk_Tree_View_Record'Class; 
  1245.           Func      : Gtk_Tree_View_Column_Drop_Func; 
  1246.           User_Data : User_Data_Type); 
  1247.       --  Sets a user function for determining where a column may be dropped 
  1248.       --  when dragged. This function is called on every column pair in turn at 
  1249.       --  the beginning of a column drag to determine where a drop can take 
  1250.       --  place. The arguments passed to Func are: the Tree_View, the 
  1251.       --  Gtk.Tree_View_Column.Gtk_Tree_View_Column being dragged, the two 
  1252.       --  Gtk.Tree_View_Column.Gtk_Tree_View_Column s determining the drop 
  1253.       --  spot, and User_Data. If either of the 
  1254.       --  Gtk.Tree_View_Column.Gtk_Tree_View_Column arguments for the drop spot 
  1255.       --  are null, then they indicate an edge. If Func is set to be null, then 
  1256.       --  Tree_View reverts to the default behavior of allowing all columns to 
  1257.       --  be dropped everywhere. 
  1258.       --  "func": A function to determine which columns are reorderable, or 
  1259.       --  null. 
  1260.       --  "user_data": User data to be passed to Func, or null 
  1261.  
  1262.    end Set_Column_Drag_Function_User_Data; 
  1263.  
  1264.    procedure Set_Cursor_On_Cell 
  1265.       (Tree_View     : not null access Gtk_Tree_View_Record; 
  1266.        Path          : Gtk.Tree_Model.Gtk_Tree_Path; 
  1267.        Focus_Column  : access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class; 
  1268.        Focus_Cell    : access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class; 
  1269.        Start_Editing : Boolean); 
  1270.    --  Sets the current keyboard focus to be at Path, and selects it. This is 
  1271.    --  useful when you want to focus the user's attention on a particular row. 
  1272.    --  If Focus_Column is not null, then focus is given to the column specified 
  1273.    --  by it. If Focus_Column and Focus_Cell are not null, and Focus_Column 
  1274.    --  contains 2 or more editable or activatable cells, then focus is given to 
  1275.    --  the cell specified by Focus_Cell. Additionally, if Focus_Column is 
  1276.    --  specified, and Start_Editing is True, then editing should be started in 
  1277.    --  the specified cell. This function is often followed by 
  1278.    --  Gtk_Widget_Grab_Focus (Tree_View) in order to give keyboard focus to the 
  1279.    --  widget. Please note that editing can only happen when the widget is 
  1280.    --  realized. 
  1281.    --  If Path is invalid for Model, the current cursor (if any) will be unset 
  1282.    --  and the function will return without failing. 
  1283.    --  Since: gtk+ 2.2 
  1284.    --  "path": A Gtk.Tree_Model.Gtk_Tree_Path 
  1285.    --  "focus_column": A Gtk.Tree_View_Column.Gtk_Tree_View_Column, or null 
  1286.    --  "focus_cell": A Gtk.Cell_Renderer.Gtk_Cell_Renderer, or null 
  1287.    --  "start_editing": True if the specified cell should start being edited. 
  1288.  
  1289.    procedure Set_Destroy_Count_Func 
  1290.       (Tree_View : not null access Gtk_Tree_View_Record; 
  1291.        Func      : Gtk_Tree_Destroy_Count_Func); 
  1292.    pragma Obsolescent (Set_Destroy_Count_Func); 
  1293.    --  This function should almost never be used. It is meant for private use 
  1294.    --  by ATK for determining the number of visible children that are removed 
  1295.    --  when the user collapses a row, or a row is deleted. 
  1296.    --  Deprecated since 3.4, Accessibility does not need the function anymore. 
  1297.    --  "func": Function to be called when a view row is destroyed, or null 
  1298.  
  1299.    generic 
  1300.       type User_Data_Type (<>) is private; 
  1301.       with procedure Destroy (Data : in out User_Data_Type) is null; 
  1302.    package Set_Destroy_Count_Func_User_Data is 
  1303.  
  1304.       type Gtk_Tree_Destroy_Count_Func is access procedure 
  1305.         (Tree_View : not null access Gtk.Tree_View.Gtk_Tree_View_Record'Class; 
  1306.          Path      : Gtk.Tree_Model.Gtk_Tree_Path; 
  1307.          Children  : Gint; 
  1308.          User_Data : User_Data_Type); 
  1309.  
  1310.       procedure Set_Destroy_Count_Func 
  1311.          (Tree_View : not null access Gtk.Tree_View.Gtk_Tree_View_Record'Class; 
  1312.           Func      : Gtk_Tree_Destroy_Count_Func; 
  1313.           Data      : User_Data_Type); 
  1314.       pragma Obsolescent (Set_Destroy_Count_Func); 
  1315.       --  This function should almost never be used. It is meant for private 
  1316.       --  use by ATK for determining the number of visible children that are 
  1317.       --  removed when the user collapses a row, or a row is deleted. 
  1318.       --  Deprecated since 3.4, Accessibility does not need the function 
  1319.       --  anymore. 
  1320.       --  "func": Function to be called when a view row is destroyed, or null 
  1321.       --  "data": User data to be passed to Func, or null 
  1322.  
  1323.    end Set_Destroy_Count_Func_User_Data; 
  1324.  
  1325.    generic 
  1326.       type User_Data_Type (<>) is private; 
  1327.       with procedure Destroy (Data : in out User_Data_Type) is null; 
  1328.    package Set_Row_Separator_Func_User_Data is 
  1329.  
  1330.       type Gtk_Tree_View_Row_Separator_Func is access function 
  1331.         (Model : Gtk.Tree_Model.Gtk_Tree_Model; 
  1332.          Iter  : Gtk.Tree_Model.Gtk_Tree_Iter; 
  1333.          Data  : User_Data_Type) return Boolean; 
  1334.       --  Function type for determining whether the row pointed to by Iter should 
  1335.       --  be rendered as a separator. A common way to implement this is to have a 
  1336.       --  boolean column in the model, whose values the 
  1337.       --  Gtk.Tree_View.Gtk_Tree_View_Row_Separator_Func returns. 
  1338.       --  "model": the Gtk.Tree_Model.Gtk_Tree_Model 
  1339.       --  "iter": a Gtk.Tree_Model.Gtk_Tree_Iter pointing at a row in Model 
  1340.       --  "data": user data 
  1341.  
  1342.       procedure Set_Row_Separator_Func 
  1343.          (Tree_View : not null access Gtk.Tree_View.Gtk_Tree_View_Record'Class; 
  1344.           Func      : Gtk_Tree_View_Row_Separator_Func; 
  1345.           Data      : User_Data_Type); 
  1346.       --  Sets the row separator function, which is used to determine whether 
  1347.       --  a row should be drawn as a separator. If the row separator function 
  1348.       --  is null, no separators are drawn. This is the default value. 
  1349.       --  Since: gtk+ 2.6 
  1350.       --  "func": a Gtk.Tree_View.Gtk_Tree_View_Row_Separator_Func 
  1351.       --  "data": user data to pass to Func, or null 
  1352.  
  1353.    end Set_Row_Separator_Func_User_Data; 
  1354.  
  1355.    generic 
  1356.       type User_Data_Type (<>) is private; 
  1357.       with procedure Destroy (Data : in out User_Data_Type) is null; 
  1358.    package Set_Search_Equal_Func_User_Data is 
  1359.  
  1360.       type Gtk_Tree_View_Search_Equal_Func is access function 
  1361.         (Model       : Gtk.Tree_Model.Gtk_Tree_Model; 
  1362.          Column      : Gint; 
  1363.          Key         : UTF8_String; 
  1364.          Iter        : Gtk.Tree_Model.Gtk_Tree_Iter; 
  1365.          Search_Data : User_Data_Type) return Boolean; 
  1366.       --  A function used for checking whether a row in Model matches a search 
  1367.       --  key string entered by the user. Note the return value is reversed from 
  1368.       --  what you would normally expect, though it has some similarity to strcmp 
  1369.       --  returning 0 for equal strings. 
  1370.       --  "model": the Gtk.Tree_Model.Gtk_Tree_Model being searched 
  1371.       --  "column": the search column set by Gtk.Tree_View.Set_Search_Column 
  1372.       --  "key": the key string to compare with 
  1373.       --  "iter": a Gtk.Tree_Model.Gtk_Tree_Iter pointing the row of Model that 
  1374.       --  should be compared with Key. 
  1375.       --  "search_data": user data from Gtk.Tree_View.Set_Search_Equal_Func 
  1376.  
  1377.       procedure Set_Search_Equal_Func 
  1378.          (Tree_View         : not null access Gtk.Tree_View.Gtk_Tree_View_Record'Class; 
  1379.           Search_Equal_Func : Gtk_Tree_View_Search_Equal_Func; 
  1380.           Search_User_Data  : User_Data_Type; 
  1381.           Search_Destroy    : Glib.G_Destroy_Notify_Address); 
  1382.       --  Sets the compare function for the interactive search capabilities; 
  1383.       --  note that somewhat like strcmp returning 0 for equality 
  1384.       --  Gtk_Tree_View_Search_Equal_Func returns False on matches. 
  1385.       --  "search_equal_func": the compare function to use during the search 
  1386.       --  "search_user_data": user data to pass to Search_Equal_Func, or null 
  1387.       --  "search_destroy": Destroy notifier for Search_User_Data, or null 
  1388.  
  1389.    end Set_Search_Equal_Func_User_Data; 
  1390.  
  1391.    generic 
  1392.       type User_Data_Type (<>) is private; 
  1393.       with procedure Destroy (Data : in out User_Data_Type) is null; 
  1394.    package Set_Search_Position_Func_User_Data is 
  1395.  
  1396.       type Gtk_Tree_View_Search_Position_Func is access procedure 
  1397.         (Tree_View     : not null access Gtk.Tree_View.Gtk_Tree_View_Record'Class; 
  1398.          Search_Dialog : not null access Gtk.Widget.Gtk_Widget_Record'Class; 
  1399.          User_Data     : User_Data_Type); 
  1400.  
  1401.       procedure Set_Search_Position_Func 
  1402.          (Tree_View : not null access Gtk.Tree_View.Gtk_Tree_View_Record'Class; 
  1403.           Func      : Gtk_Tree_View_Search_Position_Func; 
  1404.           Data      : User_Data_Type); 
  1405.       --  Sets the function to use when positioning the search dialog. 
  1406.       --  Since: gtk+ 2.10 
  1407.       --  "func": the function to use to position the search dialog, or null 
  1408.       --  to use the default search position function 
  1409.       --  "data": user data to pass to Func, or null 
  1410.  
  1411.    end Set_Search_Position_Func_User_Data; 
  1412.  
  1413.    procedure Set_Tooltip_Cell 
  1414.       (Tree_View : not null access Gtk_Tree_View_Record; 
  1415.        Tooltip   : not null access Gtk.Tooltip.Gtk_Tooltip_Record'Class; 
  1416.        Path      : Gtk.Tree_Model.Gtk_Tree_Path; 
  1417.        Column    : access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class; 
  1418.        Cell      : access Gtk.Cell_Renderer.Gtk_Cell_Renderer_Record'Class); 
  1419.    --  Sets the tip area of Tooltip to the area Path, Column and Cell have in 
  1420.    --  common. For example if Path is null and Column is set, the tip area will 
  1421.    --  be set to the full area covered by Column. See also 
  1422.    --  Gtk.Tooltip.Set_Tip_Area. 
  1423.    --  Note that if Path is not specified and Cell is set and part of a column 
  1424.    --  containing the expander, the tooltip might not show and hide at the 
  1425.    --  correct position. In such cases Path must be set to the current node 
  1426.    --  under the mouse cursor for this function to operate correctly. 
  1427.    --  See also Gtk.Tree_View.Set_Tooltip_Column for a simpler alternative. 
  1428.    --  Since: gtk+ 2.12 
  1429.    --  "tooltip": a Gtk.Tooltip.Gtk_Tooltip 
  1430.    --  "path": a Gtk.Tree_Model.Gtk_Tree_Path or null 
  1431.    --  "column": a Gtk.Tree_View_Column.Gtk_Tree_View_Column or null 
  1432.    --  "cell": a Gtk.Cell_Renderer.Gtk_Cell_Renderer or null 
  1433.  
  1434.    procedure Set_Tooltip_Row 
  1435.       (Tree_View : not null access Gtk_Tree_View_Record; 
  1436.        Tooltip   : not null access Gtk.Tooltip.Gtk_Tooltip_Record'Class; 
  1437.        Path      : Gtk.Tree_Model.Gtk_Tree_Path); 
  1438.    --  Sets the tip area of Tooltip to be the area covered by the row at Path. 
  1439.    --  See also Gtk.Tree_View.Set_Tooltip_Column for a simpler alternative. See 
  1440.    --  also Gtk.Tooltip.Set_Tip_Area. 
  1441.    --  Since: gtk+ 2.12 
  1442.    --  "tooltip": a Gtk.Tooltip.Gtk_Tooltip 
  1443.    --  "path": a Gtk.Tree_Model.Gtk_Tree_Path 
  1444.  
  1445.    procedure Unset_Rows_Drag_Dest 
  1446.       (Tree_View : not null access Gtk_Tree_View_Record); 
  1447.    --  Undoes the effect of Gtk.Tree_View.Enable_Model_Drag_Dest. Calling this 
  1448.    --  method sets Gtk.Tree_View.Gtk_Tree_View:reorderable to False. 
  1449.  
  1450.    procedure Unset_Rows_Drag_Source 
  1451.       (Tree_View : not null access Gtk_Tree_View_Record); 
  1452.    --  Undoes the effect of Gtk.Tree_View.Enable_Model_Drag_Source. Calling 
  1453.    --  this method sets Gtk.Tree_View.Gtk_Tree_View:reorderable to False. 
  1454.  
  1455.    ---------------------- 
  1456.    -- GtkAda additions -- 
  1457.    ---------------------- 
  1458.  
  1459.    procedure Gtk_New 
  1460.      (Tree_View : out Gtk_Tree_View; 
  1461.       Model     : access Gtk.Tree_Model.Gtk_Root_Tree_Model_Record'Class); 
  1462.    --  A convenience function so that one can directly pass a model, without 
  1463.    --  converting to a Gtk_Tree_Model via the "+" operator. 
  1464.  
  1465.    --------------------------------------------- 
  1466.    -- Inherited subprograms (from interfaces) -- 
  1467.    --------------------------------------------- 
  1468.    --  Methods inherited from the Buildable interface are not duplicated here 
  1469.    --  since they are meant to be used by tools, mostly. If you need to call 
  1470.    --  them, use an explicit cast through the "-" operator below. 
  1471.  
  1472.    function Get_Hadjustment 
  1473.       (Self : not null access Gtk_Tree_View_Record) 
  1474.        return Gtk.Adjustment.Gtk_Adjustment; 
  1475.  
  1476.    procedure Set_Hadjustment 
  1477.       (Self        : not null access Gtk_Tree_View_Record; 
  1478.        Hadjustment : access Gtk.Adjustment.Gtk_Adjustment_Record'Class); 
  1479.  
  1480.    function Get_Hscroll_Policy 
  1481.       (Self : not null access Gtk_Tree_View_Record) 
  1482.        return Gtk.Enums.Gtk_Scrollable_Policy; 
  1483.  
  1484.    procedure Set_Hscroll_Policy 
  1485.       (Self   : not null access Gtk_Tree_View_Record; 
  1486.        Policy : Gtk.Enums.Gtk_Scrollable_Policy); 
  1487.  
  1488.    function Get_Vadjustment 
  1489.       (Self : not null access Gtk_Tree_View_Record) 
  1490.        return Gtk.Adjustment.Gtk_Adjustment; 
  1491.  
  1492.    procedure Set_Vadjustment 
  1493.       (Self        : not null access Gtk_Tree_View_Record; 
  1494.        Vadjustment : access Gtk.Adjustment.Gtk_Adjustment_Record'Class); 
  1495.  
  1496.    function Get_Vscroll_Policy 
  1497.       (Self : not null access Gtk_Tree_View_Record) 
  1498.        return Gtk.Enums.Gtk_Scrollable_Policy; 
  1499.  
  1500.    procedure Set_Vscroll_Policy 
  1501.       (Self   : not null access Gtk_Tree_View_Record; 
  1502.        Policy : Gtk.Enums.Gtk_Scrollable_Policy); 
  1503.  
  1504.    ---------------- 
  1505.    -- Properties -- 
  1506.    ---------------- 
  1507.    --  The following properties are defined for this widget. See 
  1508.    --  Glib.Properties for more information on properties) 
  1509.  
  1510.    Activate_On_Single_Click_Property : constant Glib.Properties.Property_Boolean; 
  1511.    --  The activate-on-single-click property specifies whether the 
  1512.    --  "row-activated" signal will be emitted after a single click. 
  1513.  
  1514.    Enable_Grid_Lines_Property : constant Gtk.Enums.Property_Gtk_Tree_View_Grid_Lines; 
  1515.  
  1516.    Enable_Search_Property : constant Glib.Properties.Property_Boolean; 
  1517.  
  1518.    Enable_Tree_Lines_Property : constant Glib.Properties.Property_Boolean; 
  1519.  
  1520.    Expander_Column_Property : constant Glib.Properties.Property_Object; 
  1521.    --  Type: Gtk.Tree_View_Column.Gtk_Tree_View_Column 
  1522.  
  1523.    Fixed_Height_Mode_Property : constant Glib.Properties.Property_Boolean; 
  1524.    --  Setting the ::fixed-height-mode property to True speeds up 
  1525.    --  Gtk.Tree_View.Gtk_Tree_View by assuming that all rows have the same 
  1526.    --  height. Only enable this option if all rows are the same height. Please 
  1527.    --  see Gtk.Tree_View.Set_Fixed_Height_Mode for more information on this 
  1528.    --  option. 
  1529.  
  1530.    Headers_Clickable_Property : constant Glib.Properties.Property_Boolean; 
  1531.  
  1532.    Headers_Visible_Property : constant Glib.Properties.Property_Boolean; 
  1533.  
  1534.    Hover_Expand_Property : constant Glib.Properties.Property_Boolean; 
  1535.    --  Enables or disables the hover expansion mode of Tree_View. Hover 
  1536.    --  expansion makes rows expand or collapse if the pointer moves over them. 
  1537.    -- 
  1538.    --  This mode is primarily intended for treeviews in popups, e.g. in 
  1539.    --  Gtk.Combo_Box.Gtk_Combo_Box or 
  1540.    --  Gtk.Entry_Completion.Gtk_Entry_Completion. 
  1541.  
  1542.    Hover_Selection_Property : constant Glib.Properties.Property_Boolean; 
  1543.    --  Enables or disables the hover selection mode of Tree_View. Hover 
  1544.    --  selection makes the selected row follow the pointer. Currently, this 
  1545.    --  works only for the selection modes Gtk.Enums.Selection_Single and 
  1546.    --  Gtk.Enums.Selection_Browse. 
  1547.    -- 
  1548.    --  This mode is primarily intended for treeviews in popups, e.g. in 
  1549.    --  Gtk.Combo_Box.Gtk_Combo_Box or 
  1550.    --  Gtk.Entry_Completion.Gtk_Entry_Completion. 
  1551.  
  1552.    Level_Indentation_Property : constant Glib.Properties.Property_Int; 
  1553.    --  Extra indentation for each level. 
  1554.  
  1555.    Model_Property : constant Glib.Properties.Property_Interface; 
  1556.    --  Type: Gtk.Tree_Model.Gtk_Tree_Model 
  1557.  
  1558.    Reorderable_Property : constant Glib.Properties.Property_Boolean; 
  1559.  
  1560.    Rubber_Banding_Property : constant Glib.Properties.Property_Boolean; 
  1561.  
  1562.    Rules_Hint_Property : constant Glib.Properties.Property_Boolean; 
  1563.  
  1564.    Search_Column_Property : constant Glib.Properties.Property_Int; 
  1565.  
  1566.    Show_Expanders_Property : constant Glib.Properties.Property_Boolean; 
  1567.    --  True if the view has expanders. 
  1568.  
  1569.    Tooltip_Column_Property : constant Glib.Properties.Property_Int; 
  1570.  
  1571.    ------------- 
  1572.    -- Signals -- 
  1573.    ------------- 
  1574.  
  1575.    type Cb_Gtk_Tree_View_Void is not null access procedure (Self : access Gtk_Tree_View_Record'Class); 
  1576.  
  1577.    type Cb_GObject_Void is not null access procedure 
  1578.      (Self : access Glib.Object.GObject_Record'Class); 
  1579.  
  1580.    Signal_Columns_Changed : constant Glib.Signal_Name := "columns-changed"; 
  1581.    procedure On_Columns_Changed 
  1582.       (Self  : not null access Gtk_Tree_View_Record; 
  1583.        Call  : Cb_Gtk_Tree_View_Void; 
  1584.        After : Boolean := False); 
  1585.    procedure On_Columns_Changed 
  1586.       (Self  : not null access Gtk_Tree_View_Record; 
  1587.        Call  : Cb_GObject_Void; 
  1588.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  1589.        After : Boolean := False); 
  1590.    --  The number of columns of the treeview has changed. 
  1591.  
  1592.    Signal_Cursor_Changed : constant Glib.Signal_Name := "cursor-changed"; 
  1593.    procedure On_Cursor_Changed 
  1594.       (Self  : not null access Gtk_Tree_View_Record; 
  1595.        Call  : Cb_Gtk_Tree_View_Void; 
  1596.        After : Boolean := False); 
  1597.    procedure On_Cursor_Changed 
  1598.       (Self  : not null access Gtk_Tree_View_Record; 
  1599.        Call  : Cb_GObject_Void; 
  1600.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  1601.        After : Boolean := False); 
  1602.    --  The position of the cursor (focused cell) has changed. 
  1603.  
  1604.    type Cb_Gtk_Tree_View_Boolean_Boolean_Boolean_Boolean is not null access function 
  1605.      (Self   : access Gtk_Tree_View_Record'Class; 
  1606.       Object : Boolean; 
  1607.       P0     : Boolean; 
  1608.       P1     : Boolean) return Boolean; 
  1609.  
  1610.    type Cb_GObject_Boolean_Boolean_Boolean_Boolean is not null access function 
  1611.      (Self   : access Glib.Object.GObject_Record'Class; 
  1612.       Object : Boolean; 
  1613.       P0     : Boolean; 
  1614.       P1     : Boolean) return Boolean; 
  1615.  
  1616.    Signal_Expand_Collapse_Cursor_Row : constant Glib.Signal_Name := "expand-collapse-cursor-row"; 
  1617.    procedure On_Expand_Collapse_Cursor_Row 
  1618.       (Self  : not null access Gtk_Tree_View_Record; 
  1619.        Call  : Cb_Gtk_Tree_View_Boolean_Boolean_Boolean_Boolean; 
  1620.        After : Boolean := False); 
  1621.    procedure On_Expand_Collapse_Cursor_Row 
  1622.       (Self  : not null access Gtk_Tree_View_Record; 
  1623.        Call  : Cb_GObject_Boolean_Boolean_Boolean_Boolean; 
  1624.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  1625.        After : Boolean := False); 
  1626.    --  
  1627.    --  Callback parameters: 
  1628.  
  1629.    type Cb_Gtk_Tree_View_Gtk_Movement_Step_Gint_Boolean is not null access function 
  1630.      (Self   : access Gtk_Tree_View_Record'Class; 
  1631.       Object : Gtk.Enums.Gtk_Movement_Step; 
  1632.       P0     : Gint) return Boolean; 
  1633.  
  1634.    type Cb_GObject_Gtk_Movement_Step_Gint_Boolean is not null access function 
  1635.      (Self   : access Glib.Object.GObject_Record'Class; 
  1636.       Object : Gtk.Enums.Gtk_Movement_Step; 
  1637.       P0     : Gint) return Boolean; 
  1638.  
  1639.    Signal_Move_Cursor : constant Glib.Signal_Name := "move-cursor"; 
  1640.    procedure On_Move_Cursor 
  1641.       (Self  : not null access Gtk_Tree_View_Record; 
  1642.        Call  : Cb_Gtk_Tree_View_Gtk_Movement_Step_Gint_Boolean; 
  1643.        After : Boolean := False); 
  1644.    procedure On_Move_Cursor 
  1645.       (Self  : not null access Gtk_Tree_View_Record; 
  1646.        Call  : Cb_GObject_Gtk_Movement_Step_Gint_Boolean; 
  1647.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  1648.        After : Boolean := False); 
  1649.    --  
  1650.    --  Callback parameters: 
  1651.  
  1652.    type Cb_Gtk_Tree_View_Gtk_Tree_Path_Gtk_Tree_View_Column_Void is not null access procedure 
  1653.      (Self   : access Gtk_Tree_View_Record'Class; 
  1654.       Path   : Gtk.Tree_Model.Gtk_Tree_Path; 
  1655.       Column : not null access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class); 
  1656.  
  1657.    type Cb_GObject_Gtk_Tree_Path_Gtk_Tree_View_Column_Void is not null access procedure 
  1658.      (Self   : access Glib.Object.GObject_Record'Class; 
  1659.       Path   : Gtk.Tree_Model.Gtk_Tree_Path; 
  1660.       Column : not null access Gtk.Tree_View_Column.Gtk_Tree_View_Column_Record'Class); 
  1661.  
  1662.    Signal_Row_Activated : constant Glib.Signal_Name := "row-activated"; 
  1663.    procedure On_Row_Activated 
  1664.       (Self  : not null access Gtk_Tree_View_Record; 
  1665.        Call  : Cb_Gtk_Tree_View_Gtk_Tree_Path_Gtk_Tree_View_Column_Void; 
  1666.        After : Boolean := False); 
  1667.    procedure On_Row_Activated 
  1668.       (Self  : not null access Gtk_Tree_View_Record; 
  1669.        Call  : Cb_GObject_Gtk_Tree_Path_Gtk_Tree_View_Column_Void; 
  1670.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  1671.        After : Boolean := False); 
  1672.    --  The "row-activated" signal is emitted when the method 
  1673.    --  Gtk.Tree_View.Row_Activated is called, when the user double clicks a 
  1674.    --  treeview row with the "activate-on-single-click" property set to False, 
  1675.    --  or when the user single clicks a row when the "activate-on-single-click" 
  1676.    --  property set to True. It is also emitted when a non-editable row is 
  1677.    --  selected and one of the keys: Space, Shift+Space, Return or Enter is 
  1678.    --  pressed. 
  1679.    -- 
  1680.    --  For selection handling refer to the <link linkend="TreeWidget">tree 
  1681.    --  widget conceptual overview</link> as well as 
  1682.    --  Gtk.Tree_Selection.Gtk_Tree_Selection. 
  1683.    --  
  1684.    --  Callback parameters: 
  1685.    --    --  "path": the Gtk.Tree_Model.Gtk_Tree_Path for the activated row 
  1686.    --    --  "column": the Gtk.Tree_View_Column.Gtk_Tree_View_Column in which the 
  1687.    --    --  activation occurred 
  1688.  
  1689.    type Cb_Gtk_Tree_View_Gtk_Tree_Iter_Gtk_Tree_Path_Void is not null access procedure 
  1690.      (Self : access Gtk_Tree_View_Record'Class; 
  1691.       Iter : Gtk.Tree_Model.Gtk_Tree_Iter; 
  1692.       Path : Gtk.Tree_Model.Gtk_Tree_Path); 
  1693.  
  1694.    type Cb_GObject_Gtk_Tree_Iter_Gtk_Tree_Path_Void is not null access procedure 
  1695.      (Self : access Glib.Object.GObject_Record'Class; 
  1696.       Iter : Gtk.Tree_Model.Gtk_Tree_Iter; 
  1697.       Path : Gtk.Tree_Model.Gtk_Tree_Path); 
  1698.  
  1699.    Signal_Row_Collapsed : constant Glib.Signal_Name := "row-collapsed"; 
  1700.    procedure On_Row_Collapsed 
  1701.       (Self  : not null access Gtk_Tree_View_Record; 
  1702.        Call  : Cb_Gtk_Tree_View_Gtk_Tree_Iter_Gtk_Tree_Path_Void; 
  1703.        After : Boolean := False); 
  1704.    procedure On_Row_Collapsed 
  1705.       (Self  : not null access Gtk_Tree_View_Record; 
  1706.        Call  : Cb_GObject_Gtk_Tree_Iter_Gtk_Tree_Path_Void; 
  1707.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  1708.        After : Boolean := False); 
  1709.    --  The given row has been collapsed (child nodes are hidden). 
  1710.    --  
  1711.    --  Callback parameters: 
  1712.    --    --  "iter": the tree iter of the collapsed row 
  1713.    --    --  "path": a tree path that points to the row 
  1714.  
  1715.    Signal_Row_Expanded : constant Glib.Signal_Name := "row-expanded"; 
  1716.    procedure On_Row_Expanded 
  1717.       (Self  : not null access Gtk_Tree_View_Record; 
  1718.        Call  : Cb_Gtk_Tree_View_Gtk_Tree_Iter_Gtk_Tree_Path_Void; 
  1719.        After : Boolean := False); 
  1720.    procedure On_Row_Expanded 
  1721.       (Self  : not null access Gtk_Tree_View_Record; 
  1722.        Call  : Cb_GObject_Gtk_Tree_Iter_Gtk_Tree_Path_Void; 
  1723.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  1724.        After : Boolean := False); 
  1725.    --  The given row has been expanded (child nodes are shown). 
  1726.    --  
  1727.    --  Callback parameters: 
  1728.    --    --  "iter": the tree iter of the expanded row 
  1729.    --    --  "path": a tree path that points to the row 
  1730.  
  1731.    type Cb_Gtk_Tree_View_Boolean is not null access function 
  1732.      (Self : access Gtk_Tree_View_Record'Class) return Boolean; 
  1733.  
  1734.    type Cb_GObject_Boolean is not null access function 
  1735.      (Self : access Glib.Object.GObject_Record'Class) 
  1736.    return Boolean; 
  1737.  
  1738.    Signal_Select_All : constant Glib.Signal_Name := "select-all"; 
  1739.    procedure On_Select_All 
  1740.       (Self  : not null access Gtk_Tree_View_Record; 
  1741.        Call  : Cb_Gtk_Tree_View_Boolean; 
  1742.        After : Boolean := False); 
  1743.    procedure On_Select_All 
  1744.       (Self  : not null access Gtk_Tree_View_Record; 
  1745.        Call  : Cb_GObject_Boolean; 
  1746.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  1747.        After : Boolean := False); 
  1748.  
  1749.    Signal_Select_Cursor_Parent : constant Glib.Signal_Name := "select-cursor-parent"; 
  1750.    procedure On_Select_Cursor_Parent 
  1751.       (Self  : not null access Gtk_Tree_View_Record; 
  1752.        Call  : Cb_Gtk_Tree_View_Boolean; 
  1753.        After : Boolean := False); 
  1754.    procedure On_Select_Cursor_Parent 
  1755.       (Self  : not null access Gtk_Tree_View_Record; 
  1756.        Call  : Cb_GObject_Boolean; 
  1757.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  1758.        After : Boolean := False); 
  1759.  
  1760.    type Cb_Gtk_Tree_View_Boolean_Boolean is not null access function 
  1761.      (Self   : access Gtk_Tree_View_Record'Class; 
  1762.       Object : Boolean) return Boolean; 
  1763.  
  1764.    type Cb_GObject_Boolean_Boolean is not null access function 
  1765.      (Self   : access Glib.Object.GObject_Record'Class; 
  1766.       Object : Boolean) return Boolean; 
  1767.  
  1768.    Signal_Select_Cursor_Row : constant Glib.Signal_Name := "select-cursor-row"; 
  1769.    procedure On_Select_Cursor_Row 
  1770.       (Self  : not null access Gtk_Tree_View_Record; 
  1771.        Call  : Cb_Gtk_Tree_View_Boolean_Boolean; 
  1772.        After : Boolean := False); 
  1773.    procedure On_Select_Cursor_Row 
  1774.       (Self  : not null access Gtk_Tree_View_Record; 
  1775.        Call  : Cb_GObject_Boolean_Boolean; 
  1776.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  1777.        After : Boolean := False); 
  1778.  
  1779.    Signal_Start_Interactive_Search : constant Glib.Signal_Name := "start-interactive-search"; 
  1780.    procedure On_Start_Interactive_Search 
  1781.       (Self  : not null access Gtk_Tree_View_Record; 
  1782.        Call  : Cb_Gtk_Tree_View_Boolean; 
  1783.        After : Boolean := False); 
  1784.    procedure On_Start_Interactive_Search 
  1785.       (Self  : not null access Gtk_Tree_View_Record; 
  1786.        Call  : Cb_GObject_Boolean; 
  1787.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  1788.        After : Boolean := False); 
  1789.  
  1790.    type Cb_Gtk_Tree_View_Gtk_Tree_Iter_Gtk_Tree_Path_Boolean is not null access function 
  1791.      (Self : access Gtk_Tree_View_Record'Class; 
  1792.       Iter : Gtk.Tree_Model.Gtk_Tree_Iter; 
  1793.       Path : Gtk.Tree_Model.Gtk_Tree_Path) return Boolean; 
  1794.  
  1795.    type Cb_GObject_Gtk_Tree_Iter_Gtk_Tree_Path_Boolean is not null access function 
  1796.      (Self : access Glib.Object.GObject_Record'Class; 
  1797.       Iter : Gtk.Tree_Model.Gtk_Tree_Iter; 
  1798.       Path : Gtk.Tree_Model.Gtk_Tree_Path) return Boolean; 
  1799.  
  1800.    Signal_Test_Collapse_Row : constant Glib.Signal_Name := "test-collapse-row"; 
  1801.    procedure On_Test_Collapse_Row 
  1802.       (Self  : not null access Gtk_Tree_View_Record; 
  1803.        Call  : Cb_Gtk_Tree_View_Gtk_Tree_Iter_Gtk_Tree_Path_Boolean; 
  1804.        After : Boolean := False); 
  1805.    procedure On_Test_Collapse_Row 
  1806.       (Self  : not null access Gtk_Tree_View_Record; 
  1807.        Call  : Cb_GObject_Gtk_Tree_Iter_Gtk_Tree_Path_Boolean; 
  1808.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  1809.        After : Boolean := False); 
  1810.    --  The given row is about to be collapsed (hide its children nodes). Use 
  1811.    --  this signal if you need to control the collapsibility of individual 
  1812.    --  rows. 
  1813.    --  
  1814.    --  Callback parameters: 
  1815.    --    --  "iter": the tree iter of the row to collapse 
  1816.    --    --  "path": a tree path that points to the row 
  1817.    --    --  Returns False to allow collapsing, True to reject 
  1818.  
  1819.    Signal_Test_Expand_Row : constant Glib.Signal_Name := "test-expand-row"; 
  1820.    procedure On_Test_Expand_Row 
  1821.       (Self  : not null access Gtk_Tree_View_Record; 
  1822.        Call  : Cb_Gtk_Tree_View_Gtk_Tree_Iter_Gtk_Tree_Path_Boolean; 
  1823.        After : Boolean := False); 
  1824.    procedure On_Test_Expand_Row 
  1825.       (Self  : not null access Gtk_Tree_View_Record; 
  1826.        Call  : Cb_GObject_Gtk_Tree_Iter_Gtk_Tree_Path_Boolean; 
  1827.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  1828.        After : Boolean := False); 
  1829.    --  The given row is about to be expanded (show its children nodes). Use 
  1830.    --  this signal if you need to control the expandability of individual rows. 
  1831.    --  
  1832.    --  Callback parameters: 
  1833.    --    --  "iter": the tree iter of the row to expand 
  1834.    --    --  "path": a tree path that points to the row 
  1835.    --    --  Returns False to allow expansion, True to reject 
  1836.  
  1837.    Signal_Toggle_Cursor_Row : constant Glib.Signal_Name := "toggle-cursor-row"; 
  1838.    procedure On_Toggle_Cursor_Row 
  1839.       (Self  : not null access Gtk_Tree_View_Record; 
  1840.        Call  : Cb_Gtk_Tree_View_Boolean; 
  1841.        After : Boolean := False); 
  1842.    procedure On_Toggle_Cursor_Row 
  1843.       (Self  : not null access Gtk_Tree_View_Record; 
  1844.        Call  : Cb_GObject_Boolean; 
  1845.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  1846.        After : Boolean := False); 
  1847.  
  1848.    Signal_Unselect_All : constant Glib.Signal_Name := "unselect-all"; 
  1849.    procedure On_Unselect_All 
  1850.       (Self  : not null access Gtk_Tree_View_Record; 
  1851.        Call  : Cb_Gtk_Tree_View_Boolean; 
  1852.        After : Boolean := False); 
  1853.    procedure On_Unselect_All 
  1854.       (Self  : not null access Gtk_Tree_View_Record; 
  1855.        Call  : Cb_GObject_Boolean; 
  1856.        Slot  : not null access Glib.Object.GObject_Record'Class; 
  1857.        After : Boolean := False); 
  1858.  
  1859.    ---------------- 
  1860.    -- Interfaces -- 
  1861.    ---------------- 
  1862.    --  This class implements several interfaces. See Glib.Types 
  1863.    -- 
  1864.    --  - "Buildable" 
  1865.    -- 
  1866.    --  - "Scrollable" 
  1867.  
  1868.    package Implements_Gtk_Buildable is new Glib.Types.Implements 
  1869.      (Gtk.Buildable.Gtk_Buildable, Gtk_Tree_View_Record, Gtk_Tree_View); 
  1870.    function "+" 
  1871.      (Widget : access Gtk_Tree_View_Record'Class) 
  1872.    return Gtk.Buildable.Gtk_Buildable 
  1873.    renames Implements_Gtk_Buildable.To_Interface; 
  1874.    function "-" 
  1875.      (Interf : Gtk.Buildable.Gtk_Buildable) 
  1876.    return Gtk_Tree_View 
  1877.    renames Implements_Gtk_Buildable.To_Object; 
  1878.  
  1879.    package Implements_Gtk_Scrollable is new Glib.Types.Implements 
  1880.      (Gtk.Scrollable.Gtk_Scrollable, Gtk_Tree_View_Record, Gtk_Tree_View); 
  1881.    function "+" 
  1882.      (Widget : access Gtk_Tree_View_Record'Class) 
  1883.    return Gtk.Scrollable.Gtk_Scrollable 
  1884.    renames Implements_Gtk_Scrollable.To_Interface; 
  1885.    function "-" 
  1886.      (Interf : Gtk.Scrollable.Gtk_Scrollable) 
  1887.    return Gtk_Tree_View 
  1888.    renames Implements_Gtk_Scrollable.To_Object; 
  1889.  
  1890. private 
  1891.    Tooltip_Column_Property : constant Glib.Properties.Property_Int := 
  1892.      Glib.Properties.Build ("tooltip-column"); 
  1893.    Show_Expanders_Property : constant Glib.Properties.Property_Boolean := 
  1894.      Glib.Properties.Build ("show-expanders"); 
  1895.    Search_Column_Property : constant Glib.Properties.Property_Int := 
  1896.      Glib.Properties.Build ("search-column"); 
  1897.    Rules_Hint_Property : constant Glib.Properties.Property_Boolean := 
  1898.      Glib.Properties.Build ("rules-hint"); 
  1899.    Rubber_Banding_Property : constant Glib.Properties.Property_Boolean := 
  1900.      Glib.Properties.Build ("rubber-banding"); 
  1901.    Reorderable_Property : constant Glib.Properties.Property_Boolean := 
  1902.      Glib.Properties.Build ("reorderable"); 
  1903.    Model_Property : constant Glib.Properties.Property_Interface := 
  1904.      Glib.Properties.Build ("model"); 
  1905.    Level_Indentation_Property : constant Glib.Properties.Property_Int := 
  1906.      Glib.Properties.Build ("level-indentation"); 
  1907.    Hover_Selection_Property : constant Glib.Properties.Property_Boolean := 
  1908.      Glib.Properties.Build ("hover-selection"); 
  1909.    Hover_Expand_Property : constant Glib.Properties.Property_Boolean := 
  1910.      Glib.Properties.Build ("hover-expand"); 
  1911.    Headers_Visible_Property : constant Glib.Properties.Property_Boolean := 
  1912.      Glib.Properties.Build ("headers-visible"); 
  1913.    Headers_Clickable_Property : constant Glib.Properties.Property_Boolean := 
  1914.      Glib.Properties.Build ("headers-clickable"); 
  1915.    Fixed_Height_Mode_Property : constant Glib.Properties.Property_Boolean := 
  1916.      Glib.Properties.Build ("fixed-height-mode"); 
  1917.    Expander_Column_Property : constant Glib.Properties.Property_Object := 
  1918.      Glib.Properties.Build ("expander-column"); 
  1919.    Enable_Tree_Lines_Property : constant Glib.Properties.Property_Boolean := 
  1920.      Glib.Properties.Build ("enable-tree-lines"); 
  1921.    Enable_Search_Property : constant Glib.Properties.Property_Boolean := 
  1922.      Glib.Properties.Build ("enable-search"); 
  1923.    Enable_Grid_Lines_Property : constant Gtk.Enums.Property_Gtk_Tree_View_Grid_Lines := 
  1924.      Gtk.Enums.Build ("enable-grid-lines"); 
  1925.    Activate_On_Single_Click_Property : constant Glib.Properties.Property_Boolean := 
  1926.      Glib.Properties.Build ("activate-on-single-click"); 
  1927. end Gtk.Tree_View;