## Documentation

Table of Contents
Class Inheritance Tree
Widget Screenshots
Package groups

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

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

3.     --                                                                   --

4.     --               Copyright (C) 2001-2011, 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.     --  The type Gtk_Tree_Model defined in this model defines an abstract interface

31.     --  to represent sets of data that will be displayed in a Gtk_Tree_View.

32.     --  Various default implementations are provided  in the Gtk.Tree_Store and

33.     --  Gtk.List_Store packages.

34.     --

35.     --  Data are considered as being organized into a tree-like structure.

36.     --

37.     --  This package also defines a number of other types to manipulate these

38.     --  models:

39.     --

40.     --  A Gtk_Tree_Path is a textual pointer to a specific row/node in the

41.     --  model. It is a column separate list of numbers, that indicate the index of

42.     --  the child they point to.

43.     --  For instance, "10:4:0" would points to the first (0) child of the fifth (4)

44.     --  child of the eleventh child of the root. The depth of this path is 3.

45.     --

46.     --  A Gtk_Tree_Iter is similar to a path, but is a direct pointer to the actual

47.     --  data. It is also more efficient to use than paths.

48.     --

49.     --  A Gtk_Row_Reference is an object that tracks model changes, so that it

50.     --  always refere to the same row. A Gtk_Tree_Path refers to a position in the

51.     --  model, not a fixed row.

52.     --

53.     --  </description>

54.     --  <c_version>2.8.17</c_version>

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

57.     with Ada.Unchecked_Conversion;

58.     with Glib.GlistTo API docTo specTo body;

59.     with Glib.ObjectTo API docTo specTo body;

60.     with Glib.ValuesTo API docTo specTo body;

62.     package Gtk.Tree_ModelTo API docTo specTo body is

64.        type Gtk_Tree_Model_RecordTo API docTo body is new Glib.Object.GObject_RecordTo API docTo specTo body

65.          with private;

66.        type Gtk_Tree_Model is access all Gtk_Tree_Model_RecordTo API docTo specTo body'Class;

67.        --  This is an abstract interface

69.        type Gtk_Tree_Path is new Glib.C_ProxyTo API docTo spec;

70.        type Gtk_Tree_IterTo API docTo body is private;

72.        type Tree_Model_Flags is mod 2 ** 32;

73.        Tree_Model_Iters_Persist : constant Tree_Model_FlagsTo API docTo spec;

74.        Tree_Model_List_Only     : constant Tree_Model_FlagsTo API docTo spec;

76.        -----------------

77.        -- Tree models --

78.        -----------------

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

81.        --  Return the internal value associated with a Gtk_Tree_Model.

83.        function Get_FlagsTo API docTo body (Model : access Gtk_Tree_Model_RecordTo API docTo specTo body)

84.           return Tree_Model_FlagsTo API docTo spec;

85.        --  Return a set of flags supported by this interface. The flags

86.        --  supported should not change during the lifecycle of the tree_model.

87.        --  The flags should not change in the lifetime of the model.

89.        function Get_N_ColumnsTo API docTo body (Tree_Model : access Gtk_Tree_Model_RecordTo API docTo specTo body)

90.          return GintTo API docTo spec;

91.        --  Return the number of columns supported by Tree_Model.

93.        function Get_Column_TypeTo API docTo body

94.          (Tree_Model : access Gtk_Tree_Model_RecordTo API docTo specTo body; Index : GintTo API docTo spec) return GTypeTo API docTo spec;

95.        --  Return the type of the Index-th column in the model.

97.        type Gtk_Tree_Model_Foreach_Func is access function

98.          (Model     : access Gtk_Tree_Model_RecordTo API docTo specTo body'Class;

99.           Path      : Gtk_Tree_PathTo API docTo spec;

100.           Iter      : Gtk_Tree_IterTo API docTo specTo body;

101.           User_Data : System.Address) return Boolean;

103.        procedure ForeachTo API docTo body

104.          (Model     : access Gtk_Tree_Model_RecordTo API docTo specTo body;

105.           Func      : Gtk_Tree_Model_Foreach_FuncTo API docTo spec;

106.           User_Data : System.Address);

107.        --  Calls func on each node in model in a depth-first fashion. If func

108.        --  returns True, then the tree ceases to be walked, and Foreach returns.

110.        ------------------------

111.        -- Paths manipulation --

112.        ------------------------

