1. ----------------------------------------------------------------------- 
  2. --               GtkAda - Ada95 binding for Gtk+/Gnome               -- 
  3. --                                                                   -- 
  4. --   Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet   -- 
  5. --                Copyright (C) 2000-2007 AdaCore                    -- 
  6. --                                                                   -- 
  7. -- This library is free software; you can redistribute it and/or     -- 
  8. -- modify it under the terms of the GNU General Public               -- 
  9. -- License as published by the Free Software Foundation; either      -- 
  10. -- version 2 of the License, or (at your option) any later version.  -- 
  11. --                                                                   -- 
  12. -- This library is distributed in the hope that it will be useful,   -- 
  13. -- but WITHOUT ANY WARRANTY; without even the implied warranty of    -- 
  14. -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU -- 
  15. -- General Public License for more details.                          -- 
  16. --                                                                   -- 
  17. -- You should have received a copy of the GNU General Public         -- 
  18. -- License along with this library; if not, write to the             -- 
  19. -- Free Software Foundation, Inc., 59 Temple Place - Suite 330,      -- 
  20. -- Boston, MA 02111-1307, USA.                                       -- 
  21. --                                                                   -- 
  22. -- As a special exception, if other files instantiate generics from  -- 
  23. -- this unit, or you link this unit with other files to produce an   -- 
  24. -- executable, this  unit  does not  by itself cause  the resulting  -- 
  25. -- executable to be covered by the GNU General Public License. This  -- 
  26. -- exception does not however invalidate any other reasons why the   -- 
  27. -- executable file  might be covered by the  GNU Public License.     -- 
  28. ----------------------------------------------------------------------- 
  29.  
  30. --  <description> 
  31. --  This widget is deprecated. Use Gtk.Tree_View instead. 
  32. -- 
  33. --  This widget is similar to Gtk_Clist but it displays a tree with expandable 
  34. --  nodes instead of a simple list. Gtk_Tree is a more flexible tree widget 
  35. --  (it can have arbitrary widgets in the tree cells), but it is less efficient 
  36. --  and is limited to 32768 pixels. 
  37. -- 
  38. --  If you need horizontal or vertical scrolling, you mustn't put this widget 
  39. --  in a Gtk_Viewport, and then in a Gtk_Scrolled_Window. Put it directly into 
  40. --  a Gtk_Scrolled_Window, or horizontal scrolling will be disabled, and the 
  41. --  column headers will disappear when scrolling vertically. 
  42. -- 
  43. --  </description> 
  44. --  <c_version>2.8.17</c_version> 
  45. --  <group>Obsolescent widgets</group> 
  46. --  <testgtk>create_ctree.adb</testgtk> 
  47.  
  48. with Interfaces.C.Strings; 
  49. with Unchecked_Conversion; 
  50.  
  51. with Gdk.Bitmap; 
  52. with Gdk.Color; 
  53. with Gdk.Pixmap; 
  54.  
  55. with Glib.Glist; 
  56. pragma Elaborate_All (Glib.Glist); 
  57. with Glib.Gnodes; 
  58.  
  59. pragma Warnings (Off);  --  Gtk.Clist is obsolescent 
  60. with Gtk.Clist; 
  61. pragma Warnings (On); 
  62. with Gtk.Enums;            use Gtk.Enums; 
  63. with Gtk.Style; 
  64.  
  65. with Gtkada.Types;         use Gtkada.Types; 
  66.  
  67. package Gtk.Ctree is 
  68.    pragma Obsolescent ("use Gtk.Tree_View instead"); 
  69.    pragma Elaborate_Body; 
  70.  
  71.    pragma Warnings (Off); --  Gtk.Clist is obsolescent; 
  72.    type Gtk_Ctree_Record is new Gtk.Clist.Gtk_Clist_Record with private; 
  73.    type Gtk_Ctree is access all Gtk_Ctree_Record'Class; 
  74.  
  75.    type Gtk_Ctree_Row is new Gtk.Clist.Gtk_Clist_Row; 
  76.    pragma Warnings (On); 
  77.    --  Similar to Clist_Row, but for a Ctree. 
  78.  
  79.    type Gtk_Ctree_Node is new Gdk.C_Proxy; 
  80.    --  This type represents a node inside a Ctree. 
  81.  
  82.    --  <doc_ignore> 
  83.    Null_Ctree_Node : constant Gtk_Ctree_Node := null; 
  84.  
  85.    type Gtk_Ctree_Line_Style is 
  86.      (Ctree_Lines_None, 
  87.       --  No line will be drawn in the Ctree 
  88.  
  89.       Ctree_Lines_Solid, 
  90.       --  Solid lines will be drawn 
  91.  
  92.       Ctree_Lines_Dotted, 
  93.       --  Dotted lines will be drawn 
  94.  
  95.       Ctree_Lines_Tabbed 
  96.       --  The tree won't be highlighted by lines but by tabs surrounding nodes 
  97.      ); 
  98.    pragma Convention (C, Gtk_Ctree_Line_Style); 
  99.    --  See Gtk.Ctree.Set_Line_Style for more details. 
  100.  
  101.    type Gtk_Ctree_Expander_Style is 
  102.      (Ctree_Expander_None, 
  103.       --  No pixmap will be drawn, you will have to double-click on the node to 
  104.       --  expand it. 
  105.  
  106.       Ctree_Expander_Square, 
  107.       --  The pixmap will be a square 
  108.  
  109.       Ctree_Expander_Triangle, 
  110.       --  The pixmap will be a triangle 
  111.  
  112.       Ctree_Expander_Circular 
  113.       --  The pixmap will be a circle 
  114.      ); 
  115.    --  See Gtk.Ctree.Set_Expander_Style for more details. 
  116.    pragma Convention (C, Gtk_Ctree_Expander_Style); 
  117.  
  118.    package Row_List is new Glib.Glist.Generic_List (Gtk_Ctree_Row); 
  119.  
  120.    function Convert is new Unchecked_Conversion 
  121.      (Gtk_Ctree_Node, System.Address); 
  122.    function Convert is new Unchecked_Conversion 
  123.      (System.Address, Gtk_Ctree_Node); 
  124.    package Node_List is new Glib.Glist.Generic_List (Gtk_Ctree_Node); 
  125.    --  </doc_ignore> 
  126.  
  127.    ----------------------------------- 
  128.    -- Creation, insertion, deletion -- 
  129.    ----------------------------------- 
  130.    --  Elements inside a Gtk_Ctree are not ordered from the top to the bottom 
  131.    --  as is the case for Gtk_Clist. Instead, they are put in the ctree by 
  132.    --  indicating where in the tree they should be placed. The position of an 
  133.    --  element (called a node) is defined by a parent node and a sibling node. 
  134.    --  The node will be attached in the parent subtree, on top of the sibling 
  135.    --  node. 
  136.  
  137.    procedure Gtk_New (Widget      :    out Gtk_Ctree; 
  138.                       Columns     : in     Gint; 
  139.                       Tree_Column : in     Gint := 0); 
  140.    --  Create a ctree with Columns columns. 
  141.    --  Tree_Column indicates in which column the tree will be displayed. 
  142.  
  143.    procedure Initialize (Widget      : access Gtk_Ctree_Record'Class; 
  144.                          Columns     : in     Gint; 
  145.                          Tree_Column : in     Gint := 0); 
  146.    --  Internal initialization function. 
  147.    --  See the section "Creating your own widgets" in the documentation. 
  148.  
  149.    procedure Gtk_New (Widget      :    out Gtk_Ctree; 
  150.                       Titles      : in     Chars_Ptr_Array; 
  151.                       Tree_Column : in     Gint := 0); 
  152.    --  Create a ctree with Titles'Length columns. 
  153.    --  Titles gives the title of each column. 
  154.    --  Tree_Column indicates in which column the tree will be displayed. 
  155.  
  156.    procedure Initialize (Widget      : access Gtk_Ctree_Record'Class; 
  157.                          Titles      : in     Chars_Ptr_Array; 
  158.                          Tree_Column : in     Gint := 0); 
  159.    --  Internal initialization function. 
  160.    --  See the section "Creating your own widgets" in the documentation. 
  161.  
  162.    function Get_Type return Gtk.Gtk_Type; 
  163.    --  Return the internal value associated with a Gtk_Ctree. 
  164.  
  165.    function Insert_Node (Ctree         : access Gtk_Ctree_Record; 
  166.                          Parent        : in     Gtk_Ctree_Node; 
  167.                          Sibling       : in     Gtk_Ctree_Node; 
  168.                          Text          : in     Chars_Ptr_Array; 
  169.                          Spacing       : in     Guint8; 
  170.                          Pixmap_Closed : in     Gdk.Pixmap.Gdk_Pixmap; 
  171.                          Mask_Closed   : in     Gdk.Bitmap.Gdk_Bitmap; 
  172.                          Pixmap_Opened : in     Gdk.Pixmap.Gdk_Pixmap; 
  173.                          Mask_Opened   : in     Gdk.Bitmap.Gdk_Bitmap; 
  174.                          Is_Leaf       : in     Boolean; 
  175.                          Expanded      : in     Boolean) 
  176.                          return                 Gtk_Ctree_Node; 
  177.    --  Insert a new node in the Ctree. 
  178.    --  Parent is the parent node. If null, the new node is part of the root. 
  179.    --  The new node will be inserted right on top of Sibling. If Sibling is 
  180.    --  null, then it will be the first node in the subtree. 
  181.    --  Text contains the text for each cell of the node. Note that Insert_Node 
  182.    --  expects the length of the Text parameter to be equal to the number of 
  183.    --  columns of the Ctree. 
  184.    --  Spacing is the number of pixels between the lines of the tree and the 
  185.    --  text in the same column. 
  186.    --  If Is_Leaf is True, then the node won't contain any subtree. If False, 
  187.    --  the newly created node can be used as the Parent for further node 
  188.    --  creation. In this case, Expanded indicates whether the subtree 
  189.    --  associated with this node should be initially visible. 
  190.    --  In addition to the "+" or "-" sign indicating whether the subtree is 
  191.    --  expanded or not, it is possible to put a pixmap giving this information. 
  192.    --  Pixmap_Closed and Mask_Closed represent the image and the mask used when 
  193.    --  the subtree is closed; similarly, Pixmap_Opened and Mask_Opened 
  194.    --  represent the image and the mask used when the subtree is opened. 
  195.  
  196.    procedure Remove_Node (Ctree : access Gtk_Ctree_Record; 
  197.                           Node  : in     Gtk_Ctree_Node); 
  198.    --  Remove Node from Ctree. 
  199.  
  200.    ------------------------------------------- 
  201.    -- Tree, Node and Row basic manipulation -- 
  202.    ------------------------------------------- 
  203.  
  204.    function Get_Tree_Column 
  205.      (Widget : access Gtk.Ctree.Gtk_Ctree_Record'Class) return Gint; 
  206.    --  Return the Tree_Column attribute of a given Node. 
  207.    --  Tree_Column indicates in which column the tree will be displayed. 
  208.  
  209.    function Get_Node_List 
  210.      (Ctree : access Gtk_Ctree_Record) return Node_List.Glist; 
  211.    --   Return the list of nodes associated with a given Ctree. 
  212.    --   Note: you need to extract the nodes with Node_List.Get_Gpointer. 
  213.  
  214.    function Get_Row_List 
  215.      (Ctree : access Gtk_Ctree_Record) return Row_List.Glist; 
  216.    --  Return the list of rows associated with a given Ctree. 
  217.  
  218.    function Get_Selection 
  219.      (Ctree : access Gtk_Ctree_Record) return Node_List.Glist; 
  220.    --   Return the list of nodes currently selected. 
  221.    --   Extract the nodes with Node_List.Get_Data 
  222.  
  223.    function Node_Get_Row (Node : in Gtk_Ctree_Node) return Gtk_Ctree_Row; 
  224.    --  Return the row of a given Node. 
  225.  
  226.    function Row_Get_Children (Row : in Gtk_Ctree_Row) return Gtk_Ctree_Node; 
  227.    --  Return the children node of a given Row. 
  228.  
  229.    function Row_Get_Expanded (Row : in Gtk_Ctree_Row) return Boolean; 
  230.    --  Return the expanded attribute of a given Row. 
  231.    --  Note that Expanded can also be retrieved via Get_Node_Info, 
  232.    --  this function is just a quick accessor. 
  233.  
  234.    function Row_Get_Is_Leaf (Row : in Gtk_Ctree_Row) return Boolean; 
  235.    --  Return the leaf attribute of a given Row. 
  236.    --  Note that Is_Leaf can also be retrieved via Get_Node_Info, 
  237.    --  this function is just a quick accessor. 
  238.  
  239.    function Row_Get_Parent (Row : in Gtk_Ctree_Row) return Gtk_Ctree_Node; 
  240.    --  Return the parent node of a given Row. 
  241.  
  242.    function Row_Get_Sibling (Row : in Gtk_Ctree_Row) return Gtk_Ctree_Node; 
  243.    --  Return the sibling node of a given Row. 
  244.  
  245.    function Is_Created (Node : in Gtk_Ctree_Node) return Boolean; 
  246.    --  Return True if Node is different from Null_Ctree_Node 
  247.  
  248.    ----------------------------------------- 
  249.    -- Querying / finding tree information -- 
  250.    ----------------------------------------- 
  251.  
  252.    function Is_Viewable 
  253.      (Ctree  : access Gtk_Ctree_Record; 
  254.       Node   : in     Gtk_Ctree_Node) 
  255.       return Boolean; 
  256.    --  Return True if Node is viewable. 
  257.    --  A Node is viewable if all the trees and subtrees containing it are 
  258.    --  expanded. 
  259.  
  260.    function Last 
  261.      (Ctree  : access Gtk_Ctree_Record; 
  262.       Node   : in     Gtk_Ctree_Node) 
  263.       return Gtk_Ctree_Node; 
  264.    --  Return the last node of a given subtree. 
  265.    --  Starting at Node, this function will recursively look for the last 
  266.    --  sibling of the last child. 
  267.    --  Return an empty node is Node is empty. 
  268.  
  269.    function Find_Node_Ptr 
  270.      (Ctree     : access Gtk_Ctree_Record; 
  271.       Ctree_Row : in     Gtk_Ctree_Row) 
  272.       return Gtk_Ctree_Node; 
  273.    --  Return the node corresponding to a given row. 
  274.  
  275.    function Node_Nth (Ctree  : access Gtk_Ctree_Record; 
  276.                       Row    : in     Guint) 
  277.                       return          Gtk_Ctree_Node; 
  278.    --  Return the Node corresponding to the nth row of a given Ctree. 
  279.    --  This can be used to retrieve the root node of the tree, by passing 0 for 
  280.    --  Row. 
  281.  
  282.    function Find (Ctree : access Gtk_Ctree_Record; 
  283.                   Node  : in     Gtk_Ctree_Node; 
  284.                   Child : in     Gtk_Ctree_Node) return Boolean; 
  285.    --  Recursively search for a given Child in a given subtree. 
  286.    --  the subtree is determined by Node. If Node is empty, the search will 
  287.    --  occur on the whole tree. 
  288.    --  Return True if Child is found, False otherwise. 
  289.  
  290.    function Is_Ancestor 
  291.      (Ctree  : access Gtk_Ctree_Record; 
  292.       Node   : in     Gtk_Ctree_Node; 
  293.       Child  : in     Gtk_Ctree_Node) return Boolean; 
  294.    --  Indicate whether Node is an ancestor of Child. 
  295.    --  It is assumed that Node is not empty. 
  296.  
  297.    function Is_Hot_Spot 
  298.      (Ctree  : access Gtk_Ctree_Record; 
  299.       X      : in     Gint; 
  300.       Y      : in     Gint) return Boolean; 
  301.    --  Return True if the Ctree is centered on (x,y) 
  302.  
  303.    ------------------------------------------------------ 
  304.    -- Tree signals: move, expand, collapse, (un)select -- 
  305.    ------------------------------------------------------ 
  306.  
  307.    procedure Move (Ctree       : access Gtk_Ctree_Record; 
  308.                    Node        : in     Gtk_Ctree_Node; 
  309.                    New_Parent  : in     Gtk_Ctree_Node; 
  310.                    New_Sibling : in     Gtk_Ctree_Node); 
  311.    --  Move a node in a Ctree. 
  312.    --  After its creation, a node can be moved. 
  313.    --  New_Parent points to the new parent node that will contain Node. 
  314.    --  If null, Node will be attached to the root. 
  315.    --  New_Sibling indicates under which node Node will be inserted. 
  316.    --  If New_Sibling is null, the new node will be the lowest in its branch. 
  317.  
  318.    procedure Expand (Ctree : access Gtk_Ctree_Record; 
  319.                      Node  : in     Gtk_Ctree_Node); 
  320.    --  Expand the first level of the subtree associated with Node. 
  321.  
  322.    procedure Expand_Recursive 
  323.      (Ctree : access Gtk_Ctree_Record; 
  324.       Node  : in     Gtk_Ctree_Node := null); 
  325.    --  Expand the whole subtree associated with Node. 
  326.  
  327.    procedure Expand_To_Depth 
  328.      (Ctree : access Gtk_Ctree_Record; 
  329.       Node  : in     Gtk_Ctree_Node := null; 
  330.       Depth : in     Gint); 
  331.    --  Expand the subtree associated with Node and its descendants until Depth 
  332.    --  levels of subtrees have been reached. 
  333.  
  334.    procedure Collapse (Ctree : access Gtk_Ctree_Record; 
  335.                        Node  : in     Gtk_Ctree_Node); 
  336.    --  Collapse the first level of the subtree associated with Node. 
  337.  
  338.    procedure Collapse_Recursive 
  339.      (Ctree : access Gtk_Ctree_Record; 
  340.       Node  : in     Gtk_Ctree_Node := null); 
  341.    --  Collapse the whole subtree associated with Node. 
  342.  
  343.    procedure Collapse_To_Depth 
  344.      (Ctree : access Gtk_Ctree_Record; 
  345.       Node  : in     Gtk_Ctree_Node := null; 
  346.       Depth : in     Gint); 
  347.    --  Collapse the subtree associated with Node and its descendants until 
  348.    --  Depth levels of subtrees have been reached. 
  349.  
  350.    procedure Toggle_Expansion (Ctree : access Gtk_Ctree_Record; 
  351.                                Node  : in     Gtk_Ctree_Node); 
  352.    --  Change the state of the Ctree from expanded to collapsed and the other 
  353.    --  way around on one level. 
  354.  
  355.    procedure Toggle_Expansion_Recursive (Ctree : access Gtk_Ctree_Record; 
  356.                                          Node  : in     Gtk_Ctree_Node); 
  357.    --  Change the state of the Ctree from expanded to collapsed and the other 
  358.    --  way around for the whole subtree. 
  359.  
  360.    procedure Gtk_Select (Ctree : access  Gtk_Ctree_Record; 
  361.                          Node  : in      Gtk_Ctree_Node); 
  362.    --  Select a specified Node, and only this one. 
  363.  
  364.    procedure Select_Recursive 
  365.      (Ctree : access Gtk_Ctree_Record; 
  366.       Node  : in     Gtk_Ctree_Node := null); 
  367.    --  Select a specified Node, and its whole subtree. 
  368.  
  369.    procedure Unselect (Ctree : access Gtk_Ctree_Record; 
  370.                        Node  : in     Gtk_Ctree_Node); 
  371.    --  Unselect a specified Node, and only this one. 
  372.  
  373.    procedure Unselect_Recursive 
  374.      (Ctree : access Gtk_Ctree_Record; 
  375.       Node  : in     Gtk_Ctree_Node := null); 
  376.    --  Unselect a specified Node, and its whole subtree. 
  377.  
  378.    procedure Real_Select_Recursive (Ctree     : access Gtk_Ctree_Record; 
  379.                                     Node      : in     Gtk_Ctree_Node := null; 
  380.                                     Do_Select : in     Boolean); 
  381.    --  Similar to Select_Recursive or Unselect_Recursive. 
  382.    --  If Do_Select is True, equivalent to Select_Recursive. 
  383.    --  If Do_Select is False, equivalent to Unselect_Recursive. 
  384.  
  385.    ------------------------------------ 
  386.    -- Analogs of Gtk_Clist functions -- 
  387.    ------------------------------------ 
  388.  
  389.    procedure Node_Set_Text (Ctree  : access Gtk_Ctree_Record; 
  390.                             Node   : in     Gtk_Ctree_Node; 
  391.                             Column : in     Gint; 
  392.                             Text   : in     UTF8_String); 
  393.    --  Set the cell's text, replacing its current contents. 
  394.    --  This changes the type of the cell to Cell_Text. The pixmap (if any) 
  395.    --  will no longer be displayed. 
  396.  
  397.    function Node_Get_Text (Ctree   : access Gtk_Ctree_Record; 
  398.                            Node    : in     Gtk_Ctree_Node; 
  399.                            Column  : in     Gint) return UTF8_String; 
  400.    --  Return the text contained in cell. 
  401.    --  An empty string is returned if Column is invalid or if the Cell did not 
  402.    --  contain any text (only a pixmap) 
  403.  
  404.    procedure Node_Set_Pixmap (Ctree  : access Gtk_Ctree_Record; 
  405.                               Node   : in     Gtk_Ctree_Node; 
  406.                               Column : in     Gint; 
  407.                               Pixmap : in     Gdk.Pixmap.Gdk_Pixmap; 
  408.                               Mask   : in     Gdk.Bitmap.Gdk_Bitmap); 
  409.    --  Set the cell's pixmap, replacing its current contents. 
  410.    --  The type of the cell becomes Cell_Pixmap, and the text is no longer 
  411.    --  displayed. 
  412.  
  413.    procedure Node_Get_Pixmap (Ctree   : access Gtk_Ctree_Record; 
  414.                               Node    : in     Gtk_Ctree_Node; 
  415.                               Column  : in     Gint; 
  416.                               Pixmap  :    out Gdk.Pixmap.Gdk_Pixmap; 
  417.                               Mask    :    out Gdk.Bitmap.Gdk_Bitmap; 
  418.                               Success :    out Boolean); 
  419.    --  Return the Pixmap contained in a cell. 
  420.    --  The type of the cell should be Cell_Pixmap. 
  421.    --  The result is meaningful only if Success is True. If the Cell did not 
  422.    --  contain a pixmap, Success is set to False. 
  423.  
  424.    procedure Node_Set_Pixtext (Ctree   : access Gtk_Ctree_Record; 
  425.                                Node    : in     Gtk_Ctree_Node; 
  426.                                Column  : in     Gint; 
  427.                                Text    : in     UTF8_String; 
  428.                                Spacing : in     Guint8; 
  429.                                Pixmap  : in     Gdk.Pixmap.Gdk_Pixmap; 
  430.                                Mask    : in     Gdk.Bitmap.Gdk_Bitmap); 
  431.    --  Set both the Text and the Pixmap for the cell. 
  432.    --  Replace its current contents. The type of the cell becomes Cell_Pixtext, 
  433.    --  and both the text and the pixmap are displayed. 
  434.  
  435.    procedure Node_Get_Pixtext (Ctree   : access Gtk_Ctree_Record; 
  436.                                Node    : in     Gtk_Ctree_Node; 
  437.                                Column  : in     Gint; 
  438.                                Text    :    out Interfaces.C.Strings.chars_ptr; 
  439.                                Spacing :    out Guint8; 
  440.                                Pixmap  :    out Gdk.Pixmap.Gdk_Pixmap; 
  441.                                Mask    :    out Gdk.Bitmap.Gdk_Bitmap; 
  442.                                Success :    out Boolean); 
  443.    --  Return the Text and the Pixmap for the cell. 
  444.    --  The result is not meaningful if Success is False. 
  445.  
  446.    procedure Node_Set_Shift (Ctree      : access Gtk_Ctree_Record; 
  447.                              Node       : in     Gtk_Ctree_Node; 
  448.                              Column     : in     Gint; 
  449.                              Vertical   : in     Gint; 
  450.                              Horizontal : in     Gint); 
  451.    --  Set a horizontal and vertical shift for drawing the content of the cell. 
  452.    --  Both shifts can be either positive or negative. 
  453.    --  This is particularly useful for indenting items in a columns. 
  454.  
  455.    procedure Set_Node_Info (Ctree         : access Gtk_Ctree_Record; 
  456.                             Node          : in     Gtk_Ctree_Node; 
  457.                             Text          : in     UTF8_String; 
  458.                             Spacing       : in     Guint8; 
  459.                             Pixmap_Closed : in     Gdk.Pixmap.Gdk_Pixmap; 
  460.                             Mask_Closed   : in     Gdk.Bitmap.Gdk_Bitmap; 
  461.                             Pixmap_Opened : in     Gdk.Pixmap.Gdk_Pixmap; 
  462.                             Mask_Opened   : in     Gdk.Bitmap.Gdk_Bitmap; 
  463.                             Is_Leaf       : in     Boolean; 
  464.                             Expanded      : in     Boolean); 
  465.    --  Set all the info related to a specific Node. 
  466.  
  467.    procedure Get_Node_Info 
  468.      (Ctree         : access Gtk_Ctree_Record; 
  469.       Node          : in     Gtk_Ctree_Node; 
  470.       Text          :    out Interfaces.C.Strings.chars_ptr; 
  471.       Spacing       :    out Guint8; 
  472.       Pixmap_Closed :    out Gdk.Pixmap.Gdk_Pixmap; 
  473.       Mask_Closed   :    out Gdk.Bitmap.Gdk_Bitmap; 
  474.       Pixmap_Opened :    out Gdk.Pixmap.Gdk_Pixmap; 
  475.       Mask_Opened   :    out Gdk.Bitmap.Gdk_Bitmap; 
  476.       Is_Leaf       :    out Boolean; 
  477.       Expanded      :    out Boolean; 
  478.       Success       :    out Boolean); 
  479.    --  Return all the info related to a specific Node. 
  480.  
  481.    procedure Node_Set_Selectable (Ctree      : access Gtk_Ctree_Record; 
  482.                                   Node       : in     Gtk_Ctree_Node; 
  483.                                   Selectable : in     Boolean := True); 
  484.    --  Indicate whether the Node can be selected or not. 
  485.    --  The default value is True. 
  486.  
  487.    function Node_Get_Selectable (Ctree  : access Gtk_Ctree_Record; 
  488.                                  Node   : in     Gtk_Ctree_Node) 
  489.                                  return          Boolean; 
  490.    --  Return the selectable status of the Node. 
  491.  
  492.    procedure Node_Set_Row_Style (Ctree : access Gtk_Ctree_Record; 
  493.                                  Node  : in     Gtk_Ctree_Node; 
  494.                                  Style : in     Gtk.Style.Gtk_Style); 
  495.    --  Set the default style for the cells in the Node. 
  496.    --  This can be overridden for each cell with Node_Set_Cell_Style. 
  497.  
  498.    function Node_Get_Row_Style (Ctree  : access Gtk_Ctree_Record; 
  499.                                 Node   : in     Gtk_Ctree_Node) 
  500.                                 return          Gtk.Style.Gtk_Style; 
  501.    --  Return the default style used for the Node. 
  502.  
  503.    procedure Node_Set_Cell_Style (Ctree  : access Gtk_Ctree_Record; 
  504.                                   Node   : in     Gtk_Ctree_Node; 
  505.                                   Column : in     Gint; 
  506.                                   Style  : in     Gtk.Style.Gtk_Style); 
  507.    --  Set the style (font, color, ...) used for the cell. 
  508.    --  This overrides the Node's style. 
  509.  
  510.    function Node_Get_Cell_Style (Ctree  : access Gtk_Ctree_Record; 
  511.                                  Node   : in     Gtk_Ctree_Node; 
  512.                                  Column : in     Gint) 
  513.                                  return          Gtk.Style.Gtk_Style; 
  514.    --  Return the style of the cell. 
  515.  
  516.    procedure Node_Set_Foreground (Ctree : access Gtk_Ctree_Record; 
  517.                                   Node  : in     Gtk_Ctree_Node; 
  518.                                   Color : in     Gdk.Color.Gdk_Color); 
  519.    --  Set the foreground color for the Node. 
  520.    --  The color must already be allocated. 
  521.    --  If no such Node exists in the tree, nothing is done. 
  522.  
  523.    procedure Node_Set_Background (Ctree : access Gtk_Ctree_Record; 
  524.                                   Node  : in     Gtk_Ctree_Node; 
  525.                                   Color : in     Gdk.Color.Gdk_Color); 
  526.    --  Set the background color for the Node. 
  527.    --  The color must already be allocated. 
  528.    --  If no such Node exists in the tree, nothing is done. 
  529.  
  530.    pragma Warnings (Off);  --  Gtk.Clist is obsolescent 
  531.    function Node_Get_Cell_Type (Ctree  : access Gtk_Ctree_Record; 
  532.                                 Node   : in     Gtk_Ctree_Node; 
  533.                                 Column : in     Gint) 
  534.                                 return Gtk.Clist.Gtk_Cell_Type; 
  535.    pragma Warnings (On); 
  536.    --  Return the type of the cell at Node/Column. 
  537.    --  This indicates which of the functions Node_Get_Text. Node_Get_Pixmap, 
  538.    --  etc. should be used with this cell. 
  539.  
  540.    procedure Node_Moveto (Ctree     : access Gtk_Ctree_Record; 
  541.                           Node      : in     Gtk_Ctree_Node; 
  542.                           Column    : in     Gint; 
  543.                           Row_Align : in     Gfloat := 0.5; 
  544.                           Col_Align : in     Gfloat := 0.5); 
  545.    --  Make a Node visible. 
  546.    --  Column indicates which column of the Node should be visible, if not 
  547.    --  all columns can be displayed. 
  548.    --  Row_Align and Col_Align are parameters between 0.0 and 1.0, and 
  549.    --  specify how the Node and the Column will be centered in the Ctree 
  550.    --  window. 0.0 means a Node on the top, and a Column on the left. 
  551.  
  552.    function Node_Is_Visible 
  553.      (Ctree  : access Gtk_Ctree_Record; 
  554.       Node   : in     Gtk_Ctree_Node) 
  555.       return Gtk_Visibility; 
  556.    --  Indicate the visibility of a Node. 
  557.    --  Return Visibility_None if the Node is not visible in the Ctree window; 
  558.    --  Visibility_Partial if the Node is partially visible; Visibility_Full 
  559.    --  if the Node is entirely visible. 
  560.    --  This function ignores the fact that Node is in an expanded or collapsed 
  561.    --  subtree. 
  562.  
  563.    ------------------------------ 
  564.    -- Ctree specific functions -- 
  565.    ------------------------------ 
  566.  
  567.    procedure Set_Indent (Ctree  : access Gtk_Ctree_Record; 
  568.                          Indent : in     Gint := 20); 
  569.    --  Change the indentation of the Ctree. 
  570.    --  Each different level of a subtree is indented by a number of pixels. 
  571.    --  By default, the indentation is 20 pixels, and can be changed using this 
  572.    --  procedure. 
  573.  
  574.    function Get_Indent 
  575.      (Widget : access Gtk.Ctree.Gtk_Ctree_Record'Class) return Gint; 
  576.    --  Return the indentation of a Ctree. 
  577.  
  578.    procedure Set_Spacing (Ctree   : access Gtk_Ctree_Record; 
  579.                           Spacing : in     Gint := 5); 
  580.    --  Set the spacing between the tree's icon and the additional pixmap. 
  581.    --  The additional pixmap indicates whether the subtree is opened or closed. 
  582.    --  The default value is 5 pixels. 
  583.  
  584.    function Get_Spacing 
  585.      (Widget : access Gtk.Ctree.Gtk_Ctree_Record'Class) return Gint; 
  586.    --  Return the spacing between the tree's icon and the additional pixmap. 
  587.  
  588.    procedure Set_Show_Stub (Ctree     : access Gtk_Ctree_Record; 
  589.                             Show_Stub : in     Boolean); 
  590.    --  Set the Show_Stub attribute of Ctree. 
  591.  
  592.    function Get_Show_Stub (Ctree : access Gtk_Ctree_Record) return Boolean; 
  593.    --  Return the Show_Stub attribute of Ctree. 
  594.  
  595.    procedure Set_Line_Style 
  596.      (Ctree      : access Gtk_Ctree_Record; 
  597.       Line_Style : in     Gtk_Ctree_Line_Style := Ctree_Lines_Solid); 
  598.    --  Change the style of the lines representing the tree of a given Ctree. 
  599.    --  By default, solid lines are used. 
  600.    --  See the description of Gtk_Ctree_Line_Style for more details of the 
  601.    --  possible values. 
  602.  
  603.    function Get_Line_Style 
  604.      (Ctree : access Gtk_Ctree_Record) return Gtk_Ctree_Line_Style; 
  605.    --  return the style of the lines representing the tree of a given Ctree. 
  606.  
  607.    procedure Set_Expander_Style 
  608.      (Ctree          : access Gtk_Ctree_Record; 
  609.       Expander_Style : in     Gtk_Ctree_Expander_Style := 
  610.         Ctree_Expander_Square); 
  611.    --  Set the way a given Ctree can be expanded. 
  612.    --  To expand a subtree, you can either double-click on a node, or click on 
  613.    --  the "+/-" icon. This icon is by default included in a square pixmap. 
  614.    --  This procedure can change the form of this pixmap. 
  615.    --  See the description of Gtk_Ctree_Expander_Style for more details. 
  616.  
  617.    function Get_Expander_Style 
  618.      (Ctree : access Gtk_Ctree_Record) return Gtk_Ctree_Expander_Style; 
  619.    --  Return the way a given Ctree can be expanded. 
  620.  
  621.    type Gtk_Ctree_Compare_Drag_Func is access 
  622.      function (Ctree        : in Gtk_Ctree; 
  623.                Source_Node  : in Gtk_Ctree_Node; 
  624.                New_Parent   : in Gtk_Ctree_Node; 
  625.                New_Sibling  : in Gtk_Ctree_Node) return Boolean; 
  626.    --  Function type used in Set_Drag_Compare_Func. 
  627.  
  628.    procedure Set_Drag_Compare_Func 
  629.      (Ctree    : access Gtk_Ctree_Record; 
  630.       Cmp_Func : in     Gtk_Ctree_Compare_Drag_Func); 
  631.    --  Set the drag compare function of a given Ctree. 
  632.    --  This function is used when the Ctree receives a dragged data. 
  633.  
  634.    ---------------------------- 
  635.    -- Tree sorting functions -- 
  636.    ---------------------------- 
  637.  
  638.    procedure Sort_Node (Ctree : access Gtk_Ctree_Record; 
  639.                         Node  : in     Gtk_Ctree_Node); 
  640.    --  Sort the nodes of a given Ctree. 
  641.    --  This procedure only sorts the first level of the tree. 
  642.  
  643.    procedure Sort_Recursive (Ctree : access Gtk_Ctree_Record; 
  644.                              Node  : in     Gtk_Ctree_Node := null); 
  645.    --  Sort the nodes of a given Ctree recursively. 
  646.    --  This procedure sorts the whole tree and subtrees associated with Ctree. 
  647.    --  Set Node to null if you want to sort the whole tree starting from its 
  648.    --  root. 
  649.  
  650.    -------------------------- 
  651.    -- Ctree_Gnode handling -- 
  652.    -------------------------- 
  653.  
  654.    --  <doc_ignore> 
  655.    --  This package needs to be documented ??? 
  656.  
  657.    generic 
  658.       type Data_Type (<>) is private; 
  659.    package Ctree_Gnode is 
  660.  
  661.       type Data_Type_Access is access all Data_Type; 
  662.  
  663.       type Gtk_Ctree_Gnode_Func is access 
  664.         function (Ctree : access Gtk_Ctree_Record'Class; 
  665.                   Depth : in     Guint; 
  666.                   Gnode : in     Glib.Gnodes.Gnode; 
  667.                   Cnode : in     Gtk_Ctree_Node; 
  668.                   Data  : in     Data_Type_Access) return Boolean; 
  669.  
  670.       function Export_To_Gnode (Ctree   : access Gtk_Ctree_Record'Class; 
  671.                                 Parent  : in     Glib.Gnodes.Gnode; 
  672.                                 Sibling : in     Glib.Gnodes.Gnode; 
  673.                                 Node    : in     Gtk_Ctree_Node; 
  674.                                 Func    : in     Gtk_Ctree_Gnode_Func; 
  675.                                 Data    : in     Data_Type_Access) 
  676.         return Glib.Gnodes.Gnode; 
  677.  
  678.       function Insert_Gnode (Ctree   : access Gtk_Ctree_Record'Class; 
  679.                              Parent  : in     Glib.Gnodes.Gnode; 
  680.                              Sibling : in     Glib.Gnodes.Gnode; 
  681.                              Node    : in     Gtk_Ctree_Node; 
  682.                              Func    : in     Gtk_Ctree_Gnode_Func; 
  683.                              Data    : in     Data_Type_Access) 
  684.         return Gtk_Ctree_Node; 
  685.    private 
  686.       --  <doc_ignore> 
  687.       type Ctree_Gnode_Func_Record is record 
  688.          Func : Gtk_Ctree_Gnode_Func; 
  689.          Data : Data_Type_Access; 
  690.       end record; 
  691.       type Ctree_Gnode_Func_Record_Access is 
  692.         access all Ctree_Gnode_Func_Record; 
  693.  
  694.       function C_Ctree_Gnode_Func 
  695.         (C_Ctree : System.Address; 
  696.          Depth   : Guint; 
  697.          C_Gnode : Glib.Gnodes.Gnode; 
  698.          C_Cnode : Gtk_Ctree_Node; 
  699.          C_Data  : Ctree_Gnode_Func_Record_Access) return Gboolean; 
  700.       pragma Convention (C, C_Ctree_Gnode_Func); 
  701.       --  </doc_ignore> 
  702.    end Ctree_Gnode; 
  703.  
  704.    --  </doc_ignore> 
  705.  
  706.    ----------------------- 
  707.    -- Row_Data handling -- 
  708.    ----------------------- 
  709.  
  710.    --  <doc_ignore> 
  711.    generic 
  712.       type Data_Type (<>) is private; 
  713.    package Row_Data is 
  714.  
  715.       type Data_Type_Access is access all Data_Type; 
  716.       --  </doc_ignore> 
  717.  
  718.       procedure Node_Set_Row_Data (Ctree : access Gtk_Ctree_Record'Class; 
  719.                                    Node  : in     Gtk_Ctree_Node; 
  720.                                    Data  : in     Data_Type); 
  721.       --  Associate a Data with a Node. 
  722.  
  723.       function Node_Get_Row_Data 
  724.         (Ctree : access Gtk_Ctree_Record'Class; 
  725.          Node  : in     Gtk_Ctree_Node) 
  726.          return Data_Type; 
  727.       --  Retrieve a data associated with a Node. 
  728.       --  Error Handling: 
  729.       --  Gtkada.Types.Data_Error is raised when trying to retrieve 
  730.       --  the data from a Node for which no data has been set 
  731.       --  (using Node_Set_Row_Data). 
  732.  
  733.       function Find_By_Row_Data 
  734.         (Ctree : access Gtk_Ctree_Record'Class; 
  735.          Node  : in     Gtk_Ctree_Node; 
  736.          Data  : in     Data_Type) 
  737.          return Gtk_Ctree_Node; 
  738.       --  Find the first node containing a specified Data. 
  739.       --  Node is the starting point of the search. If null, the search will 
  740.       --  start from the root. 
  741.       --  Return the first Node whose associated data is Data, null if none 
  742.       --  can be found. 
  743.  
  744.       function Find_All_By_Row_Data 
  745.         (Ctree : access Gtk_Ctree_Record'Class; 
  746.          Node  : in     Gtk_Ctree_Node; 
  747.          Data  : in     Data_Type) 
  748.          return Node_List.Glist; 
  749.       --  Find all nodes containing a specified Data. 
  750.       --  Node is the starting point of the search. If null, the search will 
  751.       --  start from the root. 
  752.  
  753.       type Gcompare_Func is access 
  754.         function (A, B : in Data_Type) return Boolean; 
  755.       --  Function used to compare data types in the functions 
  756.       --  Find_[All] By_Row_Data_Custom. 
  757.  
  758.       function Find_By_Row_Data_Custom 
  759.         (Ctree : access Gtk_Ctree_Record'Class; 
  760.          Node  : in     Gtk_Ctree_Node; 
  761.          Data  : in     Data_Type; 
  762.          Func  : in     Gcompare_Func) 
  763.          return Gtk_Ctree_Node; 
  764.       --  Find the first node containing a specified Data. 
  765.       --  Similar to Find_By_Row_Data but Func is used to allow a more flexible 
  766.       --  (user defined) method to compare two nodes. 
  767.  
  768.       function Find_All_By_Row_Data_Custom 
  769.         (Ctree : access Gtk_Ctree_Record'Class; 
  770.          Node  : in     Gtk_Ctree_Node; 
  771.          Data  : in     Data_Type; 
  772.          Func  : in     Gcompare_Func) return Node_List.Glist; 
  773.       --  Find all the nodes containing a specified Data. 
  774.       --  Similar to Find_All_By_Row_Data but Func is used to allow a more 
  775.       --  flexible (user defined) method to compare two nodes. 
  776.  
  777.       type Gtk_Ctree_Func is access 
  778.         procedure (Ctree : access Gtk_Ctree_Record'Class; 
  779.                    Node  : in     Gtk_Ctree_Node; 
  780.                    Data  : in     Data_Type_Access); 
  781.       --  Function used by Post/Pre_Recursive functions below. 
  782.  
  783.       procedure Post_Recursive (Ctree : access Gtk_Ctree_Record'Class; 
  784.                                 Node  : in     Gtk_Ctree_Node; 
  785.                                 Func  : in     Gtk_Ctree_Func; 
  786.                                 Data  : in     Data_Type_Access); 
  787.       --  Apply Func to each node of a subtree. 
  788.       --  Node designates the root of the subtree. 
  789.       --  Data will be passed as a parameter to Func. 
  790.       --  This procedure will first apply Func to the children nodes. 
  791.  
  792.       procedure Post_Recursive_To_Depth (Ctree : access Gtk_Ctree_Record'Class; 
  793.                                          Node  : in     Gtk_Ctree_Node; 
  794.                                          Depth : in     Gint; 
  795.                                          Func  : in     Gtk_Ctree_Func; 
  796.                                          Data  : in     Data_Type_Access); 
  797.       --  Apply Func to each node of a subtree until a specified Depth. 
  798.       --  Node designates the root of the subtree. 
  799.       --  Data will be passed as a parameter to Func. 
  800.       --  This function is similar to Post_Recursive except that it 
  801.       --  stop at a specified subtree depth. 
  802.  
  803.       procedure Pre_Recursive (Ctree : access Gtk_Ctree_Record'Class; 
  804.                                Node  : in     Gtk_Ctree_Node; 
  805.                                Func  : in     Gtk_Ctree_Func; 
  806.                                Data  : in     Data_Type_Access); 
  807.       --  Apply Func to each node of a subtree. 
  808.       --  Similar to Post_Recursive but will apply Func to the parent before 
  809.       --  applying it to its children. 
  810.  
  811.       procedure Pre_Recursive_To_Depth (Ctree : access Gtk_Ctree_Record'Class; 
  812.                                         Node  : in     Gtk_Ctree_Node; 
  813.                                         Depth : in     Gint; 
  814.                                         Func  : in     Gtk_Ctree_Func; 
  815.                                         Data  : in     Data_Type_Access); 
  816.       --  Apply Func to each node of a subtree until a specific Depth. 
  817.       --  Similar to Post_Recursive_To_Depth but will apply Func to the parent 
  818.       --  before applying it to its children. 
  819.  
  820.    private 
  821.  
  822.       --  <doc_ignore> 
  823.       function Default_Gcompare_Func (A, B : in Data_Type) return Boolean; 
  824.       -- 
  825.       --  This function needs to be declared in the spec, although it is 
  826.       --  only used in the body. Otherwise, the compiler does not allow 
  827.       --  to apply the 'Access attribute to it. 
  828.  
  829.       type Ctree_Func_Record is record 
  830.          Func : Gtk_Ctree_Func; 
  831.          Data : Data_Type_Access; 
  832.       end record; 
  833.       type Ctree_Func_Record_Access is access all Ctree_Func_Record; 
  834.  
  835.       procedure Free_Data (Data : Data_Type_Access); 
  836.       pragma Convention (C, Free_Data); 
  837.       --  Note that Data is *not* an in out parameter here, since Free_Data 
  838.       --  will be used as a callback, and when called, the original variable 
  839.       --  holding the pointer no longer exists. 
  840.  
  841.       procedure C_Ctree_Func (C_Ctree : in System.Address; 
  842.                               C_Node  : in Gtk_Ctree_Node; 
  843.                               C_Data  : in Ctree_Func_Record_Access); 
  844.       pragma Convention (C, C_Ctree_Func); 
  845.  
  846.       type Gcompare_Func_Record is record 
  847.          Func : Gcompare_Func; 
  848.          Data : Data_Type_Access; 
  849.       end record; 
  850.       type Gcompare_Func_Record_Access is access all Gcompare_Func_Record; 
  851.  
  852.       function C_Gcompare_Func 
  853.         (Row_Data           : in Data_Type_Access; 
  854.          Gcompare_Func_Data : in Gcompare_Func_Record_Access) return Gint; 
  855.       pragma Convention (C, C_Gcompare_Func); 
  856.       --  </doc_ignore> 
  857.  
  858.    end Row_Data; 
  859.    -- 
  860.    --  The previous package implements the Row_Data stuff. 
  861.    --  !! Warning !! No type verification is made to check if you are 
  862.    --  using the appropriate function Get. This is your own responsability 
  863.  
  864.    ---------------- 
  865.    -- Properties -- 
  866.    ---------------- 
  867.  
  868.    --  <properties> 
  869.    --  The following properties are defined for this widget. See 
  870.    --  Glib.Properties for more information on properties. 
  871.    --  </properties> 
  872.  
  873.    ------------- 
  874.    -- Signals -- 
  875.    ------------- 
  876.  
  877.    --  <signals> 
  878.    --  The following new signals are defined for this widget: 
  879.    -- 
  880.    --  - "tree_select_row" 
  881.    --    procedure Handler (Ctree  : access Gtk_Ctree_Record'Class; 
  882.    --                       Node   : Gtk_Ctree_Node; 
  883.    --                       Column : Gint); 
  884.    -- 
  885.    --    Emitted to request the selection of a node. 
  886.    --    Column is the column number where the user clicked. 
  887.    -- 
  888.    --  - "tree_unselect_row" 
  889.    --    procedure Handler (Ctree  : access Gtk_Ctree_Record'Class; 
  890.    --                       Node   : Gtk_Ctree_Node; 
  891.    --                       Column : Gint); 
  892.    -- 
  893.    --    Emitted to request the unselection of a node. 
  894.    -- 
  895.    --  - "tree_expand" 
  896.    --    procedure Handler (Ctree  : access Gtk_Clist_Record'Class; 
  897.    --                       Node   : Gtk_Ctree_Node); 
  898.    -- 
  899.    --    Emitted when the subtree associated with a Node is expanded. 
  900.    -- 
  901.    --  - "tree_collapse" 
  902.    --    procedure Handler (Ctree  : access Gtk_Clist_Record'Class; 
  903.    --                       Node   : Gtk_Ctree_Node); 
  904.    -- 
  905.    --    Emitted when the subtree associated with a Node is collapsed. 
  906.    -- 
  907.    --  - "tree_move" 
  908.    --    procedure Handler (Ctree       : access Gtk_Clist_Record'Class; 
  909.    --                       Node        : Gtk_Ctree_Node); 
  910.    --                       New_Parent  : Gtk_Ctree_Node); 
  911.    --                       New_Sibling : Gtk_Ctree_Node); 
  912.    -- 
  913.    --    Emitted when a Node is moved (e.g its parent and/or its sibling 
  914.    --    changed). 
  915.    -- 
  916.    --  </signals> 
  917.  
  918.    Signal_Change_Focus_Row_Expansion : constant Glib.Signal_Name := 
  919.                                          "change_focus_row_expansion"; 
  920.    Signal_Tree_Collapse              : constant Glib.Signal_Name := 
  921.                                          "tree_collapse"; 
  922.    Signal_Tree_Expand                : constant Glib.Signal_Name := 
  923.                                          "tree_expand"; 
  924.    Signal_Tree_Move                  : constant Glib.Signal_Name := 
  925.                                          "tree_move"; 
  926.    Signal_Tree_Select_Row            : constant Glib.Signal_Name := 
  927.                                          "tree_select_row"; 
  928.    Signal_Tree_Unselect_Row          : constant Glib.Signal_Name := 
  929.                                          "tree_unselect_row"; 
  930.  
  931. private 
  932.  
  933.    pragma Warnings (Off);  --  Gtk.Clist is obsolescent 
  934.    type Gtk_Ctree_Record is new Gtk.Clist.Gtk_Clist_Record with null record; 
  935.    pragma Warnings (On); 
  936.  
  937.    pragma Import (C, Get_Type, "gtk_ctree_get_type"); 
  938.    pragma Import (C, Node_Get_Row, "ada_ctree_node_get_row"); 
  939.    pragma Import (C, Row_Get_Children, "ada_ctree_row_get_children"); 
  940.    pragma Import (C, Row_Get_Parent, "ada_ctree_row_get_parent"); 
  941.    pragma Import (C, Row_Get_Sibling, "ada_ctree_row_get_sibling"); 
  942.  
  943. end Gtk.Ctree; 
  944.  
  945. --  These subprograms never had a binding, and are now obsolescent: 
  946. --  No binding: gtk_ctree_find_all_by_row_data 
  947. --  No binding: gtk_ctree_find_by_row_data 
  948. --  No binding: gtk_ctree_node_get_type 
  949. --  No binding: gtk_ctree_node_set_row_data