## Documentation

Table of Contents
Class Inheritance Tree
Widget Screenshots
Package groups

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.     -----------------------------------------------------------------------

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>

48.     with Interfaces.C.Strings;

49.     with Unchecked_Conversion;

51.     with Gdk.BitmapTo API docTo specTo body;

52.     with Gdk.ColorTo API docTo specTo body;

53.     with Gdk.PixmapTo API docTo specTo body;

55.     with Glib.GlistTo API docTo specTo body;

56.     pragma Elaborate_All (Glib.GlistTo API docTo specTo body);

57.     with Glib.GnodesTo API docTo specTo body;

59.     pragma Warnings (Off);  --  Gtk.Clist is obsolescent

60.     with Gtk.ClistTo API docTo specTo body;

61.     pragma Warnings (On);

62.     with Gtk.EnumsTo API docTo specTo body;            use Gtk.EnumsTo API docTo specTo body;

63.     with Gtk.StyleTo API docTo specTo body;

65.     with Gtkada.TypesTo API docTo specTo body;         use Gtkada.TypesTo API docTo specTo body;

67.     package Gtk.CtreeTo API docTo specTo body is

68.        pragma Obsolescent ("use Gtk.Tree_View instead");

69.        pragma Elaborate_Body;

71.        pragma Warnings (Off); --  Gtk.Clist is obsolescent;

72.        type Gtk_Ctree_RecordTo API docTo body is new Gtk.Clist.Gtk_Clist_RecordTo API docTo specTo body with private;

73.        type Gtk_Ctree is access all Gtk_Ctree_RecordTo API docTo specTo body'Class;

75.        type Gtk_Ctree_Row is new Gtk.Clist.Gtk_Clist_RowTo API docTo spec;

76.        pragma Warnings (On);

77.        --  Similar to Clist_Row, but for a Ctree.

79.        type Gtk_Ctree_Node is new Gdk.C_ProxyTo API docTo spec;

80.        --  This type represents a node inside a Ctree.

82.        --  <doc_ignore>

83.        Null_Ctree_Node : constant Gtk_Ctree_NodeTo API docTo spec := null;

85.        type Gtk_Ctree_Line_Style is

86.          (Ctree_Lines_None,

87.           --  No line will be drawn in the Ctree

89.           Ctree_Lines_Solid,

90.           --  Solid lines will be drawn

92.           Ctree_Lines_Dotted,

93.           --  Dotted lines will be drawn

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_StyleTo API docTo spec);

99.        --  See Gtk.Ctree.Set_Line_Style for more details.

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.

106.           Ctree_Expander_Square,

107.           --  The pixmap will be a square

109.           Ctree_Expander_Triangle,

110.           --  The pixmap will be a triangle

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_StyleTo API docTo spec);

118.        package Row_List is new Glib.Glist.Generic_ListTo API docTo specTo body (Gtk_Ctree_RowTo API docTo spec);

120.        function Convert is new Unchecked_Conversion

121.          (Gtk_Ctree_NodeTo API docTo spec, System.Address);

122.        function Convert is new Unchecked_Conversion

123.          (System.Address, Gtk_Ctree_NodeTo API docTo spec);

124.        package Node_List is new Glib.Glist.Generic_ListTo API docTo specTo body (Gtk_Ctree_NodeTo API docTo spec);

125.        --  </doc_ignore>

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.

137.        procedure Gtk_NewTo API docTo body (Widget      :    out Gtk_CtreeTo API docTo spec;

138.                           Columns     : in     GintTo API docTo spec;

139.                           Tree_Column : in     GintTo API docTo spec := 0);

140.        --  Create a ctree with Columns columns.

141.        --  Tree_Column indicates in which column the tree will be displayed.

143.        procedure InitializeTo API docTo body (Widget      : access Gtk_Ctree_RecordTo API docTo specTo body'Class;

144.                              Columns     : in     GintTo API docTo spec;

145.                              Tree_Column : in     GintTo API docTo spec := 0);

146.        --  Internal initialization function.

147.        --  See the section "Creating your own widgets" in the documentation.