114.        function Gtk_NewTo API docTo body (Path : String := "") return Gtk_Tree_PathTo API docTo spec;

115.        --  Create a new Gtk_Tree_Path from a path string.

116.        --  Path should have the format described above, like "10:4:0". If it is the

117.        --  empty string, then a Gtk_Tree_Path of depth 0 is returned.

118.        --  The memory allocated for the path must be freed explicitely by calling

119.        --  Path_Free below.

121.        function Gtk_New_FirstTo API docTo body return Gtk_Tree_PathTo API docTo spec;

122.        --  Return a new path pointed to the first row in the model. The string

123.        --  representation is "0"

125.        function Path_Get_TypeTo API docTo body return Glib.GTypeTo API docTo spec;

126.        --  Return the internal type used for Gtk_Tree_Path

128.        function To_StringTo API docTo body (Path : Gtk_Tree_PathTo API docTo spec) return String;

129.        --  Generate a string representation of the path.

130.        --  This string is a colon-separated list of numbers, as described above.

132.        function Get_Tree_PathTo API docTo body (ValTo API docTo body : Glib.Values.GValueTo API docTo specTo body) return Gtk_Tree_PathTo API docTo spec;

133.        --  Extract the path from the given GValue.

135.        procedure Append_IndexTo API docTo body (Path : Gtk_Tree_PathTo API docTo spec; Index : GintTo API docTo spec);

136.        --  Append a new index to a path.

137.        --  As a result, the depth of the path is increased. See Path_Up for the

138.        --  opposite operation.

140.        procedure Prepend_IndexTo API docTo body (Path : Gtk_Tree_PathTo API docTo spec; Index : GintTo API docTo spec);

141.        --  Prepend a new index to a path.  As a result, the depth of the path is

142.        --  increased.

144.        function Get_DepthTo API docTo body (Path : Gtk_Tree_PathTo API docTo spec) return GintTo API docTo spec;

145.        --  Return the current depth of Path.

147.        function Get_IndicesTo API docTo body (Path : Gtk_Tree_PathTo API docTo spec) return Glib.Gint_ArrayTo API docTo spec;

148.        --  Return the list of indices from the path. This is an array of integers,

149.        --  each representing a node in a tree, as described in the path format.

151.        procedure Path_FreeTo API docTo body (Path : Gtk_Tree_PathTo API docTo spec);

152.        --  Free the memory allocated for Path.

154.        function CopyTo API docTo body (Path : Gtk_Tree_PathTo API docTo spec) return Gtk_Tree_PathTo API docTo spec;

155.        --  Create a new Gtk_Tree_Path as a copy of Path. The memory allocated for

156.        --  the new path must be freed by a call to Path_Free.

158.        function CompareTo API docTo body (A, B : Gtk_Tree_PathTo API docTo spec) return GintTo API docTo spec;

159.        --  Compare two paths.  If A appears before B in a tree, then -1 is

160.        --  returned.  If B appears before A, then 1 is returned.  If the two nodes

161.        --  are equal, then 0 is returned.

163.        procedure NextTo API docTo body (Path : Gtk_Tree_PathTo API docTo spec);

164.        --  Move the Path to point to the next node at the current depth. In effect,

165.        --  it increments the last indice of the path. Note that the path might

166.        --  become invalid if there is no more node at this depth.

168.        function PrevTo API docTo body (Path : Gtk_Tree_PathTo API docTo spec) return Boolean;

169.        --  Move Path to point to the previous node at the current depth,

170.        --  if it exists.

171.        --  Return True if Path has a previous node, and the move was made. If it

172.        --  returns False, then Path has not been changed.

174.        function UpTo API docTo body (Path : Gtk_Tree_PathTo API docTo spec) return Boolean;

175.        --  Moves the Path to point to it's parent node, if it has a parent.

176.        --  Return True if Path has a parent, and the move was made.

177.        --  In practice, the depth of Path is decreased by 1.

179.        procedure DownTo API docTo body (Path : Gtk_Tree_PathTo API docTo spec);

180.        --  Moves Path to point to the first child of the current path.

182.        function Is_AncestorTo API docTo body (Path, Descendant : Gtk_Tree_PathTo API docTo spec) return Boolean;

183.        --  Return True if Descendant is contained inside Path.

185.        function Is_DescendantTo API docTo body (Path, Ancestor : Gtk_Tree_PathTo API docTo spec) return Boolean;

