/*

 * glade-xml-utils.c - This functions are based on gnome-print/libgpa/gpa-xml.c

 * which were in turn based on gnumeric/xml-io.c

 * 

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as

 * published by the Free Software Foundation; either version 2 of the

 * License, or (at your option) any later version.

   *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

 *

 * Authors:

 *   Daniel Veillard <Daniel.Veillard@w3.org>

 *   Miguel de Icaza <miguel@gnu.org>

 *   Chema Celorio <chema@gnome.org>

 */

/**

 * SECTION:glade-xml-utils

 * @Title: Xml Utils

 * @Short_Description: An api to read and write xml.

 *

 * You may need these tools if you are implementing #GladeReadWidgetFunc

 * and/or #GladeWriteWidgetFunc on your #GladeWidgetAdaptor to read

 * and write widgets in custom ways

 */

#include "config.h"

#include <string.h>

#include <glib.h>

#include <errno.h>

#include "glade-xml-utils.h"

#include "glade-catalog.h"

#include "glade-utils.h"

#include <libxml/tree.h>

#include <libxml/parser.h>

#include <libxml/parserInternals.h>

#include <libxml/xmlmemory.h>

struct _GladeXmlNode

{

  xmlNodePtr node;

};

struct _GladeXmlDoc

{

  xmlDoc doc;

};

struct _GladeXmlContext

{

  GladeXmlDoc *doc;

  gboolean freedoc;

  xmlNsPtr ns;

};

/* This is used inside for loops so that we skip xml comments 

 * 

 * also to skip whitespace between nodes

 */

#define skip_text(node) if ((xmlStrcmp ( ((xmlNodePtr)node)->name, BAD_CAST("text")) == 0) ||\

			    (xmlStrcmp ( ((xmlNodePtr)node)->name, BAD_CAST("comment")) == 0)) { \

			         node = (GladeXmlNode *)((xmlNodePtr)node)->next; continue ; };

#define skip_text_libxml(node) if ((xmlStrcmp ( ((xmlNodePtr)node)->name, BAD_CAST("text")) == 0) ||\

			           (xmlStrcmp ( ((xmlNodePtr)node)->name, BAD_CAST("comment")) == 0)) { \

                                       node = ((xmlNodePtr)node)->next; continue ; };

static gchar *

claim_string (xmlChar *string)

{

  gchar *ret;

  ret = g_strdup (CAST_BAD (string));

  xmlFree (string);

  return ret;

}

/**

 * glade_xml_set_value:

 * @node_in: a #GladeXmlNode

 * @name: a string

 * @val: a string

 *

 * Sets the property @name in @node_in to @val

 */

void

glade_xml_set_value (GladeXmlNode *node_in, const gchar *name, const gchar *val)

{

  xmlNodePtr node = (xmlNodePtr) node_in;

  xmlChar *ret;

  ret = xmlGetProp (node, BAD_CAST (name));

  if (ret)

    {

      xmlFree (ret);

      xmlSetProp (node, BAD_CAST (name), BAD_CAST (val));

      return;

    }

}

/**

 * glade_xml_get_content:

 * @node_in: a #GladeXmlNode

 *

 * Gets a string containing the content of @node_in.

 *

 * Returns: A newly allocated string

 */

gchar *

glade_xml_get_content (GladeXmlNode *node_in)

{

  xmlNodePtr node = (xmlNodePtr) node_in;

  xmlChar *val = xmlNodeGetContent (node);

  return claim_string (val);

}

/**

 * glade_xml_set_content:

 * @node_in: a #GladeXmlNode

 * @content: a string

 *

 * Sets the content of @node to @content.

 */

void

glade_xml_set_content (GladeXmlNode *node_in, const gchar *content)

{

  xmlNodePtr node = (xmlNodePtr) node_in;

  xmlChar *content_encoded;

  g_return_if_fail (node != NULL);

  g_return_if_fail (node->doc != NULL);

  content_encoded = xmlEncodeSpecialChars (node->doc, BAD_CAST (content));

  xmlNodeSetContent (node, BAD_CAST (content_encoded));

  xmlFree (content_encoded);

}

