source: trunk/third/bonobo/bonobo/bonobo-ui-node.c @ 17169

/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/*
 * bonobo-ui-node.c: Code to manipulate BonoboUINode objects
 *
 * Author:
 *      Havoc Pennington <hp@redhat.com>
 *
 * Copyright 2000 Red Hat, Inc.
 */

#include "config.h"
#include <bonobo/bonobo-ui-node.h>
#include <stdlib.h>
#include <string.h>

#include <gnome-xml/parser.h>
#include <gnome-xml/parserInternals.h>
#include <gnome-xml/xmlmemory.h>

/* Having this struct here makes debugging nicer. */
struct _BonoboUINode {
        xmlNode real_node;
};

#define XML_NODE(x) (&(x)->real_node)
#define BNODE(x) ((BonoboUINode *)(x))

/**
 * bonobo_ui_node_new:
 * @name: The name for the node
 * 
 * Creates a new node with name @name
 * 
 * Return value: a new node pointer
 **/
BonoboUINode*
bonobo_ui_node_new (const char   *name)
{
        return BNODE (xmlNewNode (NULL, name));
}

/**
 * bonobo_ui_node_new_child:
 * @parent: the parent
 * @name: the name of the new child
 * 
 * Create a new node as a child of @parent with name @name
 * 
 * Return value: pointer to the new child
 **/
BonoboUINode*
bonobo_ui_node_new_child (BonoboUINode *parent,
                          const char   *name)
{
        return BNODE (xmlNewChild (XML_NODE (parent), NULL, name, NULL));
}

/**
 * bonobo_ui_node_copy:
 * @node: the node
 * @recursive: whether to dup children too.
 * 
 * Copy an XML node, if @recursive do a deep copy, otherwise just dup the node itself.
 * 
 * Return value: a copy of the node
 **/
BonoboUINode*
bonobo_ui_node_copy (BonoboUINode *node,
                     gboolean recursive)
{
        return BNODE (xmlCopyNode (XML_NODE (node), recursive));
}

/**
 * bonobo_ui_node_free:
 * @node: a node.
 * 
 * Frees the memory associated with the @node and unlink it from the tree
 **/
void
bonobo_ui_node_free (BonoboUINode *node)
{
        xmlFreeNode (XML_NODE (node));
}

/**
 * bonobo_ui_node_set_data:
 * @node: the node
 * @data: user data
 * 
 * Associates some user data with the node pointer
 **/
void
bonobo_ui_node_set_data (BonoboUINode *node,
                         gpointer      data)
{
        XML_NODE (node)->_private = data;
}

/**
 * bonobo_ui_node_get_data:
 * @node: the node
 * 
 * Gets user data associated with @node
 * 
 * Return value: the user data, see bonobo_ui_node_set_data
 **/
gpointer
bonobo_ui_node_get_data (BonoboUINode *node)
{
        return XML_NODE (node)->_private;
}

static xmlAttrPtr
get_attr (xmlNode *node, const char *name)
{
        xmlAttrPtr prop;

        if ((node == NULL) || (name == NULL)) return(NULL);
        /*
         * Check on the properties attached to the node
         */
        prop = node->properties;
        while (prop != NULL) {
                if (!xmlStrcmp(prop->name, name))  {
                        return(prop);
                }
                prop = prop->next;
      }
        
      return(NULL);
}

/**
 * bonobo_ui_node_set_attr:
 * @node: The node
 * @name: the name of the attr
 * @value: the value for the attr
 * 
 * Set the attribute of @name on @node to @value overriding any
 * previous values of that attr.
 **/
void
bonobo_ui_node_set_attr (BonoboUINode *node,
                         const char   *name,
                         const char   *value)
{
        if (value == NULL) {
                xmlAttrPtr attr = get_attr (XML_NODE (node), name);
                if (attr)
                        xmlRemoveProp (attr);
        } else {
                xmlSetProp (XML_NODE (node), name, value);
        }
}

