mathematical 0.1.0 → 0.1.1

data/ext/mathematical/lsmsvgpatternelement.c

@@ -0,0 +1,398 @@
+/* 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 <lsmsvgpatternelement.h>
+#include <lsmsvgview.h>
+#include <lsmdebug.h>
+#include <lsmsvgdocument.h>
+#include <stdio.h>
+
+typedef struct {
+	LsmSvgLength x;
+	LsmSvgLength y;
+	LsmSvgLength width;
+	LsmSvgLength height;
+	LsmSvgMatrix transform;
+	LsmSvgPatternUnits units;
+	LsmSvgPatternUnits content_units;
+	LsmBox viewbox;
+	LsmSvgPreserveAspectRatio preserve_aspect_ratio;
+} LsmSvgPatternElementAttributes;
+
+static LsmSvgPatternElementAttributes default_attributes = {
+	.x = { .value_unit =   0.0, .type = LSM_SVG_LENGTH_TYPE_PX},
+	.y = { .value_unit =   0.0, .type = LSM_SVG_LENGTH_TYPE_PX},
+	.width = { .value_unit =   0.0, .type = LSM_SVG_LENGTH_TYPE_PX},
+	.height = { .value_unit =   0.0, .type = LSM_SVG_LENGTH_TYPE_PX},
+	.transform = {1.0, 0.0, 0.0, 1.0, 0.0, 0.0, LSM_SVG_MATRIX_FLAGS_IDENTITY},
+	.units = LSM_SVG_PATTERN_UNITS_OBJECT_BOUNDING_BOX,
+	.content_units = LSM_SVG_PATTERN_UNITS_USER_SPACE_ON_USE,
+	.viewbox = {0.0, 0.0, 0.0, 0.0},
+	.preserve_aspect_ratio = {
+		.defer = FALSE,
+		.align = LSM_SVG_ALIGN_X_MID_Y_MID,
+		.meet_or_slice = LSM_SVG_MEET_OR_SLICE_MEET
+	}
+};
+
+static GObjectClass *parent_class;
+
+/* GdomNode implementation */
+
+static const char *
+_pattern_element_get_node_name (LsmDomNode *node)
+{
+	return "pattern";
+}
+
+/* LsmSvgElement implementation */
+
+static LsmSvgPatternElement *
+lsm_svg_pattern_element_inherit_referenced (LsmSvgDocument *owner,
+					    LsmSvgPatternElement *pattern,
+					    LsmSvgPatternElementAttributes *attributes,
+					    GSList **elements)
+{
+	LsmSvgPatternElement *referenced_pattern = pattern;
+	LsmSvgElement *element;
+
+	*elements = g_slist_prepend (*elements, pattern);
+
+	if (lsm_attribute_is_defined (&pattern->href)) {
+		char *id;
+		GSList *iter;
+		gboolean circular_reference_found = FALSE;
+
+		id = pattern->href.value;
+		if (id == NULL)
+			return NULL;
+		if (*id == '#')
+			id++;
+
+		element = lsm_svg_document_get_element_by_id (owner, id);
+
+		for (iter = *elements; iter != NULL; iter = iter->next)
+			if (iter->data == element) {
+				lsm_debug_render ("[LsmSvgPatternElement::inherit_attributes] "
+					   "Circular reference (id = %s)", id);
+				circular_reference_found = TRUE;
+			}
+
+		if (!circular_reference_found) {
+			if (LSM_IS_SVG_PATTERN_ELEMENT (element)) {
+				lsm_debug_render ("[LsmSvgPatternElement::inherit_attributes] "
+						  "Found referenced element '%s'", id);
+
+				referenced_pattern = lsm_svg_pattern_element_inherit_referenced
+					(owner,
+					 LSM_SVG_PATTERN_ELEMENT (element),
+					 attributes, elements);
+			} else {
+				lsm_debug_render ("[LsmSvgPatternElement::inherit_attributes] "
+						  "Referenced element '%s' not found", id);
+				referenced_pattern = NULL;
+			}
+		} else
+			referenced_pattern = NULL;
+	}
+
+	if (lsm_attribute_is_defined (&pattern->x.base))
+		attributes->x = pattern->x.length;
+	if (lsm_attribute_is_defined (&pattern->y.base))
+		attributes->y = pattern->y.length;
+	if (lsm_attribute_is_defined (&pattern->width.base))
+		attributes->width = pattern->width.length;
+	if (lsm_attribute_is_defined (&pattern->height.base))
+		attributes->height = pattern->height.length;
+	if (lsm_attribute_is_defined (&pattern->transform.base))
+		attributes->transform = pattern->transform.matrix;
+	if (lsm_attribute_is_defined (&pattern->units.base))
+		attributes->units = pattern->units.value;
+	if (lsm_attribute_is_defined (&pattern->content_units.base))
+		attributes->content_units = pattern->content_units.value;
+	if (lsm_attribute_is_defined (&pattern->viewbox.base))
+		attributes->viewbox = pattern->viewbox.value;
+	if (lsm_attribute_is_defined (&pattern->preserve_aspect_ratio.base))
+		attributes->preserve_aspect_ratio = pattern->preserve_aspect_ratio.value;
+
+	return referenced_pattern;
+}
+
+static void
+lsm_svg_pattern_element_render (LsmSvgElement *self, LsmSvgView *view)
+{
+	LsmSvgPatternElement *pattern = LSM_SVG_PATTERN_ELEMENT (self);
+	LsmSvgPatternElement *referenced_pattern;
+	gboolean is_object_bounding_box;
+	gboolean is_viewbox_defined;
+	LsmBox viewport;
+	LsmBox image_box;
+	const LsmBox *pattern_extents;
+	LsmSvgStyle *style;
+	gboolean is_matrix_invertible = TRUE;
+
+	if (!pattern->enable_rendering) {
+		lsm_debug_render ("[LsmSvgPatternElement::render] Direct rendering not allowed");
+		return;
+	} else {
+		pattern->enable_rendering = FALSE;
+	}
+
+	if (lsm_attribute_is_defined (&pattern->href)) {
+		LsmSvgPatternElementAttributes attributes;
+		LsmSvgDocument *owner;
+		attributes = default_attributes;
+		GSList *elements = NULL;
+
+		owner = LSM_SVG_DOCUMENT (lsm_dom_node_get_owner_document (LSM_DOM_NODE (self)));
+
+		referenced_pattern = lsm_svg_pattern_element_inherit_referenced (owner, pattern,
+										 &attributes, &elements);
+
+		g_slist_free (elements);
+
+		pattern->x.length = attributes.x;
+		pattern->y.length = attributes.y;
+		pattern->width.length = attributes.width;
+		pattern->height.length = attributes.height;
+		pattern->transform.matrix = attributes.transform;
+		pattern->units.value = attributes.units;
+		pattern->content_units.value = attributes.content_units;
+		pattern->viewbox.value = attributes.viewbox;
+		pattern->preserve_aspect_ratio.value = attributes.preserve_aspect_ratio;
+	} else
+		referenced_pattern = pattern;
+
+	if (referenced_pattern == NULL)
+		return;
+
+	style = lsm_svg_style_new_inherited (NULL, &self->property_bag);
+	style->ignore_group_opacity = FALSE;
+	lsm_svg_view_push_composition (view, style);
+
+	pattern_extents = lsm_svg_view_get_pattern_extents (view);
+
+	is_object_bounding_box = (pattern->units.value == LSM_SVG_PATTERN_UNITS_OBJECT_BOUNDING_BOX);
+
+	if (is_object_bounding_box) {
+		LsmBox viewbox = {.x = 0.0, .y = .0, .width = 1.0, .height = 1.0};
+
+		lsm_svg_view_push_viewbox (view, &viewbox);
+	}
+
+	viewport.x      = lsm_svg_view_normalize_length (view, &pattern->x.length,
+							 LSM_SVG_LENGTH_DIRECTION_HORIZONTAL);
+	viewport.y      = lsm_svg_view_normalize_length (view, &pattern->y.length,
+							 LSM_SVG_LENGTH_DIRECTION_VERTICAL);
+	viewport.width  = lsm_svg_view_normalize_length (view, &pattern->width.length,
+							 LSM_SVG_LENGTH_DIRECTION_HORIZONTAL);
+	viewport.height = lsm_svg_view_normalize_length (view, &pattern->height.length,
+							 LSM_SVG_LENGTH_DIRECTION_VERTICAL);
+
+	image_box = viewport;
+
+	if (is_object_bounding_box) {
+		lsm_svg_view_pop_viewbox (view);
+
+		image_box.x *= pattern_extents->width;
+		image_box.y *= pattern_extents->height;
+		image_box.width *= pattern_extents->width;
+		image_box.height *= pattern_extents->height;
+	}
+
+	if (viewport.width <= 0.0 || viewport.height <= 0.0) {
+		lsm_debug_render ("[LsmSvgPatternElement::render] Invalid viewport w = %g, h = %g",
+			   viewport.width, viewport.height);
+		lsm_svg_view_pop_composition (view);
+		lsm_svg_style_unref (style);
+		return;
+	}
+
+	lsm_debug_render ("[LsmSvgPatternElement::render] Create pattern x = %g, y = %g, w = %g, h = %g",
+		   viewport.x, viewport.y, viewport.width, viewport.height);
+
+	if (!lsm_svg_view_create_surface_pattern (view, &image_box,
+						  &pattern->transform.matrix,
+						  LSM_SVG_VIEW_SURFACE_TYPE_AUTO)) {
+		lsm_debug_render ("[LsmSvgPatternElement::render] Intermediate surface creation failed");
+		lsm_svg_view_pop_composition (view);
+		lsm_svg_style_unref (style);
+		return;
+	}
+
+	is_object_bounding_box = (pattern->content_units.value == LSM_SVG_PATTERN_UNITS_OBJECT_BOUNDING_BOX);
+
+	if (is_object_bounding_box) {
+		LsmSvgMatrix matrix;
+		LsmBox viewbox = {.x = 0.0, .y = .0, .width = 1.0, .height = 1.0};
+
+		lsm_svg_matrix_init_scale (&matrix, pattern_extents->width, pattern_extents->height);
+		lsm_svg_matrix_translate (&matrix, -pattern_extents->x, -pattern_extents->y);
+		lsm_svg_view_push_viewbox (view, &viewbox);
+		is_matrix_invertible = lsm_svg_view_push_matrix (view, &matrix);
+
+		lsm_debug_render ("[LsmSvgPatternElement::render] object_bounding_box"
+			   " x_scale = %g, y_scale = %g, x_offset = %g, y_offset = %g",
+			   pattern_extents->width, pattern_extents->height,
+			   pattern_extents->x,     pattern_extents->y);
+	}
+
+	if (is_matrix_invertible) {
+
+		is_viewbox_defined = lsm_attribute_is_defined (&pattern->viewbox.base);
+
+		if (!(is_viewbox_defined) ||
+		    (is_viewbox_defined && pattern->viewbox.value.width > 0.0 && pattern->viewbox.value.height > 0.0)) {
+
+			lsm_svg_view_push_viewport (view, &viewport, is_viewbox_defined ? &pattern->viewbox.value : NULL,
+						    &pattern->preserve_aspect_ratio.value, LSM_SVG_OVERFLOW_HIDDEN);
+
+			LSM_SVG_ELEMENT_CLASS (parent_class)->render (LSM_SVG_ELEMENT (referenced_pattern), view);
+
+			lsm_svg_view_pop_viewport (view);
+		}
+	}
+
+	if (is_object_bounding_box) {
+		lsm_svg_view_pop_matrix (view);
+		lsm_svg_view_pop_viewbox (view);
+	}
+
+	lsm_svg_view_pop_composition (view);
+	lsm_svg_style_unref (style);
+}
+
+static void
+lsm_svg_pattern_element_enable_rendering (LsmSvgElement *element)
+{
+	LSM_SVG_PATTERN_ELEMENT (element)->enable_rendering  = TRUE;
+}
+
+/* LsmSvgPatternElement implementation */
+
+LsmDomNode *
+lsm_svg_pattern_element_new (void)
+{
+	return g_object_new (LSM_TYPE_SVG_PATTERN_ELEMENT, NULL);
+}
+
+static void
+lsm_svg_pattern_element_init (LsmSvgPatternElement *self)
+{
+	self->enable_rendering = FALSE;
+	self->x.length = default_attributes.x;
+	self->y.length = default_attributes.y;
+	self->width.length = default_attributes.width;
+	self->height.length = default_attributes.height;
+	self->transform.matrix = default_attributes.transform;
+	self->units.value = default_attributes.units;
+	self->content_units.value = default_attributes.content_units;
+	self->preserve_aspect_ratio.value = default_attributes.preserve_aspect_ratio;
+}
+
+/* LsmSvgPatternElement class */
+
+static const LsmAttributeInfos lsm_svg_pattern_element_attribute_infos[] = {
+	{
+		.name = "x",
+		.attribute_offset = offsetof (LsmSvgPatternElement, x),
+		.trait_class = &lsm_svg_length_trait_class,
+		.trait_default = &default_attributes.x
+	},
+	{
+		.name = "y",
+		.attribute_offset = offsetof (LsmSvgPatternElement, y),
+		.trait_class = &lsm_svg_length_trait_class,
+		.trait_default = &default_attributes.y
+	},
+	{
+		.name = "width",
+		.attribute_offset = offsetof (LsmSvgPatternElement, width),
+		.trait_class = &lsm_svg_length_trait_class,
+		.trait_default = &default_attributes.width
+	},
+	{
+		.name = "height",
+		.attribute_offset = offsetof (LsmSvgPatternElement, height),
+		.trait_class = &lsm_svg_length_trait_class,
+		.trait_default = &default_attributes.height
+	},
+	{
+		.name = "patternUnits",
+		.attribute_offset = offsetof (LsmSvgPatternElement, units),
+		.trait_class = &lsm_svg_pattern_units_trait_class,
+		.trait_default = &default_attributes.units
+	},
+	{
+		.name = "patternContentUnits",
+		.attribute_offset = offsetof (LsmSvgPatternElement, content_units),
+		.trait_class = &lsm_svg_pattern_units_trait_class,
+		.trait_default = &default_attributes.content_units
+	},
+	{
+		.name = "patternTransform",
+		.attribute_offset = offsetof (LsmSvgPatternElement, transform),
+		.trait_class = &lsm_svg_matrix_trait_class,
+		.trait_default = &default_attributes.transform
+	},
+	{
+		.name = "xlink:href",
+		.attribute_offset = offsetof (LsmSvgPatternElement, href),
+		.trait_class = &lsm_null_trait_class
+	},
+	{
+		.name = "viewBox",
+		.attribute_offset = offsetof (LsmSvgPatternElement, viewbox),
+		.trait_class = &lsm_box_trait_class,
+		.trait_default = &default_attributes.viewbox
+	},
+	{
+		.name = "preserveAspectRatio",
+		.attribute_offset = offsetof (LsmSvgPatternElement, preserve_aspect_ratio),
+		.trait_class = &lsm_svg_preserve_aspect_ratio_trait_class,
+		.trait_default = &default_attributes.preserve_aspect_ratio
+	}
+};
+
+static void
+lsm_svg_pattern_element_class_init (LsmSvgPatternElementClass *klass)
+{
+	LsmDomNodeClass *d_node_class = LSM_DOM_NODE_CLASS (klass);
+	LsmSvgElementClass *s_element_class = LSM_SVG_ELEMENT_CLASS (klass);
+
+	parent_class = g_type_class_peek_parent (klass);
+
+	d_node_class->get_node_name = _pattern_element_get_node_name;
+
+	s_element_class->category = LSM_SVG_ELEMENT_CATEGORY_CONTAINER;
+
+	s_element_class->render = lsm_svg_pattern_element_render;
+	s_element_class->enable_rendering = lsm_svg_pattern_element_enable_rendering;
+	s_element_class->attribute_manager = lsm_attribute_manager_duplicate (s_element_class->attribute_manager);
+
+	lsm_attribute_manager_add_attributes (s_element_class->attribute_manager,
+					      G_N_ELEMENTS (lsm_svg_pattern_element_attribute_infos),
+					      lsm_svg_pattern_element_attribute_infos);
+}
+
+G_DEFINE_TYPE (LsmSvgPatternElement, lsm_svg_pattern_element, LSM_TYPE_SVG_ELEMENT)

