src/svgtiny_css.c: implement named_parent_node() select handler

[libsvgtiny.git] / src / svgtiny_css.c

diff --git a/src/svgtiny_css.c b/src/svgtiny_css.c
index 265204260f232b7f4326485713a8300597f38d0c..01b566f93c876ef5f86111b62aa089f614734930 100644 (file)
--- a/src/svgtiny_css.c
+++ b/src/svgtiny_css.c
@@ -4,6 +4,11 @@
 #include "svgtiny_internal.h"
 
 static css_error node_name(void *pw, void *node, css_qname *qname);
+static css_error node_classes(void *pw, void *node,
+               lwc_string ***classes, uint32_t *n_classes);
+static css_error node_id(void *pw, void *node, lwc_string **id);
+static css_error named_parent_node(void *pw, void *node,
+               const css_qname *qname, void **parent);
 
 
 /**
@@ -101,3 +106,125 @@ css_error node_name(void *pw, void *node, css_qname *qname)
 
        return CSS_OK;
 }
+
+
+/**
+ * Retrieve the given node's classes
+ *
+ * \param pw         Pointer to the current SVG parser state
+ * \param node       Libdom SVG node
+ * \param classes    Address at which to store the class name array
+ * \param n_classes  Address at which to store the length of the class
+ *                   name array
+ *
+ * \return CSS_OK on success, or CSS_NOMEM if anything goes wrong
+ *
+ * \note CSS_NOMEM is not possible in practice as of libdom-0.4.1,
+ *       because the underlying libdom function never fails
+ */
+css_error node_classes(void *pw, void *node,
+               lwc_string ***classes, uint32_t *n_classes)
+{
+       UNUSED(pw);
+       dom_exception err;
+
+       err = dom_element_get_classes((dom_node *)node, classes, n_classes);
+
+       /* The implementation does not do it, but the documentation
+          for dom_element_get_classes() says that a DOM_NO_MEM_ERR is
+          possible here, so we handle it to be on the safe side. */
+       if (err != DOM_NO_ERR) {
+               return CSS_NOMEM;
+       }
+
+       return CSS_OK;
+}
+
+
+/**
+ * Retrieve the given node's id
+ *
+ * \param pw    Pointer to the current SVG parser state
+ * \param node  Libdom SVG node
+ * \param id    Address at which to store the id
+ *
+ * \return      CSS_OK on success, or CSS_NOMEM if anything goes wrong
+ */
+css_error node_id(void *pw, void *node, lwc_string **id)
+{
+       dom_string *attr;
+       dom_exception err;
+       struct svgtiny_parse_state *state;
+
+       /* Begin with the assumption that this node has no id */
+       *id = NULL;
+
+       state = (struct svgtiny_parse_state *)pw;
+       err = dom_element_get_attribute((dom_node *)node,
+                                       state->interned_id, &attr);
+       if (err != DOM_NO_ERR) {
+               return CSS_NOMEM;
+       }
+       else if (attr == NULL) {
+               /* The node has no id attribute and our return value
+                  is already set to NULL so we're done */
+               return CSS_OK;
+       }
+
+       /* If we found an id attribute (a dom_string), intern it into
+          an lwc_string that we can return, and then cleanup the
+          dom_string. */
+       err = dom_string_intern(attr, id);
+       if (err != DOM_NO_ERR) {
+               dom_string_unref(attr);
+               return CSS_NOMEM;
+       }
+       dom_string_unref(attr);
+       return CSS_OK;
+}
+
+
+
+/**
+ * Find the first parent of the given element having the given name
+ *
+ * \param pw      Pointer to the current SVG parser state
+ * \param node    Libdom SVG node
+ * \param qname   Name of the parent node to search for
+ * \param parent  Address at which to store the parent node pointer
+ *
+ * \return Always returns CSS_OK
+ *
+ * \post If a suitable element is found, a pointer to it will be
+ *       stored at the address pointed to by \a parent; otherwise,
+ *       NULL will be stored at the address pointed to by \a parent
+ */
+css_error named_parent_node(void *pw, void *node,
+               const css_qname *qname, void **parent)
+{
+       UNUSED(pw);
+       /* dom_element_named_parent_node() was invented to implement
+        * this select handler so there isn't much for us to do except
+        * call it. It's OK if node isn't an element, libdom checks
+        * for it. */
+       dom_element_named_parent_node((dom_element *)node,
+                               qname->name,
+                               (struct dom_element **)parent);
+
+       /* Implementation detail: dom_element_named_parent_node()
+        * increments the reference count of the parent element before
+        * returning it to us. According to docs/RefCnt in the libdom
+        * repository, this will prevent the parent element from being
+        * destroyed if it is pruned from the DOM. That sounds good,
+        * since we don't want to be using a pointer to an object that
+        * has been destroyed... but we also have no way of later
+        * decrementing the reference count ourselves, and don't want
+        * to make the returned node eternal. Decrementing the
+        * reference counter now allows it to be destroyed when the
+        * DOM no longer needs it, and so long as no other parts of
+        * libsvgtiny are messing with the DOM during parsing, that
+        * shouldn't (ha ha) cause any problems. */
+       dom_node_unref(*parent);
+
+       return CSS_OK;
+}