GtkTreeModel

typedef struct _GtkTreeModel GtkTreeModel;

GtkTreeIter

typedef struct {
  gint stamp;
  gpointer user_data;
  gpointer user_data2;
  gpointer user_data3;
} GtkTreeIter;

GtkTreeIter est une structure primaire pour accèder au magasin. Les magasins sont sensés placer un entier unique dans le membre  stamp  et mettre des données spécifiques au m agasins dans les membres  user_data de l'arbre.

GtkTreePath

typedef struct _GtkTreePath GtkTreePath;

GtkTreeRowReference

typedef struct _GtkTreeRowReference GtkTreeRowReference;

GtkTreeModelIface

typedef struct {
  GTypeInterface g_iface;

  /* Signals */
  void         (* row_changed)           (GtkTreeModel *tree_model,
					  GtkTreePath  *path,
					  GtkTreeIter  *iter);
  void         (* row_inserted)          (GtkTreeModel *tree_model,
					  GtkTreePath  *path,
					  GtkTreeIter  *iter);
  void         (* row_has_child_toggled) (GtkTreeModel *tree_model,
					  GtkTreePath  *path,
					  GtkTreeIter  *iter);
  void         (* row_deleted)           (GtkTreeModel *tree_model,
					  GtkTreePath  *path);
  void         (* rows_reordered)        (GtkTreeModel *tree_model,
					  GtkTreePath  *path,
					  GtkTreeIter  *iter,
					  gint         *new_order);

  /* Virtual Table */
  GtkTreeModelFlags (* get_flags)  (GtkTreeModel *tree_model);   

  gint         (* get_n_columns)   (GtkTreeModel *tree_model);
  GType        (* get_column_type) (GtkTreeModel *tree_model,
				    gint          index_);
  gboolean     (* get_iter)        (GtkTreeModel *tree_model,
				    GtkTreeIter  *iter,
				    GtkTreePath  *path);
  GtkTreePath *(* get_path)        (GtkTreeModel *tree_model,
				    GtkTreeIter  *iter);
  void         (* get_value)       (GtkTreeModel *tree_model,
				    GtkTreeIter  *iter,
				    gint          column,
				    GValue       *value);
  gboolean     (* iter_next)       (GtkTreeModel *tree_model,
				    GtkTreeIter  *iter);
  gboolean     (* iter_children)   (GtkTreeModel *tree_model,
				    GtkTreeIter  *iter,
				    GtkTreeIter  *parent);
  gboolean     (* iter_has_child)  (GtkTreeModel *tree_model,
				    GtkTreeIter  *iter);
  gint         (* iter_n_children) (GtkTreeModel *tree_model,
				    GtkTreeIter  *iter);
  gboolean     (* iter_nth_child)  (GtkTreeModel *tree_model,
				    GtkTreeIter  *iter,
				    GtkTreeIter  *parent,
				    gint          n);
  gboolean     (* iter_parent)     (GtkTreeModel *tree_model,
				    GtkTreeIter  *iter,
				    GtkTreeIter  *child);
  void         (* ref_node)        (GtkTreeModel *tree_model,
				    GtkTreeIter  *iter);
  void         (* unref_node)      (GtkTreeModel *tree_model,
				    GtkTreeIter  *iter);
} GtkTreeModelIface;

GtkTreeModelForeachFunc ()

gboolean            (*GtkTreeModelForeachFunc)          (GtkTreeModel *model,
                                                         GtkTreePath *path,
                                                         GtkTreeIter *iter,
                                                         gpointer data);

enum GtkTreeModelFlags

typedef enum
{
  GTK_TREE_MODEL_ITERS_PERSIST = 1 << 0,
  GTK_TREE_MODEL_LIST_ONLY = 1 << 1
} GtkTreeModelFlags;

Ces flags indiquent des propriétés variées pour  GtkTreeModel. Ils sont retournés par  gtk_tree_model_get_flags(), et doivent être static pendant la durée de vie de l'objet. Une description plus complète de  GTK_TREE_MODEL_ITERS_PERSIST est présentée ci-dessus dans le chapitre "description"  de cette  section.

gtk_tree_path_new ()

GtkTreePath*        gtk_tree_path_new                   (void);

