FoNode

FoNode — Object for making trees

Synopsis

                    FoNode;
                    FoNodeClass;
FoNode*             fo_node_new                         (void);
gboolean            (*FoNodeTraverseFunc)               (FoNode *fo_node,
                                                         gpointer data);
void                (*FoNodeForeachFunc)                (FoNode *fo_node,
                                                         gpointer data);
#define             FO_NODE_IS_ROOT                     (fo_node)
#define             FO_NODE_IS_LEAF                     (fo_node)
FoNode*             fo_node_get_ancestor_or_self_by_type
                                                        (FoNode *node,
                                                         const GType type);
FoNode*             fo_node_get_ancestor_or_self_by_name
                                                        (FoNode *node,
                                                         const gchar *name);
FoNode*             fo_node_get_child_by_type           (FoNode *node,
                                                         const GType type);
FoNode*             fo_node_get_child_by_name           (FoNode *node,
                                                         const gchar *name);
FoNode*             fo_node_insert                      (FoNode *parent,
                                                         gint position,
                                                         FoNode *fo_node);
FoNode*             fo_node_insert_before               (FoNode *parent,
                                                         FoNode *sibling,
                                                         FoNode *fo_node);
FoNode*             fo_node_insert_after                (FoNode *parent,
                                                         FoNode *sibling,
                                                         FoNode *fo_node);
FoNode*             fo_node_prepend                     (FoNode *parent,
                                                         FoNode *fo_node);
#define             fo_node_n_nodes                     (root, flags)
#define             fo_node_get_root                    (root)
#define             fo_node_is_ancestor                 (fo_node, descendant)
#define             fo_node_depth                       (fo_node)
FoNode*             fo_node_append                      (FoNode *parent,
                                                         FoNode *fo_node);
void                fo_node_traverse                    (FoNode *root,
                                                         GTraverseType order,
                                                         GTraverseFlags flags,
                                                         gint max_depth,
                                                         FoNodeTraverseFunc func,
                                                         gpointer data);
#define             fo_node_max_height                  (root)
void                fo_node_children_foreach            (FoNode *fo_node,
                                                         GTraverseFlags flags,
                                                         FoNodeForeachFunc func,
                                                         gpointer data);
#define             fo_node_reverse_children            (fo_node)
#define             fo_node_n_children                  (fo_node)
#define             fo_node_nth_child                   (fo_node, n)
#define             fo_node_last_child                  (fo_node)
#define             fo_node_child_position              (fo_node, child)
#define             fo_node_first_sibling               (fo_node)
#define             fo_node_last_sibling                (fo_node)
#define             fo_node_prev_sibling                (fo_node)
FoNode*             fo_node_next_sibling                (FoNode *fo_node);
FoNode*             fo_node_first_child                 (FoNode *fo_node);
FoNode*             fo_node_parent                      (FoNode *fo_node);
#define             fo_node_unlink                      (fo_node)
void                fo_node_unlink_with_next_siblings   (FoNode *fo_node);
FoNode*             fo_node_insert_with_next_siblings   (FoNode *parent,
                                                         gint position,
                                                         FoNode *fo_node);
void                fo_node_debug_dump_tree             (FoNode *fo_node,
                                                         gint depth);

Object Hierarchy

  GObject
   +----FoObject
         +----FoNode
               +----FoArea
               +----FoFo

Properties

  "first-child"              FoNode*               : Read
  "next-sibling"             FoNode*               : Read
  "parent"                   FoNode*               : Read

Description

FoObject child type that makes trees.

Details

FoNode

typedef struct _FoNode FoNode;

Instance of FoNode.


FoNodeClass

typedef struct _FoNodeClass FoNodeClass;

Class structure for FoNode.


fo_node_new ()

FoNode*             fo_node_new                         (void);

Creates a new FoNode initialized to default value.

Returns :

the new FoNode

FoNodeTraverseFunc ()

gboolean            (*FoNodeTraverseFunc)               (FoNode *fo_node,
                                                         gpointer data);

fo_node :

data :

Returns :


FoNodeForeachFunc ()

void                (*FoNodeForeachFunc)                (FoNode *fo_node,
                                                         gpointer data);

fo_node :

data :


FO_NODE_IS_ROOT()

#define FO_NODE_IS_ROOT(fo_node)    (G_NODE_IS_ROOT(((FoNode*) (fo_node))->node))

fo_node :


FO_NODE_IS_LEAF()

