------------------------------------------------------------------------------ 

--                                                                          -- 

--      Copyright (C) 1998-2000 E. Briot, J. Brobecker and A. Charlet       -- 

--                     Copyright (C) 2000-2014, AdaCore                     -- 

--                                                                          -- 

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

-- under terms of the  GNU General Public License  as published by the Free -- 

-- Software  Foundation;  either version 3,  or (at your  option) any later -- 

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

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

-- TABILITY or FITNESS FOR A PARTICULAR PURPOSE.                            -- 

--                                                                          -- 

-- As a special exception under Section 7 of GPL version 3, you are granted -- 

-- additional permissions described in the GCC Runtime Library Exception,   -- 

-- version 3.1, as published by the Free Software Foundation.               -- 

--                                                                          -- 

-- You should have received a copy of the GNU General Public License and    -- 

-- a copy of the GCC Runtime Library Exception along with this program;     -- 

-- see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see    -- 

-- <http://www.gnu.org/licenses/>.                                          -- 

--                                                                          -- 

------------------------------------------------------------------------------ 

--  <description> 

--  The Gtk.List_Store.Gtk_List_Store object is a list model for use with a 

--  Gtk.Tree_View.Gtk_Tree_View widget. It implements the 

--  Gtk.Tree_Model.Gtk_Tree_Model interface, and consequentialy, can use all of 

--  the methods available there. It also implements the 

--  Gtk.Tree_Sortable.Gtk_Tree_Sortable interface so it can be sorted by the 

--  view. Finally, it also implements the tree <link linkend="gtktreednd">drag 

--  and drop</link> interfaces. 

-- 

--  The Gtk.List_Store.Gtk_List_Store can accept most GObject types as a 

--  column type, though it can't accept all custom types. Internally, it will 

--  keep a copy of data passed in (such as a string or a boxed pointer). 

--  Columns that accept Glib.Object.GObject<!-- -->s are handled a little 

--  differently. The Gtk.List_Store.Gtk_List_Store will keep a reference to the 

--  object instead of copying the value. As a result, if the object is 

--  modified, it is up to the application writer to call 

--  Gtk.Tree_Model.Row_Changed to emit the 

--  Gtk.Tree_Model.Gtk_Tree_Model::row_changed signal. This most commonly 

--  affects lists with Gdk.Pixbuf.Gdk_Pixbuf<!-- -->s stored. 

-- 

--  == Creating a simple list store. == 

-- 

--    enum { 

--       COLUMN_STRING, 

--       COLUMN_INT, 

--       COLUMN_BOOLEAN, 

--       N_COLUMNS 

--    }; 

--    { 

--       GtkListStore *list_store; 

--       GtkTreePath *path; 

--       GtkTreeIter iter; 

--       gint i; 

--       list_store = gtk_list_store_new (N_COLUMNS, 

--          G_TYPE_STRING, 

--          G_TYPE_INT, 

--          G_TYPE_BOOLEAN); 

--       for (i = 0; i < 10; i++) 

--       { 

--          gchar *some_data; 

--          some_data = get_some_data (i); 

--          // Add a new row to the model 

--          gtk_list_store_append (list_store, &iter); 

--          gtk_list_store_set (list_store, &iter, 

--             COLUMN_STRING, some_data, 

--             COLUMN_INT, i, 

--             COLUMN_BOOLEAN,  FALSE, 

--             -1); 

--          /<!---->* As the store will keep a copy of the string internally, we 

--          * free some_data. 

--          *<!---->/ 

--          g_free (some_data); 

--       } 

--       // Modify a particular row 

--       path = gtk_tree_path_new_from_string ("4"); 

--       gtk_tree_model_get_iter (GTK_TREE_MODEL (list_store), 

--          &iter, 

--          path); 

--       gtk_tree_path_free (path); 

--       gtk_list_store_set (list_store, &iter, 

--          COLUMN_BOOLEAN, TRUE, 

--          -1); 

--    } 

-- 

--  == Performance Considerations == 

-- 

--  Internally, the Gtk.List_Store.Gtk_List_Store was implemented with a 

--  linked list with a tail pointer prior to GTK+ 2.6. As a result, it was fast 

--  at data insertion and deletion, and not fast at random data access. The 

--  Gtk.List_Store.Gtk_List_Store sets the GTK_TREE_MODEL_ITERS_PERSIST flag, 

--  which means that Gtk.Tree_Model.Gtk_Tree_Iter<!-- -->s can be cached while 

--  the row exists. Thus, if access to a particular row is needed often and 

--  your code is expected to run on older versions of GTK+, it is worth keeping 

--  the iter around. 

-- 

--  == Atomic Operations == 

-- 

--  It is important to note that only the methods 

--  gtk_list_store_insert_with_values and gtk_list_store_insert_with_valuesv 

--  are atomic, in the sense that the row is being appended to the store and 

--  the values filled in in a single operation with regard to 

--  Gtk.Tree_Model.Gtk_Tree_Model signaling. In contrast, using e.g. 

--  Gtk.List_Store.Append and then gtk_list_store_set will first create a row, 

