GtkCTree

typedef struct _GtkCTree GtkCTree;

The GtkCTree-struct contains the following user-accessible fields. These fields should be considered read-only; to set the values, use the methods below.

GTK_CTREE_ROW()

#define GTK_CTREE_ROW(_node_) ((GtkCTreeRow *)(((GList *)(_node_))->data))

Used to get the GtkCTreeRow structure corresponding to the given GtkCTreeNode.

GTK_CTREE_NODE()

#define GTK_CTREE_NODE(_node_) ((GtkCTreeNode *)((_node_)))

GTK_CTREE_NODE_NEXT()

#define GTK_CTREE_NODE_NEXT(_nnode_) ((GtkCTreeNode *)(((GList *)(_nnode_))->next))

FIXME

GTK_CTREE_NODE_PREV()

#define GTK_CTREE_NODE_PREV(_pnode_) ((GtkCTreeNode *)(((GList *)(_pnode_))->prev))

FIXME

GTK_CTREE_FUNC()

#define GTK_CTREE_FUNC(_func_) ((GtkCTreeFunc)(_func_))

enum GtkCTreePos

typedef enum
{
  GTK_CTREE_POS_BEFORE,
  GTK_CTREE_POS_AS_CHILD,
  GTK_CTREE_POS_AFTER
} GtkCTreePos;

A value specifying the position of a new node relative to an old one.

enum GtkCTreeLineStyle

typedef enum
{
  GTK_CTREE_LINES_NONE,
  GTK_CTREE_LINES_SOLID,
  GTK_CTREE_LINES_DOTTED,
  GTK_CTREE_LINES_TABBED
} GtkCTreeLineStyle;

The appearance of the lines in the tree graphics.

enum GtkCTreeExpanderStyle

typedef enum
{
  GTK_CTREE_EXPANDER_NONE,
  GTK_CTREE_EXPANDER_SQUARE,
  GTK_CTREE_EXPANDER_TRIANGLE,
  GTK_CTREE_EXPANDER_CIRCULAR
} GtkCTreeExpanderStyle;

The appearance of the expander buttons, i.e. the small buttons which expand or contract parts of the tree when pressed.

enum GtkCTreeExpansionType

typedef enum
{
  GTK_CTREE_EXPANSION_EXPAND,
  GTK_CTREE_EXPANSION_EXPAND_RECURSIVE,
  GTK_CTREE_EXPANSION_COLLAPSE,
  GTK_CTREE_EXPANSION_COLLAPSE_RECURSIVE,
  GTK_CTREE_EXPANSION_TOGGLE,
  GTK_CTREE_EXPANSION_TOGGLE_RECURSIVE
} GtkCTreeExpansionType;

How to expand or collapse a part of a tree.

GtkCTreeFunc ()

void        (*GtkCTreeFunc)                 (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gpointer data);

A generic callback type to do something with a particular node.

GtkCTreeGNodeFunc ()

gboolean    (*GtkCTreeGNodeFunc)            (GtkCTree *ctree,
                                             guint depth,
                                             GNode *gnode,
                                             GtkCTreeNode *cnode,
                                             gpointer data);

FIXME

GtkCTreeCompareDragFunc ()

gboolean    (*GtkCTreeCompareDragFunc)      (GtkCTree *ctree,
                                             GtkCTreeNode *source_node,
                                             GtkCTreeNode *new_parent,
                                             GtkCTreeNode *new_sibling);

FIXME

GtkCTreeRow

typedef struct {
  GtkCListRow row;
  
  GtkCTreeNode *parent;
  GtkCTreeNode *sibling;
  GtkCTreeNode *children;
  
  GdkPixmap *pixmap_closed;
  GdkBitmap *mask_closed;
  GdkPixmap *pixmap_opened;
  GdkBitmap *mask_opened;
  
  guint16 level;
  
  guint is_leaf  : 1;
  guint expanded : 1;
} GtkCTreeRow;

A structure representing a single row in the tree graph. The values inside the structure should be considered read-only. This structure is derived from the GtkCListRow structure.

GtkCTreeNode

typedef struct {
  GList list;
} GtkCTreeNode;

