mathematical 0.1.0 → 0.1.1

data/ext/mathematical/lsmsvgdefselement.h

@@ -0,0 +1,55 @@
+/* Lasem
+ *
+ * Copyright © 2009-2012 Emmanuel Pacaud
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Author:
+ * 	Emmanuel Pacaud <emmanuel@gnome.org>
+ */
+
+#ifndef LSM_SVG_DEFS_ELEMENT_H
+#define LSM_SVG_DEFS_ELEMENT_H
+
+#include <lsmsvgtypes.h>
+#include <lsmsvgtransformable.h>
+
+G_BEGIN_DECLS
+
+#define LSM_TYPE_SVG_DEFS_ELEMENT             (lsm_svg_defs_element_get_type ())
+#define LSM_SVG_DEFS_ELEMENT(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), LSM_TYPE_SVG_DEFS_ELEMENT, LsmSvgDefsElement))
+#define LSM_SVG_DEFS_ELEMENT_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), LSM_TYPE_SVG_DEFS_ELEMENT, LsmSvgDefsElementClass))
+#define LSM_IS_SVG_DEFS_ELEMENT(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LSM_TYPE_SVG_DEFS_ELEMENT))
+#define LSM_IS_SVG_DEFS_ELEMENT_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), LSM_TYPE_SVG_DEFS_ELEMENT))
+#define LSM_SVG_DEFS_ELEMENT_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS((obj), LSM_TYPE_SVG_DEFS_ELEMENT, LsmSvgDefsElementClass))
+
+typedef struct _LsmSvgDefsElementClass LsmSvgDefsElementClass;
+
+struct _LsmSvgDefsElement {
+	LsmSvgTransformable base;
+};
+
+struct _LsmSvgDefsElementClass {
+	LsmSvgTransformableClass  base_class;
+};
+
+GType lsm_svg_defs_element_get_type (void);
+
+LsmDomNode *		lsm_svg_defs_element_new 		(void);
+
+G_END_DECLS
+
+#endif

data/ext/mathematical/lsmsvgdocument.c