#define FO_NODE_IS_LEAF(fo_node)    (G_NODE_IS_LEAF(((FoNode*) (fo_node))->node))

fo_node :


fo_node_get_ancestor_or_self_by_type ()

FoNode*             fo_node_get_ancestor_or_self_by_type
                                                        (FoNode *node,
                                                         const GType type);

Find the nearest ancestor node, or node itself, with the same GType as type.

Does not change the ref count of any node.

node :

FoNode at which to begin.

type :

Required GType of ancestor node.

Returns :

FoNode ancestor (or self) with required GType, or NULL.

fo_node_get_ancestor_or_self_by_name ()

FoNode*             fo_node_get_ancestor_or_self_by_name
                                                        (FoNode *node,
                                                         const gchar *name);

Find the nearest ancestor node, or node itself, with the same name as name.

Does not change the ref count of any node.

node :

FoNode at which to begin.

name :

Required name of ancestor node.

Returns :

FoNode ancestor (or self) with required GType, or NULL.

fo_node_get_child_by_type ()

FoNode*             fo_node_get_child_by_type           (FoNode *node,
                                                         const GType type);

Find the first child of node with GType matching type value.

Does not change the ref count of any node.

Allows 0 as value of type since may have been called by fo_node_get_child_by_name for a type that has yet to be instantiated. Of course, if type is 0, this function returns NULL.

node :

FoNode that is parent of nodes to be tested for matching GType.

type :

GType value.

Returns :

First child of specified type, or NULL.

fo_node_get_child_by_name ()

FoNode*             fo_node_get_child_by_name           (FoNode *node,
                                                         const gchar *name);

Find the first child of node with type name matching name value.

Does not change the ref count of any node.

node :

FoNode that is parent of nodes to be tested for type name.

name :

Name of type.

Returns :

First child of specified type, or NULL.

fo_node_insert ()

FoNode*             fo_node_insert                      (FoNode *parent,
                                                         gint position,
                                                         FoNode *fo_node);

Inserts an FoNode beneath the parent at the given position.

parent :

The FoNode to place fo_node under.

position :

The position to place fo_node at, with respect to its siblings. If position is -1, fo_node is inserted as the last child of parent.

fo_node :

The FoNode to insert.

Returns :

The inserted FoNode.

fo_node_insert_before ()

FoNode*             fo_node_insert_before               (FoNode *parent,
                                                         FoNode *sibling,
                                                         FoNode *fo_node);

Inserts an FoNode beneath the parent before the given sibling.

parent :

The FoNode to place fo_node under.

sibling :

The sibling FoNode to place fo_node before. If sibling is NULL, fo_node is inserted as the last child of parent.

fo_node :

The FoNode to insert.

Returns :

The inserted FoNode.

fo_node_insert_after ()

FoNode*             fo_node_insert_after                (FoNode *parent,
                                                         FoNode *sibling,
                                                         FoNode *fo_node);

Inserts an FoNode beneath the parent after the given sibling.

parent :

The FoNode to place fo_node under.

sibling :

The sibling FoNode to place fo_node after. If sibling is NULL, fo_node is inserted as the first child of parent.

fo_node :

The FoNode to insert.

Returns :

The inserted FoNode.

fo_node_prepend ()

FoNode*             fo_node_prepend                     (FoNode *parent,
                                                         FoNode *fo_node);

Inserts an FoNode as the first child of the given parent.

parent :

The FoNode to place fo_node under.

fo_node :

The FoNode to insert.

Returns :

The inserted FoNode.

fo_node_n_nodes()

#define             fo_node_n_nodes(root, flags)

root :

flags :


fo_node_get_root()

#define             fo_node_get_root(root)

root :


fo_node_is_ancestor()

#define             fo_node_is_ancestor(fo_node, descendant)

fo_node :

descendant :


fo_node_depth()

#define             fo_node_depth(fo_node)

fo_node :


fo_node_append ()

FoNode*             fo_node_append                      (FoNode *parent,
                                                         FoNode *fo_node);

Inserts an FoNode as the last child of the given parent.

parent :

The FoNode to place fo_node under.

fo_node :

The FoNode to insert.

Returns :

The inserted FoNode.

fo_node_traverse ()

void                fo_node_traverse                    (FoNode *root,
                                                         GTraverseType order,
                                                         GTraverseFlags flags,
                                                         gint max_depth,
                                                         FoNodeTraverseFunc func,
                                                         gpointer data);

Traverses a tree starting at the given root FoNode. It calls the given function for each node visited. The traversal can be halted at any point by returning TRUE from func.