149.        procedure Gtk_NewTo API docTo body (Widget      :    out Gtk_CtreeTo API docTo spec;

150.                           Titles      : in     Chars_Ptr_ArrayTo API docTo spec;

151.                           Tree_Column : in     GintTo API docTo spec := 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.

156.        procedure InitializeTo API docTo body (Widget      : access Gtk_Ctree_RecordTo API docTo specTo body'Class;

157.                              Titles      : in     Chars_Ptr_ArrayTo API docTo spec;

158.                              Tree_Column : in     GintTo API docTo spec := 0);

159.        --  Internal initialization function.

160.        --  See the section "Creating your own widgets" in the documentation.

162.        function Get_TypeTo API docTo body return Gtk.Gtk_TypeTo API docTo spec;

163.        --  Return the internal value associated with a Gtk_Ctree.

165.        function Insert_NodeTo API docTo body (Ctree         : access Gtk_Ctree_RecordTo API docTo specTo body;

166.                              Parent        : in     Gtk_Ctree_NodeTo API docTo spec;

167.                              Sibling       : in     Gtk_Ctree_NodeTo API docTo spec;

168.                              Text          : in     Chars_Ptr_ArrayTo API docTo spec;

169.                              Spacing       : in     Guint8To API docTo spec;

170.                              Pixmap_Closed : in     Gdk.Pixmap.Gdk_PixmapTo API docTo spec;

171.                              Mask_Closed   : in     Gdk.Bitmap.Gdk_BitmapTo API docTo spec;

172.                              Pixmap_Opened : in     Gdk.Pixmap.Gdk_PixmapTo API docTo spec;

173.                              Mask_Opened   : in     Gdk.Bitmap.Gdk_BitmapTo API docTo spec;

174.                              Is_Leaf       : in     Boolean;

175.                              Expanded      : in     Boolean)

176.                              return                 Gtk_Ctree_NodeTo API docTo spec;

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.

196.        procedure Remove_NodeTo API docTo body (Ctree : access Gtk_Ctree_RecordTo API docTo specTo body;

197.                               Node  : in     Gtk_Ctree_NodeTo API docTo spec);

198.        --  Remove Node from Ctree.

200.        -------------------------------------------

201.        -- Tree, Node and Row basic manipulation --

202.        -------------------------------------------

204.        function Get_Tree_ColumnTo API docTo body

205.          (Widget : access Gtk.Ctree.Gtk_Ctree_RecordTo API docTo specTo body'Class) return GintTo API docTo spec;

206.        --  Return the Tree_Column attribute of a given Node.

207.        --  Tree_Column indicates in which column the tree will be displayed.

209.        function Get_Node_ListTo API docTo body

210.          (Ctree : access Gtk_Ctree_RecordTo API docTo specTo body) return Node_List.GlistTo API docTo specTo body;

211.        --   Return the list of nodes associated with a given Ctree.

212.        --   Note: you need to extract the nodes with Node_List.Get_Gpointer.

214.        function Get_Row_ListTo API docTo body

215.          (Ctree : access Gtk_Ctree_RecordTo API docTo specTo body) return Row_List.GlistTo API docTo specTo body;

216.        --  Return the list of rows associated with a given Ctree.

218.        function Get_SelectionTo API docTo body

219.          (Ctree : access Gtk_Ctree_RecordTo API docTo specTo body) return Node_List.GlistTo API docTo specTo body;

220.        --   Return the list of nodes currently selected.

221.        --   Extract the nodes with Node_List.Get_Data

223.        function Node_Get_RowTo API docTo body (Node : in Gtk_Ctree_NodeTo API docTo spec) return Gtk_Ctree_RowTo API docTo spec;

224.        --  Return the row of a given Node.

226.        function Row_Get_ChildrenTo API docTo body (Row : in Gtk_Ctree_RowTo API docTo spec) return Gtk_Ctree_NodeTo API docTo spec;

227.        --  Return the children node of a given Row.

229.        function Row_Get_ExpandedTo API docTo body (Row : in Gtk_Ctree_RowTo API docTo spec) 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.

234.        function Row_Get_Is_LeafTo API docTo body (Row : in Gtk_Ctree_RowTo API docTo spec) 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.

239.        function Row_Get_ParentTo API docTo body (Row : in Gtk_Ctree_RowTo API docTo spec) return Gtk_Ctree_NodeTo API docTo spec;

240.        --  Return the parent node of a given Row.

242.        function Row_Get_SiblingTo API docTo body (Row : in Gtk_Ctree_RowTo API docTo spec) return Gtk_Ctree_NodeTo API docTo spec;

243.        --  Return the sibling node of a given Row.

245.        function Is_CreatedTo API docTo body (Node : in Gtk_Ctree_NodeTo API docTo spec) return Boolean;

246.        --  Return True if Node is different from Null_Ctree_Node

248.        -----------------------------------------

249.        -- Querying / finding tree information --

250.        -----------------------------------------

252.        function Is_ViewableTo API docTo body

253.          (Ctree  : access Gtk_Ctree_RecordTo API docTo specTo body;

254.           Node   : in     Gtk_Ctree_NodeTo API docTo spec)

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.

260.        function LastTo API docTo body

261.          (Ctree  : access Gtk_Ctree_RecordTo API docTo specTo body;

262.           Node   : in     Gtk_Ctree_NodeTo API docTo spec)

263.           return Gtk_Ctree_NodeTo API docTo spec;

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.

269.        function Find_Node_PtrTo API docTo body

270.          (Ctree     : access Gtk_Ctree_RecordTo API docTo specTo body;

271.           Ctree_Row : in     Gtk_Ctree_RowTo API docTo spec)

272.           return Gtk_Ctree_NodeTo API docTo spec;

273.        --  Return the node corresponding to a given row.

275.        function Node_NthTo API docTo body (Ctree  : access Gtk_Ctree_RecordTo API docTo specTo body;

276.                           Row    : in     GuintTo API docTo spec)

277.                           return          Gtk_Ctree_NodeTo API docTo spec;

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.

282.        function FindTo API docTo body (Ctree : access Gtk_Ctree_RecordTo API docTo specTo body;

283.                       Node  : in     Gtk_Ctree_NodeTo API docTo spec;

284.                       Child : in     Gtk_Ctree_NodeTo API docTo spec) 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.

290.        function Is_AncestorTo API docTo body

291.          (Ctree  : access Gtk_Ctree_RecordTo API docTo specTo body;

292.           Node   : in     Gtk_Ctree_NodeTo API docTo spec;

293.           Child  : in     Gtk_Ctree_NodeTo API docTo spec) return Boolean;

294.        --  Indicate whether Node is an ancestor of Child.

295.        --  It is assumed that Node is not empty.

297.        function Is_Hot_SpotTo API docTo body

298.          (Ctree  : access Gtk_Ctree_RecordTo API docTo specTo body;

299.           X      : in     GintTo API docTo spec;

300.           Y      : in     GintTo API docTo spec) return Boolean;

301.        --  Return True if the Ctree is centered on (x,y)

303.        ------------------------------------------------------

304.        -- Tree signals: move, expand, collapse, (un)select --

305.        ------------------------------------------------------

307.        procedure MoveTo API docTo body (Ctree       : access Gtk_Ctree_RecordTo API docTo specTo body;

308.                        Node        : in     Gtk_Ctree_NodeTo API docTo spec;

309.                        New_Parent  : in     Gtk_Ctree_NodeTo API docTo spec;

310.                        New_Sibling : in     Gtk_Ctree_NodeTo API docTo spec);

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.

318.        procedure ExpandTo API docTo body (Ctree : access Gtk_Ctree_RecordTo API docTo specTo body;

319.                          Node  : in     Gtk_Ctree_NodeTo API docTo spec);

320.        --  Expand the first level of the subtree associated with Node.

322.        procedure Expand_RecursiveTo API docTo body

323.          (Ctree : access Gtk_Ctree_RecordTo API docTo specTo body;

324.           Node  : in     Gtk_Ctree_NodeTo API docTo spec := null);

325.        --  Expand the whole subtree associated with Node.

327.        procedure Expand_To_DepthTo API docTo body

328.          (Ctree : access Gtk_Ctree_RecordTo API docTo specTo body;

329.           Node  : in     Gtk_Ctree_NodeTo API docTo spec := null;

330.           Depth : in     GintTo API docTo spec);

331.        --  Expand the subtree associated with Node and its descendants until Depth

332.        --  levels of subtrees have been reached.

334.        procedure CollapseTo API docTo body (Ctree : access Gtk_Ctree_RecordTo API docTo specTo body;

335.                            Node  : in     Gtk_Ctree_NodeTo API docTo spec);

336.        --  Collapse the first level of the subtree associated with Node.

338.        procedure Collapse_RecursiveTo API docTo body

339.          (Ctree : access Gtk_Ctree_RecordTo API docTo specTo body;

340.           Node  : in     Gtk_Ctree_NodeTo API docTo spec := null);

341.        --  Collapse the whole subtree associated with Node.

343.        procedure Collapse_To_DepthTo API docTo body

344.          (Ctree : access Gtk_Ctree_RecordTo API docTo specTo body;

345.           Node  : in     Gtk_Ctree_NodeTo API docTo spec := null;

346.           Depth : in     GintTo API docTo spec);

347.        --  Collapse the subtree associated with Node and its descendants until

348.        --  Depth levels of subtrees have been reached.

350.        procedure Toggle_ExpansionTo API docTo body (Ctree : access Gtk_Ctree_RecordTo API docTo specTo body;

351.                                    Node  : in     Gtk_Ctree_NodeTo API docTo spec);

352.        --  Change the state of the Ctree from expanded to collapsed and the other

353.        --  way around on one level.

355.        procedure Toggle_Expansion_RecursiveTo API docTo body (Ctree : access Gtk_Ctree_RecordTo API docTo specTo body;

356.                                              Node  : in     Gtk_Ctree_NodeTo API docTo spec);

357.        --  Change the state of the Ctree from expanded to collapsed and the other

358.        --  way around for the whole subtree.

360.        procedure Gtk_SelectTo API docTo body (Ctree : access  Gtk_Ctree_RecordTo API docTo specTo body;

361.                              Node  : in      Gtk_Ctree_NodeTo API docTo spec);

362.        --  Select a specified Node, and only this one.

364.        procedure Select_RecursiveTo API docTo body

365.          (Ctree : access Gtk_Ctree_RecordTo API docTo specTo body;

366.           Node  : in     Gtk_Ctree_NodeTo API docTo spec := null);

367.        --  Select a specified Node, and its whole subtree.

369.        procedure UnselectTo API docTo body (Ctree : access Gtk_Ctree_RecordTo API docTo specTo body;

370.                            Node  : in     Gtk_Ctree_NodeTo API docTo spec);

371.        --  Unselect a specified Node, and only this one.

373.        procedure Unselect_RecursiveTo API docTo body

374.          (Ctree : access Gtk_Ctree_RecordTo API docTo specTo body;

375.           Node  : in     Gtk_Ctree_NodeTo API docTo spec := null);

376.        --  Unselect a specified Node, and its whole subtree.

378.        procedure Real_Select_RecursiveTo API docTo body (Ctree     : access Gtk_Ctree_RecordTo API docTo specTo body;

379.                                         Node      : in     Gtk_Ctree_NodeTo API docTo spec := 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.

385.        ------------------------------------

386.        -- Analogs of Gtk_Clist functions --

387.        ------------------------------------

389.        procedure Node_Set_TextTo API docTo body (Ctree  : access Gtk_Ctree_RecordTo API docTo specTo body;

390.                                 Node   : in     Gtk_Ctree_NodeTo API docTo spec;

391.                                 Column : in     GintTo API docTo spec;

392.                                 Text   : in     UTF8_StringTo API docTo spec);

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.

397.        function Node_Get_TextTo API docTo body (Ctree   : access Gtk_Ctree_RecordTo API docTo specTo body;

398.                                Node    : in     Gtk_Ctree_NodeTo API docTo spec;

399.                                Column  : in     GintTo API docTo spec) return UTF8_StringTo API docTo spec;

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)

404.        procedure Node_Set_PixmapTo API docTo body (Ctree  : access Gtk_Ctree_RecordTo API docTo specTo body;

405.                                   Node   : in     Gtk_Ctree_NodeTo API docTo spec;

406.                                   Column : in     GintTo API docTo spec;

407.                                   Pixmap : in     Gdk.Pixmap.Gdk_PixmapTo API docTo spec;

408.                                   Mask   : in     Gdk.Bitmap.Gdk_BitmapTo API docTo spec);

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.

413.        procedure Node_Get_PixmapTo API docTo body (Ctree   : access Gtk_Ctree_RecordTo API docTo specTo body;

414.                                   Node    : in     Gtk_Ctree_NodeTo API docTo spec;

415.                                   Column  : in     GintTo API docTo spec;

416.                                   Pixmap  :    out Gdk.Pixmap.Gdk_PixmapTo API docTo spec;

417.                                   Mask    :    out Gdk.Bitmap.Gdk_BitmapTo API docTo spec;

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.

424.        procedure Node_Set_PixtextTo API docTo body (Ctree   : access Gtk_Ctree_RecordTo API docTo specTo body;

425.                                    Node    : in     Gtk_Ctree_NodeTo API docTo spec;

426.                                    Column  : in     GintTo API docTo spec;

427.                                    Text    : in     UTF8_StringTo API docTo spec;

428.                                    Spacing : in     Guint8To API docTo spec;

429.                                    Pixmap  : in     Gdk.Pixmap.Gdk_PixmapTo API docTo spec;

430.                                    Mask    : in     Gdk.Bitmap.Gdk_BitmapTo API docTo spec);

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.

435.        procedure Node_Get_PixtextTo API docTo body (Ctree   : access Gtk_Ctree_RecordTo API docTo specTo body;

436.                                    Node    : in     Gtk_Ctree_NodeTo API docTo spec;

437.                                    Column  : in     GintTo API docTo spec;

438.                                    Text    :    out Interfaces.C.Strings.chars_ptr;

439.                                    Spacing :    out Guint8To API docTo spec;

440.                                    Pixmap  :    out Gdk.Pixmap.Gdk_PixmapTo API docTo spec;

441.                                    Mask    :    out Gdk.Bitmap.Gdk_BitmapTo API docTo spec;

442.                                    Success :    out Boolean);

443.        --  Return the Text and the Pixmap for the cell.

444.        --  The result is not meaningful if Success is False.

446.        procedure Node_Set_ShiftTo API docTo body (Ctree      : access Gtk_Ctree_RecordTo API docTo specTo body;

447.                                  Node       : in     Gtk_Ctree_NodeTo API docTo spec;

448.                                  Column     : in     GintTo API docTo spec;

449.                                  Vertical   : in     GintTo API docTo spec;

450.                                  Horizontal : in     GintTo API docTo spec);

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.

455.        procedure Set_Node_InfoTo API docTo body (Ctree         : access Gtk_Ctree_RecordTo API docTo specTo body;

456.                                 Node          : in     Gtk_Ctree_NodeTo API docTo spec;

457.                                 Text          : in     UTF8_StringTo API docTo spec;

458.                                 Spacing       : in     Guint8To API docTo spec;

459.                                 Pixmap_Closed : in     Gdk.Pixmap.Gdk_PixmapTo API docTo spec;

460.                                 Mask_Closed   : in     Gdk.Bitmap.Gdk_BitmapTo API docTo spec;

461.                                 Pixmap_Opened : in     Gdk.Pixmap.Gdk_PixmapTo API docTo spec;

462.                                 Mask_Opened   : in     Gdk.Bitmap.Gdk_BitmapTo API docTo spec;

463.                                 Is_Leaf       : in     Boolean;

464.                                 Expanded      : in     Boolean);

465.        --  Set all the info related to a specific Node.

467.        procedure Get_Node_InfoTo API docTo body

468.          (Ctree         : access Gtk_Ctree_RecordTo API docTo specTo body;

469.           Node          : in     Gtk_Ctree_NodeTo API docTo spec;

470.           Text          :    out Interfaces.C.Strings.chars_ptr;

471.           Spacing       :    out Guint8To API docTo spec;

472.           Pixmap_Closed :    out Gdk.Pixmap.Gdk_PixmapTo API docTo spec;

473.           Mask_Closed   :    out Gdk.Bitmap.Gdk_BitmapTo API docTo spec;

474.           Pixmap_Opened :    out Gdk.Pixmap.Gdk_PixmapTo API docTo spec;

475.           Mask_Opened   :    out Gdk.Bitmap.Gdk_BitmapTo API docTo spec;

476.           Is_Leaf       :    out Boolean;

477.           Expanded      :    out Boolean;

478.           Success       :    out Boolean);

479.        --  Return all the info related to a specific Node.

481.        procedure Node_Set_SelectableTo API docTo body (Ctree      : access Gtk_Ctree_RecordTo API docTo specTo body;

482.                                       Node       : in     Gtk_Ctree_NodeTo API docTo spec;

483.                                       Selectable : in     Boolean := True);

484.        --  Indicate whether the Node can be selected or not.

485.        --  The default value is True.

487.        function Node_Get_SelectableTo API docTo body (Ctree  : access Gtk_Ctree_RecordTo API docTo specTo body;

488.                                      Node   : in     Gtk_Ctree_NodeTo API docTo spec)

489.                                      return          Boolean;

490.        --  Return the selectable status of the Node.

492.        procedure Node_Set_Row_StyleTo API docTo body (Ctree : access Gtk_Ctree_RecordTo API docTo specTo body;

493.                                      Node  : in     Gtk_Ctree_NodeTo API docTo spec;

494.                                      Style : in     Gtk.Style.Gtk_StyleTo API docTo spec);

495.        --  Set the default style for the cells in the Node.

496.        --  This can be overridden for each cell with Node_Set_Cell_Style.

498.        function Node_Get_Row_StyleTo API docTo body (Ctree  : access Gtk_Ctree_RecordTo API docTo specTo body;

499.                                     Node   : in     Gtk_Ctree_NodeTo API docTo spec)

500.                                     return          Gtk.Style.Gtk_StyleTo API docTo spec;

501.        --  Return the default style used for the Node.

503.        procedure Node_Set_Cell_StyleTo API docTo body (Ctree  : access Gtk_Ctree_RecordTo API docTo specTo body;

504.                                       Node   : in     Gtk_Ctree_NodeTo API docTo spec;

505.                                       Column : in     GintTo API docTo spec;

506.                                       Style  : in     Gtk.Style.Gtk_StyleTo API docTo spec);

507.        --  Set the style (font, color, ...) used for the cell.

508.        --  This overrides the Node's style.

510.        function Node_Get_Cell_StyleTo API docTo body (Ctree  : access Gtk_Ctree_RecordTo API docTo specTo body;

511.                                      Node   : in     Gtk_Ctree_NodeTo API docTo spec;

512.                                      Column : in     GintTo API docTo spec)

513.                                      return          Gtk.Style.Gtk_StyleTo API docTo spec;

514.        --  Return the style of the cell.

516.        procedure Node_Set_ForegroundTo API docTo body (Ctree : access Gtk_Ctree_RecordTo API docTo specTo body;

517.                                       Node  : in     Gtk_Ctree_NodeTo API docTo spec;

518.                                       ColorTo API docTo body : in     Gdk.Color.Gdk_ColorTo API docTo specTo body);

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.

523.        procedure Node_Set_BackgroundTo API docTo body (Ctree : access Gtk_Ctree_RecordTo API docTo specTo body;

524.                                       Node  : in     Gtk_Ctree_NodeTo API docTo spec;

525.                                       ColorTo API docTo body : in     Gdk.Color.Gdk_ColorTo API docTo specTo body);

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.

530.        pragma Warnings (Off);  --  Gtk.Clist is obsolescent

531.        function Node_Get_Cell_TypeTo API docTo body (Ctree  : access Gtk_Ctree_RecordTo API docTo specTo body;

532.                                     Node   : in     Gtk_Ctree_NodeTo API docTo spec;

533.                                     Column : in     GintTo API docTo spec)

534.                                     return Gtk.Clist.Gtk_Cell_TypeTo API docTo spec;

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.

540.        procedure Node_MovetoTo API docTo body (Ctree     : access Gtk_Ctree_RecordTo API docTo specTo body;

541.                               Node      : in     Gtk_Ctree_NodeTo API docTo spec;

542.                               Column    : in     GintTo API docTo spec;

543.                               Row_Align : in     GfloatTo API docTo spec := 0.5;

544.                               Col_Align : in     GfloatTo API docTo spec := 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.

552.        function Node_Is_VisibleTo API docTo body

553.          (Ctree  : access Gtk_Ctree_RecordTo API docTo specTo body;

554.           Node   : in     Gtk_Ctree_NodeTo API docTo spec)

555.           return Gtk_VisibilityTo API docTo spec;

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.

563.        ------------------------------

564.        -- Ctree specific functions --

565.        ------------------------------

567.        procedure Set_IndentTo API docTo body (Ctree  : access Gtk_Ctree_RecordTo API docTo specTo body;

568.                              Indent : in     GintTo API docTo spec := 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.

574.        function Get_IndentTo API docTo body

575.          (Widget : access Gtk.Ctree.Gtk_Ctree_RecordTo API docTo specTo body'Class) return GintTo API docTo spec;

576.        --  Return the indentation of a Ctree.

578.        procedure Set_SpacingTo API docTo body (Ctree   : access Gtk_Ctree_RecordTo API docTo specTo body;

579.                               Spacing : in     GintTo API docTo spec := 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.

584.        function Get_SpacingTo API docTo body

585.          (Widget : access Gtk.Ctree.Gtk_Ctree_RecordTo API docTo specTo body'Class) return GintTo API docTo spec;

586.        --  Return the spacing between the tree's icon and the additional pixmap.

588.        procedure Set_Show_StubTo API docTo body (Ctree     : access Gtk_Ctree_RecordTo API docTo specTo body;

589.                                 Show_Stub : in     Boolean);

590.        --  Set the Show_Stub attribute of Ctree.

592.        function Get_Show_StubTo API docTo body (Ctree : access Gtk_Ctree_RecordTo API docTo specTo body) return Boolean;

593.        --  Return the Show_Stub attribute of Ctree.

595.        procedure Set_Line_StyleTo API docTo body

596.          (Ctree      : access Gtk_Ctree_RecordTo API docTo specTo body;

597.           Line_StyleTo API docTo body : in     Gtk_Ctree_Line_StyleTo API docTo spec := 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.

603.        function Get_Line_StyleTo API docTo body

604.          (Ctree : access Gtk_Ctree_RecordTo API docTo specTo body) return Gtk_Ctree_Line_StyleTo API docTo spec;

605.        --  return the style of the lines representing the tree of a given Ctree.

607.        procedure Set_Expander_StyleTo API docTo body

608.          (Ctree          : access Gtk_Ctree_RecordTo API docTo specTo body;

609.           Expander_StyleTo API docTo body : in     Gtk_Ctree_Expander_StyleTo API docTo spec :=

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.

617.        function Get_Expander_StyleTo API docTo body

618.          (Ctree : access Gtk_Ctree_RecordTo API docTo specTo body) return Gtk_Ctree_Expander_StyleTo API docTo spec;

619.        --  Return the way a given Ctree can be expanded.

621.        type Gtk_Ctree_Compare_Drag_Func is access

622.          function (Ctree        : in Gtk_CtreeTo API docTo spec;

623.                    Source_Node  : in Gtk_Ctree_NodeTo API docTo spec;

624.                    New_Parent   : in Gtk_Ctree_NodeTo API docTo spec;

625.                    New_Sibling  : in Gtk_Ctree_NodeTo API docTo spec) return Boolean;

626.        --  Function type used in Set_Drag_Compare_Func.

628.        procedure Set_Drag_Compare_FuncTo API docTo body

629.          (Ctree    : access Gtk_Ctree_RecordTo API docTo specTo body;

630.           Cmp_Func : in     Gtk_Ctree_Compare_Drag_FuncTo API docTo spec);

631.        --  Set the drag compare function of a given Ctree.

632.        --  This function is used when the Ctree receives a dragged data.

634.        ----------------------------

635.        -- Tree sorting functions --

636.        ----------------------------

638.        procedure Sort_NodeTo API docTo body (Ctree : access Gtk_Ctree_RecordTo API docTo specTo body;

639.                             Node  : in     Gtk_Ctree_NodeTo API docTo spec);

640.        --  Sort the nodes of a given Ctree.

641.        --  This procedure only sorts the first level of the tree.

643.        procedure Sort_RecursiveTo API docTo body (Ctree : access Gtk_Ctree_RecordTo API docTo specTo body;

644.                                  Node  : in     Gtk_Ctree_NodeTo API docTo spec := 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.

650.        --------------------------

651.        -- Ctree_Gnode handling --

652.        --------------------------

654.        --  <doc_ignore>

655.        --  This package needs to be documented ???

657.        generic

658.           type Data_Type (<>) is private;

659.        package Ctree_GnodeTo API docTo body is

661.           type Data_Type_Access is access all Data_TypeTo API docTo spec;

663.           type Gtk_Ctree_Gnode_Func is access

664.             function (Ctree : access Gtk_Ctree_RecordTo API docTo specTo body'Class;

665.                       Depth : in     GuintTo API docTo spec;

666.                       Gnode : in     Glib.Gnodes.GnodeTo API docTo spec;

667.                       Cnode : in     Gtk_Ctree_NodeTo API docTo spec;

668.                       Data  : in     Data_Type_AccessTo API docTo spec) return Boolean;

670.           function Export_To_GnodeTo API docTo body (Ctree   : access Gtk_Ctree_RecordTo API docTo specTo body'Class;

671.                                     Parent  : in     Glib.Gnodes.GnodeTo API docTo spec;

672.                                     Sibling : in     Glib.Gnodes.GnodeTo API docTo spec;

673.                                     Node    : in     Gtk_Ctree_NodeTo API docTo spec;

674.                                     Func    : in     Gtk_Ctree_Gnode_FuncTo API docTo spec;

675.                                     Data    : in     Data_Type_AccessTo API docTo spec)

676.             return Glib.Gnodes.GnodeTo API docTo spec;

678.           function Insert_GnodeTo API docTo body (Ctree   : access Gtk_Ctree_RecordTo API docTo specTo body'Class;

679.                                  Parent  : in     Glib.Gnodes.GnodeTo API docTo spec;

680.                                  Sibling : in     Glib.Gnodes.GnodeTo API docTo spec;

681.                                  Node    : in     Gtk_Ctree_NodeTo API docTo spec;

682.                                  Func    : in     Gtk_Ctree_Gnode_FuncTo API docTo spec;

683.                                  Data    : in     Data_Type_AccessTo API docTo spec)

684.             return Gtk_Ctree_NodeTo API docTo spec;

685.        private

686.           --  <doc_ignore>

687.           type Ctree_Gnode_Func_Record is record

688.              Func : Gtk_Ctree_Gnode_FuncTo API docTo spec;

689.              Data : Data_Type_AccessTo API docTo spec;

690.           end record;

691.           type Ctree_Gnode_Func_Record_Access is

692.             access all Ctree_Gnode_Func_Record;

694.           function C_Ctree_Gnode_Func

695.             (C_Ctree : System.Address;

696.              Depth   : GuintTo API docTo spec;

697.              C_Gnode : Glib.Gnodes.GnodeTo API docTo spec;

698.              C_Cnode : Gtk_Ctree_NodeTo API docTo spec;

699.              C_Data  : Ctree_Gnode_Func_Record_Access) return GbooleanTo API docTo spec;

700.           pragma Convention (C, C_Ctree_Gnode_Func);

701.           --  </doc_ignore>

702.        end Ctree_GnodeTo API docTo specTo body;

704.        --  </doc_ignore>

706.        -----------------------

707.        -- Row_Data handling --

708.        -----------------------

710.        --  <doc_ignore>

711.        generic

712.           type Data_Type (<>) is private;

713.        package Row_DataTo API docTo body is

715.           type Data_Type_Access is access all Data_TypeTo API docTo spec;

716.           --  </doc_ignore>

718.           procedure Node_Set_Row_DataTo API docTo body (Ctree : access Gtk_Ctree_RecordTo API docTo specTo body'Class;

719.                                        Node  : in     Gtk_Ctree_NodeTo API docTo spec;

720.                                        Data  : in     Data_TypeTo API docTo spec);

721.           --  Associate a Data with a Node.

723.           function Node_Get_Row_DataTo API docTo body

724.             (Ctree : access Gtk_Ctree_RecordTo API docTo specTo body'Class;

725.              Node  : in     Gtk_Ctree_NodeTo API docTo spec)

726.              return Data_TypeTo API docTo spec;

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).

733.           function Find_By_Row_DataTo API docTo body

734.             (Ctree : access Gtk_Ctree_RecordTo API docTo specTo body'Class;

735.              Node  : in     Gtk_Ctree_NodeTo API docTo spec;

736.              Data  : in     Data_TypeTo API docTo spec)

737.              return Gtk_Ctree_NodeTo API docTo spec;

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.

744.           function Find_All_By_Row_DataTo API docTo body

745.             (Ctree : access Gtk_Ctree_RecordTo API docTo specTo body'Class;

746.              Node  : in     Gtk_Ctree_NodeTo API docTo spec;

747.              Data  : in     Data_TypeTo API docTo spec)

748.              return Node_List.GlistTo API docTo specTo body;

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.

753.           type Gcompare_Func is access

754.             function (A, B : in Data_TypeTo API docTo spec) return Boolean;

755.           --  Function used to compare data types in the functions

756.           --  Find_[All] By_Row_Data_Custom.

758.           function Find_By_Row_Data_CustomTo API docTo body

759.             (Ctree : access Gtk_Ctree_RecordTo API docTo specTo body'Class;

760.              Node  : in     Gtk_Ctree_NodeTo API docTo spec;

761.              Data  : in     Data_TypeTo API docTo spec;

762.              Func  : in     Gcompare_FuncTo API docTo spec)

763.              return Gtk_Ctree_NodeTo API docTo spec;

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.

768.           function Find_All_By_Row_Data_CustomTo API docTo body

769.             (Ctree : access Gtk_Ctree_RecordTo API docTo specTo body'Class;

770.              Node  : in     Gtk_Ctree_NodeTo API docTo spec;

771.              Data  : in     Data_TypeTo API docTo spec;

772.              Func  : in     Gcompare_FuncTo API docTo spec) return Node_List.GlistTo API docTo specTo body;

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.

777.           type Gtk_Ctree_Func is access

778.             procedure (Ctree : access Gtk_Ctree_RecordTo API docTo specTo body'Class;

779.                        Node  : in     Gtk_Ctree_NodeTo API docTo spec;

780.                        Data  : in     Data_Type_AccessTo API docTo spec);

781.           --  Function used by Post/Pre_Recursive functions below.

783.           procedure Post_RecursiveTo API docTo body (Ctree : access Gtk_Ctree_RecordTo API docTo specTo body'Class;

784.                                     Node  : in     Gtk_Ctree_NodeTo API docTo spec;

785.                                     Func  : in     Gtk_Ctree_FuncTo API docTo spec;

786.                                     Data  : in     Data_Type_AccessTo API docTo spec);

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.

792.           procedure Post_Recursive_To_DepthTo API docTo body (Ctree : access Gtk_Ctree_RecordTo API docTo specTo body'Class;

793.                                              Node  : in     Gtk_Ctree_NodeTo API docTo spec;

794.                                              Depth : in     GintTo API docTo spec;

795.                                              Func  : in     Gtk_Ctree_FuncTo API docTo spec;

796.                                              Data  : in     Data_Type_AccessTo API docTo spec);

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.

803.           procedure Pre_RecursiveTo API docTo body (Ctree : access Gtk_Ctree_RecordTo API docTo specTo body'Class;

804.                                    Node  : in     Gtk_Ctree_NodeTo API docTo spec;

805.                                    Func  : in     Gtk_Ctree_FuncTo API docTo spec;

806.                                    Data  : in     Data_Type_AccessTo API docTo spec);

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.

811.           procedure Pre_Recursive_To_DepthTo API docTo body (Ctree : access Gtk_Ctree_RecordTo API docTo specTo body'Class;

812.                                             Node  : in     Gtk_Ctree_NodeTo API docTo spec;

813.                                             Depth : in     GintTo API docTo spec;

814.                                             Func  : in     Gtk_Ctree_FuncTo API docTo spec;

815.                                             Data  : in     Data_Type_AccessTo API docTo spec);

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.

820.        private

822.           --  <doc_ignore>

823.           function Default_Gcompare_Func (A, B : in Data_TypeTo API docTo spec) 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.

829.           type Ctree_Func_Record is record

830.              Func : Gtk_Ctree_FuncTo API docTo spec;

831.              Data : Data_Type_AccessTo API docTo spec;

832.           end record;

833.           type Ctree_Func_Record_Access is access all Ctree_Func_Record;

835.           procedure Free_Data (Data : Data_Type_AccessTo API docTo spec);

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.

841.           procedure C_Ctree_Func (C_Ctree : in System.Address;

842.                                   C_Node  : in Gtk_Ctree_NodeTo API docTo spec;

843.                                   C_Data  : in Ctree_Func_Record_Access);

844.           pragma Convention (C, C_Ctree_Func);

846.           type Gcompare_Func_Record is record

847.              Func : Gcompare_FuncTo API docTo spec;

848.              Data : Data_Type_AccessTo API docTo spec;

849.           end record;

850.           type Gcompare_Func_Record_Access is access all Gcompare_Func_Record;

852.           function C_Gcompare_Func

853.             (Row_Data           : in Data_Type_AccessTo API docTo spec;

854.              Gcompare_Func_Data : in Gcompare_Func_Record_Access) return GintTo API docTo spec;

855.           pragma Convention (C, C_Gcompare_Func);

856.           --  </doc_ignore>

858.        end Row_DataTo API docTo specTo body;

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

864.        ----------------

865.        -- Properties --

866.        ----------------

868.        --  <properties>

869.        --  The following properties are defined for this widget. See

870.        --  Glib.Properties for more information on properties.

871.        --  </properties>

873.        -------------

874.        -- Signals --

875.        -------------

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>

918.        Signal_Change_Focus_Row_Expansion : constant Glib.Signal_NameTo API docTo spec :=

919.                                              "change_focus_row_expansion";

920.        Signal_Tree_Collapse              : constant Glib.Signal_NameTo API docTo spec :=

921.                                              "tree_collapse";

922.        Signal_Tree_Expand                : constant Glib.Signal_NameTo API docTo spec :=

923.                                              "tree_expand";

924.        Signal_Tree_Move                  : constant Glib.Signal_NameTo API docTo spec :=

925.                                              "tree_move";

926.        Signal_Tree_Select_Row            : constant Glib.Signal_NameTo API docTo spec :=

927.                                              "tree_select_row";

928.        Signal_Tree_Unselect_Row          : constant Glib.Signal_NameTo API docTo spec :=

929.                                              "tree_unselect_row";

931.     private

933.        pragma Warnings (Off);  --  Gtk.Clist is obsolescent

934.        type Gtk_Ctree_RecordTo API docTo spec is new Gtk.Clist.Gtk_Clist_RecordTo API docTo specTo body with null record;

935.        pragma Warnings (On);

937.        pragma Import (C, Get_TypeTo API docTo spec, "gtk_ctree_get_type");

938.        pragma Import (C, Node_Get_RowTo API docTo spec, "ada_ctree_node_get_row");

939.        pragma Import (C, Row_Get_ChildrenTo API docTo spec, "ada_ctree_row_get_children");

940.        pragma Import (C, Row_Get_ParentTo API docTo spec, "ada_ctree_row_get_parent");

941.        pragma Import (C, Row_Get_SiblingTo API docTo spec, "ada_ctree_row_get_sibling");

943.     end Gtk.CtreeTo API docTo specTo body;

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