@@ -0,0 +1,288 @@
+/* Lasem
+ *
+ * Copyright © 2009 Emmanuel Pacaud
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Author:
+ * 	Emmanuel Pacaud <emmanuel@gnome.org>
+ */
+
+#include <lsmdebug.h>
+#include <lsmsvgaelement.h>
+#include <lsmsvgcircleelement.h>
+#include <lsmsvgclippathelement.h>
+#include <lsmsvgdefselement.h>
+#include <lsmsvgdocument.h>
+#include <lsmsvgellipseelement.h>
+#include <lsmsvgfilterelement.h>
+#include <lsmsvgfilterblend.h>
+#include <lsmsvgfiltercomposite.h>
+#include <lsmsvgfilterflood.h>
+#include <lsmsvgfiltergaussianblur.h>
+#include <lsmsvgfilteroffset.h>
+#include <lsmsvgfiltermerge.h>
+#include <lsmsvgfiltermergenode.h>
+#include <lsmsvgfilterspecularlighting.h>
+#include <lsmsvgfiltertile.h>
+#include <lsmsvggelement.h>
+#include <lsmsvgimageelement.h>
+#include <lsmsvglineargradientelement.h>
+#include <lsmsvglineelement.h>
+#include <lsmsvgmarkerelement.h>
+#include <lsmsvgmaskelement.h>
+#include <lsmsvgpolylineelement.h>
+#include <lsmsvgpolygonelement.h>
+#include <lsmsvgpathelement.h>
+#include <lsmsvgpatternelement.h>
+#include <lsmsvgradialgradientelement.h>
+#include <lsmsvgrectelement.h>
+#include <lsmsvgsvgelement.h>
+#include <lsmsvgstopelement.h>
+#include <lsmsvgswitchelement.h>
+#include <lsmsvgsymbolelement.h>
+#include <lsmsvgtextelement.h>
+#include <lsmsvgtspanelement.h>
+#include <lsmsvguseelement.h>
+#include <lsmsvgview.h>
+#include <string.h>
+
+static GObjectClass *parent_class;
+
+/* LsmDomNode implementation */
+
+static gboolean
+lsm_svg_document_can_append_child (LsmDomNode *self, LsmDomNode *child)
+{
+	return (LSM_IS_SVG_SVG_ELEMENT (child));
+}
+
+/* LsmDomDocument implementation */
+
+LsmSvgElement *
+lsm_svg_document_get_element_by_url (LsmSvgDocument *document, const char *url)
+{
+	LsmSvgElement *element;
+	char *end;
+	char *id;
+
+	g_return_val_if_fail (LSM_IS_SVG_DOCUMENT (document), NULL);
+
+	if (url == NULL || strncmp (url, "url(#", 5) != 0)
+		return NULL;
+
+	id = g_strdup (url + 5);
+	for (end = id; *end != '\0' && *end != ')'; end++);
+	*end = '\0';
+
+	element = lsm_svg_document_get_element_by_id (document, id);
+
+	g_free (id);
+
+	return element;
+}
+
+static LsmDomElement *
+_create_element (LsmDomDocument *document, const char *tag_name)
+{
+	LsmDomNode *node = NULL;
+
+	if (strcmp (tag_name, "svg") == 0)
+		node = lsm_svg_svg_element_new ();
+	else if (strcmp (tag_name, "g") == 0)
+		node = lsm_svg_g_element_new ();
+	else if (strcmp (tag_name, "rect") == 0)
+		node = lsm_svg_rect_element_new ();
+	else if (strcmp (tag_name, "circle") == 0)
+		node = lsm_svg_circle_element_new ();
+	else if (strcmp (tag_name, "ellipse") == 0)
+		node = lsm_svg_ellipse_element_new ();
+	else if (strcmp (tag_name, "path") == 0)
+		node = lsm_svg_path_element_new ();
+	else if (strcmp (tag_name, "line") == 0)
+		node = lsm_svg_line_element_new ();
+	else if (strcmp (tag_name, "polyline") == 0)
+		node = lsm_svg_polyline_element_new ();
+	else if (strcmp (tag_name, "polygon") == 0)
+		node = lsm_svg_polygon_element_new ();
+	else if (strcmp (tag_name, "text") == 0)
+		node = lsm_svg_text_element_new ();
+	else if (strcmp (tag_name, "tspan") == 0)
+		node = lsm_svg_tspan_element_new ();
+	else if (strcmp (tag_name, "linearGradient") == 0)
+		node = lsm_svg_linear_gradient_element_new ();
+	else if (strcmp (tag_name, "radialGradient") == 0)
+		node = lsm_svg_radial_gradient_element_new ();
+	else if (strcmp (tag_name, "stop") == 0)
+		node = lsm_svg_stop_element_new ();
+	else if (strcmp (tag_name, "pattern") == 0)
+		node = lsm_svg_pattern_element_new ();
+	else if (strcmp (tag_name, "mask") == 0)
+		node = lsm_svg_mask_element_new ();
+	else if (strcmp (tag_name, "use") == 0)
+		node = lsm_svg_use_element_new ();
+	else if (strcmp (tag_name, "image") == 0)
+		node = lsm_svg_image_element_new ();
+	else if (strcmp (tag_name, "defs") == 0)
+		node = lsm_svg_defs_element_new ();
+	else if (strcmp (tag_name, "symbol") == 0)
+		node = lsm_svg_symbol_element_new ();
+	else if (strcmp (tag_name, "marker") == 0)
+		node = lsm_svg_marker_element_new ();
+	else if (strcmp (tag_name, "clipPath") == 0)
+		node = lsm_svg_clip_path_element_new ();
+	else if (strcmp (tag_name, "switch") == 0)
+		node = lsm_svg_switch_element_new ();
+	else if (strcmp (tag_name, "a") == 0)
+		node = lsm_svg_a_element_new ();
+	else if (strcmp (tag_name, "filter") == 0)
+		node = lsm_svg_filter_element_new ();
+	else if (strcmp (tag_name, "feBlend") == 0)
+		node = lsm_svg_filter_blend_new ();
+	else if (strcmp (tag_name, "feComposite") == 0)
+		node = lsm_svg_filter_composite_new ();
+	else if (strcmp (tag_name, "feFlood") == 0)
+		node = lsm_svg_filter_flood_new ();
+	else if (strcmp (tag_name, "feGaussianBlur") == 0)
+		node = lsm_svg_filter_gaussian_blur_new ();
+	else if (strcmp (tag_name, "feMerge") == 0)
+		node = lsm_svg_filter_merge_new ();
+	else if (strcmp (tag_name, "feMergeNode") == 0)
+		node = lsm_svg_filter_merge_node_new ();
+	else if (strcmp (tag_name, "feOffset") == 0)
+		node = lsm_svg_filter_offset_new ();
+	else if (strcmp (tag_name, "feSpecularLighting") == 0)
+		node = lsm_svg_filter_specular_lighting_new ();
+	else if (strcmp (tag_name, "feTile") == 0)
+		node = lsm_svg_filter_tile_new ();
+
+	if (node != NULL)
+		lsm_debug_dom ("[LsmSvgDocument::create_element] Create a %s element", tag_name);
+
+	return LSM_DOM_ELEMENT (node);
+}
+
+static LsmDomElement *
+lsm_svg_document_create_element (LsmDomDocument *document, const char *tag_name)
+{
+	LsmDomElement *element;
+
+	element = _create_element (document, tag_name);
+	if (element != NULL)
+		return element;
+
+	if (g_str_has_prefix (tag_name, "svg:"))
+		return _create_element (document, &tag_name[4]);
+
+	return NULL;
+}
+
+static LsmDomView *
+lsm_svg_document_create_view (LsmDomDocument *document)
+{
+	return LSM_DOM_VIEW (lsm_svg_view_new (LSM_SVG_DOCUMENT (document)));
+}
+
+/* LsmSvgDocument implementation */
+
+/**
+ * lsm_svg_document_get_element_by_id:
+ * @self: a #LsmSvgDocument
+ * @id: id of the element to find
+ *
+ * Returns: (transfer none): the requested element, NULL if not found.
+ */
+
+LsmSvgElement *
+lsm_svg_document_get_element_by_id (LsmSvgDocument *self, const char *id)
+{
+	g_return_val_if_fail (LSM_IS_SVG_DOCUMENT (self), NULL);
+	g_return_val_if_fail (id != NULL, NULL);
+
+	lsm_debug_dom ("[LsmSvgDocument::get_element_by_id] Lookup '%s'", id);
+
+	return g_hash_table_lookup (self->ids, id);
+}
+
+void
+lsm_svg_document_register_element (LsmSvgDocument *self, LsmSvgElement *element, const char *id, const char *old_id)
+{
+	g_return_if_fail (LSM_IS_SVG_DOCUMENT (self));
+	g_return_if_fail (LSM_IS_SVG_ELEMENT (element));
+
+	if (old_id != NULL) {
+		lsm_debug_dom ("[LsmSvgDocument::register_element] Unregister '%s'", old_id);
+
+		g_hash_table_remove (self->ids, old_id);
+	}
+
+	if (id != NULL) {
+		char *new_id = g_strdup (id);
+
+		lsm_debug_dom ("[LsmSvgDocument::register_element] Register '%s'", id);
+
+		g_hash_table_replace (self->ids, new_id, element);
+	}
+}
+
+LsmDomDocument *
+lsm_svg_document_new (void)
+{
+	return g_object_new (LSM_TYPE_SVG_DOCUMENT, NULL);
+}
+
+static void
+lsm_svg_document_init (LsmSvgDocument *document)
+{
+	document->ids = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
+}
+
+static void
+lsm_svg_document_finalize (GObject *object)
+{
+	LsmSvgDocument *document = LSM_SVG_DOCUMENT (object);
+
+	g_hash_table_unref (document->ids);
+
+	parent_class->finalize (object);
+}
+
+LsmSvgSvgElement *
+lsm_svg_document_get_root_element (const LsmSvgDocument *document)
+{
+	return LSM_SVG_SVG_ELEMENT (lsm_dom_document_get_document_element (LSM_DOM_DOCUMENT (document)));
+}
+
+/* LsmSvgDocument class */
+
+static void
+lsm_svg_document_class_init (LsmSvgDocumentClass *this_class)
+{
+	GObjectClass *object_class = G_OBJECT_CLASS (this_class);
+	LsmDomNodeClass *d_node_class = LSM_DOM_NODE_CLASS (this_class);
+	LsmDomDocumentClass *d_document_class = LSM_DOM_DOCUMENT_CLASS (this_class);
+
+	parent_class = g_type_class_peek_parent (this_class);
+
+	object_class->finalize = lsm_svg_document_finalize;
+
+	d_node_class->can_append_child = lsm_svg_document_can_append_child;
+
+	d_document_class->create_element = lsm_svg_document_create_element;
+	d_document_class->create_view = lsm_svg_document_create_view;
+}
+
+G_DEFINE_TYPE (LsmSvgDocument, lsm_svg_document, LSM_TYPE_DOM_DOCUMENT)

