## Documentation

Table of Contents
Class Inheritance Tree
Widget Screenshots
Package groups

1.     -----------------------------------------------------------------------

2.     --              GtkAda - Ada95 binding for Gtk+/Gnome                --

3.     --                                                                   --

4.     --                 Copyright (C) 2001-2013, AdaCore                  --

5.     --                                                                   --

6.     -- This library is free software; you can redistribute it and/or     --

7.     -- modify it under the terms of the GNU General Public               --

8.     -- License as published by the Free Software Foundation; either      --

9.     -- version 2 of the License, or (at your option) any later version.  --

10.     --                                                                   --

11.     -- This library is distributed in the hope that it will be useful,   --

12.     -- but WITHOUT ANY WARRANTY; without even the implied warranty of    --

13.     -- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU --

14.     -- General Public License for more details.                          --

15.     --                                                                   --

16.     -- You should have received a copy of the GNU General Public         --

17.     -- License along with this library; if not, write to the             --

18.     -- Free Software Foundation, Inc., 59 Temple Place - Suite 330,      --

19.     -- Boston, MA 02111-1307, USA.                                       --

20.     --                                                                   --

21.     -- As a special exception, if other files instantiate generics from  --

22.     -- this unit, or you link this unit with other files to produce an   --

23.     -- executable, this  unit  does not  by itself cause  the resulting  --

24.     -- executable to be covered by the GNU General Public License. This  --

25.     -- exception does not however invalidate any other reasons why the   --

26.     -- executable file  might be covered by the  GNU Public License.     --

27.     -----------------------------------------------------------------------

29.     --  <description>

30.     --  General organization of the tree_view widgets:

31.     --

32.     --  <example>

33.     --    ______________Tree_View___________________________________

34.     --   |   _________________________     ________________________|

35.     --   |  |_____Tree_View_Column1__|    |___Tree_View_Column2 __||

36.     --   |  |                        |    |                       ||

37.     --   |  |  ----------- ---------||    |                       ||

38.     --   |  |  |Renderer1| |render2 ||    |                       ||

39.     --   |  |  |         | |        ||    |                       ||

40.     --   |  |  |         | |        ||    |                       ||

41.     --   |  |  |         | |        ||    |                       ||

42.     --   |  |  |---------| |--------||    |                       ||

43.     --   |  |________________________|    |_______________________||

44.     --   |_________________________________________________________|

45.     --

46.     --  </example>

47.     --  A tree view can contain multiple physical columns on the screen. These

48.     --  columns can have a button at the top, typically to force an ordering

49.     --  of the tree). They can also be reorganized interactively by the user.

50.     --

51.     --  Each physical column can display several information, like buttons,

52.     --  strings, ... Each of this display comes from a cell_renderer, that displays

53.     --  some data it reads from the model associated with the tree_view.

54.     --

55.     --  The renderers are then divided into lines, which are typically pointed to

56.     --  by iterators (Gtk_Tree_Iter).

57.     --  </description>

58.     --  <c_version>2.8.17</c_version>

59.     --  <group>Trees and Lists</group>

61.     with Glib.PropertiesTo API docTo specTo body;

62.     with Glib.Generic_PropertiesTo API docTo specTo body;

63.     with Glib.ObjectTo API docTo specTo body;

64.     with Gdk.RectangleTo API docTo specTo body;

65.     with GtkTo API docTo spec;

66.     with Gtk.Cell_RendererTo API docTo specTo body;

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

68.     with Gtk.Tree_ModelTo API docTo specTo body;

69.     with Gtk.WidgetTo API docTo specTo body;

71.     with Glib.GlistTo API docTo specTo body;

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

73.     with Ada.Unchecked_Conversion;

75.     package Gtk.Tree_View_ColumnTo API docTo specTo body is

77.        type Gtk_Tree_View_Column_RecordTo API docTo body is

78.          new Glib.Object.GObject_RecordTo API docTo specTo body with private;

79.        type Gtk_Tree_View_Column is access all Gtk_Tree_View_Column_RecordTo API docTo specTo body'Class;