--  which triggers the Gtk.Tree_Model.Gtk_Tree_Model::row-inserted signal on 

--  Gtk.List_Store.Gtk_List_Store. The row, however, is still empty, and any 

--  signal handler connecting to Gtk.Tree_Model.Gtk_Tree_Model::row-inserted on 

--  this particular store should be prepared for the situation that the row 

--  might be empty. This is especially important if you are wrapping the 

--  Gtk.List_Store.Gtk_List_Store inside a 

--  Gtk.Tree_Model_Filter.Gtk_Tree_Model_Filter and are using a 

--  Gtk_Tree_Model_Filter_Visible_Func. Using any of the non-atomic operations 

--  to append rows to the Gtk.List_Store.Gtk_List_Store will cause the 

--  Gtk_Tree_Model_Filter_Visible_Func to be visited with an empty row first; 

--  the function must be prepared for that. 

-- 

--  == GtkListStore as GtkBuildable == 

-- 

--  The GtkListStore implementation of the GtkBuildable interface allows to 

--  specify the model columns with a <columns> element that may contain 

--  multiple <column> elements, each specifying one model column. The "type" 

--  attribute specifies the data type for the column. 

-- 

--  Additionally, it is possible to specify content for the list store in the 

--  UI definition, with the <data> element. It can contain multiple <row> 

--  elements, each specifying to content for one row of the list model. Inside 

--  a <row>, the <col> elements specify the content for individual cells. 

-- 

--  Note that it is probably more common to define your models in the code, 

--  and one might consider it a layering violation to specify the content of a 

--  list store in a UI definition, *data*, not *presentation*, and common 

--  wisdom is to separate the two, as far as possible. <!-- FIXME a bit 

--  inconclusive --> 

-- 

--  == A UI Definition fragment for a list store == 

-- 

--    <object class="GtkListStore"> 

--    <columns> 

--    <column type="gchararray"/> 

--    <column type="gchararray"/> 

--    <column type="gint"/> 

--    </columns> 

--    <data> 

--    <col id="0">John</col> 

--    <col id="1">Doe</col> 

--    <col id="2">25</col> 

--    <col id="0">Johan</col> 

--    <col id="1">Dahlin</col> 

--    <col id="2">50</col> 

--    </data> 

--    </object> 

--  </description> 

pragma Ada_2005; 

pragma Warnings (Off, "*is already use-visible*"); 

with Gdk.Pixbuf
To API doc
To spec
To body;           use Gdk.Pixbuf
To API doc
To spec
To body; 

with Glib
To API doc
To spec
To body;                 use Glib
To API doc
To spec
To body; 

with Glib.Types
To API doc
To spec
To body;           use Glib.Types
To API doc
To spec
To body; 

with Glib.Values
To API doc
To spec
To body;          use Glib.Values
To API doc
To spec
To body; 

with Gtk.Buildable
To API doc
To spec
To body;        use Gtk.Buildable
To API doc
To spec
To body; 

with Gtk.Enums
To API doc
To spec
To body;            use Gtk.Enums
To API doc
To spec
To body; 

with Gtk.Selection_Data
To API doc
To spec
To body;   use Gtk.Selection_Data
To API doc
To spec
To body; 

with Gtk.Tree_Drag_Dest
To API doc
To spec
To body;   use Gtk.Tree_Drag_Dest
To API doc
To spec
To body; 

with Gtk.Tree_Drag_Source
To API doc
To spec
To body; use Gtk.Tree_Drag_Source
To API doc
To spec
To body; 

with Gtk.Tree_Model
To API doc
To spec
To body;       use Gtk.Tree_Model
To API doc
To spec
To body; 

with Gtk.Tree_Sortable
To API doc
To spec
To body;    use Gtk.Tree_Sortable
To API doc
To spec
To body; 

package Gtk.List_Store
To API doc
To spec
To body is 

   type Gtk_List_Store_Record is new Gtk_Root_Tree_Model_Record
To API doc
To spec with null record; 

   type Gtk_List_Store is access all Gtk_List_Store_Record
To API doc
To spec'Class; 

   --------------- 

   -- Callbacks -- 

   --------------- 

   type Gtk_Tree_Model_Foreach_Func is access function 

     (Model : Gtk.Tree_Model.Gtk_Tree_Model
To API doc
To spec; 

      Path  : Gtk.Tree_Model.Gtk_Tree_Path
To API doc
To spec; 

      Iter  : Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body) return Boolean; 

   --  Type of the callback passed to Gtk.Tree_Model.Foreach to iterate over 

   --  the rows in a tree model. 

   --  "model": the Gtk.Tree_Model.Gtk_Tree_Model being iterated 

   --  "path": the current Gtk.Tree_Model.Gtk_Tree_Path 

   --  "iter": the current Gtk.Tree_Model.Gtk_Tree_Iter 

   type Gtk_Tree_Iter_Compare_Func is access function 

     (Model : Gtk.Tree_Model.Gtk_Tree_Model
To API doc
To spec; 

      A     : Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body; 

      B     : Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body) return Gint
