bonobo-ui-node

Name

bonobo-ui-node -- Simplified XML Node manipulation API

Synopsis



struct      BonoboUINode;
BonoboUINode* bonobo_ui_node_new            (const char *name);
BonoboUINode* bonobo_ui_node_new_child      (BonoboUINode *parent,
                                             const char *name);
BonoboUINode* bonobo_ui_node_copy           (BonoboUINode *node,
                                             gboolean recursive);
void        bonobo_ui_node_free             (BonoboUINode *node);
void        bonobo_ui_node_set_data         (BonoboUINode *node,
                                             gpointer data);
gpointer    bonobo_ui_node_get_data         (BonoboUINode *node);
void        bonobo_ui_node_set_attr         (BonoboUINode *node,
                                             const char *name,
                                             const char *value);
char*       bonobo_ui_node_get_attr         (BonoboUINode *node,
                                             const char *name);
gboolean    bonobo_ui_node_has_attr         (BonoboUINode *node,
                                             const char *name);
void        bonobo_ui_node_remove_attr      (BonoboUINode *node,
                                             const char *name);
void        bonobo_ui_node_add_child        (BonoboUINode *parent,
                                             BonoboUINode *child);
void        bonobo_ui_node_insert_before    (BonoboUINode *sibling,
                                             BonoboUINode *prev_sibling);
void        bonobo_ui_node_unlink           (BonoboUINode *node);
void        bonobo_ui_node_replace          (BonoboUINode *old_node,
                                             BonoboUINode *new_node);
void        bonobo_ui_node_set_content      (BonoboUINode *node,
                                             const char *content);
char*       bonobo_ui_node_get_content      (BonoboUINode *node);
BonoboUINode* bonobo_ui_node_next           (BonoboUINode *node);
BonoboUINode* bonobo_ui_node_prev           (BonoboUINode *node);
BonoboUINode* bonobo_ui_node_children       (BonoboUINode *node);
BonoboUINode* bonobo_ui_node_parent         (BonoboUINode *node);
const char* bonobo_ui_node_get_name         (BonoboUINode *node);
gboolean    bonobo_ui_node_has_name         (BonoboUINode *node,
                                             const char *name);
gboolean    bonobo_ui_node_transparent      (BonoboUINode *node);
void        bonobo_ui_node_copy_attrs       (BonoboUINode *src,
                                             BonoboUINode *dest);
void        bonobo_ui_node_free_string      (char *str);
char*       bonobo_ui_node_to_string        (BonoboUINode *node,
                                             gboolean recurse);
BonoboUINode* bonobo_ui_node_from_string    (const char *str);
BonoboUINode* bonobo_ui_node_from_file      (const char *filename);
void        bonobo_ui_node_strip            (BonoboUINode **node);

Description

The BonoboUINode API is designed to make XML node manipulation simple, and to hide the underlying implementation of the XML tree. This is to allow the use of some more efficient internal representation than libxml's at some later date.

Details

struct BonoboUINode

struct BonoboUINode;

The BonoboUINode structure is fully opaque to stop any code depending on libxml inadvertantly.


bonobo_ui_node_new ()

BonoboUINode* bonobo_ui_node_new            (const char *name);

Creates a new node with name name

name : The name for the node
Returns : a new node pointer


bonobo_ui_node_new_child ()

BonoboUINode* bonobo_ui_node_new_child      (BonoboUINode *parent,
                                             const char *name);

Create a new node as a child of parent with name name

parent : the parent
name : the name of the new child
Returns : pointer to the new child


bonobo_ui_node_copy ()

BonoboUINode* bonobo_ui_node_copy           (BonoboUINode *node,
                                             gboolean recursive);

Copy an XML node, if recursive do a deep copy, otherwise just dup the node itself.

node : the node
recursive : whether to dup children too.
Returns : a copy of the node


bonobo_ui_node_free ()

void        bonobo_ui_node_free             (BonoboUINode *node);

Frees the memory associated with the node and unlink it from the tree

node : a node.


bonobo_ui_node_set_data ()

void        bonobo_ui_node_set_data         (BonoboUINode *node,
                                             gpointer data);

Associates some user data with the node pointer

node : the node
data : user data


bonobo_ui_node_get_data ()

gpointer    bonobo_ui_node_get_data         (BonoboUINode *node);

Gets user data associated with node

node : the node
Returns : the user data, see bonobo_ui_node_set_data


bonobo_ui_node_set_attr ()

void        bonobo_ui_node_set_attr         (BonoboUINode *node,
                                             const char *name,
                                             const char *value);

Set the attribute of name on node to value overriding any previous values of that attr.

node : The node
name : the name of the attr
value : the value for the attr


bonobo_ui_node_get_attr ()

char*       bonobo_ui_node_get_attr         (BonoboUINode *node,
                                             const char *name);