/*

 * Get a value for a node either carried as an attibute or as

 * the content of a child.

 *

 * Returns a g_malloc'ed string.  Caller must free.

 * (taken from gnumeric )

 *

 */

static gchar *

glade_xml_get_value (xmlNodePtr node, const gchar *name)

{

  xmlNodePtr child;

  gchar *ret = NULL;

  for (child = node->children; child; child = child->next)

    if (!xmlStrcmp (child->name, BAD_CAST (name)))

      ret = claim_string (xmlNodeGetContent (child));

  return ret;

}

/**

 * glade_xml_node_verify_silent:

 * @node_in: a #GladeXmlNode

 * @name: a string

 *

 * Returns: %TRUE if @node_in's name is equal to @name, %FALSE otherwise

 */

gboolean

glade_xml_node_verify_silent (GladeXmlNode *node_in, const gchar *name)

{

  xmlNodePtr node = (xmlNodePtr) node_in;

  g_return_val_if_fail (node != NULL, FALSE);

  if (xmlStrcmp (node->name, BAD_CAST (name)) != 0)

    return FALSE;

  return TRUE;

}

/**

 * glade_xml_node_verify:

 * @node_in: a #GladeXmlNode

 * @name: a string

 *

 * This is a wrapper around glade_xml_node_verify_silent(), only it emits

 * a g_warning() if @node_in has a name different than @name.

 *

 * Returns: %TRUE if @node_in's name is equal to @name, %FALSE otherwise

 */

gboolean

glade_xml_node_verify (GladeXmlNode *node_in, const gchar *name)

{

  xmlNodePtr node = (xmlNodePtr) node_in;

  if (!glade_xml_node_verify_silent (node_in, name))

    {

      g_warning ("Expected node was \"%s\", encountered \"%s\"",

                 name, node->name);

      return FALSE;

    }

  return TRUE;

}

/**

 * glade_xml_get_value_int:

 * @node_in: a #GladeXmlNode

 * @name: a string

 * @val: a pointer to an #int

 *

 * Gets an integer value for a node either carried as an attribute or as

 * the content of a child.

 *

 * Returns: %TRUE if the node is found, %FALSE otherwise

 */

gboolean

glade_xml_get_value_int (GladeXmlNode *node_in, const gchar *name, gint *val)

{

  xmlNodePtr node = (xmlNodePtr) node_in;

  gchar *value, *endptr = NULL;

  gint64 i;

  value = glade_xml_get_value (node, name);

  if (value == NULL)

    return FALSE;

  errno = 0;

  i = g_ascii_strtoll (value, &endptr, 10);

  if (errno != 0 || (i == 0 && endptr == value))

    {

      g_free (value);

      return FALSE;

    }

  g_free (value);

  *val = (gint) i;

  return TRUE;

}

/**

 * glade_xml_get_value_int_required:

 * @node: a #GladeXmlNode

 * @name: a string

 * @val: a pointer to an #int

 * 

 * This is a wrapper around glade_xml_get_value_int(), only it emits

 * a g_warning() if @node_in did not contain the requested tag

 * 

 * Returns:

 **/

gboolean

glade_xml_get_value_int_required (GladeXmlNode *node,

                                  const gchar  *name,

                                  gint         *val)

{

  gboolean ret;

  ret = glade_xml_get_value_int (node, name, val);

  if (ret == FALSE)

    g_warning ("The file did not contain the required value \"%s\"\n"

               "Under the \"%s\" tag.", name, glade_xml_node_get_name (node));

  return ret;

}

/*

 * Get a String value for a node either carried as an attibute or as

 * the content of a child.

 */

gchar *

glade_xml_get_value_string (GladeXmlNode *node_in, const gchar *name)

{

  xmlNodePtr node = (xmlNodePtr) node_in;

  return glade_xml_get_value (node, name);

}