This structure is opaque - you should use the macros GTK_CTREE_ROW, GTK_CTREE_NODE_NEXT etc. as well as the functions below to access it.

GTK_TYPE_CTREE_NODE

#define GTK_TYPE_CTREE_NODE (gtk_ctree_node_get_type ())

gtk_ctree_new_with_titles ()

GtkWidget*  gtk_ctree_new_with_titles       (gint columns,
                                             gint tree_column,
                                             gchar *titles[]);

Create a new GtkCTree widget with the given titles for the columns.

gtk_ctree_new ()

GtkWidget*  gtk_ctree_new                   (gint columns,
                                             gint tree_column);

Create a new GtkCTree widget.

gtk_ctree_insert_node ()

GtkCTreeNode* gtk_ctree_insert_node         (GtkCTree *ctree,
                                             GtkCTreeNode *parent,
                                             GtkCTreeNode *sibling,
                                             gchar *text[],
                                             guint8 spacing,
                                             GdkPixmap *pixmap_closed,
                                             GdkBitmap *mask_closed,
                                             GdkPixmap *pixmap_opened,
                                             GdkBitmap *mask_opened,
                                             gboolean is_leaf,
                                             gboolean expanded);

Insert a new node to the tree. The position is specified through the parent-sibling notation, as explained in the introduction above.

gtk_ctree_remove_node ()

void        gtk_ctree_remove_node           (GtkCTree *ctree,
                                             GtkCTreeNode *node);

Remove the node and all nodes underneath it from the tree.

gtk_ctree_insert_gnode ()

GtkCTreeNode* gtk_ctree_insert_gnode        (GtkCTree *ctree,
                                             GtkCTreeNode *parent,
                                             GtkCTreeNode *sibling,
                                             GNode *gnode,
                                             GtkCTreeGNodeFunc func,
                                             gpointer data);

FIXME

gtk_ctree_export_to_gnode ()

GNode*      gtk_ctree_export_to_gnode       (GtkCTree *ctree,
                                             GNode *parent,
                                             GNode *sibling,
                                             GtkCTreeNode *node,
                                             GtkCTreeGNodeFunc func,
                                             gpointer data);

FIXME

gtk_ctree_post_recursive ()

void        gtk_ctree_post_recursive        (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             GtkCTreeFunc func,
                                             gpointer data);

Recursively apply a function to all nodes of the tree at or below a certain node. The function is called for each node after it has been called for that node's children.

gtk_ctree_post_recursive_to_depth ()

void        gtk_ctree_post_recursive_to_depth
                                            (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gint depth,
                                             GtkCTreeFunc func,
                                             gpointer data);

Recursively apply a function to nodes up to a certain depth. The function is called for each node after it has been called for that node's children.

gtk_ctree_pre_recursive ()

void        gtk_ctree_pre_recursive         (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             GtkCTreeFunc func,
                                             gpointer data);

Recursively apply a function to all nodes of the tree at or below a certain node. The function is called for each node after it has been called for its parent.

gtk_ctree_pre_recursive_to_depth ()

void        gtk_ctree_pre_recursive_to_depth
                                            (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gint depth,
                                             GtkCTreeFunc func,
                                             gpointer data);

Recursively apply a function to nodes up to a certain depth. The function is called for each node after it has been called for that node's children.

gtk_ctree_is_viewable ()

gboolean    gtk_ctree_is_viewable           (GtkCTree *ctree,
                                             GtkCTreeNode *node);

This function checks whether the given node is viewable i.e. so that all of its parent nodes are expanded. This is different from being actually visible: the node can be viewable but outside the scrolling area of the window.

gtk_ctree_last ()

GtkCTreeNode* gtk_ctree_last                (GtkCTree *ctree,
                                             GtkCTreeNode *node);

Returns the last child of the last child of the last child... of the given node.

gtk_ctree_find_node_ptr ()

GtkCTreeNode* gtk_ctree_find_node_ptr       (GtkCTree *ctree,
                                             GtkCTreeRow *ctree_row);

Finds the node pointer given a GtkCTreeRow structure.

gtk_ctree_find ()

gboolean    gtk_ctree_find                  (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             GtkCTreeNode *child);

gtk_ctree_is_ancestor ()