Fetch the value of an attr of name name from node see also: bonobo_ui_node_free_string

node : the node
name : the name of the attr to get
Returns : the attr text.


bonobo_ui_node_has_attr ()

gboolean    bonobo_ui_node_has_attr         (BonoboUINode *node,
                                             const char *name);

Determines whether the node has an attribute of name name

node : the node
name : the name of the attr to detect
Returns : TRUE if the attr exists


bonobo_ui_node_remove_attr ()

void        bonobo_ui_node_remove_attr      (BonoboUINode *node,
                                             const char *name);

remove any attribute with name name from node

node : the node
name : name of the attribute


bonobo_ui_node_add_child ()

void        bonobo_ui_node_add_child        (BonoboUINode *parent,
                                             BonoboUINode *child);

Add a child node to the parent node ( after the other children )

parent : the parent
child : the new child


bonobo_ui_node_insert_before ()

void        bonobo_ui_node_insert_before    (BonoboUINode *sibling,
                                             BonoboUINode *prev_sibling);

Insert a sibling before prev_sibling in a node list

sibling : the node to insert
prev_sibling : the placeholder for insertion


bonobo_ui_node_unlink ()

void        bonobo_ui_node_unlink           (BonoboUINode *node);

Unlink node from its tree, ie. disassociate it with its parent

node : the node


bonobo_ui_node_replace ()

void        bonobo_ui_node_replace          (BonoboUINode *old_node,
                                             BonoboUINode *new_node);

Replace old_node with new_node in the tree. old_node is left unlinked and floating with its children.

old_node : node to be replaced
new_node : node to replace with


bonobo_ui_node_set_content ()

void        bonobo_ui_node_set_content      (BonoboUINode *node,
                                             const char *content);

Set the textual content of node to content

node : the node
content : the new content


bonobo_ui_node_get_content ()

char*       bonobo_ui_node_get_content      (BonoboUINode *node);

see also: bonobo_ui_node_free_string

node : the node
Returns : the content of node


bonobo_ui_node_next ()

BonoboUINode* bonobo_ui_node_next           (BonoboUINode *node);

accesses the next node.

node : the node
Returns : the node after node in the list


bonobo_ui_node_prev ()

BonoboUINode* bonobo_ui_node_prev           (BonoboUINode *node);

accesses the previous node.

node : the node
Returns : the node before node in the list


bonobo_ui_node_children ()

BonoboUINode* bonobo_ui_node_children       (BonoboUINode *node);

accesses the node's children.

node : the node
Returns : the first child of node


bonobo_ui_node_parent ()

BonoboUINode* bonobo_ui_node_parent         (BonoboUINode *node);

accesses the node's parent.

node : the node
Returns : the parent node of node


bonobo_ui_node_get_name ()

const char* bonobo_ui_node_get_name         (BonoboUINode *node);

node : the node
Returns : the name of node


bonobo_ui_node_has_name ()

gboolean    bonobo_ui_node_has_name         (BonoboUINode *node,
                                             const char *name);

accesses the node's name.

node : the node
name : a name the node might have
Returns : TRUE if node has name == name


bonobo_ui_node_transparent ()

gboolean    bonobo_ui_node_transparent      (BonoboUINode *node);

Determines whether node is transparent. A node is transparent if it has no content and either no attributes or a single 'name' attribute.

node : the node
Returns : TRUE if transparent


bonobo_ui_node_copy_attrs ()

void        bonobo_ui_node_copy_attrs       (BonoboUINode *src,
                                             BonoboUINode *dest);

This function copies all the attributes from src to dest effectively cloning the src node as dest

src : the attr source node
dest : where to dump the attrs.


bonobo_ui_node_free_string ()

void        bonobo_ui_node_free_string      (char *str);

Frees a string returned by any of the get routines.

str : the string to free.


bonobo_ui_node_to_string ()

char*       bonobo_ui_node_to_string        (BonoboUINode *node,
                                             gboolean recurse);

Convert the Node to its XML string representation see also: bonobo_ui_node_free_string

node : the node tree
recurse : whether to dump its children as well
Returns : the string representation or NULL on error


bonobo_ui_node_from_string ()

BonoboUINode* bonobo_ui_node_from_string    (const char *str);

Parses a string into an XML tree

str : 
Returns : the xml tree.


bonobo_ui_node_from_file ()

BonoboUINode* bonobo_ui_node_from_file      (const char *filename);

Loads and parses the filename into an XML tree

filename : 
Returns : the xml tree.


bonobo_ui_node_strip ()

void        bonobo_ui_node_strip            (BonoboUINode **node);

This function is used to purge unwanted content from a set of nodes, and particularly clean up stray Doc and NS pointers that cause serious trouble later.

node : a pointer to the node's pointer

See Also

BonoboUIComponent, bonobo-ui-util