GtkCTree

Name

GtkCTree -- a widget displaying a hierarchical tree.

Synopsis


#include <gtk/gtk.h>


struct      GtkCTree;
#define     GTK_CTREE_ROW                   (_node_)
#define     GTK_CTREE_NODE                  (_node_)
#define     GTK_CTREE_NODE_NEXT             (_nnode_)
#define     GTK_CTREE_NODE_PREV             (_pnode_)
#define     GTK_CTREE_FUNC                  (_func_)
enum        GtkCTreePos;
enum        GtkCTreeLineStyle;
enum        GtkCTreeExpanderStyle;
enum        GtkCTreeExpansionType;
void        (*GtkCTreeFunc)                 (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gpointer data);
gboolean    (*GtkCTreeGNodeFunc)            (GtkCTree *ctree,
                                             guint depth,
                                             GNode *gnode,
                                             GtkCTreeNode *cnode,
                                             gpointer data);
gboolean    (*GtkCTreeCompareDragFunc)      (GtkCTree *ctree,
                                             GtkCTreeNode *source_node,
                                             GtkCTreeNode *new_parent,
                                             GtkCTreeNode *new_sibling);
struct      GtkCTreeRow;
struct      GtkCTreeNode;
void        gtk_ctree_construct             (GtkCTree *ctree,
                                             gint columns,
                                             gint tree_column,
                                             gchar *titles[]);
GtkWidget*  gtk_ctree_new_with_titles       (gint columns,
                                             gint tree_column,
                                             gchar *titles[]);
GtkWidget*  gtk_ctree_new                   (gint columns,
                                             gint tree_column);
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);
void        gtk_ctree_remove_node           (GtkCTree *ctree,
                                             GtkCTreeNode *node);
GtkCTreeNode* gtk_ctree_insert_gnode        (GtkCTree *ctree,
                                             GtkCTreeNode *parent,
                                             GtkCTreeNode *sibling,
                                             GNode *gnode,
                                             GtkCTreeGNodeFunc func,
                                             gpointer data);
GNode*      gtk_ctree_export_to_gnode       (GtkCTree *ctree,
                                             GNode *parent,
                                             GNode *sibling,
                                             GtkCTreeNode *node,
                                             GtkCTreeGNodeFunc func,
                                             gpointer data);
void        gtk_ctree_post_recursive        (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             GtkCTreeFunc func,
                                             gpointer data);
void        gtk_ctree_post_recursive_to_depth
                                            (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gint depth,
                                             GtkCTreeFunc func,
                                             gpointer data);
void        gtk_ctree_pre_recursive         (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             GtkCTreeFunc func,
                                             gpointer data);
void        gtk_ctree_pre_recursive_to_depth
                                            (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gint depth,
                                             GtkCTreeFunc func,
                                             gpointer data);
gboolean    gtk_ctree_is_viewable           (GtkCTree *ctree,
                                             GtkCTreeNode *node);
GtkCTreeNode* gtk_ctree_last                (GtkCTree *ctree,
                                             GtkCTreeNode *node);
GtkCTreeNode* gtk_ctree_find_node_ptr       (GtkCTree *ctree,
                                             GtkCTreeRow *ctree_row);
gboolean    gtk_ctree_find                  (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             GtkCTreeNode *child);
gboolean    gtk_ctree_is_ancestor           (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             GtkCTreeNode *child);
GtkCTreeNode* gtk_ctree_find_by_row_data    (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gpointer data);
GList*      gtk_ctree_find_all_by_row_data  (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gpointer data);
GtkCTreeNode* gtk_ctree_find_by_row_data_custom
                                            (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gpointer data,
                                             GCompareFunc func);
GList*      gtk_ctree_find_all_by_row_data_custom
                                            (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gpointer data,
                                             GCompareFunc func);
gboolean    gtk_ctree_is_hot_spot           (GtkCTree *ctree,
                                             gint x,
                                             gint y);
void        gtk_ctree_move                  (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             GtkCTreeNode *new_parent,
                                             GtkCTreeNode *new_sibling);
void        gtk_ctree_expand                (GtkCTree *ctree,
                                             GtkCTreeNode *node);
