GtkTreeView comme GtkBuildable

The GtkTreeView implementation of the GtkBuildable interface accepts GtkTreeViewColumn objects as <child> elements in UI definitions.

<object class="GtkTreeView">
  <property name="model">liststore1</property>
  <child>
    <object class="GtkTreeViewColumn">
      <property name="title">Test</property>
      <child>
        <object class="GtkCellRendererText"/>
        <attributes>"
          <attribute name="text">1</attribute>
        </attributes>
      </child>
    </object>
  </child>
</object>

GtkTreeView

typedef struct _GtkTreeView GtkTreeView;

enum GtkTreeViewDropPosition

typedef enum
{
  /* drop before/after this row */
  GTK_TREE_VIEW_DROP_BEFORE,
  GTK_TREE_VIEW_DROP_AFTER,
  /* drop as a child of this row (with fallback to before or after
   * if into is not possible)
   */
  GTK_TREE_VIEW_DROP_INTO_OR_BEFORE,
  GTK_TREE_VIEW_DROP_INTO_OR_AFTER
} GtkTreeViewDropPosition;

Enumération pour où sera déposée une ligne.

GtkTreeViewPrivate

typedef struct _GtkTreeViewPrivate GtkTreeViewPrivate;

Structure privée utilisée en interne seulement. La définition de cette structure ne peut pas être publiée.

GtkTreeViewColumnDropFunc ()

gboolean            (*GtkTreeViewColumnDropFunc)        (GtkTreeView *tree_view,
                                                         GtkTreeViewColumn *column,
                                                         GtkTreeViewColumn *prev_column,
                                                         GtkTreeViewColumn *next_column,
                                                         gpointer data);

Type de fonction pour déterminer si une colonne column peut être déposée sur un point particulier ( délimité par les colonnes  prev_column et next_column). En mode  gauche / droite, prev_column est à gauche du point potentiel du lâcher, et  next_column est à droite. En mode droite /gauche c'est l'inverse. Cette fonction doit retourner  TRUE si le point est un point de lâcher valide. Notez que la valeur  TRUE n'indique pas que le lâcher de colonne a été effectué, mais cela signifie seulement que le lâcher est possible.

GtkTreeViewMappingFunc ()

void                (*GtkTreeViewMappingFunc)           (GtkTreeView *tree_view,
                                                         GtkTreePath *path,
                                                         gpointer user_data);

Fonction utilisée pour  gtk_tree_view_map_expanded_rows.

GtkTreeViewSearchEqualFunc ()

gboolean            (*GtkTreeViewSearchEqualFunc)       (GtkTreeModel *model,
                                                         gint column,
                                                         const gchar *key,
                                                         GtkTreeIter *iter,
                                                         gpointer search_data);

Fonction utilisée pour contrôler si une rangée du magasin model correspond à une chaîne/mot  "clé" entré(e) par l'utilisateur. Notez que la valeur retournée est l'inverse de ce à quoi vous pouvez vous attendre, ainsi il y a une certaine ressemblance avec la fonction strcmp() qui retourne 0 pour des chaînes identiques.

gtk_tree_view_new ()

GtkWidget*          gtk_tree_view_new                   (void);

Crée un nouveau widget GtkTreeView.

gtk_tree_view_get_level_indentation ()

gint                gtk_tree_view_get_level_indentation (GtkTreeView *tree_view);

Retourne l'indentation supplémentaire en pixels pour les niveaux enfants dans un visualiseur d'arbre.

Depuis 2.12

gtk_tree_view_get_show_expanders ()

gboolean            gtk_tree_view_get_show_expanders    (GtkTreeView *tree_view);

Retourne si oui ou non un développeur de rangée est dessiné dans l'afficheur d'arbre tree_view.

Depuis 2.12

gtk_tree_view_set_level_indentation ()

void                gtk_tree_view_set_level_indentation (GtkTreeView *tree_view,
                                                         gint indentation);

Définit l'indentation ajoutée à l'indentation par défaut utilisée pour les niveaux enfants dans l'afficheur d'arbre tree_view . La valeur doit être donnée en pixels, une valeur de  désactive le dispositif et dans ce cas  seule l'indentation par défaut sera utilisée. Ceci n'a aucun effet pour une liste.

Depuis 2.12

gtk_tree_view_set_show_expanders ()

void                gtk_tree_view_set_show_expanders    (GtkTreeView *tree_view,
                                                         gboolean enabled);

Détermine s'il faut dessine et activer les développeurs de rangée et indenter les rangées enfants dans un afficheur d'arbre tree_view. Quand l'indentation est désactivée, il n'y a pas de développeur visible dans les arbres et  on ne peut pas développer une rangée repliée par défaut.Notez aussi que le fait de cacher les développeurs de rangée désactibe l'indentation par défaut. Vous pouvez définir une indentation dans ce cas en utilisant  gtk_tree_view_set_level_indentation(). Ceci n'a aucun effet pour une liste.

Depuis 2.12

gtk_tree_view_new_with_model ()

GtkWidget*          gtk_tree_view_new_with_model        (GtkTreeModel *model);

Crée un nouveau widget GtkTreeView avec un magasin initialisé à  model.

gtk_tree_view_get_model ()

GtkTreeModel*       gtk_tree_view_get_model             (GtkTreeView *tree_view);

Retourne le magasin sur lequel est basé  GtkTreeView . Retourne  NULL si le magasin n'est pas défini.

gtk_tree_view_set_model ()

void                gtk_tree_view_set_model             (GtkTreeView *tree_view,
                                                         GtkTreeModel *model);

Définit me magasin pour un GtkTreeView. Si l'afficheur d'arbre  tree_view a déjà un magasin défini, il sera supprimé avant que le nouveau magasin soit défini. Si  model est NULL, alors cette fonction supprimera l'ancien magasin.

gtk_tree_view_get_selection ()

GtkTreeSelection*   gtk_tree_view_get_selection         (GtkTreeView *tree_view);