To API doc
To spec; 

   --  A GtkTreeIterCompareFunc should return a negative integer, zero, or a 

   --  positive integer if A sorts before B, A sorts with B, or A sorts after B 

   --  respectively. If two iters compare as equal, their order in the sorted 

   --  model is undefined. In order to ensure that the 

   --  Gtk.Tree_Sortable.Gtk_Tree_Sortable behaves as expected, the 

   --  GtkTreeIterCompareFunc must define a partial order on the model, i.e. it 

   --  must be reflexive, antisymmetric and transitive. 

   --  For example, if Model is a product catalogue, then a compare function 

   --  for the "price" column could be one which returns 'price_of(A) - 

   --  price_of(B)'. 

   --  "model": The Gtk.Tree_Model.Gtk_Tree_Model the comparison is within 

   --  "a": A Gtk.Tree_Model.Gtk_Tree_Iter in Model 

   --  "b": Another Gtk.Tree_Model.Gtk_Tree_Iter in Model 

   ------------------ 

   -- Constructors -- 

   ------------------ 

   procedure Gtk_New
To API doc
To body (List_Store : out Gtk_List_Store
To API doc
To spec; Types : GType_Array
To API doc
To spec); 

   procedure Initialize
To API doc
To body 

      (List_Store : not null access Gtk_List_Store_Record
To API doc
To spec'Class; 

       Types      : GType_Array
To API doc
To spec); 

   --  Non-vararg creation function. Used primarily by language bindings. 

   --  "types": an array of GType types for the columns, from first to last 

   function Gtk_List_Store_Newv
To API doc
To body (Types : GType_Array
To API doc
To spec) return Gtk_List_Store
To API doc
To spec; 

   --  Non-vararg creation function. Used primarily by language bindings. 

   --  "types": an array of GType types for the columns, from first to last 

   function Get_Type
To API doc
To body return Glib.GType
To API doc
To spec; 

   pragma Import (C, Get_Type
To API doc
To spec, "gtk_list_store_get_type"); 

   ------------- 

   -- Methods -- 

   ------------- 

   procedure Append
To API doc
To body 

      (List_Store : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Iter
To API doc
To body       : out Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body); 

   --  Appends a new row to List_Store. Iter will be changed to point to this 

   --  new row. The row will be empty after this function is called. To fill in 

   --  values, you need to call gtk_list_store_set or Gtk.List_Store.Set_Value. 

   --  "iter": An unset Gtk.Tree_Model.Gtk_Tree_Iter to set to the appended 

   --  row 

   procedure Clear
To API doc
To body (List_Store : not null access Gtk_List_Store_Record
To API doc
To spec); 

   --  Removes all rows from the list store. 

   procedure Insert
To API doc
To body 

      (List_Store : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Iter
To API doc
To body       : out Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body; 

       Position   : Gint
To API doc
To spec); 

   --  Creates a new row at Position. Iter will be changed to point to this 

   --  new row. If Position is -1 or is larger than the number of rows on the 

   --  list, then the new row will be appended to the list. The row will be 

   --  empty after this function is called. To fill in values, you need to call 

   --  gtk_list_store_set or Gtk.List_Store.Set_Value. 

   --  "iter": An unset Gtk.Tree_Model.Gtk_Tree_Iter to set to the new row 

   --  "position": position to insert the new row, or -1 for last 

   procedure Insert_After
To API doc
To body 

      (List_Store : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Iter
To API doc
To body       : out Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body; 

       Sibling
To API doc
To body    : Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body); 

   --  Inserts a new row after Sibling. If Sibling is null, then the row will 

   --  be prepended to the beginning of the list. Iter will be changed to point 

   --  to this new row. The row will be empty after this function is called. To 

   --  fill in values, you need to call gtk_list_store_set or 

   --  Gtk.List_Store.Set_Value. 

   --  "iter": An unset Gtk.Tree_Model.Gtk_Tree_Iter to set to the new row 

   --  "sibling": A valid Gtk.Tree_Model.Gtk_Tree_Iter, or null 

   procedure Insert_Before
To API doc
To body 

      (List_Store : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Iter
To API doc
To body       : out Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body; 

       Sibling
To API doc
To body    : Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body); 

   --  Inserts a new row before Sibling. If Sibling is null, then the row will 

   --  be appended to the end of the list. Iter will be changed to point to 

   --  this new row. The row will be empty after this function is called. To 

   --  fill in values, you need to call gtk_list_store_set or 

   --  Gtk.List_Store.Set_Value. 

   --  "iter": An unset Gtk.Tree_Model.Gtk_Tree_Iter to set to the new row 

   --  "sibling": A valid Gtk.Tree_Model.Gtk_Tree_Iter, or null 

   function Iter_Is_Valid
To API doc
To body 

      (List_Store : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Iter
To API doc
To body       : Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body) return Boolean; 

   --  <warning>This function is slow. Only use it for debugging and/or 

   --  testing purposes.</warning> 

   --  Checks if the given iter is a valid iter for this 

   --  Gtk.List_Store.Gtk_List_Store. 

   --  Since: gtk+ 2.2 

   --  "iter": A Gtk.Tree_Model.Gtk_Tree_Iter. 

   procedure Move_After