data/ext/mathematical/lsmsvgdocument.h

@@ -0,0 +1,64 @@
+/* Lasem
+ *
+ * Copyright © 2009 Emmanuel Pacaud
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Author:
+ * 	Emmanuel Pacaud <emmanuel@gnome.org>
+ */
+
+#ifndef LSM_SVG_DOCUMENT_H
+#define LSM_SVG_DOCUMENT_H
+
+#include <lsmsvgtypes.h>
+#include <lsmdomdocument.h>
+
+G_BEGIN_DECLS
+
+#define LSM_TYPE_SVG_DOCUMENT             (lsm_svg_document_get_type ())
+#define LSM_SVG_DOCUMENT(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), LSM_TYPE_SVG_DOCUMENT, LsmSvgDocument))
+#define LSM_SVG_DOCUMENT_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), LSM_TYPE_SVG_DOCUMENT, LsmSvgDocumentClass))
+#define LSM_IS_SVG_DOCUMENT(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LSM_TYPE_SVG_DOCUMENT))
+#define LSM_IS_SVG_DOCUMENT_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), LSM_TYPE_SVG_DOCUMENT))
+#define LSM_SVG_DOCUMENT_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS((obj), LSM_TYPE_SVG_DOCUMENT, LsmSvgDocumentClass))
+
+typedef struct _LsmSvgDocumentClass LsmSvgDocumentClass;
+
+struct _LsmSvgDocument {
+	LsmDomDocument	document;
+
+	GHashTable *	ids;
+};
+
+struct _LsmSvgDocumentClass {
+	LsmDomDocumentClass  parent_class;
+};
+
+GType lsm_svg_document_get_type (void);
+
+LsmDomDocument *	lsm_svg_document_new 			(void);
+
+LsmSvgSvgElement * 	lsm_svg_document_get_root_element 	(const LsmSvgDocument *document);
+LsmSvgElement * 	lsm_svg_document_get_element_by_url 	(LsmSvgDocument *document, const char *url);
+LsmSvgElement *		lsm_svg_document_get_element_by_id 	(LsmSvgDocument *self, const char *id);
+void 			lsm_svg_document_register_element 	(LsmSvgDocument *self, LsmSvgElement *element,
+								 const char *id, const char *old_id);
+
+G_END_DECLS
+
+#endif
+