root :

The root FoNode of the tree to traverse.

order :

The order in which nodes are visited - G_IN_ORDER, G_PRE_ORDER, G_POST_ORDER, or G_LEVEL_ORDER.

flags :

Which types of children are to be visited, one of G_TRAVERSE_ALL, G_TRAVERSE_LEAFS and G_TRAVERSE_NON_LEAFS.

max_depth :

The maximum depth of the traversal. Nodes below this depth will not be visited. If max_depth is -1 all nodes in the tree are visited. If depth is 1, only the root is visited. If depth is 2, the root and its children are visited. And so on.

func :

The function to call for each visited GNode.

data :

User data to pass to the function.

fo_node_max_height()

#define             fo_node_max_height(root)

root :


fo_node_children_foreach ()

void                fo_node_children_foreach            (FoNode *fo_node,
                                                         GTraverseFlags flags,
                                                         FoNodeForeachFunc func,
                                                         gpointer data);

Calls a function for each of the children of an FoNode. Note that it doesn't descend beneath the child nodes.

fo_node :

An FoNode.

flags :

Which types of children are to be visited, one of G_TRAVERSE_ALL, G_TRAVERSE_LEAFS and G_TRAVERSE_NON_LEAFS.

func :

The function to call for each visited node.

data :

User data to pass to the function.

fo_node_reverse_children()

#define             fo_node_reverse_children(fo_node)

fo_node :


fo_node_n_children()

#define             fo_node_n_children(fo_node)

fo_node :


fo_node_nth_child()

#define             fo_node_nth_child(fo_node, n)

fo_node :

n :


fo_node_last_child()

#define             fo_node_last_child(fo_node)

fo_node :


fo_node_child_position()

#define             fo_node_child_position(fo_node, child)

fo_node :

child :


fo_node_first_sibling()

#define             fo_node_first_sibling(fo_node)

fo_node :


fo_node_last_sibling()

#define             fo_node_last_sibling(fo_node)

fo_node :


fo_node_prev_sibling()

#define             fo_node_prev_sibling(fo_node)

fo_node :


fo_node_next_sibling ()

FoNode*             fo_node_next_sibling                (FoNode *fo_node);

Gets the next sibling FoNode of fo_node.

fo_node :

The FoNode.

Returns :

The next sibling of fo_node, or NULL.

fo_node_first_child ()

FoNode*             fo_node_first_child                 (FoNode *fo_node);

Gets the first child FoNode of fo_node.

fo_node :

The FoNode.

Returns :

The first child of fo_node, or NULL.

fo_node_parent ()

FoNode*             fo_node_parent                      (FoNode *fo_node);

Gets the parent FoNode of fo_node.

fo_node :

The FoNode.

Returns :

The parent of fo_node.

fo_node_unlink()

#define             fo_node_unlink(fo_node)

fo_node :


fo_node_unlink_with_next_siblings ()

void                fo_node_unlink_with_next_siblings   (FoNode *fo_node);

Unlink fo_node and its next siblings (i.e., 'following siblings' in XPath parlance) from their place in their current FoNode tree.

fo_node and its next siblings remain linked together, and any of those nodes keep their child nodes. Neither fo_node nor any of its following siblings are valid roots since they each have a next and/or a previous sibling, even if they don't have a parent.

fo_node :

First FoNode to be unlinked

fo_node_insert_with_next_siblings ()

FoNode*             fo_node_insert_with_next_siblings   (FoNode *parent,
                                                         gint position,
                                                         FoNode *fo_node);

Insert fo_node and its next siblings (i.e., 'following siblings' in XPath parlance) beneath parent at the given position.

fo_node and its next siblings should not already have a parent FoNode.

parent :

The FoNode to place fo_node under.

position :

The position to place fo_node at, with respect to its siblings. If position is -1, fo_node is inserted as the last child of parent.

fo_node :

First FoNode to be inserted.

Returns :

The inserted FoNode.

fo_node_debug_dump_tree ()

void                fo_node_debug_dump_tree             (FoNode *fo_node,
                                                         gint depth);

Logs the tree structure beginning at fo_node.

fo_node :

FoNode to be dumped.

depth :

Relative indent to add to the output.

Property Details

The "first-child" property

  "first-child"              FoNode*               : Read

First child node in the node tree.


The "next-sibling" property

  "next-sibling"             FoNode*               : Read

Next sibling node in the node tree.


The "parent" property

  "parent"                   FoNode*               : Read

Parent node in the node tree.