Récupère la  GtkTreeSelection associée à l'afficheur d'arbre  tree_view.

gtk_tree_view_get_hadjustment ()

GtkAdjustment*      gtk_tree_view_get_hadjustment       (GtkTreeView *tree_view);

Récupère le  GtkAdjustment courant utilisé pour définir l'aspect horizontal.

gtk_tree_view_set_hadjustment ()

void                gtk_tree_view_set_hadjustment       (GtkTreeView *tree_view,
                                                         GtkAdjustment *adjustment);

Définit un GtkAdjustment pour l'aspect horizontal courant.

gtk_tree_view_get_vadjustment ()

GtkAdjustment*      gtk_tree_view_get_vadjustment       (GtkTreeView *tree_view);

Récupère le GtkAdjustment courant qui définit l'aspect vertical.

gtk_tree_view_set_vadjustment ()

void                gtk_tree_view_set_vadjustment       (GtkTreeView *tree_view,
                                                         GtkAdjustment *adjustment);

Récupère le  GtkAdjustment courant pour l'aspect vertical.

gtk_tree_view_get_headers_visible ()

gboolean            gtk_tree_view_get_headers_visible   (GtkTreeView *tree_view);

Retourne  TRUE si les entêtes dans l'afficheur d'arbre sont visibles.

gtk_tree_view_set_headers_visible ()

void                gtk_tree_view_set_headers_visible   (GtkTreeView *tree_view,
                                                         gboolean headers_visible);

Définit l'état de visibilité des entêtes.

gtk_tree_view_columns_autosize ()

void                gtk_tree_view_columns_autosize      (GtkTreeView *tree_view);

Redimensionne toutes les colonnes à leur largeur optimale. Cela fonctionne seulement quand les afficheurs d'arbres ont été  realized. (affichés, crées??)

gtk_tree_view_get_headers_clickable ()

gboolean            gtk_tree_view_get_headers_clickable (GtkTreeView *tree_view);

Retourbe si toutes les entêtes de colonnes sont cliquables.

Depuis 2.10

gtk_tree_view_set_headers_clickable ()

void                gtk_tree_view_set_headers_clickable (GtkTreeView *tree_view,
                                                         gboolean setting);

Rend le bouton du titre des colonnes cliquable.

gtk_tree_view_set_rules_hint ()

void                gtk_tree_view_set_rules_hint        (GtkTreeView *tree_view,
                                                         gboolean setting);

Cette fonction dit à GTK+ que l'interface utilisateur pour votre application indique que l'on souhaite faciliter la lecture des lignes pour l'utilisateur par un choix de couleur de fond alternée pour chaque ligne. Par défaut, GTK+ affichera ensuite l'arbre avec des rangées colorées en alternance. Vous ne devez pas utiliser cela uniquement parce que vous préférez l'apparence de  l'arbre avec ces marques ; ceci concerne le thème. Certains thèmes dessineront des rangées d'arbre en alternant les couleurs même quand les marques sont désactivées, les utilisateurs qui préfèrent que cette apparence s'affiche tout le temps peuvent choisir ce genre de thème. Vous devez appeler cette fonction seulement en tant que semantic hint  to the theme engine that your tree makes alternating colors useful from a functional standpoint (quand il y a beaucoup de colonnes en général).

gtk_tree_view_get_rules_hint ()

gboolean            gtk_tree_view_get_rules_hint        (GtkTreeView *tree_view);

Récupère la configuration définie par  gtk_tree_view_set_rules_hint().

gtk_tree_view_append_column ()

gint                gtk_tree_view_append_column         (GtkTreeView *tree_view,
                                                         GtkTreeViewColumn *column);

Ajoute une colonne column  à la fin de la liste des colonnes. Si la taille de l'afficheur d'abre tree_view est fixe , mode "fixed_height" activé, alors column doit avoir la propriété  "sizing" définit à  GTK_TREE_VIEW_COLUMN_FIXED.

gtk_tree_view_remove_column ()

gint                gtk_tree_view_remove_column         (GtkTreeView *tree_view,
                                                         GtkTreeViewColumn *column);

Supprime une colonne column de l'afficheur d'arbre tree_view.

gtk_tree_view_insert_column ()

gint                gtk_tree_view_insert_column         (GtkTreeView *tree_view,
                                                         GtkTreeViewColumn *column,
                                                         gint position);

Iserre la colonne column dans l'afficheur d'arbre  tree_view à position. SI position est -1, alors la colonne esr inserrée à la fin. Si tree_view a le mode  "fixed_height" (taille fixe) activé alors  column  doit avoir la propriété  "sizing" définie à  GTK_TREE_VIEW_COLUMN_FIXED.

gtk_tree_view_insert_column_with_attributes ()

gint                gtk_tree_view_insert_column_with_attributes
                                                        (GtkTreeView *tree_view,
                                                         gint position,
                                                         const gchar *title,
                                                         GtkCellRenderer *cell,
                                                         ...);

Crée un nouveau GtkTreeViewColumn et l'inserre dans l'afficheur d'arbre  tree_view à position. Si position est  -1, alors la nouvelle colonne est inserrée à la fin. La colonne est initialisée avec les attributs donnés. Si tree_view à le mode "fixed_height" (taille fixe) activé, alors la nouvelle colonne aura la propriété de redimensionnement définit à  GTK_TREE_VIEW_COLUMN_FIXED.

gtk_tree_view_insert_column_with_data_func ()

gint                gtk_tree_view_insert_column_with_data_func
                                                        (GtkTreeView *tree_view,
                                                         gint position,
                                                         const gchar *title,
                                                         GtkCellRenderer *cell,
                                                         GtkTreeCellDataFunc func,
                                                         gpointer data,
                                                         GDestroyNotify dnotify);