186.        --  Return True if Path is contained inside Ancestor.

188.        function Convert is new Ada.Unchecked_Conversion

189.          (Gtk_Tree_PathTo API docTo spec, System.Address);

190.        function Convert is new Ada.Unchecked_Conversion

191.          (System.Address, Gtk_Tree_PathTo API docTo spec);

192.        package Gtk_Tree_Path_List is new Glib.Glist.Generic_ListTo API docTo specTo body (Gtk_Tree_PathTo API docTo spec);

194.        --------------------------------

195.        -- Row_Reference manipulation --

196.        --------------------------------

198.        type Gtk_Tree_Row_Reference is new Glib.C_ProxyTo API docTo spec;

200.        function Gtk_NewTo API docTo body

201.          (Model : access Gtk_Tree_Model_RecordTo API docTo specTo body;

202.           Path  : Gtk_Tree_PathTo API docTo spec)

203.           return Gtk_Tree_Row_ReferenceTo API docTo spec;

204.        --  Create a row reference based on Path. This reference will keep pointing

205.        --  to the node pointed to by Path, so long as it exists.  It listens to

206.        --  all signals on model, and updates it's path appropriately.  If Path

207.        --  isn't a valid path in Model, then null is returned.

209.        function Row_Reference_Get_TypeTo API docTo body return Glib.GTypeTo API docTo spec;

210.        --  Return the internal type used for row reference.

212.        function Get_PathTo API docTo body (Reference : Gtk_Tree_Row_ReferenceTo API docTo spec) return Gtk_Tree_PathTo API docTo spec;

213.        --  Return the path that Reference currently points to.

214.        --  null is returned if Reference is no longer valid.

215.        --  The caller must free the returned path.

217.        function ValidTo API docTo body (Reference : Gtk_Tree_Row_ReferenceTo API docTo spec) return Boolean;

218.        --  Return True if Reference is non null and is still valid.

220.        function Row_Reference_CopyTo API docTo body

221.          (Ref : Gtk_Tree_Row_ReferenceTo API docTo spec) return Gtk_Tree_Row_ReferenceTo API docTo spec;

222.        --  Return a newly allocated copy of Ref

224.        procedure Row_Reference_FreeTo API docTo body (Reference : Gtk_Tree_Row_ReferenceTo API docTo spec);

225.        --  Free the memory occupied by Reference.

227.        function Get_ModelTo API docTo body

228.          (Reference : Gtk_Tree_Row_ReferenceTo API docTo spec) return Gtk_Tree_ModelTo API docTo spec;

229.        --  Returns the model which Reference is monitoring in order to

230.        --  appropriately the path.

232.        ---------------

233.        -- Iterators --

234.        ---------------

235.        --  ??? Need to be able to access the user_data fields, so that new models

236.        --  can define their own iterators

238.        Null_IterTo API docTo body : constant Gtk_Tree_IterTo API docTo specTo body;

240.        function "="To API docTo body (LeftTo API docTo body : Gtk_Tree_IterTo API docTo specTo body; RightTo API docTo body : Gtk_Tree_IterTo API docTo specTo body) return Boolean;

242.        function Iter_Get_TypeTo API docTo body return Glib.GTypeTo API docTo spec;

243.        --  Return the internal type used for iterators

245.        procedure Iter_CopyTo API docTo body (Source : Gtk_Tree_IterTo API docTo specTo body; Dest : out Gtk_Tree_IterTo API docTo specTo body);

246.        --  Create a copy of Source.

247.        --  You can also copy tree iters simply by using the ":=" Ada construct.

249.        procedure Set_Tree_IterTo API docTo body

250.          (Val  : in out Glib.Values.GValueTo API docTo specTo body;

251.           Iter : Gtk_Tree_IterTo API docTo specTo body);

252.        --  Set the value of the given GValue to Iter.

253.        --  Note that Iter is stored by reference, which means no copy of Iter

254.        --  is made. Iter should remain allocated as long as Val is being used.

256.        procedure Get_Tree_IterTo API docTo body

257.          (ValTo API docTo body  : Glib.Values.GValueTo API docTo specTo body;

258.           IterTo API docTo body : out Gtk_Tree_IterTo API docTo specTo body);

259.        --  Extract the iterator from the given GValue.

260.        --  Note that the iterator returned is a copy of the iterator referenced

