GtkCTree

GtkCTree — A widget displaying a hierarchical tree

Synopsis


#include <gtk/gtk.h>

                    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);
                    GtkCTreeRow;
                    GtkCTreeNode;
#define             GTK_TYPE_CTREE_NODE
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);
gboolean            gtk_ctree_node_get_text             (GtkCTree *ctree,
                                                         GtkCTreeNode *node,
                                                         gint column,
                                                         gchar **text);
gboolean            gtk_ctree_node_get_pixmap           (GtkCTree *ctree,
                                                         GtkCTreeNode *node,
                                                         gint column,
                                                         GdkPixmap **pixmap,
                                                         GdkBitmap **mask);
gboolean            gtk_ctree_node_get_pixtext          (GtkCTree *ctree,
                                                         GtkCTreeNode *node,
                                                         gint column,
                                                         gchar **text,
                                                         guint8 *spacing,
                                                         GdkPixmap **pixmap,
                                                         GdkBitmap **mask);
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);
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,
                                                         const GdkColor *color);
void                gtk_ctree_node_set_background       (GtkCTree *ctree,
                                                         GtkCTreeNode *node,
                                                         const 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,
                                                         GDestroyNotify 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

  GObject
   +----GInitiallyUnowned
         +----GtkObject
               +----GtkWidget
                     +----GtkContainer
                           +----GtkCList
                                 +----GtkCTree

Implemented Interfaces

GtkCTree implements AtkImplementorIface and GtkBuildable.

Properties

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

Signals

  "change-focus-row-expansion"                     : Run Last / Action
  "tree-collapse"                                  : Run Last
  "tree-expand"                                    : Run Last
  "tree-move"                                      : Run Last
  "tree-select-row"                                : Run First
  "tree-unselect-row"                              : Run First

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.

GtkCTree has been deprecated since GTK+ 2.0 and should not be used in newly written code. Use GtkTreeView instead.

Details

GtkCTree

typedef struct _GtkCTree GtkCTree;

Warning

GtkCTree is deprecated and should not be used in newly-written code.

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

Warning

GTK_CTREE_ROW is deprecated and should not be used in newly-written code.

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

_node_ :

GTK_CTREE_NODE()

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

Warning

GTK_CTREE_NODE is deprecated and should not be used in newly-written code.

_node_ :

GTK_CTREE_NODE_NEXT()

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

Warning

GTK_CTREE_NODE_NEXT is deprecated and should not be used in newly-written code.

FIXME

_nnode_ :

GTK_CTREE_NODE_PREV()

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

Warning

GTK_CTREE_NODE_PREV is deprecated and should not be used in newly-written code.

FIXME

_pnode_ :

GTK_CTREE_FUNC()

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

Warning

GTK_CTREE_FUNC is deprecated and should not be used in newly-written code.

_func_ :

enum GtkCTreePos

typedef enum
{
  GTK_CTREE_POS_BEFORE,
  GTK_CTREE_POS_AS_CHILD,
  GTK_CTREE_POS_AFTER
} GtkCTreePos;

Warning

GtkCTreePos is deprecated and should not be used in newly-written code.

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

GTK_CTREE_POS_BEFORE As a sibling, before the specified node.
GTK_CTREE_POS_AS_CHILD As a child of the specified node.
GTK_CTREE_POS_AFTER As 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;

Warning

GtkCTreeLineStyle is deprecated and should not be used in newly-written code.

The appearance of the lines in the tree graphics.

GTK_CTREE_LINES_NONE No lines.
GTK_CTREE_LINES_SOLID Solid lines.
GTK_CTREE_LINES_DOTTED Dotted lines.
GTK_CTREE_LINES_TABBED FIXME.


enum GtkCTreeExpanderStyle

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

Warning

GtkCTreeExpanderStyle is deprecated and should not be used in newly-written code.

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

GTK_CTREE_EXPANDER_NONE No expanders.
GTK_CTREE_EXPANDER_SQUARE Square expanders.
GTK_CTREE_EXPANDER_TRIANGLE Triangular expanders.
GTK_CTREE_EXPANDER_CIRCULAR Round 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;

Warning

GtkCTreeExpansionType is deprecated and should not be used in newly-written code.

How to expand or collapse a part of a tree.

GTK_CTREE_EXPANSION_EXPAND Expand this node.
GTK_CTREE_EXPANSION_EXPAND_RECURSIVE Expand this node and everything below it in the hierarchy.
GTK_CTREE_EXPANSION_COLLAPSE Collapse this node.
GTK_CTREE_EXPANSION_COLLAPSE_RECURSIVE Collapse this node and everything below it in the hierarchy.
GTK_CTREE_EXPANSION_TOGGLE Toggle this node (i.e. expand if collapsed and vice versa).
GTK_CTREE_EXPANSION_TOGGLE_RECURSIVE Toggle this node and everything below it in the hierarchy.


GtkCTreeFunc ()

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

Warning

GtkCTreeFunc is deprecated and should not be used in newly-written code.

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

Warning

GtkCTreeGNodeFunc is deprecated and should not be used in newly-written code.

FIXME

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

GtkCTreeCompareDragFunc ()

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

Warning

GtkCTreeCompareDragFunc is deprecated and should not be used in newly-written code.

FIXME

ctree :
source_node :
new_parent :
new_sibling :
Returns :

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;

Warning

GtkCTreeRow is deprecated and should not be used in newly-written code.

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.


GtkCTreeNode

typedef struct {
  GList list;
} GtkCTreeNode;

Warning

GtkCTreeNode is deprecated and should not be used in newly-written code.

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

Warning

GTK_TYPE_CTREE_NODE is deprecated and should not be used in newly-written code.


gtk_ctree_new_with_titles ()

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

Warning

gtk_ctree_new_with_titles is deprecated and should not be used in newly-written code.

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

Warning

gtk_ctree_new is deprecated and should not be used in newly-written code.

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,