To API doc
To body 

      (List_Store : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Iter
To API doc
To body       : Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body; 

       Position
To API doc
To body   : Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body); 

   --  Moves Iter in Store to the position after Position. Note that this 

   --  function only works with unsorted stores. If Position is null, Iter will 

   --  be moved to the start of the list. 

   --  Since: gtk+ 2.2 

   --  "iter": A Gtk.Tree_Model.Gtk_Tree_Iter. 

   --  "position": A Gtk.Tree_Model.Gtk_Tree_Iter or null. 

   procedure Move_Before
To API doc
To body 

      (List_Store : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Iter
To API doc
To body       : Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body; 

       Position
To API doc
To body   : Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body); 

   --  Moves Iter in Store to the position before Position. Note that this 

   --  function only works with unsorted stores. If Position is null, Iter will 

   --  be moved to the end of the list. 

   --  Since: gtk+ 2.2 

   --  "iter": A Gtk.Tree_Model.Gtk_Tree_Iter. 

   --  "position": A Gtk.Tree_Model.Gtk_Tree_Iter, or null. 

   procedure Prepend
To API doc
To body 

      (List_Store : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Iter
To API doc
To body       : out Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body); 

   --  Prepends a new row to List_Store. Iter will be changed to point to this 

   --  new row. The row will be empty after this function is called. To fill in 

   --  values, you need to call gtk_list_store_set or Gtk.List_Store.Set_Value. 

   --  "iter": An unset Gtk.Tree_Model.Gtk_Tree_Iter to set to the prepend row 

   procedure Remove
To API doc
To body 

      (List_Store : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Iter
To API doc
To body       : in out Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body); 

   --  Removes the given row from the list store. After being removed, Iter is 

   --  set to be the next valid row, or invalidated if it pointed to the last 

   --  row in List_Store. 

   --  "iter": A valid Gtk.Tree_Model.Gtk_Tree_Iter 

   procedure Reorder
To API doc
To body 

      (List_Store : not null access Gtk_List_Store_Record
To API doc
To spec; 

       New_Order  : Gint_Array
To API doc
To spec); 

   --  Reorders Store to follow the order indicated by New_Order. Note that 

   --  this function only works with unsorted stores. 

   --  Since: gtk+ 2.2 

   --  "new_order": an array of integers mapping the new position of each 

   --  child to its old position before the re-ordering, i.e. 

   --  New_Order'[newpos] = oldpos'. It must have exactly as many items as the 

   --  list store's length. 

   procedure Set_Column_Types
To API doc
To body 

      (List_Store : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Types      : GType_Array
To API doc
To spec); 

   --  This function is meant primarily for GObjects that inherit from 

   --  Gtk.List_Store.Gtk_List_Store, and should only be used when constructing 

   --  a new Gtk.List_Store.Gtk_List_Store. It will not function after a row 

   --  has been added, or a method on the Gtk.Tree_Model.Gtk_Tree_Model 

   --  interface is called. 

   --  "types": An array length n of GTypes 

   procedure Set_Value
To API doc
To body 

      (List_Store : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Iter
To API doc
To body       : Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body; 

       Column     : Gint
To API doc
To spec; 

       Value
To API doc
To body      : Glib.Values.GValue
To API doc
To spec
To body); 

   --  Sets the data in the cell specified by Iter and Column. The type of 

   --  Value must be convertible to the type of the column. 

   --  "iter": A valid Gtk.Tree_Model.Gtk_Tree_Iter for the row being modified 

   --  "column": column number to modify 

   --  "value": new value for the cell 

   procedure Swap
To API doc
To body 

      (List_Store : not null access Gtk_List_Store_Record
To API doc
To spec; 

       A
To API doc
To body          : Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body; 

       B
To API doc
To body          : Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body); 

   --  Swaps A and B in Store. Note that this function only works with 

   --  unsorted stores. 

   --  Since: gtk+ 2.2 

   --  "a": A Gtk.Tree_Model.Gtk_Tree_Iter. 

   --  "b": Another Gtk.Tree_Model.Gtk_Tree_Iter. 

   procedure Foreach
To API doc
To body 

      (Tree_Model : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Func       : Gtk_Tree_Model_Foreach_Func
To API doc
To spec); 

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

   --  If Func returns True, then the tree ceases to be walked, and 

   --  Gtk.Tree_Model.Foreach returns. 

   --  "func": a function to be called on each row 

   generic 

      type User_Data_Type (<>) is private; 

      with procedure Destroy (Data : in out User_Data_Type
To API doc
To spec) is null; 

   package Foreach_User_Data
To API doc
To body is 

      type Gtk_Tree_Model_Foreach_Func is access function 

        (Model : Gtk.Tree_Model.Gtk_Tree_Model
To API doc
To spec; 

         Path  : Gtk.Tree_Model.Gtk_Tree_Path
To API doc
To spec; 

         Iter  : Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body; 

         Data  : User_Data_Type
To API doc
To spec) return Boolean; 

      --  Type of the callback passed to Gtk.Tree_Model.Foreach to iterate over 

      --  the rows in a tree model. 

      --  "model": the Gtk.Tree_Model.Gtk_Tree_Model being iterated 

      --  "path": the current Gtk.Tree_Model.Gtk_Tree_Path 

      --  "iter": the current Gtk.Tree_Model.Gtk_Tree_Iter 

      --  "data": The user data passed to Gtk.Tree_Model.Foreach 

      procedure Foreach