void        gtk_ctree_expand_recursive      (GtkCTree *ctree,
                                             GtkCTreeNode *node);
void        gtk_ctree_expand_to_depth       (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gint depth);
void        gtk_ctree_collapse              (GtkCTree *ctree,
                                             GtkCTreeNode *node);
void        gtk_ctree_collapse_recursive    (GtkCTree *ctree,
                                             GtkCTreeNode *node);
void        gtk_ctree_collapse_to_depth     (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gint depth);
void        gtk_ctree_toggle_expansion      (GtkCTree *ctree,
                                             GtkCTreeNode *node);
void        gtk_ctree_toggle_expansion_recursive
                                            (GtkCTree *ctree,
                                             GtkCTreeNode *node);
void        gtk_ctree_select                (GtkCTree *ctree,
                                             GtkCTreeNode *node);
void        gtk_ctree_select_recursive      (GtkCTree *ctree,
                                             GtkCTreeNode *node);
void        gtk_ctree_unselect              (GtkCTree *ctree,
                                             GtkCTreeNode *node);
void        gtk_ctree_unselect_recursive    (GtkCTree *ctree,
                                             GtkCTreeNode *node);
void        gtk_ctree_real_select_recursive (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gint state);
void        gtk_ctree_node_set_text         (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gint column,
                                             const gchar *text);
void        gtk_ctree_node_set_pixmap       (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gint column,
                                             GdkPixmap *pixmap,
                                             GdkBitmap *mask);
void        gtk_ctree_node_set_pixtext      (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gint column,
                                             const gchar *text,
                                             guint8 spacing,
                                             GdkPixmap *pixmap,
                                             GdkBitmap *mask);
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);
void        gtk_ctree_node_set_shift        (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gint column,
                                             gint vertical,
                                             gint horizontal);
void        gtk_ctree_node_set_selectable   (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gboolean selectable);
gboolean    gtk_ctree_node_get_selectable   (GtkCTree *ctree,
                                             GtkCTreeNode *node);
GtkCellType gtk_ctree_node_get_cell_type    (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gint column);
gint        gtk_ctree_node_get_text         (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gint column,
                                             gchar **text);
gint        gtk_ctree_node_get_pixmap       (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gint column,
                                             GdkPixmap **pixmap,
                                             GdkBitmap **mask);
gint        gtk_ctree_node_get_pixtext      (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gint column,
                                             gchar **text,
                                             guint8 *spacing,
                                             GdkPixmap **pixmap,
                                             GdkBitmap **mask);
gint        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);
void        gtk_ctree_node_set_row_style    (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             GtkStyle *style);
GtkStyle*   gtk_ctree_node_get_row_style    (GtkCTree *ctree,
                                             GtkCTreeNode *node);
void        gtk_ctree_node_set_cell_style   (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gint column,
                                             GtkStyle *style);
GtkStyle*   gtk_ctree_node_get_cell_style   (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gint column);
void        gtk_ctree_node_set_foreground   (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             GdkColor *color);
void        gtk_ctree_node_set_background   (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             GdkColor *color);
void        gtk_ctree_node_set_row_data     (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gpointer data);
void        gtk_ctree_node_set_row_data_full
                                            (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gpointer data,
                                             GtkDestroyNotify destroy);
gpointer    gtk_ctree_node_get_row_data     (GtkCTree *ctree,
                                             GtkCTreeNode *node);
void        gtk_ctree_node_moveto           (GtkCTree *ctree,
                                             GtkCTreeNode *node,
                                             gint column,
                                             gfloat row_align,
                                             gfloat col_align);
GtkVisibility gtk_ctree_node_is_visible     (GtkCTree *ctree,
                                             GtkCTreeNode *node);
void        gtk_ctree_set_indent            (GtkCTree *ctree,
                                             gint indent);
void        gtk_ctree_set_spacing           (GtkCTree *ctree,
                                             gint spacing);
#define     gtk_ctree_set_reorderable       (t,r)
void        gtk_ctree_set_line_style        (GtkCTree *ctree,
                                             GtkCTreeLineStyle line_style);