gboolean    gtk_ctree_is_ancestor           (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             GtkCTreeNode *child);

gtk_ctree_find_by_row_data ()

GtkCTreeNode* gtk_ctree_find_by_row_data    (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gpointer data);

Finds a node in the tree under node that has the given user data pointer.

gtk_ctree_find_all_by_row_data ()

GList*      gtk_ctree_find_all_by_row_data  (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gpointer data);

Finds all nodes in the tree under node that have the given user data pointer.

gtk_ctree_find_by_row_data_custom ()

GtkCTreeNode* gtk_ctree_find_by_row_data_custom
                                            (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gpointer data,
                                             GCompareFunc func);

Find the first node under node whose row data pointer fulfills a custom criterion.

gtk_ctree_find_all_by_row_data_custom ()

GList*      gtk_ctree_find_all_by_row_data_custom
                                            (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gpointer data,
                                             GCompareFunc func);

Find all nodes under node whose row data pointer fulfills a custom criterion.

gtk_ctree_is_hot_spot ()

gboolean    gtk_ctree_is_hot_spot           (GtkCTree *ctree,
                                             gint x,
                                             gint y);

gtk_ctree_move ()

void        gtk_ctree_move                  (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             GtkCTreeNode *new_parent,
                                             GtkCTreeNode *new_sibling);

Move a node in the tree to another location.

gtk_ctree_expand ()

void        gtk_ctree_expand                (GtkCTree *ctree,
                                             GtkCTreeNode *node);

Expand one node.

gtk_ctree_expand_recursive ()

void        gtk_ctree_expand_recursive      (GtkCTree *ctree,
                                             GtkCTreeNode *node);

Expand one node and all nodes underneath.

gtk_ctree_expand_to_depth ()

void        gtk_ctree_expand_to_depth       (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gint depth);

Expand a node and its children up to the depth given.

gtk_ctree_collapse ()

void        gtk_ctree_collapse              (GtkCTree *ctree,
                                             GtkCTreeNode *node);

Collapse one node.

gtk_ctree_collapse_recursive ()

void        gtk_ctree_collapse_recursive    (GtkCTree *ctree,
                                             GtkCTreeNode *node);

Collapse one node and all its subnodes.

gtk_ctree_collapse_to_depth ()

void        gtk_ctree_collapse_to_depth     (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gint depth);

Collapse a node and its children up to the depth given.

gtk_ctree_toggle_expansion ()

void        gtk_ctree_toggle_expansion      (GtkCTree *ctree,
                                             GtkCTreeNode *node);

Toggle a node, i.e. if it is collapsed, expand it and vice versa.

gtk_ctree_toggle_expansion_recursive ()

void        gtk_ctree_toggle_expansion_recursive
                                            (GtkCTree *ctree,
                                             GtkCTreeNode *node);

Toggle the expansion of a node and all its children.

gtk_ctree_select ()

void        gtk_ctree_select                (GtkCTree *ctree,
                                             GtkCTreeNode *node);

Cause the given node to be selected and emit the appropriate signal.

gtk_ctree_select_recursive ()

void        gtk_ctree_select_recursive      (GtkCTree *ctree,
                                             GtkCTreeNode *node);

Cause the given node and its subnodes to be selected and emit the appropriate signal(s).

gtk_ctree_unselect ()

void        gtk_ctree_unselect              (GtkCTree *ctree,
                                             GtkCTreeNode *node);

Unselect the given node and emit the appropriate signal.

gtk_ctree_unselect_recursive ()

void        gtk_ctree_unselect_recursive    (GtkCTree *ctree,
                                             GtkCTreeNode *node);

Unselect the given node and its subnodes and emit the appropriate signal(s).

gtk_ctree_real_select_recursive ()

void        gtk_ctree_real_select_recursive (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gint state);

The function that implements both gtk_ctree_select_recursive and gtk_ctree_unselect_recursive.

gtk_ctree_node_set_text ()

void        gtk_ctree_node_set_text         (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gint column,
                                             const gchar *text);

Set the text in a node.

gtk_ctree_node_set_pixmap ()

void        gtk_ctree_node_set_pixmap       (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gint column,
                                             GdkPixmap *pixmap,
                                             GdkBitmap *mask);

FIXME