To API doc
To body 

         (Tree_Model : not null access Gtk.List_Store.Gtk_List_Store_Record
To API doc
To spec'Class; 

          Func       : Gtk_Tree_Model_Foreach_Func
To API doc
To spec; 

          User_Data  : User_Data_Type
To API doc
To spec); 

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

      --  If Func returns True, then the tree ceases to be walked, and 

      --  Gtk.Tree_Model.Foreach returns. 

      --  "func": a function to be called on each row 

      --  "user_data": user data to passed to Func 

   end Foreach_User_Data
To API doc
To spec
To body; 

   procedure Set_Default_Sort_Func
To API doc
To body 

      (Sortable  : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Sort_Func : Gtk_Tree_Iter_Compare_Func
To API doc
To spec); 

   --  Sets the default comparison function used when sorting to be Sort_Func. 

   --  If the current sort column id of Sortable is 

   --  GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, then the model will sort using 

   --  this function. 

   --  If Sort_Func is null, then there will be no default comparison 

   --  function. This means that once the model has been sorted, it can't go 

   --  back to the default state. In this case, when the current sort column id 

   --  of Sortable is GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will 

   --  be unsorted. 

   --  "sort_func": The comparison function 

   generic 

      type User_Data_Type (<>) is private; 

      with procedure Destroy (Data : in out User_Data_Type
To API doc
To spec) is null; 

   package Set_Default_Sort_Func_User_Data
To API doc
To body is 

      type Gtk_Tree_Iter_Compare_Func is access function 

        (Model     : Gtk.Tree_Model.Gtk_Tree_Model
To API doc
To spec; 

         A         : Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body; 

         B         : Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body; 

         User_Data : User_Data_Type
To API doc
To spec) return Gint
To API doc
To spec; 

      --  A GtkTreeIterCompareFunc should return a negative integer, zero, or a 

      --  positive integer if A sorts before B, A sorts with B, or A sorts after B 

      --  respectively. If two iters compare as equal, their order in the sorted 

      --  model is undefined. In order to ensure that the 

      --  Gtk.Tree_Sortable.Gtk_Tree_Sortable behaves as expected, the 

      --  GtkTreeIterCompareFunc must define a partial order on the model, i.e. it 

      --  must be reflexive, antisymmetric and transitive. 

      --  For example, if Model is a product catalogue, then a compare function 

      --  for the "price" column could be one which returns 'price_of(A) - 

      --  price_of(B)'. 

      --  "model": The Gtk.Tree_Model.Gtk_Tree_Model the comparison is within 

      --  "a": A Gtk.Tree_Model.Gtk_Tree_Iter in Model 

      --  "b": Another Gtk.Tree_Model.Gtk_Tree_Iter in Model 

      --  "user_data": Data passed when the compare func is assigned e.g. by 

      --  Gtk.Tree_Sortable.Set_Sort_Func 

      procedure Set_Default_Sort_Func
To API doc
To body 

         (Sortable  : not null access Gtk.List_Store.Gtk_List_Store_Record
To API doc
To spec'Class; 

          Sort_Func : Gtk_Tree_Iter_Compare_Func
To API doc
To spec; 

          User_Data : User_Data_Type
To API doc
To spec); 

      --  Sets the default comparison function used when sorting to be 

      --  Sort_Func. If the current sort column id of Sortable is 

      --  GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, then the model will sort 

      --  using this function. 

      --  If Sort_Func is null, then there will be no default comparison 

      --  function. This means that once the model has been sorted, it can't go 

      --  back to the default state. In this case, when the current sort column 

      --  id of Sortable is GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model 

      --  will be unsorted. 

      --  "sort_func": The comparison function 

      --  "user_data": User data to pass to Sort_Func, or null 

   end Set_Default_Sort_Func_User_Data
To API doc
To spec
To body; 

   procedure Set_Sort_Func
To API doc
To body 

      (Sortable       : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Sort_Column_Id : Gint
To API doc
To spec; 

       Sort_Func      : Gtk_Tree_Iter_Compare_Func
To API doc
To spec); 

   --  Sets the comparison function used when sorting to be Sort_Func. If the 

   --  current sort column id of Sortable is the same as Sort_Column_Id, then 

   --  the model will sort using this function. 

   --  "sort_column_id": the sort column id to set the function for 

   --  "sort_func": The comparison function 

   generic 

      type User_Data_Type (<>) is private; 

      with procedure Destroy (Data : in out User_Data_Type
To API doc
To spec) is null; 

   package Set_Sort_Func_User_Data