81.        function Convert is new Ada.Unchecked_Conversion

82.          (Gtk_Tree_View_ColumnTo API docTo spec, System.Address);

83.        function Convert is new Ada.Unchecked_Conversion

84.          (System.Address, Gtk_Tree_View_ColumnTo API docTo spec);

85.        package Column_List is new Glib.Glist.Generic_ListTo API docTo specTo body (Gtk_Tree_View_ColumnTo API docTo spec);

87.        type Gtk_Tree_View_Column_Sizing is

88.          (Tree_View_Column_Grow_Only,

89.           Tree_View_Column_Autosize,

90.           Tree_View_Column_Fixed);

91.        pragma Convention (C, Gtk_Tree_View_Column_SizingTo API docTo spec);

93.        procedure Gtk_NewTo API docTo body (Widget : out Gtk_Tree_View_ColumnTo API docTo spec);

94.        procedure InitializeTo API docTo body (Widget : access Gtk_Tree_View_Column_RecordTo API docTo specTo body'Class);

95.        --  Creates or initializes a new Gtk_Tree_View_Column.

97.        function Get_TypeTo API docTo body return Glib.GTypeTo API docTo spec;

98.        --  Return the internal value associated with this widget.

100.        --  function Get_Tree_View

101.        --    (Tree_Column : access Gtk_Tree_View_Column_Record)

102.        --     return Gtk_Tree_View;

103.        --  Returns the Gtk_Tree_View wherein Tree_Column has been inserted.

104.        --  This function has been relocated to the Gtk.Tree_View package to

105.        --  avoid a dependency circularity.

107.        ---------------------------------------

108.        -- Visual representation of the data --

109.        ---------------------------------------

110.        --  All the cells in a column have a similar graphical representation. This

111.        --  could be either a simple text, an editable text, a toggle button, ...

112.        --  This visual representation is independent from the actual data to

113.        --  represent. For instance, the same data from the model could be used for

114.        --  two different columns, once for a text and once for a button.

115.        --

116.        --  The visual representation is specified through a "renderer". See the

117.        --  various Gtk.Cell_Renderer* packages for more information on the

118.        --  available renderers.

119.        --

120.        --  Note that the same renderer can be used for multiple columns, even

121.        --  though its properties can be different each time. This means that for

122.        --  instance you can instantiate only one Gtk_Cell_Renderer_Text, and use it

123.        --  for all the columns that need to display text.

125.        procedure Pack_StartTo API docTo body

126.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body;

127.           Cell        : access Gtk.Cell_Renderer.Gtk_Cell_Renderer_RecordTo API docTo specTo body'Class;

128.           Expand      : Boolean);

129.        --  Add a renderer to the Tree_Column.

130.        --  Multiple renderers can be put in a specific column, and each of them can

131.        --  be associated with different data from the model. This provides a very

132.        --  powerful way to display different data in the same column.

134.        procedure Pack_EndTo API docTo body

135.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body;

136.           Cell        : access Gtk.Cell_Renderer.Gtk_Cell_Renderer_RecordTo API docTo specTo body'Class;

137.           Expand      : Boolean);

138.        --  Same as the above. See the description of Pack_Start and Pack_End in

139.        --  Gtk.Box for the precise difference between the two

141.        procedure ClearTo API docTo body (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body);

142.        --  Remove all the renderers set in the column.

143.        --  The column will always be empty until you put some new renderers.

145.        function Get_Cell_RenderersTo API docTo body

146.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body)

147.           return Gtk.Cell_Renderer.Cell_Renderer_List.GlistTo API docTo specTo body;

148.        pragma Obsolescent (Get_Cell_RenderersTo API docTo specTo body);

149.        --  Return the list of cell renderers set in the column. The returned list

150.        --  must be freed by the caller.

152.        ------------------------------------

153.        -- Specifying the data to display --

154.        ------------------------------------

155.        --  The data to display in a column is always read from the model associated

156.        --  with the tree. In some cases (like if you are using the Gtk_Tree_Store

157.        --  model), this means that is has to be physically stored in a data