void        gtk_ctree_set_expander_style    (GtkCTree *ctree,
                                             GtkCTreeExpanderStyle expander_style);
void        gtk_ctree_set_drag_compare_func (GtkCTree *ctree,
                                             GtkCTreeCompareDragFunc cmp_func);
void        gtk_ctree_sort_node             (GtkCTree *ctree,
                                             GtkCTreeNode *node);
void        gtk_ctree_sort_recursive        (GtkCTree *ctree,
                                             GtkCTreeNode *node);
GtkCTreeNode* gtk_ctree_node_nth            (GtkCTree *ctree,
                                             guint row);
void        gtk_ctree_set_show_stub         (GtkCTree *ctree,
                                             gboolean show_stub);

Object Hierarchy


  GtkObject
   +----GtkWidget
         +----GtkContainer
               +----GtkCList
                     +----GtkCTree

Args


  "n-columns"            guint                : Read / Write / Construct Only
  "tree-column"          guint                : Read / Write / Construct Only
  "indent"               guint                : Read / Write
  "spacing"              guint                : Read / Write
  "show-stub"            gboolean             : Read / Write
  "line-style"           GtkCTreeLineStyle    : Read / Write
  "expander-style"       GtkCTreeExpanderStyle : Read / Write

Signal Prototypes


"tree-select-row"
            void        user_function      (GtkCTree *ctree,
                                            GList *node,
                                            gint column,
                                            gpointer user_data);
"tree-unselect-row"
            void        user_function      (GtkCTree *ctree,
                                            GList *node,
                                            gint column,
                                            gpointer user_data);
"tree-expand"
            void        user_function      (GtkCTree *ctree,
                                            GList *node,
                                            gpointer user_data);
"tree-collapse"
            void        user_function      (GtkCTree *ctree,
                                            GList *node,
                                            gpointer user_data);
"tree-move" void        user_function      (GtkCTree *ctree,
                                            GList *node,
                                            GList *new_parent,
                                            GList *new_sibling,
                                            gpointer user_data);
"change-focus-row-expansion"
            void        user_function      (GtkCTree *ctree,
                                            GtkCTreeExpansionType expansion,
                                            gpointer user_data);

Description

The GtkCTree widget is used for showing a hierarchical tree to the user, for example a directory tree.

The tree is internally represented as a set of GtkCTreeNode structures.

The interface has much in common with the GtkCList widget: rows (nodes) can be selected by the user etc.

Positions in the tree are often indicated by two arguments, a parent and a sibling, both GtkCTreeNode pointers. If the parent is NULL, the position is at the root of the tree and if the sibling is NULL, it will be the last child of parent, otherwise it will be inserted just before the sibling.

Details

struct GtkCTree

struct GtkCTree;

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

gint tree_indent;The number of pixels each successive level of the tree is indented in the display.
gint tree_spacing;The space in pixels between the graphical tree and the text in the node.
gint tree_column;The index of the column for which the tree graphics is drawn.
GtkCTreeLineStyle line_style;The style in which the lines in the tree graphics are drawn.
GtkCTreeExpanderStyle expander_style;The style in which the expander buttons are drawn.
GtkCTreeExpanderStyle expander_style;FIXME.


GTK_CTREE_ROW()

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

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

_node_ : 


GTK_CTREE_NODE()

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

_node_ : 


GTK_CTREE_NODE_NEXT()

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

FIXME

_nnode_ : 


GTK_CTREE_NODE_PREV()

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

FIXME

_pnode_ : 


GTK_CTREE_FUNC()

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

_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.

GTK_CTREE_POS_BEFOREAs a sibling, before the specified node.
GTK_CTREE_POS_AS_CHILDAs a child of the specified node.
GTK_CTREE_POS_AFTERAs a sibling, after the specified node.


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.

GTK_CTREE_LINES_NONENo lines.
GTK_CTREE_LINES_SOLIDSolid lines.
GTK_CTREE_LINES_DOTTEDDotted lines.
GTK_CTREE_LINES_TABBEDFIXME.


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.

GTK_CTREE_EXPANDER_NONENo expanders.
GTK_CTREE_EXPANDER_SQUARESquare expanders.
GTK_CTREE_EXPANDER_TRIANGLETriangular expanders.
GTK_CTREE_EXPANDER_CIRCULARRound expanders.


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.