gtk_ctree_node_set_pixtext ()

void        gtk_ctree_node_set_pixtext      (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gint column,
                                             const gchar *text,
                                             guint8 spacing,
                                             GdkPixmap *pixmap,
                                             GdkBitmap *mask);

FIXME

gtk_ctree_set_node_info ()

void        gtk_ctree_set_node_info         (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             const gchar *text,
                                             guint8 spacing,
                                             GdkPixmap *pixmap_closed,
                                             GdkBitmap *mask_closed,
                                             GdkPixmap *pixmap_opened,
                                             GdkBitmap *mask_opened,
                                             gboolean is_leaf,
                                             gboolean expanded);

Change the information. Most parameters correspond to the parameters of gtk_ctree_insert_node.

gtk_ctree_node_set_shift ()

void        gtk_ctree_node_set_shift        (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gint column,
                                             gint vertical,
                                             gint horizontal);

Shift the given cell the given amounts in pixels.

gtk_ctree_node_set_selectable ()

void        gtk_ctree_node_set_selectable   (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gboolean selectable);

gtk_ctree_node_get_selectable ()

gboolean    gtk_ctree_node_get_selectable   (GtkCTree *ctree,
                                             GtkCTreeNode *node);

gtk_ctree_node_get_cell_type ()

GtkCellType gtk_ctree_node_get_cell_type    (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gint column);

gtk_ctree_node_get_text ()

gboolean    gtk_ctree_node_get_text         (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gint column,
                                             gchar **text);

gtk_ctree_node_get_pixmap ()

gboolean    gtk_ctree_node_get_pixmap       (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gint column,
                                             GdkPixmap **pixmap,
                                             GdkBitmap **mask);

gtk_ctree_node_get_pixtext ()

gboolean    gtk_ctree_node_get_pixtext      (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gint column,
                                             gchar **text,
                                             guint8 *spacing,
                                             GdkPixmap **pixmap,
                                             GdkBitmap **mask);

Get the parameters of a cell containing both a pixmap and text.

gtk_ctree_get_node_info ()

gboolean    gtk_ctree_get_node_info         (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gchar **text,
                                             guint8 *spacing,
                                             GdkPixmap **pixmap_closed,
                                             GdkBitmap **mask_closed,
                                             GdkPixmap **pixmap_opened,
                                             GdkBitmap **mask_opened,
                                             gboolean *is_leaf,
                                             gboolean *expanded);

Get information corresponding to a node. Any of the return parameters can be null.

gtk_ctree_node_set_row_style ()

void        gtk_ctree_node_set_row_style    (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             GtkStyle *style);

Set the style of a row.

gtk_ctree_node_get_row_style ()

GtkStyle*   gtk_ctree_node_get_row_style    (GtkCTree *ctree,
                                             GtkCTreeNode *node);

Get the style of a row.

gtk_ctree_node_set_cell_style ()

void        gtk_ctree_node_set_cell_style   (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gint column,
                                             GtkStyle *style);

Set the style of an individual cell.

gtk_ctree_node_get_cell_style ()

GtkStyle*   gtk_ctree_node_get_cell_style   (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gint column);

Get the style of an individual cell.

gtk_ctree_node_set_foreground ()

void        gtk_ctree_node_set_foreground   (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             const GdkColor *color);

gtk_ctree_node_set_background ()

void        gtk_ctree_node_set_background   (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             const GdkColor *color);

gtk_ctree_node_set_row_data ()

void        gtk_ctree_node_set_row_data     (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gpointer data);

Set the custom data associated with a node.

gtk_ctree_node_set_row_data_full ()

void        gtk_ctree_node_set_row_data_full
                                            (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gpointer data,
                                             GtkDestroyNotify destroy);

This is the full interface to setting row data, so that a destructor can be given for the data.

gtk_ctree_node_get_row_data ()

gpointer    gtk_ctree_node_get_row_data     (GtkCTree *ctree,
                                             GtkCTreeNode *node);

gtk_ctree_node_moveto ()

void        gtk_ctree_node_moveto           (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gint column,
                                             gfloat row_align,
                                             gfloat col_align);

This function makes the given column of the given node visible by scrolling.

gtk_ctree_node_is_visible ()