158.        --  structure. However, if you define your own models, you could also

159.        --  compute it on the fly.

160.        --

161.        --  For instance, if you have a database that contains some distance and

162.        --  time information, and you want to display the speed in a tree view: if

163.        --  you are using a Gtk_Tree_Store model, you have to create a third column

164.        --  in the model to store the string, and have a renderer point to that

165.        --  third column.

166.        --

167.        --  However, if you are using your own model, it is conceivable that the

168.        --  speed is computed on the fly from the distance and time.

169.        --

170.        --  The subprograms below use two or three parameters to precisely identify

171.        --  the part of the tree they impact: the column, the renderer in the

172.        --  column, and in some cases the specific line.

173.        --

174.        --  A renderer is always associated with a column in the model (even if that

175.        --  is a virtual column not associated with physical data). This is done

176.        --  through the Add_Attribute subprogram. This will read the data from the

177.        --  model. The type of the data read depends on the type of the column in

178.        --  the model.

179.        --  The type of data that Add_Attribute excepts to find in the column is

180.        --  documented in the packages for each of the renderer.

182.        procedure Add_AttributeTo API docTo body

183.          (Tree_Column   : access Gtk_Tree_View_Column_RecordTo API docTo specTo body;

184.           Cell_Renderer : access Gtk.Cell_Renderer.Gtk_Cell_Renderer_RecordTo API docTo specTo body'Class;

185.           Attribute     : String;

186.           Column        : GintTo API docTo spec);

187.        --  Add an attribute mapping to the list in Tree_Column.

188.        --  The Column is the column of the model to get a value from, and the

189.        --  Attribute is the parameter on Cell_Renderer to be set from the value. So

190.        --  for example if column 2 of the model contains strings, you could have

191.        --  the "text" attribute of a Gtk_Cell_Renderer_Text get its values from

192.        --  column 2.

193.        --

194.        --  For a list of properties available for each Cell_Renderer, please

195.        --  refer to the corresponding package specifications.

196.        --

197.        --  See also the function Set_Cell_Data_Func for another way to query the

198.        --  data to display in the tree.

200.        type Cell_Data_Func is access procedure

201.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body'Class;

202.           Cell        : access Gtk.Cell_Renderer.Gtk_Cell_Renderer_RecordTo API docTo specTo body'Class;

203.           Model       : access Gtk.Tree_Model.Gtk_Tree_Model_RecordTo API docTo specTo body'Class;

204.           Iter        : Gtk.Tree_Model.Gtk_Tree_IterTo API docTo specTo body);

205.        --  This subprogram can be used to globally modify an attribute of the

206.        --  Cell renderer.

207.        --  It is called every time some event happens in the tree (a line was

208.        --  clicked, the mouse moved into or out of a line,...). Iter and

209.        --  Tree_Column point to the location in the tree that received the event.

211.        procedure Set_Cell_Data_FuncTo API docTo body

212.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body;

213.           Cell        : access Gtk.Cell_Renderer.Gtk_Cell_Renderer_RecordTo API docTo specTo body'Class;

214.           Func        : Cell_Data_FuncTo API docTo spec);

215.        --  Set the function to use for the column.

216.        --  This function is used instead of the standard attributes mapping for

217.        --  setting the column value, and should set the value of Tree_Column's cell

218.        --  renderer as appropriate.

219.        --  Func may be null to remove an older one.

220.        --  It should be used when values from the model should be computed from

221.        --  application-specific data structures rather than stored in the model.

223.        generic

224.           type Data_Type (<>) is private;

225.        package Cell_Data_FunctionsTo API docTo body is

226.           type Cell_Data_Func is access procedure

227.             (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body'Class;

228.              Cell        : access Gtk.Cell_Renderer.Gtk_Cell_Renderer_RecordTo API docTo specTo body'Class;

229.              Model       : access Gtk.Tree_Model.Gtk_Tree_Model_RecordTo API docTo specTo body'Class;

230.              Iter        : Gtk.Tree_Model.Gtk_Tree_IterTo API docTo specTo body;

231.              Data        : Data_TypeTo API docTo spec);