GTK_CTREE_EXPANSION_EXPANDExpand this node.
GTK_CTREE_EXPANSION_EXPAND_RECURSIVEExpand this node and everything below it in the hierarchy.
GTK_CTREE_EXPANSION_COLLAPSECollapse this node.
GTK_CTREE_EXPANSION_COLLAPSE_RECURSIVECollapse this node and everything below it in the hierarchy.
GTK_CTREE_EXPANSION_TOGGLEToggle this node (i.e. expand if collapsed and vice versa).
GTK_CTREE_EXPANSION_TOGGLE_RECURSIVEToggle this node and everything below it in the hierarchy.


GtkCTreeFunc ()

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

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

ctree :The GtkCTree object.
node :The GtkCTreeNode in the tree.
data :The user data associated with the node.


GtkCTreeGNodeFunc ()

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

FIXME

ctree : 
depth : 
gnode : 
cnode : 
data : 
Returns : 


GtkCTreeCompareDragFunc ()

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

FIXME

ctree : 
source_node : 
new_parent : 
new_sibling : 
Returns : 


struct GtkCTreeRow

struct GtkCTreeRow
{
  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;
};

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 *parent;The parent node of the node corresponding to this row.
GtkCTreeNode *sibling;The next sibling node of the node corresponding to this row.
GtkCTreeNode *children;The first child node corresponding to this row; to access the other children, just use the siblings of that node.
GdkPixmap *pixmap_closed; The pixmap to be shown when the node is collapsed.
GdkBitmap *mask_closed; The mask for the above pixmap.
GdkPixmap *pixmap_opened; The pixmap to be shown when the node is expanded.
GdkBitmap *mask_opened; The mask for the above pixmap.
guint16 level;The level of this node in the tree.
guint is_leaf : 1;Whether this row is a leaf.
guint expanded : 1;Whether the children of this row are visible.


struct GtkCTreeNode

struct GtkCTreeNode {
  GList list;
};

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_ctree_construct ()

void        gtk_ctree_construct             (GtkCTree *ctree,
                                             gint columns,
                                             gint tree_column,
                                             gchar *titles[]);

This function is not usually used by users.

ctree : 
columns : 
tree_column : 
titles : 


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.

columns :Number of columns.
tree_column :Which column has the tree graphic; 0 = leftmost.
titles :The titles for the columns.
Returns :The GtkCTree widget.


gtk_ctree_new ()

GtkWidget*  gtk_ctree_new                   (gint columns,
                                             gint tree_column);

Create a new GtkCTree widget.

columns :Number of columns.
tree_column :Which columns has the tree graphic.
Returns :The 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.

ctree :The GtkCTree widget.
parent :The parent node to be.
sibling :The sibling node to be.
text :The texts to be shown in each column.
spacing :The extra space between the pixmap and the text.
pixmap_closed :The pixmap to be used when the node is collapsed. Can be NULL.
mask_closed :The mask for the above pixmap. Can be NULL.
pixmap_opened :The pixmap to be used when the children are visible. Can be NULL.
mask_opened :The mask for the above pixmap. Can be NULL.
is_leaf :Whether this node is going to be a leaf.
expanded :Whether this node should start out expanded or not.
Returns : 


gtk_ctree_remove_node ()

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

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

ctree :The widget.
node :The node to be removed.


gtk_ctree_insert_gnode ()

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

FIXME

ctree : 
parent : 
sibling : 
gnode : 
func : 
data : 
Returns : 


gtk_ctree_export_to_gnode ()

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

FIXME

ctree : 
parent : 
sibling : 
node : 
func : 
data : 
Returns : 


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.

ctree : 
node :The node where to start. NULL means to start at the root.
func :The function to apply to each node.
data :A closure argument given to each invocation of the function.


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.

ctree : 
node :The node where to start.
depth :The maximum absolute depth for applying the function. If depth is negative, this function just calls gtk_ctree_post_recursive.
func :The function to apply to each node.
data :A closure argument given to each invocation of the function.


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.