static gchar *

glade_xml_get_property (xmlNodePtr node, const gchar *name)

{

  xmlChar *val;

  val = xmlGetProp (node, BAD_CAST (name));

  if (val)

    return claim_string (val);

  return NULL;

}

static void

glade_xml_set_property (xmlNodePtr   node,

                        const gchar *name,

                        const gchar *value)

{

  if (value)

    xmlSetProp (node, BAD_CAST (name), BAD_CAST (value));

}

/*

 * Get a String value for a node either carried as an attibute or as

 * the content of a child.

 */

gboolean

glade_xml_get_boolean (GladeXmlNode *node_in,

                       const gchar  *name,

                       gboolean      _default)

{

  xmlNodePtr node = (xmlNodePtr) node_in;

  gchar *value;

  gboolean ret = FALSE;

  value = glade_xml_get_value (node, name);

  if (value == NULL)

    return _default;

  if (glade_utils_boolean_from_string (value, &ret))

    g_warning ("Boolean tag unrecognized *%s*\n", value);

  g_free (value);

  return ret;

}

/*

 * Get a String value for a node either carried as an attibute or as

 * the content of a child.

 */

gboolean

glade_xml_get_property_boolean (GladeXmlNode *node_in,

                                const gchar  *name,

                                gboolean      _default)

{

  xmlNodePtr node = (xmlNodePtr) node_in;

  gchar *value;

  gboolean ret = FALSE;

  value = glade_xml_get_property (node, name);

  if (value == NULL)

    return _default;

  if (glade_utils_boolean_from_string (value, &ret))

    g_warning ("Boolean tag unrecognized *%s*\n", value);

  g_free (value);

  return ret;

}

gdouble

glade_xml_get_property_double (GladeXmlNode *node_in,

                               const gchar  *name,

                               gdouble       _default)

{

  xmlNodePtr node = (xmlNodePtr) node_in;

  gdouble retval;

  gchar *value;

  if ((value = glade_xml_get_property (node, name)) == NULL)

    return _default;

  errno = 0;

  retval = g_ascii_strtod (value, NULL);

  if (errno)

    {

      g_free (value);

      return _default;

    }

  else

    {

      g_free (value);

      return retval;

    }

}

gint

glade_xml_get_property_int (GladeXmlNode *node_in,

                            const gchar  *name,

                            gint          _default)

{

  xmlNodePtr node = (xmlNodePtr) node_in;

  gint retval;

  gchar *value;

  if ((value = glade_xml_get_property (node, name)) == NULL)

    return _default;

  retval = g_ascii_strtoll (value, NULL, 10);

  g_free (value);

  return retval;

}

void

glade_xml_node_set_property_boolean (GladeXmlNode *node_in,

                                     const gchar  *name,

                                     gboolean      value)

{

  xmlNodePtr node = (xmlNodePtr) node_in;

  if (value)

    glade_xml_set_property (node, name, "True");

  else

    glade_xml_set_property (node, name, "False");

}

gchar *

glade_xml_get_value_string_required (GladeXmlNode *node_in,

                                     const gchar  *name,

                                     const gchar  *xtra)

{

  xmlNodePtr node = (xmlNodePtr) node_in;

  gchar *value = glade_xml_get_value (node, name);

  if (value == NULL)

    {

      if (xtra == NULL)

        g_warning ("The file did not contain the required value \"%s\"\n"

                   "Under the \"%s\" tag.", name, node->name);

      else

        g_warning ("The file did not contain the required value \"%s\"\n"

                   "Under the \"%s\" tag (%s).", name, node->name, xtra);

    }

  return value;

}

gchar *

glade_xml_get_property_string (GladeXmlNode *node_in, const gchar *name)

{

  xmlNodePtr node = (xmlNodePtr) node_in;

  return glade_xml_get_property (node, name);

}

void

glade_xml_node_set_property_string (GladeXmlNode *node_in,

                                    const gchar  *name,

                                    const gchar  *string)