Fonction d'appoint qui inserre une nouvelle colonne dans le  GtkTreeView avec l'afficheur de cellules donné et une fonction GtkCellDataFuncqui va définir les attributs de l'afficheur de cellules (normalement les données du magasin sont utilisées). Voir aussi gtk_tree_view_column_set_cell_data_func(), gtk_tree_view_column_pack_start(). Si l'afficheur d'arbre  tree_view a le mode "fixed_height" (taille fixe) activé alors la nouvelle colonne aura la propriété  de redimensionnement "sizing" définie à  GTK_TREE_VIEW_COLUMN_FIXED.

gtk_tree_view_get_column ()

GtkTreeViewColumn*  gtk_tree_view_get_column            (GtkTreeView *tree_view,
                                                         gint n);

Récupère la GtkTreeViewColumn à une position donnée de l'afficheur d'arbre.

gtk_tree_view_get_columns ()

GList*              gtk_tree_view_get_columns           (GtkTreeView *tree_view);

Retourne une GList  de toutes les  GtkTreeViewColumn s présentes dans l'afficheur d'arbre tree_view. La liste retournée doit être libérée avec g_list_free().

gtk_tree_view_move_column_after ()

void                gtk_tree_view_move_column_after     (GtkTreeView *tree_view,
                                                         GtkTreeViewColumn *column,
                                                         GtkTreeViewColumn *base_column);

Déplace une colonne column pour qu'elle soit après la colonne base_column. Si base_column est NULL, alors  column est placée en première postion.

gtk_tree_view_set_expander_column ()

void                gtk_tree_view_set_expander_column   (GtkTreeView *tree_view,
                                                         GtkTreeViewColumn *column);

Définit la colonne pour que la flèche d'extension soit dessinée. Elle doit être dans l'afficheur d'arbre tree_view. Si  column est NULL, alors la flèche d'extension est toujours dans la première colonne visible.

Si vous ne voulez pas que la flèche apparaisse dans l'arbre définissez la colonne d'extension comme une colonne invisible.

gtk_tree_view_get_expander_column ()

GtkTreeViewColumn*  gtk_tree_view_get_expander_column   (GtkTreeView *tree_view);

Retourne la colonne qui est la colonne s'extension. La flèche d'extension est dessinée dans cette colonne.

gtk_tree_view_set_column_drag_function ()

void                gtk_tree_view_set_column_drag_function
                                                        (GtkTreeView *tree_view,
                                                         GtkTreeViewColumnDropFunc func,
                                                         gpointer user_data,
                                                         GtkDestroyNotify destroy);

Définit une fonction utilisateur pour déterminer où une colonne peut être déposée quand  on la glisse. Cette fonction est appelée pour toute colonne par tour au début d'un glisser de colonne pour déterminer où la colonne peut être déposée. Les arguments passés à la fonction func sont: l'afficheur d'arbre tree_view, la  GtkTreeViewColumn qui est glissée, les deux  GtkTreeViewColumn s qui déterminent le point de lâcher de la colonne, et les données utilisateur user_data. Si l'un des arguments GtkTreeViewColumn pour déposer la colonne est  NULL, alors cela indique un bord. Si  func est définie à  NULL, alors tree_view  utilise le comportement par défaut qui permet de déposer n'importe où n'importe quelle colonne.

gtk_tree_view_scroll_to_point ()

void                gtk_tree_view_scroll_to_point       (GtkTreeView *tree_view,
                                                         gint tree_x,
                                                         gint tree_y);

si tree_x et tree_y sont définis à  -1, alors le défilement ne se fait pas dans cette direction.

gtk_tree_view_scroll_to_cell ()

void                gtk_tree_view_scroll_to_cell        (GtkTreeView *tree_view,
                                                         GtkTreePath *path,
                                                         GtkTreeViewColumn *column,
                                                         gboolean use_align,
                                                         gfloat row_align,
                                                         gfloat col_align);

Fait défiler  l'alignement de l'afficheur d'arbre  tree_view vers la position spécifiée par la colonne column et le chemin path. Si column est  NULL, alors il n'y a pas de défilement horizontal. De même, si  path est  NULL il n'y a pas de défilement vertical. Au minimum un des deux  ,column ou path, ne doit pas être NULL. row_align détermine où la rangée est placée et col_align détermine où la columnest placée. Les deux doivent être compris entre 0.0 et 1.0. 0.0 pour  l'alignement gauche/supérieur , 1.0 pour l'alignement droit/inférieur, 0.5 pour le centre.

Si  use_align est FALSE, alors les arguments de l'alignement sont ignorés et l'arbre fera un minimum de travail pour faire défiler une cellule à l'intérieur de l'écran. Ainsi la cellule défilera (glissera) to the edge closest de sa position courante . Si la cellule est visible dans l'écran, rien ne se passe.

Cette fonction marche uniquement si le magasin est défini et si le chemin  path correspond à une rangée valide du magasin. Si le magasin change avant que l'afficheur d'arbre tree_view existe, le chemin centered sera modifié pour refletter ce changement.

gtk_tree_view_set_cursor ()

void                gtk_tree_view_set_cursor            (GtkTreeView *tree_view,
                                                         GtkTreePath *path,
                                                         GtkTreeViewColumn *focus_column,
                                                         gboolean start_editing);

Définit le focus clavier courant au chemin path, et le sélectionne. Cela est utile quand vous voulez attirer l'attention de l'utilisateur sur une rangée particulière. Si focus_column n'est pas  NULL, alors le focus est attribué à la colonne que cette variable indique. De plus, si  focus_column  est défini est que start_editing est TRUE, alors l'édition peut commencer dans la cellule spécifiée. Cette fonction est souvent suivie par gtk_widget_grab_focus (tree_view) pour donner le focus clavier au widget . Notez que l'édition peut se faire seulement si le widget est existe. 

gtk_tree_view_set_cursor_on_cell ()

void                gtk_tree_view_scroll_to_cell        (GtkTreeView *tree_view,
                                                         GtkTreePath *path,
                                                         GtkTreeViewColumn *column,
                                                         gboolean use_align,
                                                         gfloat row_align,
                                                         gfloat col_align);