data/ext/mathematical/lsmsvgpatternelement.h

@@ -0,0 +1,69 @@
+/* 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_PATTERN_ELEMENT_H
+#define LSM_SVG_PATTERN_ELEMENT_H
+
+#include <lsmsvgtypes.h>
+#include <lsmsvgelement.h>
+
+G_BEGIN_DECLS
+
+#define LSM_TYPE_SVG_PATTERN_ELEMENT             (lsm_svg_pattern_element_get_type ())
+#define LSM_SVG_PATTERN_ELEMENT(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), LSM_TYPE_SVG_PATTERN_ELEMENT, LsmSvgPatternElement))
+#define LSM_SVG_PATTERN_ELEMENT_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), LSM_TYPE_SVG_PATTERN_ELEMENT, LsmSvgPatternElementClass))
+#define LSM_IS_SVG_PATTERN_ELEMENT(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LSM_TYPE_SVG_PATTERN_ELEMENT))
+#define LSM_IS_SVG_PATTERN_ELEMENT_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), LSM_TYPE_SVG_PATTERN_ELEMENT))
+#define LSM_SVG_PATTERN_ELEMENT_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS((obj), LSM_TYPE_SVG_PATTERN_ELEMENT, LsmSvgPatternElementClass))
+
+typedef struct _LsmSvgPatternElementClass LsmSvgPatternElementClass;
+
+struct _LsmSvgPatternElement {
+	LsmSvgElement element;
+
+	LsmSvgLengthAttribute		x;
+	LsmSvgLengthAttribute		y;
+	LsmSvgLengthAttribute		width;
+	LsmSvgLengthAttribute		height;
+	LsmSvgTransformAttribute 	transform;
+	LsmSvgPatternUnitsAttribute	units;
+	LsmSvgPatternUnitsAttribute	content_units;
+	LsmAttribute 			href;
+
+	LsmSvgViewboxAttribute	viewbox;
+	LsmSvgPreserveAspectRatioAttribute	preserve_aspect_ratio;
+
+	gboolean enable_rendering;
+};
+
+struct _LsmSvgPatternElementClass {
+	LsmSvgElementClass  element_class;
+};
+
+GType lsm_svg_pattern_element_get_type (void);
+
+LsmDomNode * 	lsm_svg_pattern_element_new 	(void);
+
+G_END_DECLS
+
+#endif