/**
 * bonobo_ui_node_get_attr:
 * @node: the node
 * @name: the name of the attr to get
 * 
 * Fetch the value of an attr of name @name from @node
 * see also: bonobo_ui_node_free_string
 * 
 * Return value: the attr text.
 **/
char*
bonobo_ui_node_get_attr (BonoboUINode *node,
                         const char   *name)
{
        return xmlGetProp (XML_NODE (node), name);
}

/**
 * bonobo_ui_node_has_attr:
 * @node: the node
 * @name: the name of the attr to detect
 * 
 * Determines whether the @node has an attribute of name @name
 * 
 * Return value: TRUE if the attr exists
 **/
gboolean
bonobo_ui_node_has_attr (BonoboUINode *node,
                         const char   *name)
{
        return get_attr (XML_NODE (node), name) != NULL;
}

/**
 * bonobo_ui_node_remove_attr:
 * @node: the node
 * @name: name of the attribute
 * 
 * remove any attribute with name @name from @node
 **/
void
bonobo_ui_node_remove_attr (BonoboUINode *node,
                            const char   *name)
{
        xmlAttrPtr attr = get_attr (XML_NODE (node), name);
        if (attr)
                xmlRemoveProp (attr);
}

/**
 * bonobo_ui_node_add_child:
 * @parent: the parent
 * @child: the new child
 * 
 * Add a @child node to the @parent node ( after the other children )
 **/
void
bonobo_ui_node_add_child (BonoboUINode *parent,
                          BonoboUINode *child)
{
        xmlAddChild (XML_NODE (parent), XML_NODE (child));
}

/**
 * bonobo_ui_node_insert_before:
 * @sibling: the node to insert
 * @prev_sibling: the placeholder for insertion
 * 
 * Insert a @sibling before @prev_sibling in a node list
 **/
void
bonobo_ui_node_insert_before (BonoboUINode *sibling,
                              BonoboUINode *prev_sibling)
{
        xmlAddPrevSibling (XML_NODE (sibling), XML_NODE (prev_sibling));
}

/**
 * bonobo_ui_node_unlink:
 * @node: the node
 * 
 * Unlink @node from its tree, ie. disassociate it with its parent
 **/
void
bonobo_ui_node_unlink (BonoboUINode *node)
{
        xmlUnlinkNode (XML_NODE (node));
}

/**
 * bonobo_ui_node_replace:
 * @old_node: node to be replaced
 * @new_node: node to replace with
 * 
 * Replace @old_node with @new_node in the tree. @old_node is
 * left unlinked and floating with its children.
 **/
void
bonobo_ui_node_replace (BonoboUINode *old_node,
                        BonoboUINode *new_node)
{
        /* libxml has these args indisputably backward */
        xmlReplaceNode (XML_NODE (new_node),
                        XML_NODE (old_node));
}

/**
 * bonobo_ui_node_set_content:
 * @node: the node
 * @content: the new content
 * 
 * Set the textual content of @node to @content
 **/
void
bonobo_ui_node_set_content (BonoboUINode *node,
                            const char   *content)
{
        xmlNodeSetContent (XML_NODE (node), content);
}

/**
 * bonobo_ui_node_get_content:
 * @node: the node
 * 
 * see also: bonobo_ui_node_free_string
 *
 * Return value: the content of @node
 **/
char *
bonobo_ui_node_get_content (BonoboUINode *node)
{
        return xmlNodeGetContent (XML_NODE (node));
}

/**
 * bonobo_ui_node_next:
 * @node: the node
 *
 * accesses the next node.
 *
 * Return value: the node after @node in the list
 **/
BonoboUINode*
bonobo_ui_node_next (BonoboUINode *node)
{
        return BNODE (XML_NODE (node)->next);
}

/**
 * bonobo_ui_node_prev:
 * @node: the node
 * 
 * accesses the previous node.
 *
 * Return value: the node before @node in the list
 **/
BonoboUINode*
bonobo_ui_node_prev (BonoboUINode *node)
{
        return BNODE (XML_NODE (node)->prev);
}