Définit le focus clavier courant au chemin path, et le sélectionne. Cela est utile quand vous voulez attirer l'attention de l'utilisateur sur une rangée particulière. Si  focus_column n'est pas  NULL, alors le focus est attribué à la colonne que cette variable indique.  SI focus_column et focus_cell ne sont pas  NULL, et que focus_column contient 2 ou plusieurs cellules éditables ou activables, alors le focus est donné à la cellules spécifiée par focus_cell. De plus si  focus_column est spécifié, et start_editing is TRUE, aalors l'édition peut commencer dans la cellule spécifiée.  Cette fonction est souvent suivie par gtk_widget_grab_focus (tree_view) pour donner le focus clavier au widget .Notez que l'édition peut se faire seulement si le widget est existe. 

Depuis 2.2

gtk_tree_view_get_cursor ()

void                gtk_tree_view_set_cursor            (GtkTreeView *tree_view,
                                                         GtkTreePath *path,
                                                         GtkTreeViewColumn *focus_column,
                                                         gboolean start_editing);

Remplit  path et focus_column avec le chemin courant et la colonne qui a le focus. Si le curseur n'est pas définit alors  *path sera  NULL. Si aucune colonne n'a le focus alors  *focus_column sera  NULL.

Le  GtkTreePath retourbé doit être libéré avec gtk_tree_path_free() quand vous n'en avez plus besoin.

gtk_tree_view_row_activated ()

void                gtk_tree_view_row_activated         (GtkTreeView *tree_view,
                                                         GtkTreePath *path,
                                                         GtkTreeViewColumn *column);

Active la cellule définie par le chemin  path et la colonne column.

gtk_tree_view_expand_all ()

void                gtk_tree_view_expand_all            (GtkTreeView *tree_view);

Déplie recursivement tous les embranchement de l'afficheur d'arbre  tree_view.

gtk_tree_view_collapse_all ()

void                gtk_tree_view_collapse_all          (GtkTreeView *tree_view);

Replie recursivement tous les embranchement dépliés visibles de l'afficheur d'arbre tree_view.

gtk_tree_view_expand_to_path ()

void                gtk_tree_view_expand_to_path        (GtkTreeView *tree_view,
                                                         GtkTreePath *path);

Déplie la rangée correspondant au chemin  path. Cette fonction déplie aussi tous les parents de la rangée du chemin path  si nécessaire.

Depuis 2.2

gtk_tree_view_expand_row ()

gboolean            gtk_tree_view_expand_row            (GtkTreeView *tree_view,
                                                         GtkTreePath *path,
                                                         gboolean open_all);

Ouvre la rangée pour que ses enfants soient visibles.

gtk_tree_view_collapse_row ()

gboolean            gtk_tree_view_collapse_row          (GtkTreeView *tree_view,
                                                         GtkTreePath *path);