{

  xmlNodePtr node = (xmlNodePtr) node_in;

  glade_xml_set_property (node, name, string);

}

gchar *

glade_xml_get_property_string_required (GladeXmlNode *node_in,

                                        const gchar  *name,

                                        const gchar  *xtra)

{

  xmlNodePtr node = (xmlNodePtr) node_in;

  gchar *value = glade_xml_get_property_string (node_in, name);

  if (value == NULL)

    {

      if (xtra == NULL)

        g_warning ("The file did not contain the required property \"%s\"\n"

                   "Under the \"%s\" tag.", name, node->name);

      else

        g_warning ("The file did not contain the required property \"%s\"\n"

                   "Under the \"%s\" tag (%s).", name, node->name, xtra);

    }

  return value;

}

gboolean

glade_xml_get_property_version (GladeXmlNode *node_in,

                                const gchar  *name,

                                guint16      *major,

                                guint16      * minor)

{

  xmlNodePtr node = (xmlNodePtr) node_in;

  gchar *value = glade_xml_get_property_string (node_in, name);

  gchar **split;

  if (!value)

    return FALSE;

  if ((split = g_strsplit (value, ".", 2)))

    {

      if (!split[0] || !split[1])

        {

          g_warning ("Malformed version property \"%s\"\n"

                     "Under the \"%s\" tag (%s)", name, node->name, value);

          return FALSE;

        }

      *major = g_ascii_strtoll (split[0], NULL, 10);

      *minor = g_ascii_strtoll (split[1], NULL, 10);

      g_strfreev (split);

    }

  g_free (value);

  return TRUE;

}

GList *

glade_xml_get_property_targetable_versions (GladeXmlNode *node_in,

                                            const gchar  *name)

{

  GladeTargetableVersion *version;

  GList *targetable = NULL;

  xmlNodePtr node = (xmlNodePtr) node_in;

  gchar *value;

  gchar **split, **maj_min;

  gint i;

  if (!(value = glade_xml_get_property_string (node_in, name)))

    return NULL;

  if ((split = g_strsplit (value, ",", 0)) != NULL)

    {

      for (i = 0; split[i]; i++)

        {

          maj_min = g_strsplit (split[i], ".", 2);

          if (!maj_min[0] || !maj_min[1])

            {

              g_warning ("Malformed version property \"%s\"\n"

                         "Under the \"%s\" tag (%s)", name, node->name, value);

            }

          else

            {

              version = g_new (GladeTargetableVersion, 1);

              version->major = g_ascii_strtoll (maj_min[0], NULL, 10);

              version->minor = g_ascii_strtoll (maj_min[1], NULL, 10);

              targetable = g_list_append (targetable, version);

            }

          g_strfreev (maj_min);

        }

      g_strfreev (split);

    }

  g_free (value);

  return targetable;

}

/*

 * Search a child by name,

 */

GladeXmlNode *

glade_xml_search_child (GladeXmlNode *node_in, const gchar *name)

{

  xmlNodePtr node;

  xmlNodePtr child;

  g_return_val_if_fail (node_in != NULL, NULL);

  g_return_val_if_fail (name != NULL, NULL);

  node = (xmlNodePtr) node_in;

  for (child = node->children; child; child = child->next)

    {

      if (!xmlStrcmp (child->name, BAD_CAST (name)))

        return (GladeXmlNode *) child;

    }

  return NULL;

}

/**

 * glade_xml_search_child_required:

 * @tree: 

 * @name: 

 * 

 * just a small wrapper arround glade_xml_search_child that displays

 * an error if the child was not found

 *

 * Return Value: 

 **/

GladeXmlNode *

glade_xml_search_child_required (GladeXmlNode *node, const gchar *name)

{

  GladeXmlNode *child;

  child = glade_xml_search_child (node, name);

  if (child == NULL)

    g_warning ("The file did not contain the required tag \"%s\"\n"

               "Under the \"%s\" node.", name, glade_xml_node_get_name (node));

  return child;

}