233.           procedure Set_Cell_Data_FuncTo API docTo body

234.             (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body'Class;

235.              Cell        : access Gtk.Cell_Renderer.Gtk_Cell_Renderer_RecordTo API docTo specTo body'Class;

236.              Func        : Cell_Data_FuncTo API docTo spec;

237.              Data        : Data_TypeTo API docTo spec);

239.        private

240.           --  <doc_ignore>

241.           type Data_Type_Access is access Data_TypeTo API docTo spec;

243.           type Data_Type_Record is record

244.              Func : Cell_Data_FuncTo API docTo spec;

245.              Data : Data_Type_Access;

246.           end record;

247.           type Data_Type_Record_Access is access Data_Type_Record;

248.           pragma Convention (C, Data_Type_Record_Access);

250.           procedure Internal_Destroy_Notify (Data : Data_Type_Record_Access);

251.           pragma Convention (C, Internal_Destroy_Notify);

253.           procedure Internal_Data_Cell_Data_Func

254.             (Tree_Column, Cell, Model, Iter : System.Address;

255.              Data : Data_Type_Record_Access);

256.           pragma Convention (C, Internal_Data_Cell_Data_Func);

257.           --  </doc_ignore>

258.        end Cell_Data_FunctionsTo API docTo specTo body;

260.        procedure Clear_AttributesTo API docTo body

261.          (Tree_Column   : access Gtk_Tree_View_Column_RecordTo API docTo specTo body;

262.           Cell_Renderer : access Gtk.Cell_Renderer.Gtk_Cell_Renderer_RecordTo API docTo specTo body'Class);

263.        --  Clear all existing attributes previously set with

264.        --  Gtk.Tree_View_Column.Set_Attributes.

266.        ------------------------------------------

267.        -- Options for manipulating the columns --

268.        ------------------------------------------

270.        procedure Set_SpacingTo API docTo body

271.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body;

272.           Spacing     : GintTo API docTo spec);

273.        function Get_SpacingTo API docTo body

274.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body) return GintTo API docTo spec;

275.        --  Set the spacing field of Tree_Column.

276.        --  The spacing field is the number of pixels to place between cell

277.        --  renderers packed into it.

279.        procedure Set_VisibleTo API docTo body

280.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body;

281.           Visible     : Boolean);

282.        function Get_VisibleTo API docTo body

283.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body) return Boolean;

284.        --  Set the visibility of Tree_Column.

286.        procedure Set_ResizableTo API docTo body

287.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body;

288.           Resizable   : Boolean);

289.        function Get_ResizableTo API docTo body

290.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body) return Boolean;

291.        --  Set whether the Tree_Column is resizable.

293.        procedure Set_SizingTo API docTo body

294.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body;

295.           The_TypeTo API docTo body    : Gtk_Tree_View_Column_SizingTo API docTo spec);

296.        function Get_SizingTo API docTo body

297.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body)

298.           return Gtk_Tree_View_Column_SizingTo API docTo spec;

299.        --  Set the growth behavior of Tree_Column to The_Type.

301.        function Get_WidthTo API docTo body

302.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body) return GintTo API docTo spec;

303.        --  Return the current size of the Tree_Column in pixels.

305.        procedure Queue_ResizeTo API docTo body

306.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body);

307.        --  Flags the column, and the cell renderers added to this column, to have

308.        --  their sizes renegotiated.

310.        procedure Set_Fixed_WidthTo API docTo body

311.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body;

312.           Fixed_Width : GintTo API docTo spec);

313.        function Get_Fixed_WidthTo API docTo body

314.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body) return GintTo API docTo spec;

315.        --  Set the size of the column in pixels.

316.        --  This is meaningful only if the sizing type is

317.        --  Gtk_Tree_View_Column_Fixed. In this case, the value is discarded as the

318.        --  size of the column is based on the calculated width of the column. The

319.        --  width is clamped to the min/max width for the column.