261.        --  by the give GValue. Modifying the iterator returned does not modify

262.        --  the iterator referenced by the GValue.

264.        function Get_Tree_IterTo API docTo body (ValTo API docTo body : Glib.Values.GValueTo API docTo specTo body) return Gtk_Tree_IterTo API docTo specTo body;

265.        --  Extract the iterator from the given GValue.

267.        function To_AddressTo API docTo body (IterTo API docTo body : Gtk_Tree_IterTo API docTo specTo body) return System.Address;

268.        --  Return address of the specified iterator.

270.        function Get_IterTo API docTo body

271.          (Tree_Model : access Gtk_Tree_Model_RecordTo API docTo specTo body;

272.           Path       : Gtk_Tree_PathTo API docTo spec) return Gtk_Tree_IterTo API docTo specTo body;

273.        --  Return an iterator pointing to Path.

274.        --  Null_Iter is returned if Path was invalid or no iterator could be set.

276.        function Get_Iter_From_StringTo API docTo body

277.          (Tree_Model  : access Gtk_Tree_Model_RecordTo API docTo specTo body;

278.           Path_String : String) return Gtk_Tree_IterTo API docTo specTo body;

279.        --  Return an iterator pointing to Path_String.

280.        --  Null_Iter is returned if Path was invalid or no iterator could be set.

282.        function Get_String_From_IterTo API docTo body

283.          (Tree_Model : access Gtk_Tree_Model_RecordTo API docTo specTo body;

284.           IterTo API docTo body       : Gtk_Tree_IterTo API docTo specTo body) return String;

285.        --  Generates a string representation of the iter. This string is a ':'

286.        --  separated list of numbers. For example, "4:10:0:3" would be an

287.        --  acceptable return value for this string.

289.        function Get_Iter_FirstTo API docTo body

290.          (Tree_Model : access Gtk_Tree_Model_RecordTo API docTo specTo body) return Gtk_Tree_IterTo API docTo specTo body;

291.        --  Return an iterator pointing to the root of Tree_Model.

292.        --  Null_Iter is returned if Tree_Model is empty.

294.        function Get_PathTo API docTo body

295.          (Tree_Model : access Gtk_Tree_Model_RecordTo API docTo specTo body;

296.           IterTo API docTo body       : Gtk_Tree_IterTo API docTo specTo body) return Gtk_Tree_PathTo API docTo spec;

297.        --  Return a newly created Gtk_Tree_Path referenced by Iter.

298.        --  This path must be freed with Path_Free.

300.        procedure NextTo API docTo body

301.          (Tree_Model : access Gtk_Tree_Model_RecordTo API docTo specTo body;

302.           IterTo API docTo body       : in out Gtk_Tree_IterTo API docTo specTo body);

303.        --  Sets Iter to point to the node following it at the current level.

304.        --  If there is none, Iter is set to Null_Iter.

306.        function ChildrenTo API docTo body

307.          (Tree_Model : access Gtk_Tree_Model_RecordTo API docTo specTo body;

308.           ParentTo API docTo body     : Gtk_Tree_IterTo API docTo specTo body) return Gtk_Tree_IterTo API docTo specTo body;

309.        --  Return the first child of Parent.

310.        --  If Parent has no children, return Null_Iter.

311.        --  Parent will remain a valid node after this function has been called.

313.        function Has_ChildTo API docTo body

314.          (Tree_Model : access Gtk_Tree_Model_RecordTo API docTo specTo body;

315.           IterTo API docTo body       : Gtk_Tree_IterTo API docTo specTo body) return Boolean;

316.        --  Return True if Iter has children, False otherwise.

318.        function N_ChildrenTo API docTo body

319.          (Tree_Model : access Gtk_Tree_Model_RecordTo API docTo specTo body;

320.           IterTo API docTo body       : Gtk_Tree_IterTo API docTo specTo body := Null_IterTo API docTo specTo body) return GintTo API docTo spec;

321.        --  Return the number of children that Iter has.

322.        --  As a special case, if Iter is Null_Iter, then the number of toplevel

323.        --  nodes is returned.

325.        function Nth_ChildTo API docTo body

326.          (Tree_Model : access Gtk_Tree_Model_RecordTo API docTo specTo body;

327.           ParentTo API docTo body     : Gtk_Tree_IterTo API docTo specTo body;

328.           N          : GintTo API docTo spec) return Gtk_Tree_IterTo API docTo specTo body;