data/ext/mathematical/lsmsvgelement.c

@@ -0,0 +1,373 @@
+/* Lasem
+ *
+ * Copyright © 2009 Emmanuel Pacaud
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General
+ * Public License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ * Boston, MA 02111-1307, USA.
+ *
+ * Author:
+ * 	Emmanuel Pacaud <emmanuel@gnome.org>
+ */
+
+#include <lsmdebug.h>
+#include <lsmattributes.h>
+#include <lsmproperties.h>
+#include <lsmsvgdocument.h>
+#include <lsmsvgelement.h>
+#include <lsmsvgtransformable.h>
+#include <lsmsvgpatternelement.h>
+#include <lsmsvgradialgradientelement.h>
+#include <lsmsvglineargradientelement.h>
+#include <lsmsvgclippathelement.h>
+#include <lsmsvgmarkerelement.h>
+#include <lsmsvgmaskelement.h>
+#include <lsmsvgfilterelement.h>
+#include <lsmsvgview.h>
+#include <string.h>
+
+static GObjectClass *parent_class;
+
+/* LsmDomNode implementation */
+
+static gboolean
+lsm_svg_element_can_append_child (LsmDomNode *self, LsmDomNode *child)
+{
+	return (LSM_IS_SVG_ELEMENT (child));
+}
+
+static gboolean
+lsm_svg_element_child_changed (LsmDomNode *parent, LsmDomNode *child)
+{
+#if 0
+	if (LSM_IS_SVG_ELEMENT (child) &&
+	    lsm_svg_element_get_category (LSM_SVG_ELEMENT (child)) == 0)
+		g_warning ("Category not defined for '%s'", lsm_dom_node_get_node_name (child));
+#endif
+
+	return TRUE;
+}
+
+/* LsmDomElement implementation */
+
+static void
+lsm_svg_element_set_attribute (LsmDomElement *self, const char* name, const char *value)
+{
+	LsmSvgElementClass *s_element_class = LSM_SVG_ELEMENT_GET_CLASS (self);
+	LsmSvgElement *s_element = LSM_SVG_ELEMENT (self);
+
+	lsm_debug_dom ("[LsmSvgElement::set_attribute] node = %s, name = %s, value = %s",
+		    lsm_dom_node_get_node_name (LSM_DOM_NODE (self)), name, value);
+
+	if (g_strcmp0 (name, "id") == 0 ||
+	    g_strcmp0 (name, "xml:id") == 0) {
+		LsmDomDocument *document;
+
+		document = lsm_dom_node_get_owner_document (LSM_DOM_NODE (self));
+		if (document != NULL)
+			lsm_svg_document_register_element (LSM_SVG_DOCUMENT (document), LSM_SVG_ELEMENT (self),
+							   value, s_element->id.value);
+
+		lsm_attribute_manager_set_attribute (s_element_class->attribute_manager,
+						     self, name, value);
+
+		return;
+	}
+
+	/* TODO Avoid double hash table lookup */
+	if (!lsm_attribute_manager_set_attribute (s_element_class->attribute_manager,
+						  self, name, value))
+		lsm_svg_property_bag_set_property (&s_element->property_bag, name, value);
+}
+
+static const char *
+lsm_svg_element_get_attribute (LsmDomElement *self, const char *name)
+{
+	LsmSvgElementClass *s_element_class = LSM_SVG_ELEMENT_GET_CLASS(self);
+	LsmSvgElement *s_element = LSM_SVG_ELEMENT (self);
+	const char *value;
+
+	/* TODO Avoid double hash table lookup */
+	value = lsm_attribute_manager_get_attribute (s_element_class->attribute_manager,
+						     self, name);
+	if (value != NULL)
+		return value;
+
+	return lsm_svg_property_bag_get_property (&s_element->property_bag, name);
+}
+
+static char *
+lsm_svg_element_get_serialized_attributes (LsmDomElement *self)
+{
+	LsmSvgElementClass *s_element_class = LSM_SVG_ELEMENT_GET_CLASS(self);
+	LsmSvgElement *s_element = LSM_SVG_ELEMENT (self);
+	char *properties;
+	char *attributes;
+	char *result;
+
+	properties = lsm_svg_property_bag_serialize (&s_element->property_bag);
+	attributes = lsm_attribute_manager_serialize (s_element_class->attribute_manager, self);
+
+	if (attributes == NULL)
+		return properties;
+
+	if (properties == NULL)
+		return attributes;
+
+	result = g_strconcat (attributes, " ", properties, NULL);
+
+	g_free (properties);
+	g_free (attributes);
+
+	return result;
+}
+
+/* LsmSvgElement implementation */
+
+LsmSvgElementCategory
+lsm_svg_element_get_category (LsmSvgElement *element)
+{
+	LsmSvgElementClass *s_element_class = LSM_SVG_ELEMENT_GET_CLASS (element);
+
+	return s_element_class != NULL ? s_element_class->category : 0;
+}
+
+static void
+_render (LsmSvgElement *element, LsmSvgView *view)
+{
+	LsmDomNode *node;
+
+	lsm_debug_render ("[LsmSvgElement::_render");
+
+	for (node = LSM_DOM_NODE (element)->first_child; node != NULL; node = node->next_sibling)
+		if (LSM_IS_SVG_ELEMENT (node))
+		    lsm_svg_element_render (LSM_SVG_ELEMENT (node), view);
+}
+
+static void
+_transformed_render (LsmSvgElement *element, LsmSvgView *view)
+{
+	LsmSvgElementClass *element_class;
+	const LsmSvgStyle *parent_style;
+	LsmSvgStyle *style;
+
+	element_class = LSM_SVG_ELEMENT_GET_CLASS (element);
+
+	parent_style = lsm_svg_view_get_current_style (view);
+	style = lsm_svg_style_new_inherited (parent_style, &element->property_bag);
+	style->ignore_group_opacity = element_class->is_shape_element;
+
+	if (style->visibility->value == LSM_SVG_VISIBILITY_VISIBLE &&
+	    style->display->value != LSM_SVG_DISPLAY_NONE) {
+
+		lsm_debug_render ("[LsmSvgElement::render] Render %s (%s)",
+				  lsm_dom_node_get_node_name (LSM_DOM_NODE (element)),
+				  element->id.value != NULL ? element->id.value : "no id");
+		lsm_svg_view_push_element (view, element);
+		lsm_svg_view_push_composition (view, style);
+
+		element_class->render (element, view);
+
+		lsm_svg_view_pop_composition (view);
+		lsm_svg_view_pop_element (view);
+	}
+
+	lsm_svg_style_unref (style);
+}
+
+void
+lsm_svg_element_render (LsmSvgElement *element, LsmSvgView *view)
+{
+	LsmSvgElementClass *element_class;
+
+	g_return_if_fail (LSM_IS_SVG_ELEMENT (element));
+
+	element_class = LSM_SVG_ELEMENT_GET_CLASS (element);
+
+	if (element_class->render != NULL)
+		element_class->transformed_render (element, view);
+}
+
+static void
+lsm_svg_element_enable_rendering (LsmSvgElement *element)
+{
+	LsmSvgElementClass *element_class;
+
+	g_return_if_fail (LSM_IS_SVG_ELEMENT (element));
+
+	element_class = LSM_SVG_ELEMENT_GET_CLASS (element);
+	g_return_if_fail (element_class->enable_rendering != NULL);
+
+	element_class->enable_rendering (element);
+}
+
+void
+lsm_svg_element_force_render (LsmSvgElement *element, LsmSvgView *view)
+{
+	g_return_if_fail (LSM_IS_SVG_PATTERN_ELEMENT (element) ||
+			  LSM_IS_SVG_RADIAL_GRADIENT_ELEMENT (element) ||
+			  LSM_IS_SVG_LINEAR_GRADIENT_ELEMENT (element) ||
+			  LSM_IS_SVG_MASK_ELEMENT (element) ||
+			  LSM_IS_SVG_CLIP_PATH_ELEMENT (element) ||
+			  LSM_IS_SVG_MARKER_ELEMENT (element) ||
+			  LSM_IS_SVG_FILTER_ELEMENT (element));
+
+	lsm_svg_element_enable_rendering (element);
+	lsm_svg_element_render (element, view);
+}
+
+void
+lsm_svg_element_transformed_get_extents (LsmSvgElement *element, LsmSvgView *view, LsmExtents *extents)
+{
+	LsmSvgElementClass *element_class;
+	g_return_if_fail (LSM_IS_SVG_ELEMENT (element));
+	g_return_if_fail (LSM_IS_SVG_VIEW (view));
+	g_return_if_fail (extents != NULL);
+
+	element_class = LSM_SVG_ELEMENT_GET_CLASS (element);
+
+	if (element_class->transformed_get_extents != NULL)
+		element_class->transformed_get_extents (element, view, extents);
+	else
+		element_class->get_extents (element, view, extents);
+}
+
+static void
+_get_extents (LsmSvgElement *element, LsmSvgView *view, LsmExtents *extents)
+{
+	LsmDomNode *node;
+	gboolean first_child = TRUE;
+	LsmExtents element_extents = {0.0, 0.0, 0.0, 0.0};
+
+	lsm_debug_render ("[LsmSvgElement::_get_extents]");
+
+	for (node = LSM_DOM_NODE (element)->first_child; node != NULL; node = node->next_sibling) {
+		if (LSM_IS_SVG_ELEMENT (node)) {
+			LsmExtents child_extents;
+			LsmSvgElement *child_element;
+			LsmSvgElementClass *child_element_class;
+
+			child_element = LSM_SVG_ELEMENT (node);
+			child_element_class = LSM_SVG_ELEMENT_GET_CLASS (node);
+			
+			if (child_element_class->transformed_get_extents != NULL)
+				child_element_class->transformed_get_extents (child_element, view, &child_extents);
+			else
+				child_element_class->get_extents (child_element, view, &child_extents);
+
+			if (first_child) {
+				element_extents = child_extents;
+				first_child = FALSE;
+			} else {
+				element_extents.x1 = MIN (element_extents.x1, child_extents.x1);
+				element_extents.y1 = MIN (element_extents.y1, child_extents.y1);
+				element_extents.x2 = MAX (element_extents.x2, child_extents.x2);
+				element_extents.y2 = MAX (element_extents.y2, child_extents.y2);
+			}
+		}
+	}
+
+	*extents = element_extents;
+}
+
+void
+lsm_svg_element_get_extents (LsmSvgElement *element, LsmSvgView *view, LsmExtents *extents)
+{
+	LsmSvgElementClass *element_class;
+
+	g_return_if_fail (LSM_IS_SVG_ELEMENT (element));
+	g_return_if_fail (LSM_IS_SVG_VIEW (view));
+	g_return_if_fail (extents != NULL);
+
+	element_class = LSM_SVG_ELEMENT_GET_CLASS (element);
+	element_class->get_extents (element, view, extents);
+
+	if (element->id.value != NULL)
+		lsm_debug_measure ("LsmSvgElement::get_extents] Extents for '%s' = %g,%g %g,%g",
+				   element->id.value,
+				   extents->x1, extents->y1, extents->x2, extents->y2);
+	else
+		lsm_debug_measure ("LsmSvgElement::get_extents] Extents for <%s> = %g,%g %g,%g",
+				   lsm_dom_node_get_node_name (LSM_DOM_NODE (element)),
+				   extents->x1, extents->y1, extents->x2, extents->y2);
+}
+
+static void
+lsm_svg_element_init (LsmSvgElement *element)
+{
+}
+
+static void
+lsm_svg_element_finalize (GObject *object)
+{
+	LsmSvgElementClass *s_element_class = LSM_SVG_ELEMENT_GET_CLASS (object);
+	LsmSvgElement *svg_element = LSM_SVG_ELEMENT (object);
+
+	lsm_svg_property_bag_clean (&svg_element->property_bag);
+	lsm_attribute_manager_clean_attributes (s_element_class->attribute_manager, svg_element);
+
+	parent_class->finalize (object);
+}
+
+/* LsmSvgElement class */
+
+static const LsmSvgMatrix matrix_default =	 { 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, LSM_SVG_MATRIX_FLAGS_IDENTITY};
+
+static const LsmAttributeInfos lsm_svg_attribute_infos[] = {
+	{
+		.name = "id",
+		.trait_class = &lsm_null_trait_class,
+		.attribute_offset = offsetof (LsmSvgElement, id)
+	},
+	{
+		.name = "xml:id",
+		.trait_class = &lsm_null_trait_class,
+		.attribute_offset = offsetof (LsmSvgElement, id)
+	},
+	{
+		.name = "class",
+		.trait_class = &lsm_null_trait_class,
+		.attribute_offset = offsetof (LsmSvgElement, class_name)
+	}
+};
+
+static void
+lsm_svg_element_class_init (LsmSvgElementClass *s_element_class)
+{
+	GObjectClass *object_class = G_OBJECT_CLASS (s_element_class);
+	LsmDomNodeClass *d_node_class = LSM_DOM_NODE_CLASS (s_element_class);
+	LsmDomElementClass *d_element_class = LSM_DOM_ELEMENT_CLASS (s_element_class);
+
+	parent_class = g_type_class_peek_parent (s_element_class);
+
+	object_class->finalize = lsm_svg_element_finalize;
+
+	d_node_class->can_append_child = lsm_svg_element_can_append_child;
+	d_node_class->child_changed = lsm_svg_element_child_changed;
+
+	d_element_class->get_attribute = lsm_svg_element_get_attribute;
+	d_element_class->set_attribute = lsm_svg_element_set_attribute;
+	d_element_class->get_serialized_attributes = lsm_svg_element_get_serialized_attributes;
+
+	s_element_class->category = 0;
+
+	s_element_class->render = _render;
+	s_element_class->get_extents = _get_extents;
+	s_element_class->transformed_render = _transformed_render;
+	s_element_class->transformed_get_extents = NULL;
+	s_element_class->attribute_manager = lsm_attribute_manager_new (G_N_ELEMENTS (lsm_svg_attribute_infos),
+									lsm_svg_attribute_infos);
+}
+
+G_DEFINE_ABSTRACT_TYPE (LsmSvgElement, lsm_svg_element, LSM_TYPE_DOM_ELEMENT)