To API doc
To body is 

      type Gtk_Tree_Iter_Compare_Func is access function 

        (Model     : Gtk.Tree_Model.Gtk_Tree_Model
To API doc
To spec; 

         A         : Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body; 

         B         : Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body; 

         User_Data : User_Data_Type
To API doc
To spec) return Gint
To API doc
To spec; 

      --  A GtkTreeIterCompareFunc should return a negative integer, zero, or a 

      --  positive integer if A sorts before B, A sorts with B, or A sorts after B 

      --  respectively. If two iters compare as equal, their order in the sorted 

      --  model is undefined. In order to ensure that the 

      --  Gtk.Tree_Sortable.Gtk_Tree_Sortable behaves as expected, the 

      --  GtkTreeIterCompareFunc must define a partial order on the model, i.e. it 

      --  must be reflexive, antisymmetric and transitive. 

      --  For example, if Model is a product catalogue, then a compare function 

      --  for the "price" column could be one which returns 'price_of(A) - 

      --  price_of(B)'. 

      --  "model": The Gtk.Tree_Model.Gtk_Tree_Model the comparison is within 

      --  "a": A Gtk.Tree_Model.Gtk_Tree_Iter in Model 

      --  "b": Another Gtk.Tree_Model.Gtk_Tree_Iter in Model 

      --  "user_data": Data passed when the compare func is assigned e.g. by 

      --  Gtk.Tree_Sortable.Set_Sort_Func 

      procedure Set_Sort_Func
To API doc
To body 

         (Sortable       : not null access Gtk.List_Store.Gtk_List_Store_Record
To API doc
To spec'Class; 

          Sort_Column_Id : Gint
To API doc
To spec; 

          Sort_Func      : Gtk_Tree_Iter_Compare_Func
To API doc
To spec; 

          User_Data      : User_Data_Type
To API doc
To spec); 

      --  Sets the comparison function used when sorting to be Sort_Func. If 

      --  the current sort column id of Sortable is the same as Sort_Column_Id, 

      --  then the model will sort using this function. 

      --  "sort_column_id": the sort column id to set the function for 

      --  "sort_func": The comparison function 

      --  "user_data": User data to pass to Sort_Func, or null 

   end Set_Sort_Func_User_Data
To API doc
To spec
To body; 

   ---------------------- 

   -- GtkAda additions -- 

   ---------------------- 

   procedure Set
To API doc
To body 

     (Tree_Store : access Gtk_List_Store_Record
To API doc
To spec; 

      Iter
To API doc
To body       : Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body; 

      Column     : Gint
To API doc
To spec; 

      Value      : UTF8_String
To API doc
To spec); 

   procedure Set
To API doc
To body 

     (Tree_Store : access Gtk_List_Store_Record
To API doc
To spec; 

      Iter
To API doc
To body       : Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body; 

      Column     : Gint
To API doc
To spec; 

      Value      : Boolean); 

   procedure Set
To API doc
To body 

     (Tree_Store : access Gtk_List_Store_Record
To API doc
To spec; 

      Iter
To API doc
To body       : Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body; 

      Column     : Gint
To API doc
To spec; 

      Value      : Gint
To API doc
To spec); 

   procedure Set
To API doc
To body 

     (Tree_Store : access Gtk_List_Store_Record
To API doc
To spec; 

      Iter
To API doc
To body       : Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body; 

      Column     : Gint
To API doc
To spec; 

      Value      : Gdk.Pixbuf.Gdk_Pixbuf
To API doc
To spec); 

   --------------------------------------------- 

   -- Inherited subprograms (from interfaces) -- 

   --------------------------------------------- 

   --  Methods inherited from the Buildable interface are not duplicated here 

   --  since they are meant to be used by tools, mostly. If you need to call 

   --  them, use an explicit cast through the "-" operator below. 

   function Drag_Data_Received
To API doc
To body 

      (Self           : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Dest
To API doc
To body           : Gtk.Tree_Model.Gtk_Tree_Path
To API doc
To spec; 

       Selection_Data
To API doc
To body : Gtk.Selection_Data.Gtk_Selection_Data
To API doc
To spec) 

       return Boolean; 

   function Row_Drop_Possible
To API doc
To body 

      (Self           : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Dest_Path
To API doc
To body      : Gtk.Tree_Model.Gtk_Tree_Path
To API doc
To spec; 

       Selection_Data
To API doc
To body : Gtk.Selection_Data.Gtk_Selection_Data
To API doc
To spec) 

       return Boolean; 

   function Drag_Data_Delete
To API doc
To body 

      (Self : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Path
To API doc
To body : Gtk.Tree_Model.Gtk_Tree_Path
To API doc
To spec) return Boolean; 

   function Drag_Data_Get
To API doc
To body 

      (Self           : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Path
To API doc
To body           : Gtk.Tree_Model.Gtk_Tree_Path
To API doc
To spec; 

       Selection_Data
To API doc
To body : Gtk.Selection_Data.Gtk_Selection_Data
To API doc
To spec) 

       return Boolean; 

   function Row_Draggable
To API doc
To body 

      (Self : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Path
To API doc
To body : Gtk.Tree_Model.Gtk_Tree_Path
To API doc
To spec) return Boolean; 

   function Get_Column_Type