GtkVisibility gtk_ctree_node_is_visible     (GtkCTree *ctree,
                                             GtkCTreeNode *node);

gtk_ctree_set_indent ()

void        gtk_ctree_set_indent            (GtkCTree *ctree,
                                             gint indent);

gtk_ctree_set_spacing ()

void        gtk_ctree_set_spacing           (GtkCTree *ctree,
                                             gint spacing);

The spacing between the tree graphic and the actual node content.

gtk_ctree_set_reorderable()

#define gtk_ctree_set_reorderable(t,r)                    gtk_clist_set_reorderable((GtkCList*) (t),(r))

gtk_ctree_set_line_style ()

void        gtk_ctree_set_line_style        (GtkCTree *ctree,
                                             GtkCTreeLineStyle line_style);

gtk_ctree_set_expander_style ()

void        gtk_ctree_set_expander_style    (GtkCTree *ctree,
                                             GtkCTreeExpanderStyle expander_style);

gtk_ctree_set_drag_compare_func ()

void        gtk_ctree_set_drag_compare_func (GtkCTree *ctree,
                                             GtkCTreeCompareDragFunc cmp_func);

FIXME

gtk_ctree_sort_node ()

void        gtk_ctree_sort_node             (GtkCTree *ctree,
                                             GtkCTreeNode *node);

Sort the children of a node. See GtkCList for how to set the sorting criteria etc.

gtk_ctree_sort_recursive ()

void        gtk_ctree_sort_recursive        (GtkCTree *ctree,
                                             GtkCTreeNode *node);

Sort the descendants of a node. See GtkCList for how to set the sorting criteria etc.

gtk_ctree_node_nth ()

GtkCTreeNode* gtk_ctree_node_nth            (GtkCTree *ctree,
                                             guint row);

gtk_ctree_set_show_stub ()

void        gtk_ctree_set_show_stub         (GtkCTree *ctree,
                                             gboolean show_stub);

The "expander-style" property

  "expander-style"       GtkCTreeExpanderStyle  : Read / Write

The style of the expander buttons.

Default value: GTK_CTREE_EXPANDER_NONE

The "indent" property

  "indent"               guint                 : Read / Write

The number of pixels to indent the tree levels.

Default value: 0

The "line-style" property

  "line-style"           GtkCTreeLineStyle     : Read / Write

The style of the lines in the tree graphic.

Default value: GTK_CTREE_LINES_NONE

The "n-columns" property

  "n-columns"            guint                 : Read / Write / Construct Only

The number of columns in the tree.

Default value: 0

The "show-stub" property

  "show-stub"            gboolean              : Read / Write

Default value: FALSE

The "spacing" property

  "spacing"              guint                 : Read / Write

The number of pixels between the tree and the columns.

Default value: 0

The "tree-column" property

  "tree-column"          guint                 : Read / Write / Construct Only

The column in which the actual tree graphic appears.

Default value: 0

The "change-focus-row-expansion" signal

void        user_function                  (GtkCTree *ctree,
                                            GtkCTreeExpansionType expansion,
                                            gpointer user_data);

The row which has the focus is either collapsed or expanded or toggled.

The "tree-collapse" signal

void        user_function                  (GtkCTree *ctree,
                                            GtkCTreeNode *node,
                                            gpointer user_data);

Emitted when a node is collapsed.

The "tree-expand" signal

void        user_function                  (GtkCTree *ctree,
                                            GtkCTreeNode *node,
                                            gpointer user_data);

Emitted when a node is expanded.

The "tree-move" signal

void        user_function                  (GtkCTree *ctree,
                                            GtkCTreeNode *node,
                                            GtkCTreeNode *new_parent,
                                            GtkCTreeNode *new_sibling,
                                            gpointer user_data);

Emitted when a node is moved.

The "tree-select-row" signal

void        user_function                  (GtkCTree *ctree,
                                            GtkCTreeNode *node,
                                            gint column,
                                            gpointer user_data);

Emitted when a row is selected.

The "tree-unselect-row" signal

void        user_function                  (GtkCTree *ctree,
                                            GtkCTreeNode *node,
                                            gint column,
                                            gpointer user_data);

Emitted when a node is unselected.