## 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 displays a multi-column list. Each line is made of

34.     --  a number of column, each being able to display any kind of widget.

35.     --

36.     --  The intersection of a line and a column is called a Cell. Each cell can

37.     --  have a different type (Cell_Text, Cell_Pixmap, Cell_Pixtext), and display

38.     --  its contents depending on this type. For instance, the text is not

39.     --  displayed in the type is Cell_Pixmap.

40.     --  Note that this type is changed dynamically by some of the subprograms

41.     --  below, like Set_Pixmap, Set_Text, ... and Set_Cell_Contents

42.     --

43.     --  This is one of the most powerful widgets in GtkAda, that can be used to

44.     --  display an kind of information. Look also into using Gtk_Ctree, which is

45.     --  a similar widget.

46.     --

47.     --  You can add scrolling in a Gtk_Clist by adding it in a Gtk_Scrolled_Window.

48.     --  </description>

49.     --  <c_version>2.8.17</c_version>

50.     --  <group>Obsolescent widgets</group>

51.     --  <testgtk>create_clist.adb</testgtk>

53.     with Gdk.BitmapTo API docTo specTo body;

54.     with Gdk.ColorTo API docTo specTo body;

55.     with Gdk.PixmapTo API docTo specTo body;

56.     with Gdk.WindowTo API docTo specTo body;

57.     with Glib.GlistTo API docTo specTo body;

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

59.     with Gtk.AdjustmentTo API docTo specTo body;

60.     with Gtk.ContainerTo API docTo specTo body;

61.     with Gtk.EnumsTo API docTo specTo body;

62.     with Gtk.StyleTo API docTo specTo body;

63.     with Gtk.WidgetTo API docTo specTo body;

64.     with Gtkada.TypesTo API docTo specTo body;

65.     with Unchecked_Conversion;

67.     package Gtk.ClistTo API docTo specTo body is

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

70.        type Gtk_Clist_RecordTo API docTo body is new Gtk.Container.Gtk_Container_RecordTo API docTo specTo body

71.          with private;

72.        type Gtk_Clist is access all Gtk_Clist_RecordTo API docTo specTo body'Class;

74.        type Gtk_Clist_Row is new Gdk.C_ProxyTo API docTo spec;

75.        --  A row of the clist.

76.        --  Application-specific data can be associated with each row.

77.        --  In the following subprograms, rows can also be accessed via their

78.        --  number, starting from 0.

80.        type Gtk_Button_Action is new GuintTo API docTo spec;

81.        Button_Ignored : constant Gtk_Button_ActionTo API docTo spec := 0;

82.        Button_Selects : constant Gtk_Button_ActionTo API docTo spec := 1 ** 0;

83.        Button_Drags   : constant Gtk_Button_ActionTo API docTo spec := 1 ** 1;

84.        Button_Expands : constant Gtk_Button_ActionTo API docTo spec := 1 ** 2;

86.        type Gtk_Cell_Type is

87.          (Cell_Empty,

88.           Cell_Text,

89.           Cell_Pixmap,

90.           Cell_Pixtext,

91.           Cell_Widget);

92.        pragma Convention (C, Gtk_Cell_TypeTo API docTo spec);

94.        type Gtk_Sort_Type is (Ascending, Descending);

95.        pragma Convention (C, Gtk_Sort_TypeTo API docTo spec);

96.        --  The order in which the rows should be sorted.

98.        --  <doc_ignore>

99.        function Convert is new Unchecked_Conversion

100.          (Gtk_Clist_RowTo API docTo spec, System.Address);

101.        function Convert is new Unchecked_Conversion

102.          (System.Address, Gtk_Clist_RowTo API docTo spec);

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

105.        --  </doc_ignore>

107.        type Gtk_Clist_Compare_Func is access

108.          function

109.            (Clist : access Gtk_Clist_RecordTo API docTo specTo body'Class;

110.             Row1  : Gtk_Clist_RowTo API docTo spec;

111.             Row2  : Gtk_Clist_RowTo API docTo spec) return GintTo API docTo spec;

112.        --  Function used when sorting a clist. This function takes two

113.        --  rows as its arguments, and should return a Gint indicating in which

114.        --  order the rows are found (-1 if Row1 comes first, 0 if they are equal,

115.        --  1 if Row2 comes first).

117.        ------------------------------------------------

118.        -- Creating a list and setting the attributes --

119.        ------------------------------------------------

121.        procedure Gtk_NewTo API docTo body (Widget : out Gtk_ClistTo API docTo spec; Columns : in GintTo API docTo spec);

122.        --  Create a list with Columns columns.

123.        --  Each line will have this exact number of column

124.        --  The number of columns can not be changed once the widget has been

125.        --  created.

127.        procedure InitializeTo API docTo body