To API doc
To body 

      (Tree_Model : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Index      : Gint
To API doc
To spec) return GType
To API doc
To spec; 

   function Get_Flags
To API doc
To body 

      (Tree_Model : not null access Gtk_List_Store_Record
To API doc
To spec) 

       return Gtk.Tree_Model.Tree_Model_Flags
To API doc
To spec; 

   function Get_Iter
To API doc
To body 

      (Tree_Model : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Path
To API doc
To body       : Gtk.Tree_Model.Gtk_Tree_Path
To API doc
To spec) 

       return Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body; 

   function Get_Iter_First
To API doc
To body 

      (Tree_Model : not null access Gtk_List_Store_Record
To API doc
To spec) 

       return Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body; 

   function Get_Iter_From_String
To API doc
To body 

      (Tree_Model  : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Path_String : UTF8_String
To API doc
To spec) return Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body; 

   function Get_N_Columns
To API doc
To body 

      (Tree_Model : not null access Gtk_List_Store_Record
To API doc
To spec) return Gint
To API doc
To spec; 

   function Get_Path
To API doc
To body 

      (Tree_Model : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Iter
To API doc
To body       : Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body) 

       return Gtk.Tree_Model.Gtk_Tree_Path
To API doc
To spec; 

   function Get_String_From_Iter
To API doc
To body 

      (Tree_Model : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Iter
To API doc
To body       : Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body) return UTF8_String
To API doc
To spec; 

   procedure Get_Value
To API doc
To body 

      (Tree_Model : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Iter
To API doc
To body       : Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body; 

       Column     : Gint
To API doc
To spec; 

       Value
To API doc
To body      : out Glib.Values.GValue
To API doc
To spec
To body); 

   function Children
To API doc
To body 

      (Tree_Model : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Parent
To API doc
To body     : Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body) 

       return Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body; 

   function Has_Child
To API doc
To body 

      (Tree_Model : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Iter
To API doc
To body       : Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body) return Boolean; 

   function N_Children
To API doc
To body 

      (Tree_Model : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Iter
To API doc
To body       : Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body := Gtk.Tree_Model.Null_Iter
To API doc
To spec
To body) 

       return Gint
To API doc
To spec; 

   procedure Next
To API doc
To body 

      (Tree_Model : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Iter
To API doc
To body       : in out Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body); 

   function Nth_Child
To API doc
To body 

      (Tree_Model : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Parent
To API doc
To body     : Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body; 

       N          : Gint
To API doc
To spec) return Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body; 

   function Parent
To API doc
To body 

      (Tree_Model : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Child
To API doc
To body      : Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body) 

       return Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body; 

   procedure Previous
To API doc
To body 

      (Tree_Model : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Iter
To API doc
To body       : in out Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body); 

   procedure Ref_Node
To API doc
To body 

      (Tree_Model : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Iter
To API doc
To body       : Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body); 

   procedure Row_Changed
To API doc
To body 

      (Tree_Model : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Path
To API doc
To body       : Gtk.Tree_Model.Gtk_Tree_Path
To API doc
To spec; 

       Iter
To API doc
To body       : Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body); 

   procedure Row_Deleted
To API doc
To body 

      (Tree_Model : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Path
To API doc
To body       : Gtk.Tree_Model.Gtk_Tree_Path
To API doc
To spec); 

   procedure Row_Has_Child_Toggled
To API doc
To body 

      (Tree_Model : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Path
To API doc
To body       : Gtk.Tree_Model.Gtk_Tree_Path
To API doc
To spec; 

       Iter
To API doc
To body       : Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body); 

   procedure Row_Inserted
To API doc
To body 

      (Tree_Model : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Path
To API doc
To body       : Gtk.Tree_Model.Gtk_Tree_Path
To API doc
To spec; 

       Iter
To API doc
To body       : Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body); 

   procedure Rows_Reordered
To API doc
To body 

      (Tree_Model : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Path
To API doc
To body       : Gtk.Tree_Model.Gtk_Tree_Path
To API doc
To spec; 

       Iter
To API doc
To body       : Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body; 

       New_Order  : Gint_Array
To API doc
To spec); 

   procedure Unref_Node
To API doc
To body 

      (Tree_Model : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Iter
To API doc
To body       : Gtk.Tree_Model.Gtk_Tree_Iter
To API doc
To spec
To body); 

   procedure Get_Sort_Column_Id
To API doc
To body 

      (Sortable       : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Sort_Column_Id : out Gint
To API doc
To spec; 

       Order
To API doc
To body          : out Gtk.Enums.Gtk_Sort_Type
To API doc
To spec); 

   procedure Set_Sort_Column_Id
To API doc
To body 

      (Sortable       : not null access Gtk_List_Store_Record
To API doc
To spec; 

       Sort_Column_Id : Gint
To API doc
To spec; 

       Order
To API doc
To body          : Gtk.Enums.Gtk_Sort_Type
To API doc
To spec); 

   function Has_Default_Sort_Func
To API doc
To body 

      (Sortable : not null access Gtk_List_Store_Record
To API doc
To spec) return Boolean; 

   procedure Sort_Column_Changed