320.        --  The value returned by Get_Fixed_width may not be the actual width of the

321.        --  column on the screen, just what is requested.

323.        procedure Set_Min_WidthTo API docTo body

324.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body;

325.           Min_Width   : GintTo API docTo spec);

326.        function Get_Min_WidthTo API docTo body

327.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body) return GintTo API docTo spec;

328.        --  Set the minimum width of the Tree_Column.

329.        --  If Min_Width is -1, then the minimum width is unset.

331.        procedure Set_Max_WidthTo API docTo body

332.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body;

333.           Max_Width   : GintTo API docTo spec);

334.        function Get_Max_WidthTo API docTo body

335.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body) return GintTo API docTo spec;

336.        --  Set the maximum width of the Tree_Column.

337.        --  If Max_Width is -1, then the maximum width is unset.

338.        --  Note, the column can actually be wider than max width if it's the last

339.        --  column in a view. In this case, the column expands to fill the view.

341.        procedure ClickedTo API docTo body (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body);

342.        --  Emit the "clicked" signal on the column.

343.        --  This function will only work if the user could have conceivably clicked

344.        --  on the button.

346.        procedure Set_ExpandTo API docTo body

347.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body; Expand : Boolean);

348.        function Get_ExpandTo API docTo body

349.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body) return Boolean;

350.        --  Sets the column to take available extra space. This space is shared

351.        --  equally amongst all columns that have the expand set to TRUE. If no

352.        --  column has this option set, then the last column gets all extra space.

353.        --  By default, every column is created with this FALSE.

355.        procedure Set_TitleTo API docTo body

356.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body;

357.           Title       : UTF8_StringTo API docTo spec);

358.        function Get_TitleTo API docTo body

359.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body) return UTF8_StringTo API docTo spec;

360.        --  Set the title of the Tree_Column.

361.        --  If a custom widget has been set, then this value is ignored.

363.        procedure Set_ClickableTo API docTo body

364.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body;

365.           Clickable   : Boolean);

366.        function Get_ClickableTo API docTo body

367.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body) return Boolean;

368.        --  Set the header to be active if Active is True.

369.        --  When the header is active, then it can take keyboard focus, and can be

370.        --  clicked.

372.        procedure Set_WidgetTo API docTo body

373.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body;

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

375.        function Get_WidgetTo API docTo body

376.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body)

377.            return Gtk.Widget.Gtk_WidgetTo API docTo spec;

378.        --  Return the Gtk_Widget in the button in the column header.

379.        --  If a custom widget has not been set, then this will be a Gtk_Alignment

380.        --  with a Gtk_Label in it.

382.        procedure Set_AlignmentTo API docTo body

383.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body;

384.           Xalign      : GfloatTo API docTo spec);

385.        function Get_AlignmentTo API docTo body

386.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body) return GfloatTo API docTo spec;

387.        --  Set the alignment of the title or custom widget inside the column header

388.        --  The alignment determines its location inside the button

389.        --  0.0 for left, 0.5 for center, 1.0 for right.

391.        procedure Set_ReorderableTo API docTo body

392.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body;

393.           Reorderable : Boolean);

394.        function Get_ReorderableTo API docTo body

395.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body) return Boolean;

396.        --  Whether this column can be drag-and-dropped to some other place in the

397.        --  tree.

399.        procedure Set_Sort_Column_IdTo API docTo body

400.          (Tree_Column    : access Gtk_Tree_View_Column_RecordTo API docTo specTo body;

401.           Sort_Column_Id : GintTo API docTo spec);

402.        function Get_Sort_Column_IdTo API docTo body

403.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body) return GintTo API docTo spec;

404.        --  Set the logical model columns that this column sorts on when this

405.        --  column is selected for sorting. Doing so makes the column header

406.        --  clickable.

407.        --  Get_Sort_Column_Id returns -1 if this column can't be used for sorting.

409.        procedure Set_Sort_IndicatorTo API docTo body

410.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body;

411.           Setting     : Boolean);

412.        function Get_Sort_IndicatorTo API docTo body