329.        --  Return the child of Parent, using the given index.

330.        --  The First index is 0. If Index is too big, or Parent has no children,

331.        --  return Null_Iter.

332.        --  If Parent is Null_Iter, then the nth root node is set.

334.        function ParentTo API docTo body

335.          (Tree_Model : access Gtk_Tree_Model_RecordTo API docTo specTo body;

336.           ChildTo API docTo body      : Gtk_Tree_IterTo API docTo specTo body) return Gtk_Tree_IterTo API docTo specTo body;

337.        --  Return the parent of Child.

338.        --  If Child is at the toplevel, and doesn't have a parent, then Null_Iter

339.        --  is returned.

341.        procedure Ref_NodeTo API docTo body

342.          (Tree_Model : access Gtk_Tree_Model_RecordTo API docTo specTo body;

343.           IterTo API docTo body       : Gtk_Tree_IterTo API docTo specTo body);

344.        --  Let the tree reference the node.

345.        --  This is an optional method for models to implement.

346.        --  To be more specific, models may ignore this call as it exists primarily

347.        --  for performance reasons. This function is primarily meant as a way for

348.        --  views to let caching model know when nodes are being displayed (and

349.        --  hence, whether or not to cache that node). For example, a file-system

350.        --  based model would not want to keep the entire file-hierarchy in memory,

351.        --  just the sections that are currently being displayed by every current

352.        --  view.

354.        procedure Unref_NodeTo API docTo body

355.          (Tree_Model : access Gtk_Tree_Model_RecordTo API docTo specTo body;

356.           IterTo API docTo body       : Gtk_Tree_IterTo API docTo specTo body);

357.        --  Let the tree unref the node.

358.        --  This is an optional method for models to implement. To be more specific,

359.        --  models may ignore this call as it exists primarily for performance

360.        --  reasons. For more information on what this means, please see

361.        --  Tree_Model_Ref_Node. Please note that nodes that are deleted are not

362.        --  unreferenced.

364.        procedure Get_ValueTo API docTo body

365.          (Tree_Model : access Gtk_Tree_Model_RecordTo API docTo specTo body;

366.           IterTo API docTo body       : Gtk_Tree_IterTo API docTo specTo body;

367.           Column     : GintTo API docTo spec;

368.           ValueTo API docTo body      : out Glib.Values.GValueTo API docTo specTo body);

369.        --  Get a value from the model, at column Column and line Iter.

370.        --  Value must be freed by the caller.

372.        function Get_IntTo API docTo body