/**
 * bonobo_ui_node_children:
 * @node: the node
 * 
 * accesses the node's children.
 *
 * Return value: the first child of @node
 **/
BonoboUINode*
bonobo_ui_node_children (BonoboUINode *node)
{
        return BNODE (XML_NODE (node)->xmlChildrenNode);
}

/**
 * bonobo_ui_node_parent:
 * @node: the node
 *
 * accesses the node's parent.
 * 
 * Return value: the parent node of @node
 **/
BonoboUINode*
bonobo_ui_node_parent (BonoboUINode *node)
{
        return BNODE (XML_NODE (node)->parent);
}

/**
 * bonobo_ui_node_get_name:
 * @node: the node
 * 
 * Return value: the name of @node
 **/
const char*
bonobo_ui_node_get_name (BonoboUINode *node)
{
        return XML_NODE (node)->name;
}

/**
 * bonobo_ui_node_has_name:
 * @node: the node
 * @name: a name the node might have
 * 
 * accesses the node's name.
 * 
 * Return value: TRUE if @node has name == @name
 **/
gboolean
bonobo_ui_node_has_name (BonoboUINode *node,
                         const char   *name)
{
        return strcmp (XML_NODE (node)->name, name) == 0;
}

/**
 * bonobo_ui_node_free_string:
 * @str: the string to free.
 * 
 * Frees a string returned by any of the get routines.
 **/
void
bonobo_ui_node_free_string (char *str)
{
        if (str)
                xmlFree (str);
}

/**
 * bonobo_ui_node_to_string:
 * @node: the node tree
 * @recurse: whether to dump its children as well
 * 
 * Convert the Node to its XML string representation
 * see also: bonobo_ui_node_free_string
 * 
 * Return value: the string representation or NULL on error
 **/
char *
bonobo_ui_node_to_string (BonoboUINode *node,
                          gboolean      recurse)
{
        xmlDoc     *doc;
        xmlChar    *mem = NULL;
        int         size;

        doc = xmlNewDoc ("1.0");
        g_return_val_if_fail (doc != NULL, NULL);

        doc->xmlRootNode = XML_NODE(bonobo_ui_node_copy (node, TRUE));
        g_return_val_if_fail (doc->xmlRootNode != NULL, NULL);

        if (!recurse && bonobo_ui_node_children (BNODE (doc->xmlRootNode))) {
                BonoboUINode *tmp;
                while ((tmp = bonobo_ui_node_children (BNODE (doc->xmlRootNode)))) {
                        xmlUnlinkNode (XML_NODE(tmp));
                        bonobo_ui_node_free (tmp);
                }
        }

        xmlDocDumpMemory (doc, &mem, &size);

        g_return_val_if_fail (mem != NULL, NULL);

        xmlFreeDoc (doc);

        return mem;
}

/**
 * bonobo_ui_node_from_string:
 * @xml: the xml string
 * 
 * Parses a string into an XML tree
 * 
 * Return value: the xml tree.
 **/
BonoboUINode*
bonobo_ui_node_from_string (const char *xml)
{
        /* We have crap error reporting for this function */
        xmlDoc  *doc;
        BonoboUINode *node;
        
        doc = xmlParseDoc ((char *)xml);
        if (!doc)
                return NULL;
        
        node = BNODE (doc->xmlRootNode);
        bonobo_ui_node_strip (&node);

        xmlUnlinkNode (XML_NODE (node));
        doc->xmlRootNode = NULL;
        
        xmlFreeDoc (doc);

        return node;
}

/**
 * bonobo_ui_node_from_file:
 * @fname: the filename containing the xml
 * 
 * Loads and parses the filename into an XML tree
 * 
 * Return value: the xml tree.
 **/
BonoboUINode*
bonobo_ui_node_from_file (const char *fname)
{
        /* Error reporting blows here too (because it blows
         * in libxml)
         */
        xmlDoc  *doc;
        BonoboUINode *node;

        g_return_val_if_fail (fname != NULL, NULL);
        
        doc = xmlParseFile (fname);

        g_return_val_if_fail (doc != NULL, NULL);

        node = BNODE (doc->xmlRootNode);
        bonobo_ui_node_strip (&node);

        xmlUnlinkNode (XML_NODE (node));
        doc->xmlRootNode = NULL;

        xmlFreeDoc (doc);

        return node;
}