Crée un nouveau GtkTreePath. Cette structure se rapporte à une rangée.

gtk_tree_path_new_from_string ()

GtkTreePath*        gtk_tree_path_new_from_string       (const gchar *path);

Crée un nouveau  GtkTreePath initialisé à  path. pathest une liste de nombres séparés par deux points. Par exemple la chaîne "10:4:0" crééra un chemin de profondeur 3 pointant sur le 11ème enfant de la racine de l'arbre , le 5ème enfant de ce 11ème enfant et le premier enfant de ce 5ème enfant. Si une chaîne de chemin  invalide  est passée, la fonction retournera NULL.

gtk_tree_path_new_from_indices ()

GtkTreePath*        gtk_tree_path_new_from_indices      (gint first_index,
                                                         ...);

Créé un nouveau chemin avec  first_index et varargs en indices.

Depuis 2.2

gtk_tree_path_to_string ()

gchar*              gtk_tree_path_to_string             (GtkTreePath *path);

gtk_tree_path_new_first ()

GtkTreePath*        gtk_tree_path_new_first             (void);

gtk_tree_path_new_root()

#define gtk_tree_path_new_root() gtk_tree_path_new_first()

Alternative est gtk_tree_path_new_first() fourni pour des raisons de compatibilité.

gtk_tree_path_append_index ()

void                gtk_tree_path_append_index          (GtkTreePath *path,
                                                         gint index_);

Ajoute un nouvel index à la fin d'un chemin. Ainsi la profondeur du chemin augmente.

gtk_tree_path_prepend_index ()

void                gtk_tree_path_prepend_index         (GtkTreePath *path,
                                                         gint index_);

Ajoute un nouvel  index au début d'un chemin. Ainsi la profondeur du chemin augmente.

gtk_tree_path_get_depth ()

gint                gtk_tree_path_get_depth             (GtkTreePath *path);

Retourne la profondeur courante d'un chemin path.

gtk_tree_path_get_indices ()

gint*               gtk_tree_path_get_indices           (GtkTreePath *path);

Retourne les indices courants du chemin  path. C'est un tableau d'entiers, chaque entier représente un embranchement de l'arbre. Cette valeur ne doit pas être libérée.

gtk_tree_path_free ()

void                gtk_tree_path_free                  (GtkTreePath *path);

Libére un chemin path.

gtk_tree_path_copy ()

GtkTreePath*        gtk_tree_path_copy                  (const GtkTreePath *path);

Crée un nouveau  GtkTreePath en copiant le chemin  path.

gtk_tree_path_compare ()

gint                gtk_tree_path_compare               (const GtkTreePath *a,
                                                         const GtkTreePath *b);

Compare deux chemins. Si a apparaît avant  b dans un arbre, alors -1 sera retourné. Si b apparaît avant  a, alors  1 sera retourné. Si les deux embranchements sont égaux, alors 0 sera retourné.

gtk_tree_path_next ()

void                gtk_tree_path_next                  (GtkTreePath *path);

Déplace le chemin  path pour qu'il pointe sur l'embranchement suivant à la profondeur courante.

gtk_tree_path_prev ()

gboolean            gtk_tree_path_prev                  (GtkTreePath *path);

Déplace le chemin  path  pour qu'il pointe sur l'embranchement précédent à la profondeur courante, si il existe.

gtk_tree_path_up ()

gboolean            gtk_tree_path_up                    (GtkTreePath *path);

Déplace le chemin  path pour qu'il pointe sur l'embranchement parent si il a un embranchement parent.

gtk_tree_path_down ()

void                gtk_tree_path_down                  (GtkTreePath *path);

Déplace le chemin  path pour qu'il pointe sur le premier enfant du chemin courant.

gtk_tree_path_is_ancestor ()

gboolean            gtk_tree_path_is_ancestor           (GtkTreePath *path,
                                                         GtkTreePath *descendant);

Retourne TRUE si descendant est un descendant du chemin path.

gtk_tree_path_is_descendant ()

gboolean            gtk_tree_path_is_descendant         (GtkTreePath *path,
                                                         GtkTreePath *ancestor);

Retourne TRUE si le chemin  path est un descendant de ancestor.

gtk_tree_row_reference_new ()

