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)      : 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.