/* --------------------------- Parse Context ----------------------------*/

static GladeXmlContext *

glade_xml_context_new_real (GladeXmlDoc *doc, gboolean freedoc, xmlNsPtr ns)

{

  GladeXmlContext *context = g_new0 (GladeXmlContext, 1);

  context->doc = doc;

  context->freedoc = freedoc;

  context->ns = ns;

  return context;

}

GladeXmlContext *

glade_xml_context_new (GladeXmlDoc *doc, const gchar *name_space)

{

  /* We are not using the namespace now */

  return glade_xml_context_new_real (doc, TRUE, NULL);

}

void

glade_xml_context_destroy (GladeXmlContext * context)

{

  g_return_if_fail (context != NULL);

  if (context->freedoc)

    xmlFreeDoc ((xmlDoc *) context->doc);

  g_free (context);

}

GladeXmlContext *

glade_xml_context_new_from_path (const gchar *full_path,

                                 const gchar *nspace,

                                 const gchar *root_name)

{

  GladeXmlContext *context;

  xmlDocPtr doc;

  xmlNsPtr name_space;

  xmlNodePtr root;

  g_return_val_if_fail (full_path != NULL, NULL);

  doc = xmlParseFile (full_path);

  /* That's not an error condition.  The file is not readable, and we can't know it

   * before we try to read it (testing for readability is a call to race conditions).

   * So we should not print a warning */

  if (doc == NULL)

    return NULL;

  if (doc->children == NULL)

    {

      g_warning ("Invalid xml File, tree empty [%s]&", full_path);

      xmlFreeDoc (doc);

      return NULL;

    }

  name_space = xmlSearchNsByHref (doc, doc->children, BAD_CAST (nspace));

  if (name_space == NULL && nspace != NULL)

    {

      g_warning ("The file did not contain the expected name space\n"

                 "Expected \"%s\" [%s]", nspace, full_path);

      xmlFreeDoc (doc);

      return NULL;

    }

  root = xmlDocGetRootElement (doc);

  if (root_name != NULL &&

      ((root->name == NULL) ||

       (xmlStrcmp (root->name, BAD_CAST (root_name)) != 0)))

    {

      g_warning ("The file did not contain the expected root name\n"

                 "Expected \"%s\", actual : \"%s\" [%s]",

                 root_name, root->name, full_path);

      xmlFreeDoc (doc);

      return NULL;

    }

  context = glade_xml_context_new_real ((GladeXmlDoc *) doc, TRUE, name_space);

  return context;

}

/**

 * glade_xml_context_free:

 * @context: 

 * 

 * Similar to glade_xml_context_destroy but it also frees the document set in the context

 **/

void

glade_xml_context_free (GladeXmlContext *context)

{

  g_return_if_fail (context != NULL);

  if (context->doc)

    xmlFreeDoc ((xmlDocPtr) context->doc);

  context->doc = NULL;

  g_free (context);

}

void

glade_xml_node_append_child (GladeXmlNode *node_in,

                             GladeXmlNode *child_in)

{

  xmlNodePtr node = (xmlNodePtr) node_in;

  xmlNodePtr child = (xmlNodePtr) child_in;

  g_return_if_fail (node != NULL);

  g_return_if_fail (child != NULL);

  xmlAddChild (node, child);

}

void

glade_xml_node_remove (GladeXmlNode * node_in)

{

  xmlNodePtr node = (xmlNodePtr) node_in;

  g_return_if_fail (node != NULL);

  xmlReplaceNode (node, NULL);

}

GladeXmlNode *

glade_xml_node_new (GladeXmlContext *context, const gchar *name)

{

  g_return_val_if_fail (context != NULL, NULL);

  g_return_val_if_fail (name != NULL, NULL);

  return (GladeXmlNode *) xmlNewDocNode ((xmlDocPtr) context->doc, context->ns,

                                         BAD_CAST (name), NULL);

}

GladeXmlNode *

glade_xml_node_new_comment (GladeXmlContext *context, const gchar *comment)