/**
 * bonobo_ui_node_transparent:
 * @node: the node
 * 
 * Determines whether @node is transparent. A node is
 * transparent if it has no content and either no attributes
 * or a single 'name' attribute.
 * 
 * Return value: TRUE if transparent
 **/
gboolean
bonobo_ui_node_transparent (BonoboUINode *node)
{
        xmlNode *n = XML_NODE (node);
        gboolean ret = FALSE;

        g_return_val_if_fail (n != NULL, TRUE);

        if (n->content) {
                ret = FALSE;

        } else if (!n->properties) {
                if (!strcmp (XML_NODE (node)->name, "placeholder"))
                        ret = TRUE;
                else if (!strcmp (XML_NODE (node)->name, "menu"))
                        ret = TRUE;

        } else if (!n->properties->next) {
                if (!strcmp (n->properties->name, "name"))
                        ret = TRUE;
        }

        return ret;
}

/**
 * bonobo_ui_node_copy_attrs:
 * @src: the attr source node
 * @dest: where to dump the attrs.
 * 
 * This function copies all the attributes from @src to @dest
 * effectively cloning the @src node as @dest
 **/
void
bonobo_ui_node_copy_attrs (BonoboUINode *src,
                           BonoboUINode *dest)
{
        xmlAttr *attr;
        
        for (attr = XML_NODE (src)->properties; attr; attr = attr->next) {
                char *txt = xmlGetProp (XML_NODE (src), attr->name);

                g_assert (txt != NULL);

                xmlSetProp (XML_NODE (dest), attr->name, txt);

                xmlFree (txt);
        }
}

static gboolean
do_strip (xmlNode *node)
{
        xmlNode *l, *next;
        gboolean suspicious = FALSE;

        if (!node)
                return FALSE;

        switch (node->type) {
        case XML_DOCUMENT_FRAG_NODE:
        case XML_ELEMENT_NODE:
        case XML_TEXT_NODE:
        case XML_ENTITY_NODE:
        case XML_ENTITY_REF_NODE: {
                xmlAttr *a, *nexta;

                node->nsDef = NULL;
                node->ns = NULL;
                node->doc = NULL;

                for (a = node->properties; a; a = nexta) {
                        nexta = a->next;
                        a->ns = NULL;
                        do_strip (a->val);
                }

                for (l = node->xmlChildrenNode; l; l = next) {
                        next = l->next;
                        do_strip (l);
                }
                break;
        }

        case XML_ATTRIBUTE_NODE: {
                xmlAttr *attr = (xmlAttr *)node;
                attr->ns = NULL;
                do_strip (attr->val);
                break;
        }

        case XML_PI_NODE:
        case XML_COMMENT_NODE:
        case XML_DOCUMENT_NODE:
        case XML_HTML_DOCUMENT_NODE:
        case XML_DOCUMENT_TYPE_NODE:
        case XML_NOTATION_NODE:
        case XML_CDATA_SECTION_NODE:
                suspicious = TRUE;
                break;
        }

        if (suspicious) {
/*              g_warning ("node looks suspicious %d: '%s'",
                           node->type,
                           bonobo_ui_node_to_string (BNODE (node), TRUE));*/
                xmlUnlinkNode (node);
                bonobo_ui_node_free (BNODE (node));
                return TRUE;
        } else
                return FALSE;
}

/**
 * bonobo_ui_node_strip:
 * @node: a pointer to the node's pointer
 * 
 *   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.
 **/
void
bonobo_ui_node_strip (BonoboUINode **node)
{
        BonoboUINode *next, *l;

        for (l = *node; l; l = next) {
                next = bonobo_ui_node_next (l);
                if (l == *node && do_strip (XML_NODE (l)))
                        *node = next;
        }
}