GtkTreeRowReference* gtk_tree_row_reference_new         (GtkTreeModel *model,
                                                         GtkTreePath *path);

gtk_tree_row_reference_new_proxy ()

GtkTreeRowReference* gtk_tree_row_reference_new_proxy   (GObject *proxy,
                                                         GtkTreeModel *model,
                                                         GtkTreePath *path);

Vous ne devez pas avoir besoin d'utiliser cette fonction. Elle crée une référence de rangée basée sur le chemin  path. Cette référence pointera sur l'embranchement indiqué par le chemin  path aussi longtemps que cet embranchement existera. Si path n'est pas valide dans me magasin model,alors NULL sera retourné. Cependant, contrairement aux références créées avec  gtk_tree_row_reference_new(), elle ne sera pas à l'écoute des changements du magasin. Le créateur de la référence de rangée doit gérer cela explicitement en utilisant  gtk_tree_row_reference_inserted(), gtk_tree_row_reference_deleted(), gtk_tree_row_reference_reordered().

Ces fonctions doivent être appelées exactement une fois par proxy quand le signal correspondant est émis sur le magasin. Cette appel unique met à jour toutes les références de rangée pour ce proxy. Depuis que GTK+ a intégré des objets comme GtkTreeView qui utilisent déjà ce mécanisme en interne, les utiliser comme des objets intermédiaires (proxy) provoque des résultats imprévisibles. De plus, le passage du même objet comme magasin model et comme proxy  ne fonctionne pour des raisons d'exécution interne.

Ce type de référence de rangée a une signification principalement  pour des structures qui ont besoin  d'être surveillées soigneusement, précisément quand la référence de rangée se met à jour elle même. Elle n'est généralement pas nécessaire à la plupart des applications.

gtk_tree_row_reference_get_model ()

GtkTreeModel*       gtk_tree_row_reference_get_model    (GtkTreeRowReference *reference);

Retourne le magasin que la référence de rangée surveille.

Depuis 2.8

gtk_tree_row_reference_get_path ()

GtkTreePath*        gtk_tree_row_reference_get_path     (GtkTreeRowReference *reference);

Retourne un chemin sur lequel  la référence de rangée pointe ou  NULL si le chemin pointé n'est plus valide.

gtk_tree_row_reference_valid ()

gboolean            gtk_tree_row_reference_valid        (GtkTreeRowReference *reference);

Retourne TRUE si la reference n'est pas NULL et fait référence à un chemin valide courant.

gtk_tree_row_reference_free ()

void                gtk_tree_row_reference_free         (GtkTreeRowReference *reference);

Libére la  reference. reference peu être NULL.

gtk_tree_row_reference_copy ()

GtkTreeRowReference* gtk_tree_row_reference_copy        (GtkTreeRowReference *reference);

Copie une GtkTreeRowReference.

Depuis 2.2

gtk_tree_row_reference_inserted ()

void                gtk_tree_row_reference_inserted     (GObject *proxy,
                                                         GtkTreePath *path);

Imforme un ensemble de références de rangée créé par  gtk_tree_row_reference_new_proxy() que le magasin a émis un signal  "row_inserted".

gtk_tree_row_reference_deleted ()

void                gtk_tree_row_reference_deleted      (GObject *proxy,
                                                         GtkTreePath *path);

gtk_tree_row_reference_reordered ()

void                gtk_tree_row_reference_reordered    (GObject *proxy,
                                                         GtkTreePath *path,
                                                         GtkTreeIter *iter,
                                                         gint *new_order);

Informe un ensemble de références de rangées créé par  gtk_tree_row_reference_new_proxy() que le magasin a émis le signal  "rows_reordered".

gtk_tree_iter_copy ()

GtkTreeIter*        gtk_tree_iter_copy                  (GtkTreeIter *iter);

Crée un itérateur d'arbre alloué dynamiquement en copiant iter. Cette fonction n'est pas prévue pour être utilisée dans des application parce que vous pouvez copier la structure ainsi (GtkTreeIter new_iter = iter;). Vous devez libérer cet itérateur avec  gtk_tree_iter_free().

gtk_tree_iter_free ()

void                gtk_tree_iter_free                  (GtkTreeIter *iter);