Replie la rangée (cache les rangées de ses enfants s'ils existent).

gtk_tree_view_map_expanded_rows ()

void                gtk_tree_view_map_expanded_rows     (GtkTreeView *tree_view,
                                                         GtkTreeViewMappingFunc func,
                                                         gpointer data);

Appelle la focntion func sur tous les rangées dépliées.

gtk_tree_view_row_expanded ()

gboolean            gtk_tree_view_row_expanded          (GtkTreeView *tree_view,
                                                         GtkTreePath *path);

Retourne TRUE si l'embranchement pointé par le chemin  path est déplié dans l'afficheur d'arbre tree_view.

gtk_tree_view_set_reorderable ()

void                gtk_tree_view_set_reorderable       (GtkTreeView *tree_view,
                                                         gboolean reorderable);

Cette fonction est une fonction pratique qui permet de réorganiser des magasins qui supportent le GtkDragSourceIface et le GtkDragDestIface. GtkTreeStore et GtkListStore mes supportent. Si reorderable est TRUE, amors l'utilisateur peut réorganiser le magasin en glissant et déposant des rangées. Le développeur peut  détecter ces changements en connectant les signaux row_inserted et row_deleted du magasin.

Le degré de contrôle que vous donne cette fonction ne va pas au delà d'une permission de réorganisation. Si vous avez besoin de plus de contrôle alors vous devrez sans doute définir  le glisser- déposer manuellement.

gtk_tree_view_get_reorderable ()

gboolean            gtk_tree_view_get_reorderable       (GtkTreeView *tree_view);

Dit si l'utilisateur peut réorganiser l'arbre via le glisser-déposer. Voir  gtk_tree_view_set_reorderable().

gtk_tree_view_get_path_at_pos ()

gboolean gtk_tree_view_get_path_at_pos (GtkTreeView *tree_view,
gint x,
gint y,
GtkTreePath **path,
GtkTreeViewColumn **column,
gint *cell_x,
gint *cell_y);

Finds the path at the point (x, y), relative to bin_window coordinates (please see gtk_tree_view_get_bin_window()). That is, x and y are relative to an events coordinates. x and y must come from an event on the tree_view only where event->window == gtk_tree_view_get_bin_window (). It is primarily for things like popup menus. If path is non-NULL, then it will be filled with the GtkTreePath at that point. This path should be freed with gtk_tree_path_free(). If column is non-NULL, then it will be filled with the column at that point. cell_x and cell_y return the coordinates relative to the cell background (i.e. the background_area passed to gtk_cell_renderer_render()). This function is only meaningful if tree_view is realized.

For converting widget coordinates (eg. the ones you get from GtkWidget::query-tooltip), please see gtk_tree_view_convert_widget_to_bin_window_coords().

gtk_tree_view_get_cell_area ()

void gtk_tree_view_get_cell_area (GtkTreeView *tree_view,
GtkTreePath *path,
GtkTreeViewColumn *column,
GdkRectangle *rect);

Fills the bounding rectangle in bin_window coordinates for the cell at the row specified by path and the column specified by column. If path is NULL, or points to a path not currently displayed, the y and height fields of the rectangle will be filled with 0. If column is NULL, the x and width fields will be filled with 0. The sum of all cell rects does not cover the entire tree; there are extra pixels in between rows, for example. The returned rectangle is equivalent to the cell_area passed to gtk_cell_renderer_render(). This function is only valid if tree_view is realized.

gtk_tree_view_get_background_area ()

void gtk_tree_view_get_background_area (GtkTreeView *tree_view,
GtkTreePath *path,
GtkTreeViewColumn *column,
GdkRectangle *rect);

Fills the bounding rectangle in bin_window coordinates for the cell at the row specified by path and the column specified by column. If path is NULL, or points to a node not found in the tree, the y and height fields of the rectangle will be filled with 0. If column is NULL, the x and width fields will be filled with 0. The returned rectangle is equivalent to the background_area passed to gtk_cell_renderer_render(). These background areas tile to cover the entire bin window. Contrast with the cell_area, returned by gtk_tree_view_get_cell_area(), which returns only the cell itself, excluding surrounding borders and the tree expander area.

gtk_tree_view_get_visible_rect ()

void gtk_tree_view_get_visible_rect (GtkTreeView *tree_view,
GdkRectangle *visible_rect);

Fills visible_rect with the currently-visible region of the buffer, in tree coordinates. Convert to bin_window coordinates with gtk_tree_view_convert_tree_to_bin_window_coords(). Tree coordinates start at 0,0 for row 0 of the tree, and cover the entire scrollable area of the tree.

gtk_tree_view_get_visible_range ()

gboolean gtk_tree_view_get_visible_range (GtkTreeView *tree_view,
GtkTreePath **start_path,
GtkTreePath **end_path);

Sets start_path and end_path to be the first and last visible path. Note that there may be invisible paths in between.

The paths should be freed with gtk_tree_path_free() after use.

Since 2.8

gtk_tree_view_get_bin_window ()

GdkWindow* gtk_tree_view_get_bin_window (GtkTreeView *tree_view);

Returns the window that tree_view renders to. This is used primarily to compare to event->window to confirm that the event on tree_view is on the right window.

gtk_tree_view_widget_to_tree_coords ()

void gtk_tree_view_widget_to_tree_coords (GtkTreeView *tree_view,
gint wx,
gint wy,
gint *tx,
gint *ty);

Converts bin_window coordinates to coordinates for the tree (the full scrollable area of the tree).

gtk_tree_view_tree_to_widget_coords ()

void gtk_tree_view_tree_to_widget_coords (GtkTreeView *tree_view,
gint tx,
gint ty,
gint *wx,
gint *wy);

Converts tree coordinates (coordinates in full scrollable area of the tree) to bin_window coordinates.

gtk_tree_view_convert_bin_window_to_tree_coords ()

void gtk_tree_view_convert_bin_window_to_tree_coords
(GtkTreeView *tree_view,
gint bx,
gint by,
gint *tx,
gint *ty);

Converts bin_window coordinates to coordinates for the tree (the full scrollable area of the tree).

Since 2.12

gtk_tree_view_convert_bin_window_to_widget_coords ()

void gtk_tree_view_convert_bin_window_to_widget_coords
(GtkTreeView *tree_view,
gint bx,
gint by,
gint *wx,
gint *wy);

Converts bin_window coordinates (see gtk_tree_view_get_bin_window()). to widget relative coordinates.

Since 2.12

gtk_tree_view_convert_tree_to_bin_window_coords ()

void gtk_tree_view_convert_tree_to_bin_window_coords
(GtkTreeView *tree_view,
gint tx,
gint ty,
gint *bx,
gint *by);

Converts tree coordinates (coordinates in full scrollable area of the tree) to bin_window coordinates.

Since 2.12

gtk_tree_view_convert_tree_to_widget_coords ()

void gtk_tree_view_convert_tree_to_widget_coords
(GtkTreeView *tree_view,
gint tx,
gint ty,
gint *wx,
gint *wy);

Converts tree coordinates (coordinates in full scrollable area of the tree) to widget coordinates.

Since 2.12

gtk_tree_view_convert_widget_to_bin_window_coords ()

void gtk_tree_view_convert_widget_to_bin_window_coords
(GtkTreeView *tree_view,
gint wx,
gint wy,
gint *bx,
gint *by);

Converts widget coordinates to coordinates for the bin_window (see gtk_tree_view_get_bin_window()).

Since 2.12

gtk_tree_view_convert_widget_to_tree_coords ()

void gtk_tree_view_convert_widget_to_tree_coords
(GtkTreeView *tree_view,
gint wx,
gint wy,
gint *tx,
gint *ty);

Converts widget coordinates to coordinates for the tree (the full scrollable area of the tree).

Since 2.12

gtk_tree_view_enable_model_drag_dest ()

void gtk_tree_view_enable_model_drag_dest
(GtkTreeView *tree_view,
const GtkTargetEntry *targets,
gint n_targets,
GdkDragAction actions);

Turns tree_view into a drop destination for automatic DND.

gtk_tree_view_enable_model_drag_source ()

void gtk_tree_view_enable_model_drag_source
(GtkTreeView *tree_view,
GdkModifierType start_button_mask,
const GtkTargetEntry *targets,
gint n_targets,
GdkDragAction actions);

Turns tree_view into a drag source for automatic DND.

gtk_tree_view_unset_rows_drag_source ()

void gtk_tree_view_unset_rows_drag_source
(GtkTreeView *tree_view);

Undoes the effect of gtk_tree_view_enable_model_drag_source().

gtk_tree_view_unset_rows_drag_dest ()

void gtk_tree_view_unset_rows_drag_dest (GtkTreeView *tree_view);

Undoes the effect of gtk_tree_view_enable_model_drag_dest().

gtk_tree_view_set_drag_dest_row ()

void gtk_tree_view_set_drag_dest_row (GtkTreeView *tree_view,
GtkTreePath *path,
GtkTreeViewDropPosition pos);

Sets the row that is highlighted for feedback.

gtk_tree_view_get_drag_dest_row ()

void gtk_tree_view_get_drag_dest_row (GtkTreeView *tree_view,
GtkTreePath **path,
GtkTreeViewDropPosition *pos);

Gets information about the row that is highlighted for feedback.

gtk_tree_view_get_dest_row_at_pos ()

gboolean gtk_tree_view_get_dest_row_at_pos (GtkTreeView *tree_view,
gint drag_x,
gint drag_y,
GtkTreePath **path,
GtkTreeViewDropPosition *pos);

Determines the destination row for a given position. drag_x and drag_y are expected to be in widget coordinates.

gtk_tree_view_create_row_drag_icon ()

GdkPixmap* gtk_tree_view_create_row_drag_icon (GtkTreeView *tree_view,
GtkTreePath *path);

Creates a GdkPixmap representation of the row at path. This image is used for a drag icon.

gtk_tree_view_set_enable_search ()

void gtk_tree_view_set_enable_search (GtkTreeView *tree_view,
gboolean enable_search);

If enable_search is set, then the user can type in text to search through the tree interactively (this is sometimes called "typeahead find").

Note that even if this is FALSE, the user can still initiate a search using the "start-interactive-search" key binding.

gtk_tree_view_get_enable_search ()

gboolean gtk_tree_view_get_enable_search (GtkTreeView *tree_view);

Returns whether or not the tree allows to start interactive searching by typing in text.

gtk_tree_view_get_search_column ()

gint gtk_tree_view_get_search_column (GtkTreeView *tree_view);

Gets the column searched on by the interactive search code.

gtk_tree_view_set_search_column ()

void gtk_tree_view_set_search_column (GtkTreeView *tree_view,
gint column);

Sets column as the column where the interactive search code should search in.

If the sort column is set, users can use the "start-interactive-search" key binding to bring up search popup. The enable-search property controls whether simply typing text will also start an interactive search.

Note that column refers to a column of the model.

gtk_tree_view_get_search_equal_func ()

GtkTreeViewSearchEqualFunc gtk_tree_view_get_search_equal_func
(GtkTreeView *tree_view);

Returns the compare function currently in use.

gtk_tree_view_set_search_equal_func ()

void gtk_tree_view_set_search_equal_func (GtkTreeView *tree_view,
GtkTreeViewSearchEqualFunc search_equal_func,
gpointer search_user_data,
GtkDestroyNotify search_destroy);

Sets the compare function for the interactive search capabilities; note that somewhat like strcmp() returning 0 for equality GtkTreeViewSearchEqualFunc returns FALSE on matches.

gtk_tree_view_get_search_entry ()

GtkEntry* gtk_tree_view_get_search_entry (GtkTreeView *tree_view);

Returns the GtkEntry which is currently in use as interactive search entry for tree_view. In case the built-in entry is being used, NULL will be returned.

Since 2.10

gtk_tree_view_set_search_entry ()

void gtk_tree_view_set_search_entry (GtkTreeView *tree_view,
GtkEntry *entry);

Sets the entry which the interactive search code will use for this tree_view. This is useful when you want to provide a search entry in our interface at all time at a fixed position. Passing NULL for entry will make the interactive search code use the built-in popup entry again.

Since 2.10

GtkTreeViewSearchPositionFunc ()

void (*GtkTreeViewSearchPositionFunc) (GtkTreeView *tree_view,
GtkWidget *search_dialog,
gpointer user_data);

gtk_tree_view_get_search_position_func ()

GtkTreeViewSearchPositionFunc gtk_tree_view_get_search_position_func
(GtkTreeView *tree_view);

Returns the positioning function currently in use.

Since 2.10

gtk_tree_view_set_search_position_func ()

void gtk_tree_view_set_search_position_func
(GtkTreeView *tree_view,
GtkTreeViewSearchPositionFunc func,
gpointer data,
GDestroyNotify destroy);

Sets the function to use when positioning the seach dialog.

Since 2.10

gtk_tree_view_get_fixed_height_mode ()

gboolean gtk_tree_view_get_fixed_height_mode (GtkTreeView *tree_view);

Returns whether fixed height mode is turned on for tree_view.

Since 2.6

gtk_tree_view_set_fixed_height_mode ()

void gtk_tree_view_set_fixed_height_mode (GtkTreeView *tree_view,
gboolean enable);

Enables or disables the fixed height mode of tree_view. Fixed height mode speeds up GtkTreeView by assuming that all rows have the same height. Only enable this option if all rows are the same height and all columns are of type GTK_TREE_VIEW_COLUMN_FIXED.

Since 2.6

gtk_tree_view_get_hover_selection ()

gboolean gtk_tree_view_get_hover_selection (GtkTreeView *tree_view);

Returns whether hover selection mode is turned on for tree_view.

Since 2.6

gtk_tree_view_set_hover_selection ()

void gtk_tree_view_set_hover_selection (GtkTreeView *tree_view,
gboolean hover);

Enables of disables the hover selection mode of tree_view. Hover selection makes the selected row follow the pointer. Currently, this works only for the selection modes GTK_SELECTION_SINGLE and GTK_SELECTION_BROWSE.

Since 2.6

gtk_tree_view_get_hover_expand ()

gboolean gtk_tree_view_get_hover_expand (GtkTreeView *tree_view);

Returns whether hover expansion mode is turned on for tree_view.

Since 2.6

gtk_tree_view_set_hover_expand ()

void gtk_tree_view_set_hover_expand (GtkTreeView *tree_view,
gboolean expand);

Enables of disables the hover expansion mode of tree_view. Hover expansion makes rows expand or collaps if the pointer moves over them.

Since 2.6

GtkTreeDestroyCountFunc ()

void (*GtkTreeDestroyCountFunc) (GtkTreeView *tree_view,
GtkTreePath *path,
gint children,
gpointer user_data);

gtk_tree_view_set_destroy_count_func ()

void gtk_tree_view_set_destroy_count_func
(GtkTreeView *tree_view,
GtkTreeDestroyCountFunc func,
gpointer data,
GtkDestroyNotify destroy);

This function should almost never be used. It is meant for private use by ATK for determining the number of visible children that are removed when the user collapses a row, or a row is deleted.

GtkTreeViewRowSeparatorFunc ()

gboolean (*GtkTreeViewRowSeparatorFunc) (GtkTreeModel *model,
GtkTreeIter *iter,
gpointer data);

Function type for determining whether the row pointed to by iter should be rendered as a separator. A common way to implement this is to have a boolean column in the model, whose values the GtkTreeViewRowSeparatorFunc returns.

gtk_tree_view_get_row_separator_func ()

GtkTreeViewRowSeparatorFunc gtk_tree_view_get_row_separator_func
(GtkTreeView *tree_view);

Returns the current row separator function.

Since 2.6

gtk_tree_view_set_row_separator_func ()

void gtk_tree_view_set_row_separator_func
(GtkTreeView *tree_view,
GtkTreeViewRowSeparatorFunc func,
gpointer data,
GtkDestroyNotify destroy);

Sets the row separator function, which is used to determine whether a row should be drawn as a separator. If the row separator function is NULL, no separators are drawn. This is the default value.

Since 2.6

gtk_tree_view_get_rubber_banding ()

gboolean gtk_tree_view_get_rubber_banding (GtkTreeView *tree_view);

Returns whether rubber banding is turned on for tree_view. If the selection mode is GTK_SELECTION_MULTIPLE, rubber banding will allow the user to select multiple rows by dragging the mouse.

Since 2.10

gtk_tree_view_set_rubber_banding ()

void gtk_tree_view_set_rubber_banding (GtkTreeView *tree_view,
gboolean enable);

Enables or disables rubber banding in tree_view. If the selection mode is GTK_SELECTION_MULTIPLE, rubber banding will allow the user to select multiple rows by dragging the mouse.

Since 2.10

gtk_tree_view_get_enable_tree_lines ()

gboolean gtk_tree_view_get_enable_tree_lines (GtkTreeView *tree_view);

Returns whether or not tree lines are drawn in tree_view.

Since 2.10

gtk_tree_view_set_enable_tree_lines ()

void gtk_tree_view_set_enable_tree_lines (GtkTreeView *tree_view,
gboolean enabled);

Sets whether to draw lines interconnecting the expanders in tree_view. This does not have any visible effects for lists.

Since 2.10

enum GtkTreeViewGridLines

typedef enum {
GTK_TREE_VIEW_GRID_LINES_NONE,
GTK_TREE_VIEW_GRID_LINES_HORIZONTAL,
GTK_TREE_VIEW_GRID_LINES_VERTICAL,
GTK_TREE_VIEW_GRID_LINES_BOTH
} GtkTreeViewGridLines;

gtk_tree_view_get_grid_lines ()

GtkTreeViewGridLines gtk_tree_view_get_grid_lines (GtkTreeView *tree_view);

Returns which grid lines are enabled in tree_view.

Since 2.10

gtk_tree_view_set_grid_lines ()

void gtk_tree_view_set_grid_lines (GtkTreeView *tree_view,
GtkTreeViewGridLines grid_lines);

Sets which grid lines to draw in tree_view.

Since 2.10

The "enable-grid-lines" property

 "enable-grid-lines" GtkTreeViewGridLines : Lire / Ecrire

Whether grid lines should be drawn in the tree view.

Default value: GTK_TREE_VIEW_GRID_LINES_NONE

The "enable-search" property

 "enable-search" gboolean : Lire / Ecrire

View allows user to search through columns interactively.

Default value: TRUE

The "enable-tree-lines" property

 "enable-tree-lines" gboolean : Lire / Ecrire

Whether tree lines should be drawn in the tree view.

Default value: FALSE

The "expander-column" property

 "expander-column" GtkTreeViewColumn : Lire / Ecrire

Set the column for the expander column.

The "fixed-height-mode" property

 "fixed-height-mode" gboolean : Lire / Ecrire

Setting the ::fixed-height-mode property to TRUE speeds up GtkTreeView by assuming that all rows have the same height. Only enable this option if all rows are the same height. Please see gtk_tree_view_set_fixed_height_mode() for more information on this option.

Default value: FALSE

Since 2.4

The "hadjustment" property

 "hadjustment" GtkAdjustment : Lire / Ecrire

Horizontal Adjustment for the widget.

The "headers-clickable" property

 "headers-clickable" gboolean : Lire / Ecrire

Column headers respond to click events.

Default value: FALSE

The "headers-visible" property

 "headers-visible" gboolean : Lire / Ecrire

Show the column header buttons.

Default value: TRUE

The "hover-expand" property

 "hover-expand" gboolean : Lire / Ecrire

Enables of disables the hover expansion mode of tree_view. Hover expansion makes rows expand or collaps if the pointer moves over them.

This mode is primarily indended for treeviews in popups, e.g. in GtkComboBox or GtkEntryCompletion.

Default value: FALSE

Since 2.6

The "hover-selection" property

 "hover-selection" gboolean : Lire / Ecrire

Enables of disables the hover selection mode of tree_view. Hover selection makes the selected row follow the pointer. Currently, this works only for the selection modes GTK_SELECTION_SINGLE and GTK_SELECTION_BROWSE.

This mode is primarily indended for treeviews in popups, e.g. in GtkComboBox or GtkEntryCompletion.

Default value: FALSE

Since 2.6

The "level-indentation" property

 "level-indentation" gint : Lire / Ecrire

Extra indentation for each level.

Allowed values: >= 0

Default value: 0

Since 2.12

The "model" property

 "model" GtkTreeModel : Lire / Ecrire

The model for the tree view.

The "reorderable" property

 "reorderable" gboolean : Lire / Ecrire

View is reorderable.

Default value: FALSE

The "rubber-banding" property

 "rubber-banding" gboolean : Lire / Ecrire

Whether to enable selection of multiple items by dragging the mouse pointer.

Default value: FALSE

The "rules-hint" property

 "rules-hint" gboolean : Lire / Ecrire

Set a hint to the theme engine to draw rows in alternating colors.

Default value: FALSE

The "search-column" property

 "search-column" gint : Lire / Ecrire

Model column to search through when searching through code.

Allowed values: >= -1

Default value: -1

The "show-expanders" property

 "show-expanders" gboolean : Lire / Ecrire

TRUE if the view has expanders.

Default value: TRUE

Since 2.12

The "vadjustment" property

 "vadjustment" GtkAdjustment : Lire / Ecrire

Vertical Adjustment for the widget.

The "allow-rules" style property

 "allow-rules" gboolean : Read

Allow drawing of alternating color rows.

Default value: TRUE

The "even-row-color" style property

 "even-row-color" GdkColor : Read

Color to use for even rows.

The "expander-size" style property

 "expander-size" gint : Read

Size of the expander arrow.

Allowed values: >= 0

Default value: 12

The "grid-line-pattern" style property

 "grid-line-pattern" gchararray : Read

Dash pattern used to draw the tree view grid lines.

Default value: "\001\001"

The "grid-line-width" style property

 "grid-line-width" gint : Read

Width, in pixels, of the tree view grid lines.

Allowed values: >= 0

Default value: 1

The "horizontal-separator" style property

 "horizontal-separator" gint : Read

Horizontal space between cells. Must be an even number.

Allowed values: >= 0

Default value: 2

The "indent-expanders" style property

 "indent-expanders" gboolean : Read

Make the expanders indented.

Default value: TRUE

The "odd-row-color" style property

 "odd-row-color" GdkColor : Read

Color to use for odd rows.

The "row-ending-details" style property

 "row-ending-details" gboolean : Read

Enable extended row background theming.

Default value: FALSE

The "tree-line-pattern" style property

 "tree-line-pattern" gchararray : Read

Dash pattern used to draw the tree view lines.

Default value: "\001\001"

The "tree-line-width" style property

 "tree-line-width" gint : Read

Width, in pixels, of the tree view lines.

Allowed values: >= 0

Default value: 1

The "vertical-separator" style property

 "vertical-separator" gint : Read

Vertical space between cells. Must be an even number.

Allowed values: >= 0

Default value: 2

The "columns-changed" signal

void user_function (GtkTreeView *tree_view,
gpointer user_data) : Exécuter Dernier 

The number of columns of the treeview has changed.

The "cursor-changed" signal

void user_function (GtkTreeView *tree_view,
gpointer user_data) : Exécuter Dernier 

The position of the cursor (focused cell) has changed.

The "expand-collapse-cursor-row" signal

gboolean user_function (GtkTreeView *treeview,
gboolean arg1,
gboolean arg2,
gboolean arg3,
gpointer user_data) : Exécuter Dernier / Action

The "move-cursor" signal

gboolean user_function (GtkTreeView *treeview,
GtkMovementStep arg1,
gint arg2,
gpointer user_data) : Exécuter Dernier / Action

The "row-activated" signal

void user_function (GtkTreeView *tree_view,
GtkTreePath *path,
GtkTreeViewColumn *column,
gpointer user_data) : Exécuter Dernier / Action

The "row-activated" signal is emitted when the method gtk_tree_view_row_activated() is called or the user double clicks a treeview row. It is also emitted when a non-editable row is selected and one of the keys: Space, Shift+Space, Return or Enter is pressed.

For selection handling refer to the tree widget conceptual overview as well as GtkTreeSelection.

The "row-collapsed" signal

void user_function (GtkTreeView *tree_view,
GtkTreeIter *iter,
GtkTreePath *path,
gpointer user_data) : Exécuter Dernier 

The given row has been collapsed (child nodes are hidden).

The "row-expanded" signal

void user_function (GtkTreeView *tree_view,
GtkTreeIter *iter,
GtkTreePath *path,
gpointer user_data) : Exécuter Dernier 

The given row has been expanded (child nodes are shown).

The "select-all" signal

gboolean user_function (GtkTreeView *treeview,
gpointer user_data) : Exécuter Dernier / Action

The "select-cursor-parent" signal

gboolean user_function (GtkTreeView *treeview,
gpointer user_data) : Exécuter Dernier / Action

The "select-cursor-row" signal

gboolean user_function (GtkTreeView *treeview,
gboolean arg1,
gpointer user_data) : Exécuter Dernier / Action

The "set-scroll-adjustments" signal

void user_function (GtkTreeView *treeview,
GtkAdjustment *arg1,
GtkAdjustment *arg2,
gpointer user_data) : Exécuter Dernier / Action

The "start-interactive-search" signal

gboolean user_function (GtkTreeView *treeview,
gpointer user_data) : Exécuter Dernier / Action

The "test-collapse-row" signal

gboolean user_function (GtkTreeView *tree_view,
GtkTreeIter *iter,
GtkTreePath *path,
gpointer user_data) : Exécuter Dernier 

The given row is about to be collapsed (hide its children nodes). Use this signal if you need to control the collapsibility of individual rows.

The "test-expand-row" signal

gboolean user_function (GtkTreeView *tree_view,
GtkTreeIter *iter,
GtkTreePath *path,
gpointer user_data) : Exécuter Dernier 

The given row is about to be expanded (show its children nodes). Use this signal if you need to control the expandability of individual rows.

The "toggle-cursor-row" signal

gboolean user_function (GtkTreeView *treeview,
gpointer user_data) : Exécuter Dernier / Action

The "unselect-all" signal

gboolean user_function (GtkTreeView *treeview,
gpointer user_data) : Exécuter Dernier / Action