413.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body) return Boolean;

414.        --  Call this function with a Setting of True to display an arrow in

415.        --  the header button indicating the column is sorted. Call

416.        --  Set_Sort_Order to change the direction of the arrow.

418.        procedure Set_Sort_OrderTo API docTo body

419.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body;

420.           OrderTo API docTo body       : Gtk_Sort_TypeTo API docTo spec);

421.        function Get_Sort_OrderTo API docTo body

422.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body) return Gtk_Sort_TypeTo API docTo spec;

423.        --  Change the appearance of the sort indicator.

424.        --  This does *not* actually sort the model. Use

425.        --  Gtk.Tree_View_Column.Set_Sort_Column_Id if you want automatic sorting

426.        --  support. This function is primarily for custom sorting behavior, and

427.        --  should be used in conjunction with Gtk.Tree_Sortable.Set_Sort_Column

428.        --  to do that. For custom models, the mechanism will vary. The sort

429.        --  indicator changes direction to indicate normal sort or reverse sort.

430.        --  Note that you must have the sort indicator enabled to see anything

431.        --  when calling this function; see Set_Sort_Indicator.

433.        procedure Cell_Set_Cell_DataTo API docTo body

434.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body;

435.           Tree_Model  : access Gtk.Tree_Model.Gtk_Tree_Model_RecordTo API docTo specTo body'Class;

436.           IterTo API docTo body        : Gtk.Tree_Model.Gtk_Tree_IterTo API docTo specTo body;

437.           Is_Expander : Boolean;

438.           Is_Expanded : Boolean);

439.        --  Set the cell renderer based on the Tree_Model and Tree_Node.

440.        --  That is, for every attribute mapping in Tree_Column, it will get a

441.        --  value from the set column on the Tree_Node, and use that value to

442.        --  set the attribute on the cell renderer.  This is used primarily by

443.        --  the Gtk_Tree_View.

445.        procedure Cell_Get_SizeTo API docTo body

446.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body;

447.           Cell_AreaTo API docTo body   : Gdk.Rectangle.Gdk_RectangleTo API docTo spec;

448.           X_Offset    : out GintTo API docTo spec;

449.           Y_Offset    : out GintTo API docTo spec;

450.           Width       : out GintTo API docTo spec;

451.           Height      : out GintTo API docTo spec);

452.        --  Obtain the width and height needed to render the column.

453.        --  This is used primarily by the Gtk_Tree_View.

455.        function Cell_Is_VisibleTo API docTo body

456.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body) return Boolean;

457.        --  Returns true if any of the cells packed in the column is visible

459.        procedure Cell_Get_PositionTo API docTo body

460.          (Tree_Column   : access Gtk_Tree_View_Column_RecordTo API docTo specTo body;

461.           Cell_Renderer : access Gtk.Cell_Renderer.Gtk_Cell_Renderer_RecordTo API docTo specTo body'Class;

462.           Start_Pos     : out GintTo API docTo spec;

463.           Width         : out GintTo API docTo spec;

464.           Success       : out Boolean);

465.        --  Obtains the horizontal position and size of a cell in a column. If the

466.        --  cell is not found in the column, start_pos and width are not changed

467.        --  and FALSE is returned.

469.        procedure Focus_CellTo API docTo body