gtk_tree_model_get_flags ()

GtkTreeModelFlags   gtk_tree_model_get_flags            (GtkTreeModel *tree_model);

Retourne un ensemble de flags supporté par cet interface. Les flags sont des combinaisons au niveau des bits  de GtkTreeModelFlags . Les flags supportés de doivent pas être modifiés pendant le temps de vie deu magasin tree_model.

gtk_tree_model_get_n_columns ()

gint                gtk_tree_model_get_n_columns        (GtkTreeModel *tree_model);

gtk_tree_model_get_column_type ()

GType               gtk_tree_model_get_column_type      (GtkTreeModel *tree_model,
                                                         

Retourne le type de la colonne.

gtk_tree_model_get_iter ()

gboolean            gtk_tree_model_get_iter             (GtkTreeModel *tree_model,
                                                         GtkTreeIter *iter,
                                                         GtkTreePath *path);

Définit iter comme un itérateur valide pointant sur le chemin path.

gtk_tree_model_get_iter_from_string ()

gboolean            gtk_tree_model_get_iter_from_string (GtkTreeModel *tree_model,
                                                         GtkTreeIter *iter,
                                                         const gchar *path_string);

Définit iter à un itérateur valide pointant sur  path_string, si'l existe. Autrement, iter reste invalide et FALSE sera retourné.

gtk_tree_model_get_iter_first ()

gboolean            gtk_tree_model_get_iter_first       (GtkTreeModel *tree_model,
                                                         GtkTreeIter *iter);

gtk_tree_model_get_iter_root()

#define gtk_tree_model_get_iter_root(tree_model, iter) gtk_tree_model_get_iter_first(tree_model, iter)

Alternative pour gtk_tree_model_get_iter_first()foourni pour des raisons de compatibilité; cette macro sera  désapprouvée dans une prochaine version de GTK+.

gtk_tree_model_get_path ()

GtkTreePath*        gtk_tree_model_get_path             (GtkTreeModel *tree_model,
                                                         GtkTreeIter *iter);

Retourne GtkTreePath nouvellement créé et référencé par iter.  Ce chemin doit être libéré avec gtk_tree_path_free().

gtk_tree_model_get_value ()

void                gtk_tree_model_get_value            (GtkTreeModel *tree_model,
                                                         GtkTreeIter *iter,
                                                         gint column,
                                                         GValue *value);

Sets initializes and sets value to that at column. (??) Quand vous avez terminé d'utiliser value, il faut appeler g_value_unset()  pour libérer toute la mémoire allouée.

gtk_tree_model_iter_next ()

gboolean            gtk_tree_model_iter_next            (GtkTreeModel *tree_model,
                                                         GtkTreeIter *iter);

Définit iter pour qu'il pointe sur l'embranchement qui suit celui du niveau courant. S'il n'est pas suivi par un autre iter, FALSE est retourné et iter est défini comme étant invalide.

gtk_tree_model_iter_children ()

gboolean            gtk_tree_model_iter_children        (GtkTreeModel *tree_model,
                                                         GtkTreeIter *iter,
                                                         GtkTreeIter *parent);

Définit  iter pour qu'il pointe sur le premier enfant de  parent. Si  parent n'a pas d'enfant, FALSE est retourné et  iter est défini comme invalide. parent sera toujours un embranchement valide après l'appelle de cette fonction.

Si  parent est NULL le premier embranchement sera définit, cette fonction est équivalente dans ce cas à  gtk_tree_model_get_iter_first (tree_model, iter);

gtk_tree_model_iter_has_child ()

gboolean            gtk_tree_model_iter_has_child       (GtkTreeModel *tree_model,
                                                         GtkTreeIter *iter);

Retourne  TRUE si iter a un ou des enfants, FALSE autrement.

gtk_tree_model_iter_n_children ()

gint                gtk_tree_model_iter_n_children      (GtkTreeModel *tree_model,
                                                         GtkTreeIter *iter);

Retourne le nombre d'enfants que iter  a. Cas particulier, si  iter est NULL, alors le nombre de niveaux supérieurs sera retourne.

gtk_tree_model_iter_nth_child ()

gboolean            gtk_tree_model_iter_nth_child       (GtkTreeModel *tree_model,
                                                         GtkTreeIter *iter,
                                                         GtkTreeIter *parent,
                                                         gint n);

Définit  iter pour qu'il soit l'enfant de  parent,  en utilisant un index donné. Le premier index est 0. Si  n est trop grand, ou si  parent n'a pas d'enfant, iter sera définit comme itérateur invalide et FALSE sera retourné. parent  reste un embranchement valide après que la fonction ait été appelée. Cas particulier, si  parent est NULL alors le  nième embranchement sera définit.

gtk_tree_model_iter_parent ()

gboolean            gtk_tree_model_iter_parent          (GtkTreeModel *tree_model,
                                                         GtkTreeIter *iter,
                                                         GtkTreeIter *child);

Définit  iter pour qu'il soit le parent de l'enfant child. Si child est au niveau supérieur et qu'il n'a pas de parent alors  iter sera définit comme itérateur invalide et  FALSE sera retourné. child restera un embranchement valide après l'appelle de la fonction.

gtk_tree_model_get_string_from_iter ()

gchar*              gtk_tree_model_get_string_from_iter (GtkTreeModel *tree_model,
                                                         GtkTreeIter *iter);

Génère une chaîne de caractères représentant l'itérateur. cette chaîne est une liste de nombres séparés par ":". Par exemple  "4:10:0:3" serait une valeur correcte pour ce genre de chaîne.

Depuis 2.2

gtk_tree_model_ref_node ()

void                gtk_tree_model_ref_node             (GtkTreeModel *tree_model,
                                                         GtkTreeIter *iter);

L'arbre va référencer l'embranchement. C'est une méthode facultative pour la mise en application des magasins. Les magasins peuvent ignorer cet appel (si son existance est antérieure) ??, ceci pour des questions d'exécution.

Le rôle principal de cette fonction est de donner aux visualiseurs  la possibilité de permettre au model caché de savoir quand l'embranchement est affiché (et par conséquent, si  oui ou non il faut cacher cet embranchement.) Par exemple, un systèle de fichiers basé sur un magasin ne conserve pas la hiérarchie entière des fichiers en mémoire, il lui suffit de mémoriser simplement les sections qui sont affichées par toutes les vues courantes.

Un magasin devrait être prévu pour pouvoir obtenir un  iter indépendant de son état de référence.

gtk_tree_model_unref_node ()

void                gtk_tree_model_unref_node           (GtkTreeModel *tree_model,
                                                         GtkTreeIter *iter);

L'arbre supprime la référence de l'embranchement. C'est une méthode optionnelle à appliquer. Pour être plus précis, les magasins peuvent ignorer cet appel  (si son existance est antérieure) ?? pour des raisons liées à l'exécution.

Pour plus d'informations à ce sujet, voir gtk_tree_model_ref_node(). Notez que les embranchements supprimés non sont pas déréférencés.

gtk_tree_model_get ()

void                gtk_tree_model_get                  (GtkTreeModel *tree_model,
                                                         GtkTreeIter *iter,
                                                         ...);

Donne la valeur d'une ou plusieures cellules de la rangée référencée par  iter. La liste  à nombre variable d'arguments doit contenir l'entier remprésentant le numéro descolonnes, chaque numéro de colonne est suivi par une place où stocker les valeurs trouvées. Cette liste se termine par  -1. Par exemple, pour trouver la valeur de la colonne 0 qui a le type  G_TYPE_STRING, vous écririez : gtk_tree_model_get (magasin, iter, 0, &mettez_chaine_ici, -1), où mettez_chaine_ici est un  gchar* contenant la chaîne. Si cela est approprié, les valeurs retournées doivent être libées ou déréférencées.

gtk_tree_model_get_valist ()

void                gtk_tree_model_get_valist           (GtkTreeModel *tree_model,
                                                         GtkTreeIter *iter,
                                                         va_list var_args);

Voir gtk_tree_model_get(), cette version prend un  va_list (comme raccourci de langage à utiliser) ?for language bindings to use.

gtk_tree_model_foreach ()

void                gtk_tree_model_foreach              (GtkTreeModel *model,
                                                         GtkTreeModelForeachFunc func,
                                                         gpointer user_data);

Appelle une fonction pour chaque embranchement d'un magasin en mode  depth-first. Si func retourne TRUE, alors l'arbre cesse de fonctionner, et gtk_tree_model_foreach() retourne.

gtk_tree_model_row_changed ()

void                gtk_tree_model_row_changed          (GtkTreeModel *tree_model,
                                                         GtkTreePath *path,
                                                         GtkTreeIter *iter);

Emet le signal  "row_changed" sur tree_model.

gtk_tree_model_row_inserted ()

void                gtk_tree_model_row_inserted         (GtkTreeModel *tree_model,
                                                         GtkTreePath *path,
                                                         GtkTreeIter *iter);

Emet le signal "row_inserted" sur tree_model

gtk_tree_model_row_has_child_toggled ()

void                gtk_tree_model_row_has_child_toggled
                                                        (GtkTreeModel *tree_model,
                                                         GtkTreePath *path,
                                                         GtkTreeIter *iter);

Emet le signal "row_has_child_toggled" sur tree_model. Elle doit être appelée par les magasins après que l'état de l'enfant de l'embranchement ait changé.

gtk_tree_model_row_deleted ()

void                gtk_tree_model_row_deleted          (GtkTreeModel *tree_model,
                                                         GtkTreePath *path);

Emet le signal  "row_deleted" sur tree_model. Elle doit être appelée par les magasins après qu'une rangée ait été supprimée. L'endroit sur lequel pointe le chemin  path doit être l'endroit où la rangée était avant sa suppression. Ce ne sera jamais une localisation valide.

gtk_tree_model_rows_reordered ()

void                gtk_tree_model_rows_reordered       (GtkTreeModel *tree_model,
                                                         GtkTreePath *path,
                                                         GtkTreeIter *iter,
                                                         gint *new_order);

Emet le signal  "rows_reordered" sur tree_model. Elle doit être appelée par les magasins quand leurs rangées ont été réorganisée.

Le signal  "row-changed" 

void                user_function                      (GtkTreeModel *tree_model,
                                                        GtkTreePath  *path,
                                                        GtkTreeIter  *iter,
                                                        gpointer      user_data)       : Run Last

Ce signal est émis quand la rangée du magasin a changé.

Le signal "row-deleted" 

void                user_function                      (GtkTreeModel *tree_model,
                                                        GtkTreePath  *path,
                                                        gpointer      user_data)       : Run First

Ce signal est émis quand la rangée a été supprimée.

Notez qu'aucun itérateur n'est passé au gestionnaire de signal puisque la rangée est supprimée.

Les applications de  GtkTreeModel doivent émettre  row-deleted avantde supprimer l'embranchement de leurs structures de données internes. En effet les magasins et les visualisateurs qui accèdent et gèrent ce magasin doivent  posséder une référence de l'embranchement qui devra être libéré dans le gestionnaire de  row-deleted.

Le signal "row-has-child-toggled"

void                user_function                      (GtkTreeModel *tree_model,
                                                        GtkTreePath  *path,
                                                        GtkTreeIter  *iter,
                                                        gpointer      user_data)       : Run Last

Ce signal est émis quand la rangée est devenu la première rangée  enfant ou a perdu  sa dernière rangée enfant.

Le signal "row-inserted" 

void                user_function                      (GtkTreeModel *tree_model,
                                                        GtkTreePath  *path,
                                                        GtkTreeIter  *iter,
                                                        gpointer      user_data)       : Run First

Ce signal est émis quand la nouvelle rangée a été inserrée dans le magasin.

Notez que cette rangée peut être vide à ce moment, puisque que l'insertion d'une rangée vide est une méthode commune,elle sera remplie avec les valeurs désirées en deuxième lieu.

Le signal  "rows-reordered" 

void                user_function                      (GtkTreeModel *tree_model,
                                                        GtkTreePath  *path,
                                                        GtkTreeIter  *iter,
                                                        gpointer      arg3,
                                                        gpointer      user_data)       : Run First

Ce signal est émis quand les enfants de l'embranchement dans  GtkTreeModel ont été réordonnées.

Notez que ce signal n'est pas émis quand les rangées sont réordonnées par DND puisque cela se fait en supprimant puis en réinserrant la rangée.