373.          (Tree_Model : access Gtk_Tree_Model_RecordTo API docTo specTo body;

374.           IterTo API docTo body       : Gtk_Tree_IterTo API docTo specTo body;

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

376.        --  Get the int value of one cell in the row referenced by Iter.

378.        function Get_BooleanTo API docTo body

379.          (Tree_Model : access Gtk_Tree_Model_RecordTo API docTo specTo body;

380.           IterTo API docTo body       : Gtk_Tree_IterTo API docTo specTo body;

381.           Column     : GintTo API docTo spec) return Boolean;

382.        --  Get the boolean value of one cell in the row referenced by Iter.

384.        function Get_ObjectTo API docTo body

385.          (Tree_Model : access Gtk_Tree_Model_RecordTo API docTo specTo body;

386.           IterTo API docTo body       : Gtk_Tree_IterTo API docTo specTo body;

387.           Column     : GintTo API docTo spec) return Glib.Object.GObjectTo API docTo spec;

388.        --  Get the object value of one cell in the row referenced by Iter.

390.        function Get_C_ProxyTo API docTo body

391.          (Tree_Model : access Gtk_Tree_Model_RecordTo API docTo specTo body;

392.           IterTo API docTo body       : Gtk_Tree_IterTo API docTo specTo body;

393.           Column     : GintTo API docTo spec) return Glib.C_ProxyTo API docTo spec;

394.        --  Get the address value of one cell in the row referenced by Iter.

396.        function Get_StringTo API docTo body

397.          (Tree_Model : access Gtk_Tree_Model_RecordTo API docTo specTo body;

398.           IterTo API docTo body       : Gtk_Tree_IterTo API docTo specTo body;

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

400.        --  Get the string stored at a specific location in the model.

402.        function Get_AddressTo API docTo body

403.          (Tree_Model : access Gtk_Tree_Model_RecordTo API docTo specTo body;

404.           IterTo API docTo body       : Gtk_Tree_IterTo API docTo specTo body;

405.           Column     : GintTo API docTo spec) return System.Address;

406.        --  Get the pointer stored at a specific location in the model.

408.        -------------

409.        -- Signals --

410.        -------------

412.        --  <signals>

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

414.        --

415.        --  - "row_changed"

416.        --    procedure Handler

417.        --       (Tree_Model : access Gtk_Tree_Model_Record'Class;

418.        --        Path       : Gtk_Tree_Path;

419.        --        Iter       : Gtk_Tree_Iter);

420.        --    This signal should be emitted every time the contents of a row (any

421.        --    column) has changed. This forces the tree_view to refresh the display.

422.        --

423.        --  - "row_inserted"

424.        --    procedure Handler

425.        --      (Tree_Model : access Gtk_Tree_Model_Record'Class;

426.        --       Path       : Gtk_Tree_Path;

427.        --       Iter       : Gtk_Tree_Iter);

428.        --    This signal should be emitted every time a new row has been inserted.

429.        --

430.        --  - "row_has_child_toggled"

431.        --    procedure Handler

432.        --      (Tree_Model : access Gtk_Tree_Model_Record'Class;

433.        --       Path       : Gtk_Tree_Path;

434.        --       Iter       : Gtk_Tree_Iter);

435.        --    This should be emitted by models after the child state of a node

436.        --    changes.

437.        --

438.        --  - "row_deleted"

439.        --    procedure Handler

440.        --      (Tree_Model : access Gtk_Tree_Model_Record'Class;

441.        --       Path       : Gtk_Tree_Path);

442.        --    This should be emitted by models after the child state of a node

443.        --    changes.

444.        --

445.        --  - "rows_reordered"

446.        --    procedure Handler

447.        --      (Tree_Model : access Gtk_Tree_Model_Record'Class;

448.        --       Path       : Gtk_Tree_Path;

449.        --       Iter       : Gtk_Tree_Iter;

450.        --       New_Order  : Gint_Array);

451.        --   This should be emitted when the rows have been reordered

452.        --

453.        --  </signals>

455.        procedure Row_ChangedTo API docTo body

456.          (Tree_Model : access Gtk_Tree_Model_RecordTo API docTo specTo body'Class;

457.           Path       : Gtk_Tree_PathTo API docTo spec;

458.           IterTo API docTo body       : Gtk_Tree_IterTo API docTo specTo body);

459.        --  Emit the "row_changed" signal.

461.        procedure Row_InsertedTo API docTo body

462.          (Tree_Model : access Gtk_Tree_Model_RecordTo API docTo specTo body'Class;

463.           Path       : Gtk_Tree_PathTo API docTo spec;

464.           IterTo API docTo body       : Gtk_Tree_IterTo API docTo specTo body);

465.        --  Emit the "row_inserted" signal.

467.        procedure Row_Has_Child_ToggledTo API docTo body

468.          (Tree_Model : access Gtk_Tree_Model_RecordTo API docTo specTo body'Class;

469.           Path       : Gtk_Tree_PathTo API docTo spec;

470.           IterTo API docTo body       : Gtk_Tree_IterTo API docTo specTo body);

471.        --  Emit the "row_has_child_toggled" signal.

473.        procedure Row_DeletedTo API docTo body

474.          (Tree_Model : access Gtk_Tree_Model_RecordTo API docTo specTo body'Class;

475.           Path       : Gtk_Tree_PathTo API docTo spec);

476.        --  Emit the "row_has_child_toggled" signal.

478.        procedure Rows_ReorderedTo API docTo body

479.          (Tree_Model : access Gtk_Tree_Model_RecordTo API docTo specTo body'Class;

480.           Path       : Gtk_Tree_PathTo API docTo spec;

481.           IterTo API docTo body       : Gtk_Tree_IterTo API docTo specTo body;

482.           New_Order  : Gint_ArrayTo API docTo spec);

483.        --  Emit the "rows_reordered" signal

485.        Signal_Row_Changed           : constant Glib.Signal_NameTo API docTo spec :=

486.                                         "row_changed";

487.        Signal_Row_Inserted          : constant Glib.Signal_NameTo API docTo spec :=

488.                                         "row_inserted";

489.        Signal_Row_Has_Child_Toggled : constant Glib.Signal_NameTo API docTo spec :=

490.                                         "row_has_child_toggled";

491.        Signal_Row_Deleted           : constant Glib.Signal_NameTo API docTo spec :=

492.                                         "row_deleted";

493.        Signal_Rows_Reordered        : constant Glib.Signal_NameTo API docTo spec :=

494.                                         "rows_reordered";

496.     private

497.        pragma Convention (C, Tree_Model_FlagsTo API docTo spec);

499.        pragma Convention (C, To_AddressTo API docTo specTo body);

500.        --  Note: To_Address needs a pass-by-reference semantic to work properly

501.        --  On some ABIs (e.g. IA64), Gtk_Tree_Iter is passed by copy, since it's

502.        --  a "small enough" record.

504.        Tree_Model_Iters_PersistTo API docTo spec : constant Tree_Model_FlagsTo API docTo spec := 2 ** 0;

505.        Tree_Model_List_OnlyTo API docTo spec     : constant Tree_Model_FlagsTo API docTo spec := 2 ** 1;

507.        type Gtk_Tree_Model_RecordTo API docTo spec is new Glib.Object.GObject_RecordTo API docTo specTo body

508.          with null record;

510.        type Gtk_Tree_IterTo API docTo spec is record

511.           Stamp      : GintTo API docTo spec;

512.           User_Data  : System.Address;

513.           User_Data2 : System.Address;

514.           User_Data3 : System.Address;

515.        end record;

516.        pragma Convention (C, Gtk_Tree_IterTo API docTo specTo body);

518.        Null_IterTo API docTo spec : constant Gtk_Tree_IterTo API docTo specTo body :=

519.          (0, System.Null_Address, System.Null_Address, System.Null_Address);

521.        pragma Import (C, Get_TypeTo API docTo spec,      "gtk_tree_model_get_type");

522.        pragma Import (C, Row_Reference_FreeTo API docTo spec, "gtk_tree_row_reference_free");

523.        pragma Import (C, Append_IndexTo API docTo spec,  "gtk_tree_path_append_index");

524.        pragma Import (C, Prepend_IndexTo API docTo spec, "gtk_tree_path_prepend_index");

525.        pragma Import (C, Get_DepthTo API docTo spec,     "gtk_tree_path_get_depth");

526.        pragma Import (C, Path_FreeTo API docTo spec,     "gtk_tree_path_free");

527.        pragma Import (C, CopyTo API docTo spec,          "gtk_tree_path_copy");

528.        pragma Import (C, CompareTo API docTo spec,       "gtk_tree_path_compare");

529.        pragma Import (C, DownTo API docTo spec,          "gtk_tree_path_down");

530.        pragma Import (C, Iter_Get_TypeTo API docTo spec, "gtk_tree_iter_get_type");

531.        pragma Import (C, Path_Get_TypeTo API docTo spec, "gtk_tree_path_get_type");

532.        pragma Import (C, Gtk_New_FirstTo API docTo spec, "gtk_tree_path_new_first");

533.        pragma Import (C, Iter_CopyTo API docTo spec,     "ada_tree_iter_copy");

534.        pragma Import (C, Row_Reference_CopyTo API docTo spec, "gtk_tree_row_reference_copy");

535.        pragma Import

536.          (C, Row_Reference_Get_TypeTo API docTo spec, "gtk_tree_row_reference_get_type");

538.        pragma Import (C, Set_Tree_IterTo API docTo spec, "g_value_set_pointer");

539.        --  External binding: g_value_set_pointer

541.     end Gtk.Tree_ModelTo API docTo specTo body;

543.     --  This function is not intended to be used by applications anyway

544.     --  No binding: gtk_tree_iter_copy

545.     --  No binding: gtk_tree_iter_free

547.     --  variable number of arguments, no convenient binding

548.     --  No binding: gtk_tree_model_get

549.     --  No binding: gtk_tree_model_get_valist

550.     --  No binding: gtk_tree_path_new_from_indices

552.     --  Not needed by most applications, in fact, only for low-level monitoring:

553.     --  No binding: gtk_tree_row_reference_deleted

554.     --  No binding: gtk_tree_row_reference_inserted

555.     --  No binding: gtk_tree_row_reference_new_proxy

556.     --  No binding: gtk_tree_row_reference_reordered