470.          (Tree_Column : access Gtk_Tree_View_Column_RecordTo API docTo specTo body;

471.           Cell        : access Gtk.Cell_Renderer.Gtk_Cell_Renderer_RecordTo API docTo specTo body'Class);

472.        --  Sets the current keyboard focus to be at Cell, if the column contains

473.        --  2 or more editable and activatable cells.

475.        ----------------

476.        -- Properties --

477.        ----------------

479.        --  <properties>

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

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

482.        --

483.        --  Name:  Alignment_Property

484.        --  Type:  Float

485.        --  Descr: X Alignment of the column header text or widget

486.        --

487.        --  Name:  Clickable_Property

488.        --  Type:  Boolean

489.        --  Descr: Whether the header can be clicked

490.        --

491.        --  Name:  Expand_Property

492.        --  Type:  Boolean

493.        --  Descr: Column gets share of extra width allocated to the widget

494.        --

495.        --  Name:  Fixed_Width_Property

496.        --  Type:  Int

497.        --  Descr: Current fixed width of the column

498.        --

499.        --  Name:  Max_Width_Property

500.        --  Type:  Int

501.        --  Descr: Maximum allowed width of the column

502.        --

503.        --  Name:  Min_Width_Property

504.        --  Type:  Int

505.        --  Descr: Minimum allowed width of the column

506.        --

507.        --  Name:  Reorderable_Property

508.        --  Type:  Boolean

509.        --  Descr: Whether the column can be reordered around the headers

510.        --

511.        --  Name:  Resizable_Property

512.        --  Type:  Boolean

513.        --  Descr: Column is user-resizable

514.        --

515.        --  Name:  Sizing_Property

516.        --  Type:  Enum

517.        --  Descr: Resize mode of the column

518.        --

519.        --  Name:  Sort_Indicator_Property

520.        --  Type:  Boolean

521.        --  Descr: Whether to show a sort indicator

522.        --

523.        --  Name:  Sort_Order_Property

524.        --  Type:  Enum

525.        --  Descr: Sort direction the sort indicator should indicate

526.        --

527.        --  Name:  Spacing_Property

528.        --  Type:  Int

529.        --  Descr: Space which is inserted between cells

530.        --

531.        --  Name:  Title_Property

532.        --  Type:  String

533.        --  Descr: Title to appear in column header

534.        --

535.        --  Name:  Visible_Property

536.        --  Type:  Boolean

537.        --  Descr: Whether to display the column

538.        --

539.        --  Name:  Widget_Property

540.        --  Type:  Object

541.        --  Descr: Widget to put in column header button instead of column title

542.        --

543.        --  Name:  Width_Property

544.        --  Type:  Int

545.        --  Descr: Current width of the column

546.        --

547.        --  </properties>

549.        package Column_Sizing_Properties is new

550.          Glib.Generic_Properties.Generic_Internal_Discrete_PropertyTo API docTo specTo body

551.            (Gtk_Tree_View_Column_SizingTo API docTo spec);

552.        type Property_Column_Sizing is new Column_Sizing_Properties.PropertyTo API docTo spec;

554.        Alignment_Property      : constant Glib.Properties.Property_FloatTo API docTo spec;

555.        Clickable_Property      : constant Glib.Properties.Property_BooleanTo API docTo spec;

556.        Expand_Property         : constant Glib.Properties.Property_BooleanTo API docTo spec;

557.        Fixed_Width_Property    : constant Glib.Properties.Property_IntTo API docTo spec;

558.        Max_Width_Property      : constant Glib.Properties.Property_IntTo API docTo spec;

559.        Min_Width_Property      : constant Glib.Properties.Property_IntTo API docTo spec;

560.        Reorderable_Property    : constant Glib.Properties.Property_BooleanTo API docTo spec;

561.        Resizable_Property      : constant Glib.Properties.Property_BooleanTo API docTo spec;

562.        Sizing_Property         : constant Property_Column_SizingTo API docTo spec;

563.        Sort_Indicator_Property : constant Glib.Properties.Property_BooleanTo API docTo spec;

564.        Sort_Order_Property     : constant Gtk.Enums.Property_Sort_TypeTo API docTo spec;

565.        Spacing_Property        : constant Glib.Properties.Property_IntTo API docTo spec;

566.        Title_Property          : constant Glib.Properties.Property_StringTo API docTo spec;

567.        Visible_Property        : constant Glib.Properties.Property_BooleanTo API docTo spec;

568.        Widget_Property         : constant Glib.Properties.Property_ObjectTo API docTo spec;

569.        Width_Property          : constant Glib.Properties.Property_IntTo API docTo spec;

571.        -------------

572.        -- Signals --

573.        -------------

575.        --  <signals>

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

577.        --

578.        --  - "clicked"

579.        --    procedure Handler (Widget : access Gtk_Tree_View_Column_Record'Class);

580.        --

581.        --  </signals>

583.        Signal_Clicked : constant Glib.Signal_NameTo API docTo spec := "clicked";

585.     private

586.        type Gtk_Tree_View_Column_RecordTo API docTo spec is

587.          new Glib.Object.GObject_RecordTo API docTo specTo body with null record;

589.           Alignment_PropertyTo API docTo spec : constant Glib.Properties.Property_FloatTo API docTo spec :=

590.          Glib.Properties.BuildTo API docTo specTo body ("alignment");

591.        Clickable_PropertyTo API docTo spec : constant Glib.Properties.Property_BooleanTo API docTo spec :=

592.          Glib.Properties.BuildTo API docTo specTo body ("clickable");

593.        Expand_PropertyTo API docTo spec : constant Glib.Properties.Property_BooleanTo API docTo spec :=

594.          Glib.Properties.BuildTo API docTo specTo body ("expand");

595.        Fixed_Width_PropertyTo API docTo spec : constant Glib.Properties.Property_IntTo API docTo spec :=

596.          Glib.Properties.BuildTo API docTo specTo body ("fixed-width");

597.        Max_Width_PropertyTo API docTo spec : constant Glib.Properties.Property_IntTo API docTo spec :=

598.          Glib.Properties.BuildTo API docTo specTo body ("max-width");

599.        Min_Width_PropertyTo API docTo spec : constant Glib.Properties.Property_IntTo API docTo spec :=

600.          Glib.Properties.BuildTo API docTo specTo body ("min-width");

601.        Reorderable_PropertyTo API docTo spec : constant Glib.Properties.Property_BooleanTo API docTo spec :=

602.          Glib.Properties.BuildTo API docTo specTo body ("reorderable");

603.        Resizable_PropertyTo API docTo spec : constant Glib.Properties.Property_BooleanTo API docTo spec :=

604.          Glib.Properties.BuildTo API docTo specTo body ("resizable");

605.        Sizing_PropertyTo API docTo spec : constant Property_Column_SizingTo API docTo spec :=

606.          BuildTo API docTo specTo body ("sizing");

607.        Sort_Indicator_PropertyTo API docTo spec : constant Glib.Properties.Property_BooleanTo API docTo spec :=

608.          Glib.Properties.BuildTo API docTo specTo body ("sort-indicator");

609.        Sort_Order_PropertyTo API docTo spec : constant Gtk.Enums.Property_Sort_TypeTo API docTo spec :=

610.          Gtk.Enums.BuildTo API docTo specTo body ("sort-order");

611.        Spacing_PropertyTo API docTo spec : constant Glib.Properties.Property_IntTo API docTo spec :=

612.          Glib.Properties.BuildTo API docTo specTo body ("spacing");

613.        Title_PropertyTo API docTo spec : constant Glib.Properties.Property_StringTo API docTo spec :=

614.          Glib.Properties.BuildTo API docTo specTo body ("title");

615.        Visible_PropertyTo API docTo spec : constant Glib.Properties.Property_BooleanTo API docTo spec :=

616.          Glib.Properties.BuildTo API docTo specTo body ("visible");

617.        Widget_PropertyTo API docTo spec : constant Glib.Properties.Property_ObjectTo API docTo spec :=

618.          Glib.Properties.BuildTo API docTo specTo body ("widget");

619.        Width_PropertyTo API docTo spec : constant Glib.Properties.Property_IntTo API docTo spec :=

620.          Glib.Properties.BuildTo API docTo specTo body ("width");

622.        pragma Import (C, Get_TypeTo API docTo spec, "gtk_tree_view_column_get_type");

623.     end Gtk.Tree_View_ColumnTo API docTo specTo body;

625.     --  No binding: gtk_tree_view_column_new_with_attributes

626.     --  No binding: gtk_tree_view_column_set_attributes

628.     --  Implemented in Gtk.Tree_View:

629.     --  No binding: gtk_tree_view_column_get_tree_view