128.          (Widget : access Gtk_Clist_RecordTo API docTo specTo body'Class; Columns : in GintTo API docTo spec);

129.        --  Internal initialization function.

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

132.        procedure Gtk_NewTo API docTo body

133.          (Widget  : out Gtk_ClistTo API docTo spec;

134.           Columns : in  GintTo API docTo spec;

135.           Titles  : in  Gtkada.Types.Chars_Ptr_ArrayTo API docTo spec);

136.        --  Create a new list with Columns columns.

137.        --  The title of the columns is specified in Titles.

138.        --  The results are undefined (and can raise an exception) if Titles does

139.        --  not have at least Columns items.

141.        procedure InitializeTo API docTo body

142.          (Widget  : access Gtk_Clist_RecordTo API docTo specTo body'Class;

143.           Columns : in GintTo API docTo spec;

144.           Titles  : in Gtkada.Types.Chars_Ptr_ArrayTo API docTo spec);

145.        --  Internal initialization function.

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

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

149.        --  Return the internal value associated with a Gtk_Clist.

151.        procedure Set_HadjustmentTo API docTo body

152.          (Clist      : access Gtk_Clist_RecordTo API docTo specTo body;

153.           Adjustment : Gtk.Adjustment.Gtk_AdjustmentTo API docTo spec);

154.        --  Set the horizontal adjustment used for the clist.

155.        --  Note that such an adjustment is automatically created when the clist

156.        --  is added to a Gtk_Scrolled_Window. You should rather use

157.        --  Gtk.Scrolled_Window.Set_Hadjustment if you want to modify the

158.        --  adjustment.

159.        --  If there was already such an adjustment, it is unref-ed, and might

160.        --  be deleted.

162.        procedure Set_VadjustmentTo API docTo body

163.          (Clist      : access Gtk_Clist_RecordTo API docTo specTo body;

164.           Adjustment : Gtk.Adjustment.Gtk_AdjustmentTo API docTo spec);

165.        --  Set the vertical adjustment used for the clist.

166.        --  Note that such an adjustment is automatically created when the clist

167.        --  is added to a Gtk_Scrolled_Window. You should rather use

168.        --  Gtk.Scrolled_Window.Set_Hadjustment if you want to modify the

169.        --  adjustment.

170.        --  If there was already such an adjustment, it is unref-ed, and might

171.        --  be deleted.

173.        function Get_HadjustmentTo API docTo body

174.          (Clist  : access  Gtk_Clist_RecordTo API docTo specTo body) return Gtk.Adjustment.Gtk_AdjustmentTo API docTo spec;

175.        --  Return the horizontal adjustment used for the clist.

176.        --  This indicates what position the clist is presently displaying, and

177.        --  by changing its value, the clist is automatically scrolled horizontally.

178.        --  This is done automatically when the clist's parent is a

179.        --  Gtk_Scrolled_Window.

181.        function Get_VadjustmentTo API docTo body

182.          (Clist  : access Gtk_Clist_RecordTo API docTo specTo body) return Gtk.Adjustment.Gtk_AdjustmentTo API docTo spec;

183.        --  Return the vertical adjustment used for the clist.

184.        --  This indicates what position the clist is presently displaying, and

185.        --  by changing its value, the clist is automatically scrolled vertically.

186.        --  This is done automatically when the clist's parent is a

187.        --  Gtk_Scrolled_Window.

189.        procedure Set_Selection_ModeTo API docTo body

190.          (Clist : access Gtk_Clist_RecordTo API docTo specTo body;

191.           ModeTo API docTo body  : in Gtk.Enums.Gtk_Selection_ModeTo API docTo spec);

192.        --  Modify the selection mode for the clist.

193.        --  This indicates whether one or more lines can be selected at the

194.        --  same time in the clist, and how this selection can done by the

195.        --  user (does he have to click explicitly on an item, or can he

196.        --  browse through the clist and select the last item he was on, etc.)

197.        --

198.        --  Note that changing the selection mode to Selection_Single or

199.        --  Selection_Browse will deselect all the items in the clist.

201.        function Get_Selection_ModeTo API docTo body

202.          (Clist : access Gtk_Clist_RecordTo API docTo specTo body) return Gtk.Enums.Gtk_Selection_ModeTo API docTo spec;

203.        --  Return the selection mode for the clist.

205.        --  <doc_ignore>

206.        function Get_Clist_WindowTo API docTo body

207.          (Clist : access Gtk_Clist_RecordTo API docTo specTo body) return Gdk.Window.Gdk_WindowTo API docTo spec;

208.        --  Returns the scrolling window used in the clist. This function is

209.        --  kept for backward compatibility reasons, and you probably won't have

210.        --  to use it.

211.        --  </doc_ignore>

213.        --------------------

214.        -- Visual aspects --

215.        --------------------

217.        procedure FreezeTo API docTo body (Clist : access Gtk_Clist_RecordTo API docTo specTo body);

218.        --  Freeze all visual updates on the list, while you make big changes.

219.        --  This is more efficient than working on an unfrozen list.

221.        procedure ThawTo API docTo body (Clist : access Gtk_Clist_RecordTo API docTo specTo body);

222.        --  Thaw the list, ie reactivate all the visual updates.

223.        --  This also forces an immediate refresh of the list.

224.        --  Note that each Freeze must be followed by a Thaw. The visual updates

225.        --  are not reactivated until the last Thaw has been emitted, but there is

226.        --  an immediate refresh every time anyway.

228.        procedure Set_Shadow_TypeTo API docTo body

229.          (Clist    : access Gtk_Clist_RecordTo API docTo specTo body;

230.           The_TypeTo API docTo body : in Gtk.Enums.Gtk_Shadow_TypeTo API docTo spec);

231.        --  Set the border style of the clist.

233.        ----------------------------

234.        -- Modifying the contents --

235.        ----------------------------

237.        function AppendTo API docTo body

238.          (Clist : access Gtk_Clist_RecordTo API docTo specTo body;

239.           Text  : in     Gtkada.Types.Chars_Ptr_ArrayTo API docTo spec) return GintTo API docTo spec;

240.        --  Append a new row to the clist, and return the index of the row created.

241.        --  The row is added at the end of the Clist.

242.        --  The behavior is undefined if Text does not have at least as many items

243.        --  as there are columns in the Clist.

245.        function PrependTo API docTo body

246.          (Clist : access Gtk_Clist_RecordTo API docTo specTo body;

247.           Text  : in     Gtkada.Types.Chars_Ptr_ArrayTo API docTo spec) return GintTo API docTo spec;

248.        --  Add a new row at the beginning of the clist, and return its index.

249.        --  The behavior is undefined if Text does not have at least as many items

250.        --  as there are columns in the Clist.

252.        procedure InsertTo API docTo body

253.          (Clist : access Gtk_Clist_RecordTo API docTo specTo body;

254.           Row   : in     GintTo API docTo spec;

255.           Text  : in     Gtkada.Types.Chars_Ptr_ArrayTo API docTo spec);

256.        --  Add a new row in the clist.

257.        --  The row 0 is the first in the clist. If Row is not in the range for

258.        --  clist, the new row is added at the end. The behavior is undefined if

259.        --  Text does not have enough items.

261.        procedure RemoveTo API docTo body (Clist : access Gtk_Clist_RecordTo API docTo specTo body; Row : in GintTo API docTo spec);

262.        --  Remove a row from the clist (0 is the first one).

264.        procedure ClearTo API docTo body (Clist : access Gtk_Clist_RecordTo API docTo specTo body);

265.        --  Clears the entire list. This is much faster than doing a Remove on each

266.        --  line.

268.        procedure Swap_RowsTo API docTo body

269.          (Clist : access Gtk_Clist_RecordTo API docTo specTo body;

270.           Row1  : in     GintTo API docTo spec;

271.           Row2  : in     GintTo API docTo spec);

272.        --  Exchange the position of two rows in the clist.

274.        procedure Row_MoveTo API docTo body

275.          (Clist      : access Gtk_Clist_RecordTo API docTo specTo body;

276.           Source_Row : in     GintTo API docTo spec;

277.           Dest_Row   : in     GintTo API docTo spec);

278.        --  Move the row at Source_Row to Dest_Row (0 indicates the first row in

279.        --  the clist)

281.        procedure Set_Sort_ColumnTo API docTo body

282.          (Clist  : access Gtk_Clist_RecordTo API docTo specTo body;

283.           Column : GintTo API docTo spec);

284.        --  Indicate the column on which to sort the clist.

285.        --  This column is relevant when you use Sort or Set_Auto_Sort below.

286.        --  The first column is number 0.

288.        function Get_Sort_ColumnTo API docTo body (Clist : access Gtk_Clist_RecordTo API docTo specTo body) return GintTo API docTo spec;

289.        --  Return the column on which the clist is sorted.

291.        procedure Set_Sort_TypeTo API docTo body

292.          (Clist     : access Gtk_Clist_RecordTo API docTo specTo body;

293.           Sort_TypeTo API docTo body : Gtk_Sort_TypeTo API docTo spec);

294.        --  Indicate in which order the sort should be done on the clist

295.        --  (ascending or descending).

297.        function Get_Sort_TypeTo API docTo body

298.          (Clist : access Gtk_Clist_RecordTo API docTo specTo body) return Gtk_Sort_TypeTo API docTo spec;

299.        --  Return the sort type currently used for the list

301.        procedure SortTo API docTo body (Clist : access Gtk_Clist_RecordTo API docTo specTo body);

302.        --  Sort the lines of the clist, based on the column set by Set_Sort_Column,

303.        --  and in the order set by Set_Sort_Type.

305.        procedure Set_Auto_SortTo API docTo body

306.          (Clist     : access Gtk_Clist_RecordTo API docTo specTo body;

307.           Auto_Sort : Boolean);

308.        --  If Auto_Sort is true, then the clist will be automatically sorted every

309.        --  time a new line is inserted into the clist.

311.        procedure Set_Compare_FuncTo API docTo body

312.          (Clist : access Gtk_Clist_RecordTo API docTo specTo body;

313.           Func  : Gtk_Clist_Compare_FuncTo API docTo spec);

314.        --  Set the function used when sorting the list. This function takes two

315.        --  rows as its arguments, and should return a Gint indicating in which

316.        --  order the rows are found (-1 if Row1 comes first, 0 if they are equal,

317.        --  1 if Row2 comes last).

318.        --  Func should be null to restore the default sorting functions.

320.        -------------

321.        -- Columns --

322.        -------------

324.        function Get_ColumnsTo API docTo body (Clist : access Gtk_Clist_RecordTo API docTo specTo body) return GintTo API docTo spec;

325.        --  Return the number of columns in the clist.

327.        procedure Column_Titles_HideTo API docTo body (Clist : access Gtk_Clist_RecordTo API docTo specTo body);

328.        --  Hide the column titles for the list.

329.        --  This is the default behavior if no column titles were given when the

330.        --  list was created.

332.        procedure Column_Titles_ShowTo API docTo body (Clist : access Gtk_Clist_RecordTo API docTo specTo body);

333.        --  Show the column titles for the list.

334.        --  This is the default behavior if some column titles were given when the

335.        --  list was created.

337.        procedure Column_Title_ActiveTo API docTo body

338.          (Clist : access Gtk_Clist_RecordTo API docTo specTo body;

339.           Column : in GintTo API docTo spec);

340.        --  Set the column title to be an activate title.

341.        --  In other words, answer all button presses, highlights when the mouse is

342.        --  over it, ...

344.        procedure Column_Title_PassiveTo API docTo body

345.          (Clist : access Gtk_Clist_RecordTo API docTo specTo body;

346.           Column : in GintTo API docTo spec);

347.        --  Set the column title to be passive.

348.        --  Act just as a title, and do not react to mouse events.

350.        procedure Column_Titles_ActiveTo API docTo body (Clist : access Gtk_Clist_RecordTo API docTo specTo body);

351.        --  Set all column titles to be active.

353.        procedure Column_Titles_PassiveTo API docTo body (Clist : access Gtk_Clist_RecordTo API docTo specTo body);

354.        --  Set all column titles to be passive.

356.        procedure Set_Column_TitleTo API docTo body

357.          (Clist  : access Gtk_Clist_RecordTo API docTo specTo body;

358.           Column : in GintTo API docTo spec;

359.           Title  : in UTF8_StringTo API docTo spec);

360.        --  Set the text for the button of the column's title.

361.        --  See Set_Column_Widget if you want to put a pixmap inside the button.

363.        function Get_Column_TitleTo API docTo body

364.          (Clist  : access Gtk_Clist_RecordTo API docTo specTo body;

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

366.        --  Return the text used for the title's column.

367.        --  This is a copy of the title, so you can't modify it to automatically

368.        --  change the column's title.

370.        procedure Set_Column_WidgetTo API docTo body

371.          (Clist  : access Gtk_Clist_RecordTo API docTo specTo body;

372.           Column : in     GintTo API docTo spec;

373.           Widget : access Gtk.Widget.Gtk_Widget_RecordTo API docTo specTo body'Class);

374.        --  Modify the widget used in the Gtk_Button that is the column's title.

375.        --  By default, this button contains a simple Gtk_Label, which is replaced

376.        --  by Widget. This is the function to use if you want to put a pixmap

377.        --  (or a Gtk_Box that contains both a pixmap and some text) in a column's

378.        --  title.

380.        function Get_Column_WidgetTo API docTo body

381.          (Clist  : access Gtk_Clist_RecordTo API docTo specTo body;

382.           Column : in GintTo API docTo spec) return Gtk.Widget.Gtk_WidgetTo API docTo spec;

383.        --  Return the child of the button that makes the column's title.

384.        --  Unless you changed it with Set_Column_Widget, this will return a

385.        --  Gtk_Label. Note also that if this widget was not created in Ada, but

386.        --  transparently by gtk+, you have to 'with' Gtk.Type_Conversion so that

387.        --  the correct type of the widget is created (See the user's guide for

388.        --  more information on type conversion).

390.        procedure Set_Column_JustificationTo API docTo body

391.          (Clist         : access Gtk_Clist_RecordTo API docTo specTo body;

392.           Column        : in GintTo API docTo spec;

393.           JustificationTo API docTo body : in Gtk.Enums.Gtk_JustificationTo API docTo spec);

394.        --  Change the way the text in the whole column is justified.

395.        --  This function has no effect on the title if you used Set_Column_Widget

396.        --  before.

398.        procedure Set_Column_VisibilityTo API docTo body

399.          (Clist   : access Gtk_Clist_RecordTo API docTo specTo body;

400.           Column  : in GintTo API docTo spec;

401.           Visible : in Boolean);

402.        --  Modify the visibility of a column.

403.        --  Note that GtkAda prevents the last remaining visible column to be

404.        --  hidden. Nothing will be done if you try to hide that last column.

405.        --  See the example below for an example how to hide all the columns but

406.        --  one.

408.        procedure Set_Column_ResizeableTo API docTo body

409.          (Clist    : access Gtk_Clist_RecordTo API docTo specTo body;

410.           Column   : in GintTo API docTo spec;

411.           Resizeable : in Boolean);

412.        --  Set whether the column can be dynamically resized with the mouse.

413.        --  If Resizeable is true, then the column can be resized by clicking

414.        --  and dragging the lines that separates the column from the next one.

416.        procedure Set_Column_Auto_ResizeTo API docTo body

417.          (Clist       : access Gtk_Clist_RecordTo API docTo specTo body;

418.           Column      : in GintTo API docTo spec;

419.           Auto_Resize : in Boolean);

420.        --  Set whether the column should automatically be resized to the optimal

421.        --  size (based on its contents). Note that this operation could slow things

422.        --  down a lot if you have a lot of items in your list.

424.        function Columns_AutosizeTo API docTo body (Clist  : access Gtk_Clist_RecordTo API docTo specTo body) return GintTo API docTo spec;

425.        --  Set all the columns' width to their optimal size.

426.        --  Return the total width of the clist after this operation.

428.        function Optimal_Column_WidthTo API docTo body

429.          (Clist : access Gtk_Clist_RecordTo API docTo specTo body;

430.           Column : GintTo API docTo spec) return GintTo API docTo spec;

431.        --  Return the optimal width for Column, based on its contents.

432.        --  This is the maximal cell width in the column.

434.        procedure Set_Column_WidthTo API docTo body

435.          (Clist  : access Gtk_Clist_RecordTo API docTo specTo body;

436.           Column : in GintTo API docTo spec;

437.           Width  : in GintTo API docTo spec);

438.        --  Set the column width in pixels.

439.        --  By default, the column's width is chosen from the column's title.

441.        procedure Set_Column_Min_WidthTo API docTo body

442.          (Clist     : access Gtk_Clist_RecordTo API docTo specTo body;

443.           Column    : GintTo API docTo spec;

444.           Min_Width : GintTo API docTo spec);

445.        --  Set the minimal width for the column, in pixels.

446.        --  if Min_Width is negative, there is no limit on the minimal width for

447.        --  the column.

449.        procedure Set_Column_Max_WidthTo API docTo body

450.          (Clist     : access Gtk_Clist_RecordTo API docTo specTo body;

451.           Column    : GintTo API docTo spec;

452.           Max_Width : GintTo API docTo spec);

453.        --  Set the maximal width for the column, in pixels.

454.        --  If Max_Width is negative, there is no limit on the maximal width for

455.        --  the column.

457.        ----------

458.        -- Rows --

459.        ----------

461.        function Get_RowsTo API docTo body (Clist : access Gtk_Clist_RecordTo API docTo specTo body) return GintTo API docTo spec;

462.        --  Return the number of rows in the clist.

464.        procedure Set_Row_HeightTo API docTo body

465.          (Clist  : access Gtk_Clist_RecordTo API docTo specTo body;

466.           Height : GintTo API docTo spec);

467.        --  Set the height of the rows, in pixels.

468.        --  if Height is 0, the chosen height will be the current's font height.

470.        function Row_Is_VisibleTo API docTo body

471.          (Clist : access Gtk_Clist_RecordTo API docTo specTo body;

472.           Row   : in GintTo API docTo spec) return Gtk.Enums.Gtk_VisibilityTo API docTo spec;

473.        --  Return the visibility status of the row.

475.        procedure Set_ForegroundTo API docTo body

476.          (Clist : access Gtk_Clist_RecordTo API docTo specTo body;

477.           Row   : in GintTo API docTo spec;

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

479.        --  Set the foreground color for the row.

480.        --  The color must already be allocated.

481.        --  If no such row exists in the list, nothing is done.

483.        procedure Set_BackgroundTo API docTo body

484.          (Clist : access Gtk_Clist_RecordTo API docTo specTo body;

485.           Row   : in GintTo API docTo spec;

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

487.        --  Set the background color for the row.

488.        --  The color must already be allocated.

489.        --  If no such row exists in the list, nothing is done.

491.        procedure Set_Row_StyleTo API docTo body

492.          (Clist : access Gtk_Clist_RecordTo API docTo specTo body; Row : GintTo API docTo spec;

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

494.        --  Set the default style for the cells in the row. This can be

495.        --  overridden for each cell with Set_Cell_Style.

497.        function Get_Row_StyleTo API docTo body

498.          (Clist  : access Gtk_Clist_RecordTo API docTo specTo body;

499.           Row    : in     GintTo API docTo spec) return Gtk.Style.Gtk_StyleTo API docTo spec;

500.        --  Return the default style used for the row.

502.        procedure Set_SelectableTo API docTo body

503.          (Clist      : access Gtk_Clist_RecordTo API docTo specTo body;

504.           Row        : GintTo API docTo spec;

505.           Selectable : Boolean);

506.        --  Indicate whether the row can be selected or not.

507.        --  The default value is True.

509.        function Get_SelectableTo API docTo body

510.          (Clist : access Gtk_Clist_RecordTo API docTo specTo body;

511.           Row   : GintTo API docTo spec) return Boolean;

512.        --  Return the selectable status of the row.

514.        procedure Select_RowTo API docTo body

515.          (Clist  : access Gtk_Clist_RecordTo API docTo specTo body;

516.           Row    : in GintTo API docTo spec;

517.           Column : in GintTo API docTo spec);

518.        --  Emit the signal "select_row". This simulates the user pressing

519.        --  the mouse on Row, Column on the clist.

521.        procedure Unselect_RowTo API docTo body

522.          (Clist  : access Gtk_Clist_RecordTo API docTo specTo body;

523.           Row    : in GintTo API docTo spec;

524.           Column : in GintTo API docTo spec);

525.        --  Emit the signal "unselect_row", as if the user had clicked on

526.        --  Row, Column on the clist.

528.        procedure Undo_SelectionTo API docTo body (Clist  : access Gtk_Clist_RecordTo API docTo specTo body);

529.        --  Undo the last select/unselect operation.

531.        procedure Get_Selection_InfoTo API docTo body

532.          (Clist    : access Gtk_Clist_RecordTo API docTo specTo body;

533.           X        : in GintTo API docTo spec;

534.           Y        : in GintTo API docTo spec;

535.           Row      : out GintTo API docTo spec;

536.           Column   : out GintTo API docTo spec;

537.           Is_Valid : out Boolean);

538.        --  Return the Row/Column corresponding to the coordinates X,Y in the

539.        --  Row column. The coordinates X,Y are relative to the clist window

540.        --  (ie 0,0 is the top left corner of the clist).

541.        --  The result is valid only if Is_Valid is true

543.        procedure Select_AllTo API docTo body (Clist : access Gtk_Clist_RecordTo API docTo specTo body);

544.        --  Select all the rows in the clist. This only works if the selection

545.        --  mode allows for multiple rows selected at the same time (extended or

546.        --  multiple).

548.        procedure Unselect_AllTo API docTo body (Clist : access Gtk_Clist_RecordTo API docTo specTo body);

549.        --  Deselect all the rows in the clist. If the selection mode is

550.        --  Browse, then only the current line is deselected.

552.        function Get_Focus_RowTo API docTo body (Clist : access Gtk_Clist_RecordTo API docTo specTo body) return GintTo API docTo spec;

553.        --  Return the number of the line that currently has the focus.

555.        function Get_Row_ListTo API docTo body

556.          (Clist : access Gtk_Clist_RecordTo API docTo specTo body) return Row_List.GlistTo API docTo specTo body;

557.        --  Return the list of all the rows in the clist. This might speed up

558.        --  the access to the rows a little.

559.        --  You can then use the function Set_Cell_Contents to modify the cells

560.        --  in the row, and Get_Text or Get_Pixmap to get its contents.

562.        function Get_SelectionTo API docTo body

563.          (Widget : access Gtk_Clist_RecordTo API docTo specTo body) return Gtk.Enums.Gint_List.GlistTo API docTo specTo body;

564.        --  Return the list of selected rows, by number.

566.        -----------

567.        -- Cells --

568.        -----------

570.        function Get_Cell_TypeTo API docTo body

571.          (Clist  : access Gtk_Clist_RecordTo API docTo specTo body;

572.           Row    : in GintTo API docTo spec;

573.           Column : in GintTo API docTo spec) return Gtk_Cell_TypeTo API docTo spec;

574.        --  Return the type of the cell at Row/Column.

575.        --  This indicates which of the functions Get_Text. Get_Pixmap, etc.

576.        --  below you can use.

578.        procedure Set_TextTo API docTo body

579.          (Clist  : access Gtk_Clist_RecordTo API docTo specTo body;

580.           Row    : in GintTo API docTo spec;

581.           Column : in GintTo API docTo spec;

582.           Text   : in UTF8_StringTo API docTo spec);

583.        --  Set the cell's text, replacing its current contents.

584.        --  This changes the type of the cell to Cell_Text. The pixmap (if any)

585.        --  will no longer be displayed.

587.        function Get_TextTo API docTo body

588.          (Clist    : access Gtk_Clist_RecordTo API docTo specTo body;

589.           Row      : in GintTo API docTo spec;

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

591.        --  Return the text contained in cell. The type of the cell should be

592.        --  either Cell_Text or Cell_Pixtext.

593.        --  If there was a problem, a null-length string is returned.

594.        --  The problem might appear in case the row or the column are

595.        --  invalid, or if the cell does not contain any text.

597.        function Get_TextTo API docTo body

598.          (Clist    : access Gtk_Clist_RecordTo API docTo specTo body;

599.           Row      : Gtk_Clist_RowTo API docTo spec;

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

601.        --  Return the text contained in cell. The Row can be obtained from

602.        --  Get_Row_List, this function speeds up the access a little compared

603.        --  to the other Get_Text above.

605.        procedure Set_PixmapTo API docTo body

606.          (Clist  : access Gtk_Clist_RecordTo API docTo specTo body;

607.           Row    : in GintTo API docTo spec;

608.           Column : in GintTo API docTo spec;

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

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

611.        --  Set the cell's pixmap, replacing its current contents.

612.        --  The type of the cell becomes Cell_Pixmap, and the text is no longer

613.        --  displayed.

615.        procedure Get_PixmapTo API docTo body

616.          (Clist    : access Gtk_Clist_RecordTo API docTo specTo body;

617.           Row      : in GintTo API docTo spec;

618.           Column   : in GintTo API docTo spec;

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

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

621.           Is_Valid : out Boolean);

622.        --  Return the pixmap contained in a cell. The type of the cell should

623.        --  be Cell_Pixmap.

624.        --  The result is meaningful only if Is_Valid is True. If the Cell did not

625.        --  contain a pixmap, Is_Valid is set to False

627.        procedure Get_PixmapTo API docTo body

628.          (Clist    : access Gtk_Clist_RecordTo API docTo specTo body;

629.           Row      : in Gtk_Clist_RowTo API docTo spec;

630.           Column   : in GintTo API docTo spec;

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

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

633.           Is_Valid : out Boolean);

634.        --  Return the pixmap contained in a cell. Row can be obtained directly with

635.        --  Get_Row_List, and speeds up the access a little compared to the previous

636.        --  Get_Pixmap function.

638.        procedure Set_PixtextTo API docTo body

639.          (Clist   : access Gtk_Clist_RecordTo API docTo specTo body;

640.           Row     : in GintTo API docTo spec;

641.           Column  : in GintTo API docTo spec;

642.           Text    : in UTF8_StringTo API docTo spec;

643.           Spacing : in Guint8To API docTo spec;

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

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

646.        --  Set both the text and the pixmap for the cell.

647.        --  Replace its current contents. The type of the cell becomes Cell_Pixtext,

648.        --  and both the text and the pixmap are displayed.

650.        procedure Get_PixtextTo API docTo body

651.          (Clist    : access Gtk_Clist_RecordTo API docTo specTo body;

652.           Row      : in GintTo API docTo spec;

653.           Column   : in GintTo API docTo spec;

654.           Spacing  : out Guint8To API docTo spec;

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

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

657.           Is_Valid : out Boolean);

658.        --  The result is not meaningful if Is_Valid is False.

659.        --  The only way to get the string is to use Get_Text, since a String is

660.        --  an unconstrained type in Ada and is not really convenient to use as an

661.        --  out parameter.

663.        procedure Set_Cell_StyleTo API docTo body

664.          (Clist  : access Gtk_Clist_RecordTo API docTo specTo body;

665.           Row    : in GintTo API docTo spec;

666.           Column : in GintTo API docTo spec;

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

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

669.        --  This overrides the row's style.

671.        function Get_Cell_StyleTo API docTo body

672.          (Clist  : access Gtk_Clist_RecordTo API docTo specTo body;

673.           Row    : in     GintTo API docTo spec;

674.           Column : in     GintTo API docTo spec) return Gtk.Style.Gtk_StyleTo API docTo spec;

675.        --  Return the style of the cell.

677.        procedure Set_ShiftTo API docTo body

678.          (Clist      : access Gtk_Clist_RecordTo API docTo specTo body;

679.           Row        : in GintTo API docTo spec;

680.           Column     : in GintTo API docTo spec;

681.           Vertical   : in GintTo API docTo spec;

682.           Horizontal : in GintTo API docTo spec);

683.        --  Set a horizontal and vertical shift for drawing the content of the cell.

684.        --  Both shifts can be either positive or negative.

685.        --  This is particularly useful for indenting items in a columns.

687.        procedure Set_Cell_ContentsTo API docTo body

688.          (Clist     : access Gtk_Clist_RecordTo API docTo specTo body;

689.           Row       : Gtk_Clist_RowTo API docTo spec;

690.           Column    : GintTo API docTo spec;

691.           Cell_TypeTo API docTo body : Gtk_Cell_TypeTo API docTo spec;

692.           Text      : UTF8_StringTo API docTo spec;

693.           Spacing   : Guint8To API docTo spec;

694.           Pixmap    : Gdk.Pixmap.Gdk_PixmapTo API docTo spec;

695.           Mask      : Gdk.Bitmap.Gdk_BitmapTo API docTo spec);

696.        --  Modify the contents and type of a cell.

697.        --  Cell_Type indicates what should be displayed in the cell. Note that

698.        --  if you do not want any string, you should pass an empty string "".

699.        --  You get Row from Get_Row_List.

701.        -------------------------

702.        -- Reordering the list --

703.        -------------------------

705.        procedure Set_ReorderableTo API docTo body

706.          (Clist : access Gtk_Clist_RecordTo API docTo specTo body; Reorderable : Boolean);

707.        --  Set whether the list can be dynamically reordered by the user.

708.        --  (using a simple drag-n-drop protocol).

710.        procedure Set_Use_Drag_IconsTo API docTo body

711.          (Clist : access Gtk_Clist_RecordTo API docTo specTo body; Use_Icons : Boolean);

712.        --  Set whether drag icons are shown while the user is reordering the list.

713.        --  The default value is True.

715.        procedure Set_Button_ActionsTo API docTo body

716.          (Clist         : access Gtk_Clist_RecordTo API docTo specTo body;

717.           Button        : GuintTo API docTo spec;

718.           Button_Action : Gtk_Button_ActionTo API docTo spec);

719.        --  Set the action for a specific button on the list.

720.        --  The default if for the left mouse button to select or drag and item,

721.        --  the other buttons are ignored.

722.        --  The Button_Expands action has no effect on a clist.

724.        procedure MovetoTo API docTo body

725.          (Clist     : access Gtk_Clist_RecordTo API docTo specTo body;

726.           Row       : in GintTo API docTo spec;

727.           Column    : in GintTo API docTo spec;

728.           Row_Align : in GfloatTo API docTo spec;

729.           Col_Align : in GfloatTo API docTo spec);

730.        --  Scroll the list so that Row/Column is visible.

731.        --  If Row is -1, the clist is not scrolled vertically.

732.        --  If Column is -1, the clist is not scrolled horizontally.

733.        --  The new location of Row/Column depends on the value of Row_Align and

734.        --  Col_Align (from 0.0x0.0 (top-left) to 1.0x1.0 (bottom-right), all

735.        --  intermediate values are possible).

737.        ---------------

738.        -- Row_Data --

739.        ---------------

740.        --  You can associate one private data with each row in the clist. If you

741.        --  want to store multiple values, you should create a record type that

742.        --  contains all the values, and associate with value with the relevant

743.        --  line in the clist.

744.        --  This package is the equivalent of Gtk.Widget.User_Data for the Clists.

745.        --

746.        --  This is your responsibility to use the Get and Set functions from the

747.        --  same generic package. However, you can use different packages for

748.        --  different lines (although this will definitely make things harder to

749.        --  use!)

750.        --

751.        --  Note also that an internal copy of the Data is done, therefore the

752.        --  "find" functions found in gtk+ have no equivalent in GtkAda, although it

753.        --  would be enough to write one by iterating over the Row numbers.

755.        generic

756.           --  <doc_ignore>

757.           type Data_Type (<>) is private;

758.           --  </doc_ignore>

759.        package Row_DataTo API docTo body is

760.           function GetTo API docTo body

761.             (Object : access Gtk_Clist_RecordTo API docTo specTo body'Class;

762.              Row    : in     GintTo API docTo spec) return Data_TypeTo API docTo spec;

763.           --  Get the data associated to a specific row.

765.           function GetTo API docTo body

766.             (Object : access Gtk_Clist_RecordTo API docTo specTo body'Class;

767.              Row    : in     Gtk_Clist_RowTo API docTo spec) return Data_TypeTo API docTo spec;

768.           --  Same as above, but acts directly on a row obtained through

769.           --  Get_Row_List. This is faster for big lists.

771.           procedure SetTo API docTo body

772.             (Object : access Gtk_Clist_RecordTo API docTo specTo body'Class;

773.              Row    : in GintTo API docTo spec;

774.              Data   : in Data_TypeTo API docTo spec);

775.           --  Modify the data associated with a row

777.           procedure SetTo API docTo body

778.             (Object : access Gtk_Clist_RecordTo API docTo specTo body'Class;

779.              Row    : in Gtk_Clist_RowTo API docTo spec;

780.              Data   : in Data_TypeTo API docTo spec);

781.           --  Same as above but acts directly on a row obtained through

782.           --  Get_Row_List. This is faster for big lists.

784.        private

785.           --  <doc_ignore>

786.           procedure Free_Data (Data : System.Address);

787.           --  Free memory associated with Data

788.           pragma Convention (C, Free_Data);

789.           --  </doc_ignore>

790.        end Row_DataTo API docTo specTo body;

792.        --  <doc_ignore>

793.        procedure Set_Show_TitlesTo API docTo body (Clist : access Gtk_Clist_RecordTo API docTo specTo body; Show : Boolean);

794.        --  If show is true, call Column_Titles_Show. Do nothing otherwise.

795.        --  This procedure is primarily used by Gate generated code.

796.        --  </doc_ignore>

798.        ----------------

799.        -- Properties --

800.        ----------------

802.        --  <properties>

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

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

805.        --

806.        --  </properties>

808.        -------------

809.        -- Signals --

810.        -------------

812.        --  <signals>

813.        --  The following new signals are defined for this widget:

814.        --

815.        --  - "select_row"

816.        --    procedure Handler (Clist  : access Gtk_Clist_Record'Class;

817.        --                       Row    : Gint;

818.        --                       Column : Gint;

819.        --                       Event  : Gdk.Event.Gdk_Event);

820.        --

821.        --    Emitted when a row is selected. Column contains the column number in

822.        --    which the user has clicked, or -1 if the selection was done internally

823.        --    by GtkAda.

824.        --    Event will be null if the selection was not triggered by an event, eg

825.        --    if the row was selected through a call to Select_Row.

826.        --

827.        --  - "unselect_row"

828.        --    procedure Handler (Clist  : access Gtk_Clist_Record'Class;

829.        --                       Row    : Gint;

830.        --                       Column : Gint;

831.        --                       Event  : Gdk.Event.Gdk_Event);

832.        --

833.        --    Emitted to request the unselection of a row. Event will be null most

834.        --    of the time when the event is emitted directly by GtkAda. You should

835.        --    use Unselect_Row instead.

836.        --

837.        --  - "row_move"

838.        --    procedure Handler (Clist      : access Gtk_Clist_Record'Class;

839.        --                       Source_Row : Gint;

840.        --                       Dest_Row   : Gint);

841.        --

842.        --    Emitted to request the change of a Source_Row to Dest_Row. You should

843.        --    use Row_Move instead.

844.        --

845.        --  - "click_column"

846.        --    procedure Handler (Clist  : access Gtk_Clist_Record'Class;

847.        --                       Column : Gint);

848.        --

849.        --    Emitted when the user has clicked on one of the buttons at the top

850.        --    of a column. The first column has number 0.

851.        --

852.        --  - "resize_column"

853.        --    procedure Handler (Clist  : access Gtk_Clist_Record'Class;

854.        --                       Column : Gint;

855.        --                       Width  : Gint);

856.        --

857.        --    Emitted to request a new size for a given column. You should use

858.        --    Set_Column_Width instead.

859.        --

860.        --  - "toggle_focus_row"

861.        --    procedure Handler (Clist  : access Gtk_Clist_Record'Class);

862.        --

863.        --    Emitted to request the change of the selection status (selected/

864.        --    unselected) of the focus row. This signal is not emitted internally

865.        --    by GtkAda.

866.        --

867.        --  - "select_all"

868.        --    procedure Handler (Clist  : access Gtk_Clist_Record'Class);

869.        --

870.        --    Emitted to request the selection of all the rows in the Clist, if the

871.        --    selection mode allows. You should use Select_All instead.

872.        --

873.        --  - "unselect_all"

874.        --    procedure Handler (Clist  : access Gtk_Clist_Record'Class);

875.        --

876.        --    Emitted to request the unselection of all the rows in the Clist, if

877.        --    the selection mode is different from Browse. You should use

878.        --    Unselect_All instead.

879.        --

880.        --  - "undo_selection"

881.        --    procedure Handler (Clist  : access Gtk_Clist_Record'Class);

882.        --

883.        --    Emitted to request the cancellation of the last select/unselect

884.        --    operation. You should use Undo_Selection instead.

885.        --

886.        --  - "start_selection"

887.        --    procedure Handler (Clist  : access Gtk_Clist_Record'Class);

888.        --

889.        --    Request the start of the selection. This signal is not emitted

890.        --    internally by GtkAda, but acts as if the user had clicked on the

891.        --    focus row (the exact visual modification depends on the selection

892.        --    mode).

893.        --

894.        --  - "end_selection"

895.        --    procedure Handler (Clist  : access Gtk_Clist_Record'Class);

896.        --

897.        --    Ends the current selection process. This is never emitted internally

898.        --    by GtkAda, but acts as if the user had just released the mouse button.

899.        --

900.        --  - "toggle_add_mode"

901.        --    procedure Handler (Clist  : access Gtk_Clist_Record'Class);

902.        --

903.        --    Changes the add_mode for the clist (indicates whether the next line

904.        --    clicked on will be added to the selection or will replace it).

905.        --    This is never emitted internally by GtkAda.

906.        --

907.        --  - "extend_selection"

908.        --    procedure Handler (Clist       : access Gtk_Clist_Record'Class;

909.        --                       Scroll_Type : Gtk.Enums.Gtk_Scroll_Type;

910.        --                       Position    : Gfloat;

911.        --                       Auto_Start_Selection : Boolean);

912.        --

913.        --    Extends the current selection. Position is used only for certain

914.        --    values of Scroll_Type. It is never emitted internally by GtkAda. It

915.        --    has no effect if the selection mode is not Extended.

916.        --

917.        --  - "scroll_vertical"

918.        --    procedure Handler (Clist       : access Gtk_Clist_Record'Class;

919.        --                       Scroll_Type : Gtk.Enums.Gtk_Scroll_Type;

920.        --                       Position    : Gfloat);

921.        --

922.        --    Scrolls the clist vertically. This also modifies the selection.

923.        --    It is never emitted internally by GtkAda. You should consider using

924.        --    Moveto instead.

925.        --

926.        --  - "scroll_horizontal"

927.        --    procedure Handler (Clist       : access Gtk_Clist_Record'Class;

928.        --                       Scroll_Type : Gtk.Enums.Gtk_Scroll_Type;

929.        --                       Position    : Gfloat);

930.        --

931.        --    Scrolls the clist horizontally. This also modifies the selection.

932.        --    It is never emitted internally by GtkAda. You should consider using

933.        --    Moveto instead.

934.        --

935.        --  - "abort_column_resize"

936.        --    procedure Handler (Clist       : access Gtk_Clist_Record'Class);

937.        --

938.        --    Aborts the current interactive resizing of the column by the user.

939.        --    This releases the grab done on the pointer. It is never emitted

940.        --    internally by GtkAda.

941.        --

942.        --  </signals>

944.        Signal_Abort_Column_Resize    : constant Glib.Signal_NameTo API docTo spec :=

945.                                          "abort_column_resize";

946.        Signal_Click_Column           : constant Glib.Signal_NameTo API docTo spec :=

947.                                          "click_column";

948.        Signal_End_Selection          : constant Glib.Signal_NameTo API docTo spec :=

949.                                          "end_selection";

950.        Signal_Extend_Selection       : constant Glib.Signal_NameTo API docTo spec :=

951.                                          "extend_selection";

952.        Signal_Resize_Column          : constant Glib.Signal_NameTo API docTo spec :=

953.                                          "resize_column";

954.        Signal_Row_Move               : constant Glib.Signal_NameTo API docTo spec :=

955.                                          "row_move";

956.        Signal_Scroll_Horizontal      : constant Glib.Signal_NameTo API docTo spec :=

957.                                          "scroll_horizontal";

958.        Signal_Scroll_Vertical        : constant Glib.Signal_NameTo API docTo spec :=

959.                                          "scroll_vertical";

960.        Signal_Select_All             : constant Glib.Signal_NameTo API docTo spec :=

961.                                          "select_all";

962.        Signal_Select_Row             : constant Glib.Signal_NameTo API docTo spec :=

963.                                          "select_row";

964.        Signal_Set_Scroll_Adjustments : constant Glib.Signal_NameTo API docTo spec :=

965.                                          "set_scroll_adjustments";

966.        Signal_Start_Selection        : constant Glib.Signal_NameTo API docTo spec :=

967.                                          "start_selection";

968.        Signal_Toggle_Add_Mode        : constant Glib.Signal_NameTo API docTo spec :=

969.                                          "toggle_add_mode";

970.        Signal_Toggle_Focus_Row       : constant Glib.Signal_NameTo API docTo spec :=

971.                                          "toggle_focus_row";

972.        Signal_Undo_Selection         : constant Glib.Signal_NameTo API docTo spec :=

973.                                          "undo_selection";

974.        Signal_Unselect_All           : constant Glib.Signal_NameTo API docTo spec :=

975.                                          "unselect_all";

976.        Signal_Unselect_Row           : constant Glib.Signal_NameTo API docTo spec :=

977.                                          "unselect_row";

979.     private

980.        type Gtk_Clist_RecordTo API docTo spec is new Gtk.Container.Gtk_Container_RecordTo API docTo specTo body with record

981.           Sort_Func : Gtk_Clist_Compare_FuncTo API docTo spec := null;

982.        end record;

984.        pragma Import (C, Get_TypeTo API docTo spec, "gtk_clist_get_type");

985.     end Gtk.ClistTo API docTo specTo body;

987.     --  <example>

988.     --  <include>../examples/documentation/clist.adb</include>

989.     --  </example>

991.     --  The following subprograms never had a binding, and are now obsolescent:

992.     --  No binding: gtk_clist_find_row_from_data

993.     --  No binding: gtk_clist_set_row_data