ctree : 
node :The node where to start. NULL means to start at the root.
func :The function to apply to each node.
data :A closure argument given to each invocation of the function.


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.

ctree : 
node :The node where to start.
depth :The maximum absolute depth for applying the function. If depth is negative, this function just calls gtk_ctree_post_recursive.
func :The function to apply to each node.
data :A closure argument given to each invocation of the function.


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.

ctree : 
node : 
Returns :Whether the node is viewable.


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.

ctree : 
node : 
Returns : 


gtk_ctree_find_node_ptr ()

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

Finds the node pointer given a GtkCTreeRow structure.

ctree : 
ctree_row : 
Returns :The node pointer.


gtk_ctree_find ()

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

ctree : 
node :The node to start searching from. May be NULL.
child : 
Returns :True if child is on some level a child (grandchild...) of the node.


gtk_ctree_is_ancestor ()

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

ctree : 
node : 
child : 
Returns :True is node is an ancestor of 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.

ctree : 
node : 
data : 
Returns :The node, or NULL if not found.


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.

ctree : 
node : 
data : 
Returns :A list of nodes that have the given 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.

ctree : 
node :The node where to start searching.
data :User data for the criterion function.
func :The criterion function.
Returns :The first node found.


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.

ctree : 
node :The node where to start searching.
data :User data for the criterion function.
func :The criterion function.
Returns :A list of all nodes found.


gtk_ctree_is_hot_spot ()

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

ctree : 
x : 
y : 
Returns :True if the given coordinates lie on an expander button.


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.

ctree : 
node :The node to be moved.
new_parent :The new parent-to-be of the node.
new_sibling :The new sibling-to-be of the node.


gtk_ctree_expand ()

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

Expand one node.

ctree : 
node : 


gtk_ctree_expand_recursive ()

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

Expand one node and all nodes underneath.

ctree : 
node : 


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.

ctree : 
node : 
depth :The (absolute) depth up to which to expand nodes.


gtk_ctree_collapse ()

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

Collapse one node.

ctree : 
node : 


gtk_ctree_collapse_recursive ()

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

Collapse one node and all its subnodes.

ctree : 
node : 


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.

ctree : 
node : 
depth :The (absolute) depth up to which to collapse nodes.


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.

ctree : 
node : 


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.

ctree : 
node : 


gtk_ctree_select ()

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

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

ctree : 
node : 


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

ctree : 
node : 


gtk_ctree_unselect ()

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

Unselect the given node and emit the appropriate signal.

ctree : 
node : 


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

ctree : 
node : 


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.

ctree : 
node : 
state :True for selecting, false for unselecting.


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.

ctree : 
node : 
column :The column whose text to change.
text :The new text.


gtk_ctree_node_set_pixmap ()

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

FIXME

ctree : 
node : 
column : 
pixmap : 
mask : 


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

ctree : 
node : 
column : 
text : 
spacing : 
pixmap : 
mask : 


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.

ctree : 
node : 
text :The text to be in the tree column.
spacing : 
pixmap_closed : 
mask_closed : 
pixmap_opened : 
mask_opened : 
is_leaf : 
expanded : 


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.

ctree : 
node : 
column : 
vertical : 
horizontal : 


gtk_ctree_node_set_selectable ()

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

ctree : 
node : 
selectable :Whether this node can be selected by the user.


gtk_ctree_node_get_selectable ()

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

ctree : 
node : 
Returns :Whether this node can be selected by the user.


gtk_ctree_node_get_cell_type ()

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

ctree : 
node : 
column : 
Returns :The type of the given cell.


gtk_ctree_node_get_text ()

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

ctree : 
node : 
column : 
text :If nonnull, the pointer to the text string is assigned to *text.
Returns :True if the given cell has text in it.


gtk_ctree_node_get_pixmap ()

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

ctree : 
node : 
column : 
pixmap :If nonnull, the pointer to the pixmap is returned through this.
mask :If nonnull, the pointer to the mask is returned through this.
Returns :True if the given cell contains a pixmap.


gtk_ctree_node_get_pixtext ()

gint        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.

ctree : 
node : 
column : 
text : 
spacing : 
pixmap : 
mask : 
Returns : 


