GtkCTree

typedef struct _GtkCTree GtkCTree;

The GtkCTree 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)      : Run Last / Action

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)      : Run Last

Emitted when a node is collapsed.

The "tree-expand" signal

void                user_function                      (GtkCTree     *ctree,
                                                        GtkCTreeNode *node,
                                                        gpointer      user_data)      : Run Last

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)        : Run Last

Emitted when a node is moved.

The "tree-select-row" signal

void                user_function                      (GtkCTree     *ctree,
                                                        GtkCTreeNode *node,
                                                        gint          column,
                                                        gpointer      user_data)      : Run First

Emitted when a row is selected.

The "tree-unselect-row" signal

void                user_function                      (GtkCTree     *ctree,
                                                        GtkCTreeNode *node,
                                                        gint          column,
                                                        gpointer      user_data)      : Run First

Emitted when a node is unselected.