G_CONST_RETURN gchar *
xml_reader_get_local_name (XmlReader *reader)
{
g_return_val_if_fail(XML_IS_READER (reader), NULL);
return XML_TO_CHAR (xmlTextReaderConstLocalName (reader->xml));
}
/**
* xml_reader_read_attribute_name:
* @reader: a #XmlReader
* @attribute_name: the name of the attribute to read
*
* Moves the internal cursor to the @attribute_name of the current
* element inside the XML document object model:
*
* |[
* /* inspect "node" */
* xml_reader_read_start_element (reader, "node");
*
* /* inspect the node attributes */
* xml_reader_read_attribute_name (reader, "role");
* role = g_strdup (xml_reader_get_attribute_value (reader));
* xml_reader_read_attribute_name (reader, "direction");
* direction = g_strdup (xml_reader_get_attribute_value (reader));
*
* /* retrieve the node content */
* node = g_strdup (xml_reader_get_element_value (reader));
*
* xml_reader_read_end_element (reader);
*
* g_print ("Node has role of '%s' and direction '%s': %s\n",
* role, direction, node);
*
* g_free (role);
* g_free (direction);
* g_free (node);
* ]|
*
* Return value: %TRUE if the attribute was found
*/
gboolean
xml_reader_read_attribute_name (XmlReader *reader,
const gchar *attribute_name)
{
XmlReaderPrivate *priv;
xmlAttrPtr attr;
g_return_val_if_fail (XML_IS_READER (reader), FALSE);
g_return_val_if_fail (attribute_name != NULL, FALSE);
priv = reader->priv;
if (!priv->node_cursor)
return FALSE;
if (!xml_reader_has_attributes (reader))
return FALSE;
for (attr = priv->node_cursor->properties;
attr != NULL;
attr = attr->next)
{
if (strcmp (XML_TO_CHAR (attr->name), attribute_name) == 0)
{
priv->attr_cursor = attr;
priv->attr_value = xmlGetProp (priv->node_cursor, attr->name);
return TRUE;
}
}
return FALSE;
}
static gboolean
read_to_type_and_name (XmlReader *reader,
gint type,
const gchar *name)
{
gboolean success = FALSE;
g_return_val_if_fail (XML_IS_READER (reader), FALSE);
g_return_val_if_fail (reader->xml != NULL, FALSE);
while (xmlTextReaderRead (reader->xml) == 1)
{
if (xmlTextReaderNodeType (reader->xml) == type)
{
if (g_strcmp0 (XML_TO_CHAR (xmlTextReaderConstName (reader->xml)), name) == 0)
{
success = TRUE;
break;
}
}
}
return success;
}
gboolean
xml_reader_is_namespace (XmlReader *reader,
const gchar *ns)
{
g_return_val_if_fail (XML_IS_READER (reader), FALSE);
return (g_strcmp0 (XML_TO_CHAR(xmlTextReaderConstNamespaceUri (reader->xml)), ns) == 0);
}
G_CONST_RETURN gchar *
xml_reader_get_value (XmlReader *reader)
{
g_return_val_if_fail (XML_IS_READER (reader), NULL);
g_return_val_if_fail (reader->xml != NULL, NULL);
return XML_TO_CHAR (xmlTextReaderConstValue (reader->xml));
}
/**
* xml_reader_get_attribute_value:
* @reader: a #XmlReader
*
* Retrieves the value of the currently read attribute.
*
* Return value: the content of the attribute, or %NULL
*/
G_CONST_RETURN gchar *
xml_reader_get_attribute_value (XmlReader *reader)
{
XmlReaderPrivate *priv;
g_return_val_if_fail (XML_IS_READER (reader), NULL);
priv = reader->priv;
return XML_TO_CHAR (priv->attr_value);
}
/**
* xml_reader_get_element_value:
* @reader: a #XmlReader
*
* Retrieves the value of the element the cursor is currently on.
*
* Return value: the value of the current element. The string is owned
* by the #XmlReader instance and should never be modified or freed.
*/
G_CONST_RETURN gchar *
xml_reader_get_element_value (XmlReader *reader)
{
XmlReaderPrivate *priv;
g_return_val_if_fail (XML_IS_READER (reader), NULL);
priv = reader->priv;
if (xml_reader_get_error (reader, NULL))
return NULL;
if (priv->cursor_value)
return XML_TO_CHAR (priv->cursor_value);
return NULL;
}
static gboolean
gstyle_palette_xml_get_header (xmlTextReaderPtr reader,
gchar **id,
gchar **name,
gchar **domain)
{
g_assert (reader != NULL);
g_assert (id != NULL);
g_assert (name != NULL);
g_assert (domain != NULL);
*id = *name = *domain = NULL;
if (xmlTextReaderRead(reader) == 1 &&
xmlTextReaderNodeType (reader) == XML_READER_TYPE_ELEMENT &&
!g_strcmp0 (XML_TO_CHAR (xmlTextReaderConstName (reader)), "palette") &&
xmlTextReaderDepth (reader) == 0)
{
*id = strdup_and_xmlfree (xmlTextReaderGetAttribute (reader, CHAR_TO_XML ("id")));
*name = strdup_and_xmlfree (xmlTextReaderGetAttribute (reader, CHAR_TO_XML ("name")));
if (*name == NULL)
{
*name = strdup_and_xmlfree (xmlTextReaderGetAttribute (reader, CHAR_TO_XML ("_name")));
*domain = strdup_and_xmlfree (xmlTextReaderGetAttribute (reader, CHAR_TO_XML ("gettext-domain")));
}
if (gstyle_str_empty0 (*id) || gstyle_utf8_is_spaces (*id))
{
g_warning ("Palette '%s'has an empty or NULL id\n", *name);
return FALSE;
}
if (gstyle_utf8_is_spaces (*name))
g_clear_pointer (name, g_free);
}
return (*id != NULL);
}
static GstyleColor *
gstyle_palette_xml_get_color (xmlTextReaderPtr reader)
{
GstyleColor *color = NULL;
g_autofree gchar *name;
g_autofree gchar *value;
g_assert (reader != NULL);
if (xmlTextReaderNodeType (reader) == XML_READER_TYPE_ELEMENT &&
!g_strcmp0 (XML_TO_CHAR (xmlTextReaderConstName (reader)), "color") &&
xmlTextReaderDepth (reader) == 1)
{
name = strdup_and_xmlfree (xmlTextReaderGetAttribute (reader, CHAR_TO_XML ("name")));
if (gstyle_utf8_is_spaces (name))
g_clear_pointer (&name, g_free);
value = strdup_and_xmlfree (xmlTextReaderGetAttribute (reader, CHAR_TO_XML ("value")));
if (!gstyle_str_empty0 (value))
color = gstyle_color_new_from_string (name, value);
}
return color;
}
/**
* xml_reader_read_start_element:
* @reader: a #XmlReader
* @element_name: the name of the element to position the cursor on
*
* Moves the internal cursor to the first element named @element_name
* inside the XML document object model.
*
* For instance, this example will find the <book> element and
* iterate over its children "author" and "copyright" and retrieve
* their value:
*
* |[
* gchar *author, *title;
*
* xml_reader_read_start_element (reader, "book");
* xml_reader_read_start_element (reader, "author");
* author = g_strdup (xml_reader_get_element_value (reader));
* xml_reader_read_end_element (reader);
* xml_reader_read_start_element (reader, "title");
* title = g_strdup (xml_reader_get_element_value (reader));
* xml_reader_read_end_element (reader);
* xml_reader_read_end_element (reader);
*
* g_print ("The author of the book '%s' is %s\n", author, title);
* g_free (author);
* g_free (title);
* ]|
*
* Return value: %TRUE if the cursor positioning was successful
*/
gboolean
xml_reader_read_start_element (XmlReader *reader,
const gchar *element_name)
{
XmlReaderPrivate *priv;
xmlNodePtr cursor, node;
g_return_val_if_fail (XML_IS_READER (reader), FALSE);
g_return_val_if_fail (element_name != NULL, FALSE);
if (xml_reader_get_error (reader, NULL))
return FALSE;
priv = reader->priv;
cursor = priv->node_cursor;
if (!cursor)
cursor = priv->current_doc->xmlRootNode;
else
cursor = cursor->xmlChildrenNode;
for (node = cursor;
node != NULL;
node = node->next)
{
if (node->type == XML_ELEMENT_NODE &&
node->name != NULL &&
strcmp (XML_TO_CHAR (node->name), element_name) == 0)
{
xmlNodePtr child;
priv->parent = priv->node_cursor;
priv->node_cursor = node;
priv->depth += 1;
/* preload the text, if any */
child = priv->node_cursor->xmlChildrenNode;
if (child && xmlNodeIsText (child))
{
if (priv->cursor_value)
xmlFree (priv->cursor_value);
priv->cursor_value = xmlNodeGetContent (child);
}
/* unset the attributes cache */
priv->attr_cursor = priv->node_cursor->properties;
if (priv->attr_value)
{
xmlFree (priv->attr_value);
priv->attr_value = NULL;
}
return TRUE;
}
}
priv->error_state = TRUE;
priv->last_error = XML_READER_ERROR_UNKNOWN_NODE;
priv->parent = priv->node_cursor;
if (!priv->parent)
priv->parent = priv->current_doc->xmlRootNode;
priv->node_cursor = NULL;
priv->attr_cursor = NULL;
return FALSE;
}
