------------------------------------------------------------------------------ -- -- -- 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> -- A Gtk.Tree_Model_Filter.Gtk_Tree_Model_Filter is a tree model which wraps -- another tree model, and can do the following things: -- -- * Filter specific rows, based on data from a "visible column", a column -- storing booleans indicating whether the row should be filtered or not, or -- based on the return value of a "visible function", which gets a model, iter -- and user_data and returns a boolean indicating whether the row should be -- filtered or not. -- -- * Modify the "appearance" of the model, using a modify function. This -- is extremely powerful and allows for just changing some values and also for -- creating a completely different model based on the given child model. -- -- * Set a different root node, also known as a "virtual root". You can -- pass in a Gtk.Tree_Model.Gtk_Tree_Path indicating the root node for the -- filter at construction time. -- -- The basic API is similar to Gtk.Tree_Model_Sort.Gtk_Tree_Model_Sort. For -- an example on its usage, see the section on -- Gtk.Tree_Model_Sort.Gtk_Tree_Model_Sort. -- -- When using Gtk.Tree_Model_Filter.Gtk_Tree_Model_Filter, it is important to -- realize that Gtk.Tree_Model_Filter.Gtk_Tree_Model_Filter maintains an -- internal cache of all nodes which are visible in its clients. The cache is -- likely to be a subtree of the tree exposed by the child model. -- Gtk.Tree_Model_Filter.Gtk_Tree_Model_Filter will not cache the entire child -- model when unnecessary to not compromise the caching mechanism that is -- exposed by the reference counting scheme. If the child model implements -- reference counting, unnecessary signals may not be emitted because of -- reference counting rule 3, see the Gtk.Tree_Model.Gtk_Tree_Model -- documentation. (Note that e.g. Gtk.Tree_Store.Gtk_Tree_Store does not -- implement reference counting and will always emit all signals, even when -- the receiving node is not visible). -- -- Because of this, limitations for possible visible functions do apply. In -- general, visible functions should only use data or properties from the node -- for which the visibility state must be determined, its siblings or its -- parents. Usually, having a dependency on the state of any child node is not -- possible, unless references are taken on these explicitly. When no such -- reference exists, no signals may be received for these child nodes (see -- reference couting rule number 3 in the Gtk.Tree_Model.Gtk_Tree_Model -- section). -- -- Determining the visibility state of a given node based on the state of its -- child nodes is a frequently occurring use case. Therefore, -- Gtk.Tree_Model_Filter.Gtk_Tree_Model_Filter explicitly supports this. For -- example, when a node does not have any children, you might not want the -- node to be visible. As soon as the first row is added to the node's child -- level (or the last row removed), the node's visibility should be updated. -- -- This introduces a dependency from the node on its child nodes. In order to -- accommodate this, Gtk.Tree_Model_Filter.Gtk_Tree_Model_Filter must make -- sure the necesary signals are received from the child model. This is -- achieved by building, for all nodes which are exposed as visible nodes to -- Gtk.Tree_Model_Filter.Gtk_Tree_Model_Filter's clients, the child level (if -- any) and take a reference on the first node in this level. Furthermore, for -- every row-inserted, row-changed or row-deleted signal (also these which -- were not handled because the node was not cached), -- Gtk.Tree_Model_Filter.Gtk_Tree_Model_Filter will check if the visibility -- state of any parent node has changed. -- -- Beware, however, that this explicit support is limited to these two cases. -- For example, if you want a node to be visible only if two nodes in a -- child's child level (2 levels deeper) are visible, you are on your own. In -- this case, either rely on Gtk.Tree_Store.Gtk_Tree_Store to emit all signals -- because it does not implement reference counting, or for models that do -- implement reference counting, obtain references on these child levels -- yourself. -- -- </description> pragma Ada_2005; pragma Warnings (Off, "*is already use-visible*");
with Glib; use Glib;
with Glib.Properties; use Glib.Properties;
with Glib.Types; use Glib.Types;
with Glib.Values; use Glib.Values;
with Gtk.Selection_Data; use Gtk.Selection_Data;
with Gtk.Tree_Drag_Source; use Gtk.Tree_Drag_Source;
with Gtk.Tree_Model; use Gtk.Tree_Model;
package Gtk.Tree_Model_Filter is
type Gtk_Tree_Model_Filter_Record is new Gtk_Root_Tree_Model_Record with null record;
type Gtk_Tree_Model_Filter is access all Gtk_Tree_Model_Filter_Record'Class;
--------------- -- Callbacks -- --------------- type Gtk_Tree_Model_Filter_Modify_Func is access procedure
(Model : Gtk.Tree_Model.Gtk_Tree_Model; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Value : in out Glib.Values.GValue;
Column : Gint); -- A function which calculates display values from raw values in the -- model. It must fill Value with the display value for the column Column -- in the row indicated by Iter. -- Since this function is called for each data access, it's not a -- particularly efficient operation. -- "model": the Gtk.Tree_Model_Filter.Gtk_Tree_Model_Filter -- "iter": a Gtk.Tree_Model.Gtk_Tree_Iter pointing to the row whose -- display values are determined -- "value": A Glib.Values.GValue which is already initialized for with the -- correct type for the column Column. -- "column": the column whose display value is determined type Gtk_Tree_Model_Filter_Visible_Func is access function
(Model : Gtk.Tree_Model.Gtk_Tree_Model; Iter : Gtk.Tree_Model.Gtk_Tree_Iter) return Boolean;
-- A function which decides whether the row indicated by Iter is visible. -- "model": the child model of the -- Gtk.Tree_Model_Filter.Gtk_Tree_Model_Filter -- "iter": a Gtk.Tree_Model.Gtk_Tree_Iter pointing to the row in Model -- whose visibility is determined type Gtk_Tree_Model_Foreach_Func is access function
(Model : Gtk.Tree_Model.Gtk_Tree_Model; Path : Gtk.Tree_Model.Gtk_Tree_Path; Iter : Gtk.Tree_Model.Gtk_Tree_Iter) 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 ------------------ -- Constructors -- ------------------ procedure Gtk_New
(Self : out Gtk_Tree_Model_Filter;
Child_Model : Gtk.Tree_Model.Gtk_Tree_Model;
Root : Gtk.Tree_Model.Gtk_Tree_Path := Null_Gtk_Tree_Path);
procedure Initialize
(Self : not null access Gtk_Tree_Model_Filter_Record'Class;
Child_Model : Gtk.Tree_Model.Gtk_Tree_Model;
Root : Gtk.Tree_Model.Gtk_Tree_Path := Null_Gtk_Tree_Path);
-- Creates a new Gtk.Tree_Model.Gtk_Tree_Model, with Child_Model as the -- child_model and Root as the virtual root. -- Since: gtk+ 2.4 -- "child_model": A Gtk.Tree_Model.Gtk_Tree_Model. -- "root": A Gtk.Tree_Model.Gtk_Tree_Path or null. function Gtk_Tree_Model_Filter_Filter_New
(Child_Model : Gtk.Tree_Model.Gtk_Tree_Model;
Root : Gtk.Tree_Model.Gtk_Tree_Path := Null_Gtk_Tree_Path)
return Gtk_Tree_Model_Filter;
-- Creates a new Gtk.Tree_Model.Gtk_Tree_Model, with Child_Model as the -- child_model and Root as the virtual root. -- Since: gtk+ 2.4 -- "child_model": A Gtk.Tree_Model.Gtk_Tree_Model. -- "root": A Gtk.Tree_Model.Gtk_Tree_Path or null. function Get_Type return Glib.GType;
pragma Import (C, Get_Type, "gtk_tree_model_filter_get_type");
------------- -- Methods -- ------------- procedure Clear_Cache
(Self : not null access Gtk_Tree_Model_Filter_Record);
-- This function should almost never be called. It clears the Filter of -- any cached iterators that haven't been reffed with -- Gtk.Tree_Model.Ref_Node. This might be useful if the child model being -- filtered is static (and doesn't change often) and there has been a lot -- of unreffed access to nodes. As a side effect of this function, all -- unreffed iters will be invalid. -- Since: gtk+ 2.4 procedure Convert_Child_Iter_To_Iter
(Self : not null access Gtk_Tree_Model_Filter_Record;
Filter_Iter : out Gtk.Tree_Model.Gtk_Tree_Iter;
Child_Iter : Gtk.Tree_Model.Gtk_Tree_Iter);
-- Sets Filter_Iter to point to the row in Filter that corresponds to the -- row pointed at by Child_Iter. If Filter_Iter was not set, False is -- returned. -- Since: gtk+ 2.4 -- "filter_iter": An uninitialized Gtk.Tree_Model.Gtk_Tree_Iter. -- "child_iter": A valid Gtk.Tree_Model.Gtk_Tree_Iter pointing to a row on -- the child model. function Convert_Child_Path_To_Path
(Self : not null access Gtk_Tree_Model_Filter_Record;
Child_Path : Gtk.Tree_Model.Gtk_Tree_Path)
return Gtk.Tree_Model.Gtk_Tree_Path;
-- Converts Child_Path to a path relative to Filter. That is, Child_Path -- points to a path in the child model. The rerturned path will point to -- the same row in the filtered model. If Child_Path isn't a valid path on -- the child model or points to a row which is not visible in Filter, then -- null is returned. -- Since: gtk+ 2.4 -- "child_path": A Gtk.Tree_Model.Gtk_Tree_Path to convert. procedure Convert_Iter_To_Child_Iter
(Self : not null access Gtk_Tree_Model_Filter_Record;
Child_Iter : out Gtk.Tree_Model.Gtk_Tree_Iter;
Filter_Iter : Gtk.Tree_Model.Gtk_Tree_Iter);
-- Sets Child_Iter to point to the row pointed to by Filter_Iter. -- Since: gtk+ 2.4 -- "child_iter": An uninitialized Gtk.Tree_Model.Gtk_Tree_Iter. -- "filter_iter": A valid Gtk.Tree_Model.Gtk_Tree_Iter pointing to a row -- on Filter. function Convert_Path_To_Child_Path
(Self : not null access Gtk_Tree_Model_Filter_Record;
Filter_Path : Gtk.Tree_Model.Gtk_Tree_Path)
return Gtk.Tree_Model.Gtk_Tree_Path;
-- Converts Filter_Path to a path on the child model of Filter. That is, -- Filter_Path points to a location in Filter. The returned path will point -- to the same location in the model not being filtered. If Filter_Path -- does not point to a location in the child model, null is returned. -- Since: gtk+ 2.4 -- "filter_path": A Gtk.Tree_Model.Gtk_Tree_Path to convert. function Get_Model
(Self : not null access Gtk_Tree_Model_Filter_Record)
return Gtk.Tree_Model.Gtk_Tree_Model;
-- Returns a pointer to the child model of Filter. -- Since: gtk+ 2.4 procedure Refilter (Self : not null access Gtk_Tree_Model_Filter_Record);
-- Emits ::row_changed for each row in the child model, which causes the -- filter to re-evaluate whether a row is visible or not. -- Since: gtk+ 2.4 procedure Set_Modify_Func
(Self : not null access Gtk_Tree_Model_Filter_Record;
Types : Glib.GType_Array;
Func : Gtk_Tree_Model_Filter_Modify_Func);
-- With the N_Columns and Types parameters, you give an array of column -- types for this model (which will be exposed to the parent model/view). -- The Func, Data and Destroy parameters are for specifying the modify -- function. The modify function will get called for *each* data access, -- the goal of the modify function is to return the data which should be -- displayed at the location specified using the parameters of the modify -- function. -- Since: gtk+ 2.4 -- "types": The GType<!-- -->s of the columns. -- "func": A Gtk_Tree_Model_Filter_Modify_Func generic type User_Data_Type (<>) is private;
with procedure Destroy (Data : in out User_Data_Type) is null;
package Set_Modify_Func_User_Data is
type Gtk_Tree_Model_Filter_Modify_Func is access procedure
(Model : Gtk.Tree_Model.Gtk_Tree_Model; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Value : in out Glib.Values.GValue;
Column : Gint; Data : User_Data_Type); -- A function which calculates display values from raw values in the -- model. It must fill Value with the display value for the column Column -- in the row indicated by Iter. -- Since this function is called for each data access, it's not a -- particularly efficient operation. -- "model": the Gtk.Tree_Model_Filter.Gtk_Tree_Model_Filter -- "iter": a Gtk.Tree_Model.Gtk_Tree_Iter pointing to the row whose -- display values are determined -- "value": A Glib.Values.GValue which is already initialized for with the -- correct type for the column Column. -- "column": the column whose display value is determined -- "data": user data given to Gtk.Tree_Model_Filter.Set_Modify_Func procedure Set_Modify_Func
(Self : not null access Gtk.Tree_Model_Filter.Gtk_Tree_Model_Filter_Record'Class;
Types : Glib.GType_Array;
Func : Gtk_Tree_Model_Filter_Modify_Func;
Data : User_Data_Type);
-- With the N_Columns and Types parameters, you give an array of column -- types for this model (which will be exposed to the parent -- model/view). The Func, Data and Destroy parameters are for specifying -- the modify function. The modify function will get called for *each* -- data access, the goal of the modify function is to return the data -- which should be displayed at the location specified using the -- parameters of the modify function. -- Since: gtk+ 2.4 -- "types": The GType<!-- -->s of the columns. -- "func": A Gtk_Tree_Model_Filter_Modify_Func -- "data": User data to pass to the modify function, or null. end Set_Modify_Func_User_Data;
procedure Set_Visible_Column
(Self : not null access Gtk_Tree_Model_Filter_Record;
Column : Gint);
-- Sets Column of the child_model to be the column where Filter should -- look for visibility information. Columns should be a column of type -- G_TYPE_BOOLEAN, where True means that a row is visible, and False if -- not. -- Since: gtk+ 2.4 -- "column": A Gint which is the column containing the visible -- information. procedure Set_Visible_Func
(Self : not null access Gtk_Tree_Model_Filter_Record;
Func : Gtk_Tree_Model_Filter_Visible_Func);
-- Sets the visible function used when filtering the Filter to be Func. -- The function should return True if the given row should be visible and -- False otherwise. -- If the condition calculated by the function changes over time (e.g. -- because it depends on some global parameters), you must call -- Gtk.Tree_Model_Filter.Refilter to keep the visibility information of the -- model uptodate. -- Note that Func is called whenever a row is inserted, when it may still -- be empty. The visible function should therefore take special care of -- empty rows, like in the example below. -- static gboolean -- visible_func (GtkTreeModel *model, -- GtkTreeIter *iter, -- gpointer data) -- { -- /* Visible if row is non-empty and first column is "HI" */ -- gchar *str; -- gboolean visible = FALSE; -- gtk_tree_model_get (model, iter, 0, &str, -1); -- if (str && strcmp (str, "HI") == 0) -- visible = TRUE; -- g_free (str); -- return visible; -- } -- Since: gtk+ 2.4 -- "func": A Gtk_Tree_Model_Filter_Visible_Func, the visible function. generic type User_Data_Type (<>) is private;
with procedure Destroy (Data : in out User_Data_Type) is null;
package Set_Visible_Func_User_Data is
type Gtk_Tree_Model_Filter_Visible_Func is access function
(Model : Gtk.Tree_Model.Gtk_Tree_Model; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Data : User_Data_Type) return Boolean;
-- A function which decides whether the row indicated by Iter is visible. -- "model": the child model of the -- Gtk.Tree_Model_Filter.Gtk_Tree_Model_Filter -- "iter": a Gtk.Tree_Model.Gtk_Tree_Iter pointing to the row in Model -- whose visibility is determined -- "data": user data given to Gtk.Tree_Model_Filter.Set_Visible_Func procedure Set_Visible_Func
(Self : not null access Gtk.Tree_Model_Filter.Gtk_Tree_Model_Filter_Record'Class;
Func : Gtk_Tree_Model_Filter_Visible_Func;
Data : User_Data_Type);
-- Sets the visible function used when filtering the Filter to be Func. -- The function should return True if the given row should be visible -- and False otherwise. -- If the condition calculated by the function changes over time (e.g. -- because it depends on some global parameters), you must call -- Gtk.Tree_Model_Filter.Refilter to keep the visibility information of -- the model uptodate. -- Note that Func is called whenever a row is inserted, when it may -- still be empty. The visible function should therefore take special -- care of empty rows, like in the example below. -- static gboolean -- visible_func (GtkTreeModel *model, -- GtkTreeIter *iter, -- gpointer data) -- { -- /* Visible if row is non-empty and first column is "HI" */ -- gchar *str; -- gboolean visible = FALSE; -- gtk_tree_model_get (model, iter, 0, &str, -1); -- if (str && strcmp (str, "HI") == 0) -- visible = TRUE; -- g_free (str); -- return visible; -- } -- Since: gtk+ 2.4 -- "func": A Gtk_Tree_Model_Filter_Visible_Func, the visible function. -- "data": User data to pass to the visible function, or null. end Set_Visible_Func_User_Data;
procedure Foreach
(Tree_Model : not null access Gtk_Tree_Model_Filter_Record;
Func : Gtk_Tree_Model_Foreach_Func);
-- 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) is null;
package Foreach_User_Data is
type Gtk_Tree_Model_Foreach_Func is access function
(Model : Gtk.Tree_Model.Gtk_Tree_Model; Path : Gtk.Tree_Model.Gtk_Tree_Path; Iter : Gtk.Tree_Model.Gtk_Tree_Iter; Data : User_Data_Type) 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
(Tree_Model : not null access Gtk.Tree_Model_Filter.Gtk_Tree_Model_Filter_Record'Class;
Func : Gtk_Tree_Model_Foreach_Func;
User_Data : User_Data_Type);
-- 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;
--------------------------------------------- -- Inherited subprograms (from interfaces) -- --------------------------------------------- function Drag_Data_Delete
(Self : not null access Gtk_Tree_Model_Filter_Record;
Path : Gtk.Tree_Model.Gtk_Tree_Path) return Boolean;
function Drag_Data_Get
(Self : not null access Gtk_Tree_Model_Filter_Record;
Path : Gtk.Tree_Model.Gtk_Tree_Path;
Selection_Data : Gtk.Selection_Data.Gtk_Selection_Data)
return Boolean; function Row_Draggable
(Self : not null access Gtk_Tree_Model_Filter_Record;
Path : Gtk.Tree_Model.Gtk_Tree_Path) return Boolean;
function Get_Column_Type
(Tree_Model : not null access Gtk_Tree_Model_Filter_Record;
Index : Gint) return GType;
function Get_Flags
(Tree_Model : not null access Gtk_Tree_Model_Filter_Record)
return Gtk.Tree_Model.Tree_Model_Flags;
function Get_Iter
(Tree_Model : not null access Gtk_Tree_Model_Filter_Record;
Path : Gtk.Tree_Model.Gtk_Tree_Path)
return Gtk.Tree_Model.Gtk_Tree_Iter;
function Get_Iter_First
(Tree_Model : not null access Gtk_Tree_Model_Filter_Record)
return Gtk.Tree_Model.Gtk_Tree_Iter;
function Get_Iter_From_String
(Tree_Model : not null access Gtk_Tree_Model_Filter_Record;
Path_String : UTF8_String) return Gtk.Tree_Model.Gtk_Tree_Iter;
function Get_N_Columns
(Tree_Model : not null access Gtk_Tree_Model_Filter_Record)
return Gint;
function Get_Path
(Tree_Model : not null access Gtk_Tree_Model_Filter_Record;
Iter : Gtk.Tree_Model.Gtk_Tree_Iter)
return Gtk.Tree_Model.Gtk_Tree_Path;
function Get_String_From_Iter
(Tree_Model : not null access Gtk_Tree_Model_Filter_Record;
Iter : Gtk.Tree_Model.Gtk_Tree_Iter) return UTF8_String;
procedure Get_Value
(Tree_Model : not null access Gtk_Tree_Model_Filter_Record;
Iter : Gtk.Tree_Model.Gtk_Tree_Iter;
Column : Gint;
Value : out Glib.Values.GValue);
function Children
(Tree_Model : not null access Gtk_Tree_Model_Filter_Record;
Parent : Gtk.Tree_Model.Gtk_Tree_Iter)
return Gtk.Tree_Model.Gtk_Tree_Iter;
function Has_Child
(Tree_Model : not null access Gtk_Tree_Model_Filter_Record;
Iter : Gtk.Tree_Model.Gtk_Tree_Iter) return Boolean;
function N_Children
(Tree_Model : not null access Gtk_Tree_Model_Filter_Record;
Iter : Gtk.Tree_Model.Gtk_Tree_Iter := Gtk.Tree_Model.Null_Iter)
return Gint;
procedure Next
(Tree_Model : not null access Gtk_Tree_Model_Filter_Record;
Iter : in out Gtk.Tree_Model.Gtk_Tree_Iter);
function Nth_Child
(Tree_Model : not null access Gtk_Tree_Model_Filter_Record;
Parent : Gtk.Tree_Model.Gtk_Tree_Iter;
N : Gint) return Gtk.Tree_Model.Gtk_Tree_Iter;
function Parent
(Tree_Model : not null access Gtk_Tree_Model_Filter_Record;
Child : Gtk.Tree_Model.Gtk_Tree_Iter)
return Gtk.Tree_Model.Gtk_Tree_Iter;
procedure Previous
(Tree_Model : not null access Gtk_Tree_Model_Filter_Record;
Iter : in out Gtk.Tree_Model.Gtk_Tree_Iter);
procedure Ref_Node
(Tree_Model : not null access Gtk_Tree_Model_Filter_Record;
Iter : Gtk.Tree_Model.Gtk_Tree_Iter);
procedure Row_Changed
(Tree_Model : not null access Gtk_Tree_Model_Filter_Record;
Path : Gtk.Tree_Model.Gtk_Tree_Path;
Iter : Gtk.Tree_Model.Gtk_Tree_Iter);
procedure Row_Deleted
(Tree_Model : not null access Gtk_Tree_Model_Filter_Record;
Path : Gtk.Tree_Model.Gtk_Tree_Path);
procedure Row_Has_Child_Toggled
(Tree_Model : not null access Gtk_Tree_Model_Filter_Record;
Path : Gtk.Tree_Model.Gtk_Tree_Path;
Iter : Gtk.Tree_Model.Gtk_Tree_Iter);
procedure Row_Inserted
(Tree_Model : not null access Gtk_Tree_Model_Filter_Record;
Path : Gtk.Tree_Model.Gtk_Tree_Path;
Iter : Gtk.Tree_Model.Gtk_Tree_Iter);
procedure Rows_Reordered
(Tree_Model : not null access Gtk_Tree_Model_Filter_Record;
Path : Gtk.Tree_Model.Gtk_Tree_Path;
Iter : Gtk.Tree_Model.Gtk_Tree_Iter;
New_Order : Gint_Array);
procedure Unref_Node
(Tree_Model : not null access Gtk_Tree_Model_Filter_Record;
Iter : Gtk.Tree_Model.Gtk_Tree_Iter);
---------------- -- Properties -- ---------------- -- The following properties are defined for this widget. See -- Glib.Properties for more information on properties) Child_Model_Property : constant Glib.Properties.Property_Interface;
-- Type: Gtk.Tree_Model.Gtk_Tree_Model Virtual_Root_Property : constant Glib.Properties.Property_Object;
-- Type: Gtk.Tree_Model.Gtk_Tree_Path ---------------- -- Interfaces -- ---------------- -- This class implements several interfaces. See Glib.Types -- -- - "TreeDragSource" -- -- - "TreeModel" package Implements_Gtk_Tree_Drag_Source is new Glib.Types.Implements
(Gtk.Tree_Drag_Source.Gtk_Tree_Drag_Source, Gtk_Tree_Model_Filter_Record, Gtk_Tree_Model_Filter);
function "+"
(Widget : access Gtk_Tree_Model_Filter_Record'Class)
return Gtk.Tree_Drag_Source.Gtk_Tree_Drag_Source
renames Implements_Gtk_Tree_Drag_Source.To_Interface;
function "-"
(Interf : Gtk.Tree_Drag_Source.Gtk_Tree_Drag_Source)
return Gtk_Tree_Model_Filter
renames Implements_Gtk_Tree_Drag_Source.To_Object;
package Implements_Gtk_Tree_Model is new Glib.Types.Implements
(Gtk.Tree_Model.Gtk_Tree_Model, Gtk_Tree_Model_Filter_Record, Gtk_Tree_Model_Filter);
function "+"
(Widget : access Gtk_Tree_Model_Filter_Record'Class)
return Gtk.Tree_Model.Gtk_Tree_Model
renames Implements_Gtk_Tree_Model.To_Interface;
function "-"
(Interf : Gtk.Tree_Model.Gtk_Tree_Model)
return Gtk_Tree_Model_Filter
renames Implements_Gtk_Tree_Model.To_Object;
private Virtual_Root_Property : constant Glib.Properties.Property_Object :=
Glib.Properties.Build ("virtual-root");
Child_Model_Property : constant Glib.Properties.Property_Interface :=
Glib.Properties.Build ("child-model");
end Gtk.Tree_Model_Filter;