To API doc
To body 

      (Sortable : not null access Gtk_List_Store_Record
To API doc
To spec); 

   ---------------- 

   -- Interfaces -- 

   ---------------- 

   --  This class implements several interfaces. See Glib.Types 

   -- 

   --  - "Buildable" 

   -- 

   --  - "TreeDragDest" 

   -- 

   --  - "TreeDragSource" 

   -- 

   --  - "TreeModel" 

   -- 

   --  - "TreeSortable" 

   package Implements_Gtk_Buildable is new Glib.Types.Implements
To API doc
To spec
To body 

     (Gtk.Buildable.Gtk_Buildable
To API doc
To spec, Gtk_List_Store_Record
To API doc
To spec, Gtk_List_Store
To API doc
To spec); 

   function "+" 

     (Widget : access Gtk_List_Store_Record
To API doc
To spec'Class) 

   return Gtk.Buildable.Gtk_Buildable
To API doc
To spec 

   renames Implements_Gtk_Buildable.To_Interface
To API doc
To spec
To body; 

   function "-" 

     (Interf : Gtk.Buildable.Gtk_Buildable
To API doc
To spec) 

   return Gtk_List_Store
To API doc
To spec 

   renames Implements_Gtk_Buildable.To_Object
To API doc
To spec
To body; 

   package Implements_Gtk_Tree_Drag_Dest is new Glib.Types.Implements
To API doc
To spec
To body 

     (Gtk.Tree_Drag_Dest.Gtk_Tree_Drag_Dest
To API doc
To spec, Gtk_List_Store_Record
To API doc
To spec, Gtk_List_Store
To API doc
To spec); 

   function "+" 

     (Widget : access Gtk_List_Store_Record
To API doc
To spec'Class) 

   return Gtk.Tree_Drag_Dest.Gtk_Tree_Drag_Dest
To API doc
To spec 

   renames Implements_Gtk_Tree_Drag_Dest.To_Interface
To API doc
To spec
To body; 

   function "-" 

     (Interf : Gtk.Tree_Drag_Dest.Gtk_Tree_Drag_Dest
To API doc
To spec) 

   return Gtk_List_Store
To API doc
To spec 

   renames Implements_Gtk_Tree_Drag_Dest.To_Object
To API doc
To spec
To body; 

   package Implements_Gtk_Tree_Drag_Source is new Glib.Types.Implements
To API doc
To spec
To body 

     (Gtk.Tree_Drag_Source.Gtk_Tree_Drag_Source
To API doc
To spec, Gtk_List_Store_Record
To API doc
To spec, Gtk_List_Store
To API doc
To spec); 

   function "+" 

     (Widget : access Gtk_List_Store_Record
To API doc
To spec'Class) 

   return Gtk.Tree_Drag_Source.Gtk_Tree_Drag_Source
To API doc
To spec 

   renames Implements_Gtk_Tree_Drag_Source.To_Interface
To API doc
To spec
To body; 

   function "-" 

     (Interf : Gtk.Tree_Drag_Source.Gtk_Tree_Drag_Source
To API doc
To spec) 

   return Gtk_List_Store
To API doc
To spec 

   renames Implements_Gtk_Tree_Drag_Source.To_Object
To API doc
To spec
To body; 

   package Implements_Gtk_Tree_Model is new Glib.Types.Implements
To API doc
To spec
To body 

     (Gtk.Tree_Model.Gtk_Tree_Model
To API doc
To spec, Gtk_List_Store_Record
To API doc
To spec, Gtk_List_Store
To API doc
To spec); 

   function "+" 

     (Widget : access Gtk_List_Store_Record
To API doc
To spec'Class) 

   return Gtk.Tree_Model.Gtk_Tree_Model
To API doc
To spec 

   renames Implements_Gtk_Tree_Model.To_Interface
To API doc
To spec
To body; 

   function "-" 

     (Interf : Gtk.Tree_Model.Gtk_Tree_Model
To API doc
To spec) 

   return Gtk_List_Store
To API doc
To spec 

   renames Implements_Gtk_Tree_Model.To_Object
To API doc
To spec
To body; 

   package Implements_Gtk_Tree_Sortable is new Glib.Types.Implements
To API doc
To spec
To body 

     (Gtk.Tree_Sortable.Gtk_Tree_Sortable
To API doc
To spec, Gtk_List_Store_Record
To API doc
To spec, Gtk_List_Store
To API doc
To spec); 

   function "+" 

     (Widget : access Gtk_List_Store_Record
To API doc
To spec'Class) 

   return Gtk.Tree_Sortable.Gtk_Tree_Sortable
To API doc
To spec 

   renames Implements_Gtk_Tree_Sortable.To_Interface
To API doc
To spec
To body; 

   function "-" 

     (Interf : Gtk.Tree_Sortable.Gtk_Tree_Sortable
To API doc
To spec) 

   return Gtk_List_Store
To API doc
To spec 

   renames Implements_Gtk_Tree_Sortable.To_Object
To API doc
To spec
To body; 

end Gtk.List_Store
To API doc
To spec
To body;