{

  g_return_val_if_fail (context != NULL, NULL);

  g_return_val_if_fail (comment != NULL, NULL);

  return (GladeXmlNode *) xmlNewDocComment ((xmlDocPtr) context->doc,

                                            BAD_CAST (comment));

}

GladeXmlNode *

glade_xml_node_copy (GladeXmlNode *node)

{

  if (node)

    {

      xmlNodePtr xnode = (xmlNodePtr) node;

      return (GladeXmlNode *) xmlDocCopyNode (xnode, NULL, 1);

    }

  else

    return NULL;

}

void

glade_xml_node_delete (GladeXmlNode *node)

{

  xmlFreeNode ((xmlNodePtr) node);

}

GladeXmlDoc *

glade_xml_context_get_doc (GladeXmlContext *context)

{

  return context->doc;

}

gchar *

glade_xml_dump_from_context (GladeXmlContext *context)

{

  GladeXmlDoc *doc;

  xmlChar *string = NULL;

  gchar *text;

  int size;

  doc = glade_xml_context_get_doc (context);

  xmlDocDumpFormatMemory (&(doc->doc), &string, &size, 1);

  text = claim_string (string);

  return text;

}

gboolean

glade_xml_node_is_comment (GladeXmlNode *node_in)

{

  xmlNodePtr node = (xmlNodePtr) node_in;

  return (node) ? node->type == XML_COMMENT_NODE : FALSE;

}

static inline gboolean

glade_xml_node_is_comment_or_text (GladeXmlNode *node_in)

{

  xmlNodePtr node = (xmlNodePtr) node_in;

  return (node) ? node->type == XML_COMMENT_NODE || node->type == XML_TEXT_NODE : FALSE;

}

GladeXmlNode *

glade_xml_node_get_children (GladeXmlNode * node_in)

{

  xmlNodePtr node = (xmlNodePtr) node_in;

  xmlNodePtr children;

  children = node->children;

  while (glade_xml_node_is_comment_or_text ((GladeXmlNode *) children))

    children = children->next;

  return (GladeXmlNode *) children;

}

GladeXmlNode *

glade_xml_node_get_parent (GladeXmlNode *node_in)

{

  xmlNodePtr node = (xmlNodePtr) node_in;

  return (GladeXmlNode *) node->parent;

}

GladeXmlNode *

glade_xml_node_get_children_with_comments (GladeXmlNode *node_in)

{

  xmlNodePtr node = (xmlNodePtr) node_in;

  return (GladeXmlNode *) node->children;

}

GladeXmlNode *

glade_xml_node_next (GladeXmlNode *node_in)

{

  xmlNodePtr node = (xmlNodePtr) node_in;

  node = node->next;

  while (glade_xml_node_is_comment_or_text ((GladeXmlNode *) node))

    node = node->next;

  return (GladeXmlNode *) node;

}

GladeXmlNode *

glade_xml_node_next_with_comments (GladeXmlNode *node_in)

{

  xmlNodePtr node = (xmlNodePtr) node_in;

  return (GladeXmlNode *) node->next;

}

GladeXmlNode *

glade_xml_node_prev_with_comments (GladeXmlNode *node_in)

{

  xmlNodePtr node = (xmlNodePtr) node_in;

  return (GladeXmlNode *) node->prev;

}

const gchar *

glade_xml_node_get_name (GladeXmlNode *node_in)

{

  xmlNodePtr node = (xmlNodePtr) node_in;

  return CAST_BAD (node->name);

}

GladeXmlDoc *

glade_xml_doc_new (void)

{

  xmlDocPtr xml_doc = xmlNewDoc (BAD_CAST ("1.0"));

  return (GladeXmlDoc *) xml_doc;

}

void

glade_xml_doc_set_root (GladeXmlDoc *doc_in, GladeXmlNode *node_in)

{

  xmlNodePtr node = (xmlNodePtr) node_in;

  xmlDocPtr doc = (xmlDocPtr) doc_in;