gtk_ctree_get_node_info ()

gint        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.

ctree : 
node : 
text : 
spacing : 
pixmap_closed : 
mask_closed : 
pixmap_opened : 
mask_opened : 
is_leaf : 
expanded : 
Returns : 


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.

ctree : 
node : 
style : 


gtk_ctree_node_get_row_style ()

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

Get the style of a row.

ctree : 
node : 
Returns : 


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.

ctree : 
node : 
column : 
style : 


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.

ctree : 
node : 
column : 
Returns : 


gtk_ctree_node_set_foreground ()

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

ctree : 
node : 
color : 


gtk_ctree_node_set_background ()

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

ctree : 
node : 
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.

ctree : 
node : 
data : 


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.

ctree : 
node : 
data : 
destroy :The routine to be called when data is no longer needed.


gtk_ctree_node_get_row_data ()

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

ctree : 
node : 
Returns : 


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.

ctree : 
node :The node to be made visible.
column :The column to be made visible.
row_align :Where in the window the row should appear.
col_align :Where in the window the column should appear.


gtk_ctree_node_is_visible ()

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

ctree : 
node : 
Returns :True if the node is currently inside the bounds of the window. Note that this function can return true even if the node is not viewable, if the node's ancestor is visible.


gtk_ctree_set_indent ()

void        gtk_ctree_set_indent            (GtkCTree *ctree,
                                             gint indent);

ctree : 
indent :The number of pixels to shift the levels of the tree.


gtk_ctree_set_spacing ()

void        gtk_ctree_set_spacing           (GtkCTree *ctree,
                                             gint spacing);

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

ctree : 
spacing : 


gtk_ctree_set_reorderable()

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

t : 
r : 


gtk_ctree_set_line_style ()

void        gtk_ctree_set_line_style        (GtkCTree *ctree,
                                             GtkCTreeLineStyle line_style);

ctree : 
line_style : 


gtk_ctree_set_expander_style ()

void        gtk_ctree_set_expander_style    (GtkCTree *ctree,
                                             GtkCTreeExpanderStyle expander_style);

ctree : 
expander_style : 


gtk_ctree_set_drag_compare_func ()

void        gtk_ctree_set_drag_compare_func (GtkCTree *ctree,
                                             GtkCTreeCompareDragFunc cmp_func);

FIXME

ctree : 
cmp_func : 


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.

ctree : 
node : 


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.

ctree : 
node : 


gtk_ctree_node_nth ()

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

ctree : 
row : 
Returns :The node corresponding to the row th row.


gtk_ctree_set_show_stub ()

void        gtk_ctree_set_show_stub         (GtkCTree *ctree,
                                             gboolean show_stub);

ctree : 
show_stub : 

Args

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

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

"indent" (guint : Read / Write)

The number of pixels to indent the tree levels.

"spacing" (guint : Read / Write)

The number of pixels between the tree and the columns.

"show-stub" (gboolean : Read / Write)

"line-style" (GtkCTreeLineStyle : Read / Write)

"expander-style" (GtkCTreeExpanderStyle : Read / Write)

Signals

The "tree-select-row" signal

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

Emitted when a row is selected.

ctree :the object which received the signal.
node :The node corresponding to the selected row.
column :The column which was selected.
user_data :user data set when the signal handler was connected.


The "tree-unselect-row" signal

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

Emitted when a node is unselected.

ctree :the object which received the signal.
node :The node corresponding to the selected row.
column : 
user_data :user data set when the signal handler was connected.


The "tree-expand" signal

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

Emitted when a node is expanded.

ctree :the object which received the signal.
node : 
user_data :user data set when the signal handler was connected.


The "tree-collapse" signal

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

Emitted when a node is collapsed.

ctree :the object which received the signal.
node : 
user_data :user data set when the signal handler was connected.


The "tree-move" signal

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

Emitted when a node is moved.

ctree :the object which received the signal.
node :The node that is moved.
new_parent :The new parent of the node.
new_sibling :The new sibling of the node.
user_data :user data set when the signal handler was connected.


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.

ctree :the object which received the signal.
expansion :What is being done.
user_data :user data set when the signal handler was connected.