mathematical 0.1.0 → 0.1.1

data/ext/mathematical/lsmsvgelement.h

@@ -0,0 +1,81 @@
+/* Lasem
+ *
+ * Copyright © 2007-2008 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_ELEMENT_H
+#define LSM_SVG_ELEMENT_H
+
+#include <lsmsvgtypes.h>
+#include <lsmsvgattributes.h>
+#include <lsmsvgstyle.h>
+#include <lsmdom.h>
+#include <cairo.h>
+
+G_BEGIN_DECLS
+
+#define LSM_TYPE_SVG_ELEMENT             (lsm_svg_element_get_type ())
+#define LSM_SVG_ELEMENT(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), LSM_TYPE_SVG_ELEMENT, LsmSvgElement))
+#define LSM_SVG_ELEMENT_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), LSM_TYPE_SVG_ELEMENT, LsmSvgElementClass))
+#define LSM_IS_SVG_ELEMENT(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LSM_TYPE_SVG_ELEMENT))
+#define LSM_IS_SVG_ELEMENT_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), LSM_TYPE_SVG_ELEMENT))
+#define LSM_SVG_ELEMENT_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS((obj), LSM_TYPE_SVG_ELEMENT, LsmSvgElementClass))
+
+typedef struct _LsmSvgElementClass LsmSvgElementClass;
+
+struct _LsmSvgElement {
+	LsmDomElement	element;
+
+	LsmPropertyBag property_bag;
+
+	LsmAttribute			id;
+	LsmAttribute			class_name;
+};
+
+struct _LsmSvgElementClass {
+	LsmDomElementClass  parent_class;
+
+	LsmAttributeManager *attribute_manager;
+
+	LsmSvgElementCategory category;
+
+	void		(*enable_rendering)		(LsmSvgElement *element);
+	void 		(*render)			(LsmSvgElement *element, LsmSvgView *view);
+	void 		(*get_extents)			(LsmSvgElement *element, LsmSvgView *view, LsmExtents *extents);
+	void 		(*transformed_render)		(LsmSvgElement *element, LsmSvgView *view);
+	void 		(*transformed_get_extents)	(LsmSvgElement *element, LsmSvgView *view, LsmExtents *extents);
+
+	gboolean is_shape_element;
+};
+
+GType lsm_svg_element_get_type (void);
+
+LsmSvgElementCategory	lsm_svg_element_get_category	(LsmSvgElement *element);
+
+void 		lsm_svg_element_render 				(LsmSvgElement *element, LsmSvgView *view);
+void 		lsm_svg_element_render 				(LsmSvgElement *element, LsmSvgView *view);
+void 		lsm_svg_element_force_render 			(LsmSvgElement *element, LsmSvgView *view);
+void		lsm_svg_element_get_extents			(LsmSvgElement *element, LsmSvgView *view, LsmExtents *extents);
+void 		lsm_svg_element_transformed_get_extents 	(LsmSvgElement *element, LsmSvgView *view, LsmExtents *extents);
+
+G_END_DECLS
+
+#endif

data/ext/mathematical/lsmsvgellipseelement.c

@@ -0,0 +1,158 @@
+/* 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>
+ */
+
+#include <lsmsvgellipseelement.h>
+#include <lsmsvgview.h>
+
+static GObjectClass *parent_class;
+
+/* GdomNode implementation */
+
+static const char *
+lsm_svg_ellipse_element_get_node_name (LsmDomNode *node)
+{
+	return "ellipse";
+}
+
+/* LsmSvgElement implementation */
+
+/* LsmSvgGraphic implementation */
+
+static void
+_normalize_length (LsmSvgEllipseElement *ellipse, LsmSvgView *view, double *cx, double *cy, double *rx, double *ry)
+{
+	*cx = lsm_svg_view_normalize_length (view, &ellipse->cx.length, LSM_SVG_LENGTH_DIRECTION_HORIZONTAL);
+	*cy = lsm_svg_view_normalize_length (view, &ellipse->cy.length, LSM_SVG_LENGTH_DIRECTION_VERTICAL);
+	*rx = lsm_svg_view_normalize_length (view, &ellipse->rx.length, LSM_SVG_LENGTH_DIRECTION_HORIZONTAL);
+	*ry = lsm_svg_view_normalize_length (view, &ellipse->ry.length, LSM_SVG_LENGTH_DIRECTION_VERTICAL);
+}
+
+static void
+lsm_svg_ellipse_element_render (LsmSvgElement *self, LsmSvgView *view)
+{
+	LsmSvgEllipseElement *ellipse = LSM_SVG_ELLIPSE_ELEMENT (self);
+	double cx, cy, rx, ry;
+
+	_normalize_length (ellipse, view, &cx, &cy, &rx, &ry);
+
+	lsm_svg_view_show_ellipse (view, cx, cy, rx, ry);
+}
+
+static void
+lsm_svg_ellipse_element_get_extents (LsmSvgElement *self, LsmSvgView *view, LsmExtents *extents)
+{
+	LsmSvgEllipseElement *ellipse = LSM_SVG_ELLIPSE_ELEMENT (self);
+	double cx, cy, rx, ry;
+
+	_normalize_length (ellipse, view, &cx, &cy, &rx, &ry);
+
+	extents->x1 = cx - rx;
+	extents->y1 = cy - ry;
+	extents->x2 = cx + rx;
+	extents->y2 = cy + ry;
+}
+
+/* LsmSvgEllipseElement implementation */
+
+LsmDomNode *
+lsm_svg_ellipse_element_new (void)
+{
+	return g_object_new (LSM_TYPE_SVG_ELLIPSE_ELEMENT, NULL);
+}
+
+static const LsmSvgLength length_default = 	 { .value_unit =   0.0, .type = LSM_SVG_LENGTH_TYPE_PX};
+
+static void
+lsm_svg_ellipse_element_init (LsmSvgEllipseElement *self)
+{
+	self->cx.length = length_default;
+	self->cy.length = length_default;
+	self->rx.length = length_default;
+	self->ry.length = length_default;
+}
+
+static void
+lsm_svg_ellipse_element_finalize (GObject *object)
+{
+	parent_class->finalize (object);
+}
+
+/* LsmSvgEllipseElement class */
+
+static const LsmAttributeInfos lsm_svg_ellipse_element_attribute_infos[] = {
+	{
+		.name = "cx",
+		.attribute_offset = offsetof (LsmSvgEllipseElement, cx),
+		.trait_class = &lsm_svg_length_trait_class,
+		.trait_default = &length_default
+	},
+	{
+		.name = "cy",
+		.attribute_offset = offsetof (LsmSvgEllipseElement, cy),
+		.trait_class = &lsm_svg_length_trait_class,
+		.trait_default = &length_default
+	},
+	{
+		.name = "rx",
+		.attribute_offset = offsetof (LsmSvgEllipseElement, rx),
+		.trait_class = &lsm_svg_length_trait_class,
+		.trait_default = &length_default
+	},
+	{
+		.name = "ry",
+		.attribute_offset = offsetof (LsmSvgEllipseElement, ry),
+		.trait_class = &lsm_svg_length_trait_class,
+		.trait_default = &length_default
+	}
+};
+
+static void
+lsm_svg_ellipse_element_class_init (LsmSvgEllipseElementClass *s_rect_class)
+{
+	GObjectClass *object_class = G_OBJECT_CLASS (s_rect_class);
+	LsmDomNodeClass *d_node_class = LSM_DOM_NODE_CLASS (s_rect_class);
+	LsmSvgElementClass *s_element_class = LSM_SVG_ELEMENT_CLASS (s_rect_class);
+
+	parent_class = g_type_class_peek_parent (s_rect_class);
+
+	object_class->finalize = lsm_svg_ellipse_element_finalize;
+
+	d_node_class->get_node_name = lsm_svg_ellipse_element_get_node_name;
+
+	s_element_class->category =
+		LSM_SVG_ELEMENT_CATEGORY_GRAPHICS |
+		LSM_SVG_ELEMENT_CATEGORY_SHAPE |
+		LSM_SVG_ELEMENT_CATEGORY_BASIC_SHAPE;
+
+	s_element_class->render = lsm_svg_ellipse_element_render;
+	s_element_class->get_extents = lsm_svg_ellipse_element_get_extents;
+	s_element_class->attribute_manager = lsm_attribute_manager_duplicate (s_element_class->attribute_manager);
+
+	s_element_class->is_shape_element = TRUE;
+
+	lsm_attribute_manager_add_attributes (s_element_class->attribute_manager,
+					      G_N_ELEMENTS (lsm_svg_ellipse_element_attribute_infos),
+					      lsm_svg_ellipse_element_attribute_infos);
+}
+
+G_DEFINE_TYPE (LsmSvgEllipseElement, lsm_svg_ellipse_element, LSM_TYPE_SVG_TRANSFORMABLE)

data/ext/mathematical/lsmsvgellipseelement.h

@@ -0,0 +1,60 @@
+/* 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_ELLIPSE_ELEMENT_H
+#define LSM_SVG_ELLIPSE_ELEMENT_H
+
+#include <lsmsvgtypes.h>
+#include <lsmsvgtransformable.h>
+
+G_BEGIN_DECLS
+
+#define LSM_TYPE_SVG_ELLIPSE_ELEMENT             (lsm_svg_ellipse_element_get_type ())
+#define LSM_SVG_ELLIPSE_ELEMENT(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), LSM_TYPE_SVG_ELLIPSE_ELEMENT, LsmSvgEllipseElement))
+#define LSM_SVG_ELLIPSE_ELEMENT_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), LSM_TYPE_SVG_ELLIPSE_ELEMENT, LsmSvgEllipseElementClass))
+#define LSM_IS_SVG_ELLIPSE_ELEMENT(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LSM_TYPE_SVG_ELLIPSE_ELEMENT))
+#define LSM_IS_SVG_ELLIPSE_ELEMENT_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), LSM_TYPE_SVG_ELLIPSE_ELEMENT))
+#define LSM_SVG_ELLIPSE_ELEMENT_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS((obj), LSM_TYPE_SVG_ELLIPSE_ELEMENT, LsmSvgEllipseElementClass))
+
+typedef struct _LsmSvgEllipseElementClass LsmSvgEllipseElementClass;
+
+struct _LsmSvgEllipseElement {
+	LsmSvgTransformable base;
+
+	LsmSvgLengthAttribute	cx;
+	LsmSvgLengthAttribute	cy;
+	LsmSvgLengthAttribute	rx;
+	LsmSvgLengthAttribute	ry;
+};
+
+struct _LsmSvgEllipseElementClass {
+	LsmSvgTransformableClass  base_class;
+};
+
+GType lsm_svg_ellipse_element_get_type (void);
+
+LsmDomNode *		lsm_svg_ellipse_element_new 		(void);
+
+G_END_DECLS
+
+#endif

data/ext/mathematical/lsmsvgenums.c

@@ -0,0 +1,544 @@
+/* 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 <lsmsvgenums.h>
+#include <lsmtraits.h>
+#include <string.h>
+
+static const char *lsm_svg_blending_mode_strings[] = {
+	"normal",
+	"multiply",
+	"screen",
+	"darken",
+	"lighten",
+	"over",
+	"in",
+	"out",
+	"atop",
+	"xor"
+};
+
+const char *
+lsm_svg_blending_mode_to_string (LsmSvgBlendingMode blending_mode)
+{
+	if (blending_mode < 0 || blending_mode > LSM_SVG_BLENDING_MODE_XOR)
+		return NULL;
+
+	return lsm_svg_blending_mode_strings[blending_mode];
+}
+
+LsmSvgBlendingMode
+lsm_svg_blending_mode_from_string (const char *string)
+{
+	return lsm_enum_value_from_string (string, lsm_svg_blending_mode_strings,
+					   G_N_ELEMENTS (lsm_svg_blending_mode_strings));
+}
+
+static const char *lsm_svg_enable_background_strings[] = {
+	"accumulate",
+	"new"
+};
+
+const char *
+lsm_svg_enable_background_to_string (LsmSvgEnableBackground enable_background)
+{
+	if (enable_background < 0 || enable_background > LSM_SVG_ENABLE_BACKGROUND_NEW)
+		return NULL;
+
+	return lsm_svg_enable_background_strings[enable_background];
+}
+
+LsmSvgEnableBackground
+lsm_svg_enable_background_from_string (const char *string)
+{
+	return lsm_enum_value_from_string (string, lsm_svg_enable_background_strings,
+					   G_N_ELEMENTS (lsm_svg_enable_background_strings));
+}
+
+static const char *lsm_svg_length_type_strings[] = {
+	"",
+	"%",
+	"em",
+	"ex",
+	"px",
+	"cm",
+	"mm",
+	"in",
+	"pt",
+	"pc"
+};
+
+const char *
+lsm_svg_length_type_to_string (LsmSvgLengthType length_type)
+{
+	if (length_type < 0 || length_type > LSM_SVG_LENGTH_TYPE_PC)
+		return NULL;
+
+	return lsm_svg_length_type_strings[length_type];
+}
+
+LsmSvgLengthType
+lsm_svg_length_type_from_string (const char *string)
+{
+	return lsm_enum_value_from_string (string, lsm_svg_length_type_strings,
+					   G_N_ELEMENTS (lsm_svg_length_type_strings));
+}
+
+static const char *lsm_svg_fill_rule_strings[] = {
+	"nonzero",
+	"evenodd"
+};
+
+const char *
+lsm_svg_fill_rule_to_string (LsmSvgFillRule fill_rule)
+{
+	if (fill_rule < 0 || fill_rule > LSM_SVG_FILL_RULE_EVEN_ODD)
+		return NULL;
+
+	return lsm_svg_fill_rule_strings[fill_rule];
+}
+
+LsmSvgFillRule
+lsm_svg_fill_rule_from_string (const char *string)
+{
+	return lsm_enum_value_from_string (string, lsm_svg_fill_rule_strings,
+					   G_N_ELEMENTS (lsm_svg_fill_rule_strings));
+}
+
+static const char *lsm_svg_line_join_strings[] = {
+	"miter",
+	"round",
+	"bevel"
+};
+
+const char *
+lsm_svg_line_join_to_string (LsmSvgLineJoin line_join)
+{
+	if (line_join < 0 || line_join > LSM_SVG_LINE_JOIN_BEVEL)
+		return NULL;
+
+	return lsm_svg_line_join_strings[line_join];
+}
+
+LsmSvgLineJoin
+lsm_svg_line_join_from_string (const char *string)
+{
+	return lsm_enum_value_from_string (string, lsm_svg_line_join_strings,
+					   G_N_ELEMENTS (lsm_svg_line_join_strings));
+}
+
+static const char *lsm_svg_line_cap_strings[] = {
+	"butt",
+	"round",
+	"square"
+};
+
+const char *
+lsm_svg_line_cap_to_string (LsmSvgLineCap line_cap)
+{
+	if (line_cap < 0 || line_cap > LSM_SVG_LINE_CAP_SQUARE)
+		return NULL;
+
+	return lsm_svg_line_cap_strings[line_cap];
+}
+
+LsmSvgLineCap
+lsm_svg_line_cap_from_string (const char *string)
+{
+	return lsm_enum_value_from_string (string, lsm_svg_line_cap_strings,
+					   G_N_ELEMENTS (lsm_svg_line_cap_strings));
+}
+
+static const char *lsm_svg_overflow_strings[] = {
+	"visible",
+	"hidden",
+	"scroll",
+	"auto"
+};
+
+const char *
+lsm_svg_overflow_to_string (LsmSvgOverflow overflow)
+{
+	if (overflow < 0 || overflow > LSM_SVG_OVERFLOW_AUTO)
+		return NULL;
+
+	return lsm_svg_overflow_strings[overflow];
+}
+
+LsmSvgOverflow
+lsm_svg_overflow_from_string (const char *string)
+{
+	LsmSvgOverflow overflow = lsm_enum_value_from_string (string, lsm_svg_overflow_strings,
+							      G_N_ELEMENTS (lsm_svg_overflow_strings));
+
+	return overflow;
+}
+
+static const char *lsm_svg_pattern_units_strings[] = {
+	"userSpaceOnUse",
+	"objectBoundingBox"
+};
+
+const char *
+lsm_svg_pattern_units_to_string (LsmSvgPatternUnits units)
+{
+	if (units < 0 || units > LSM_SVG_PATTERN_UNITS_OBJECT_BOUNDING_BOX)
+		return NULL;
+
+	return lsm_svg_pattern_units_strings[units];
+}
+
+LsmSvgPatternUnits
+lsm_svg_pattern_units_from_string (const char *string)
+{
+	return lsm_enum_value_from_string (string, lsm_svg_pattern_units_strings,
+					   G_N_ELEMENTS (lsm_svg_pattern_units_strings));
+}
+
+static const char *lsm_svg_marker_units_strings[] = {
+	"strokeWidth",
+	"userSpaceOnUse"
+};
+
+const char *
+lsm_svg_marker_units_to_string (LsmSvgMarkerUnits units)
+{
+	if (units < 0 || units > LSM_SVG_MARKER_UNITS_STROKE_WIDTH)
+		return NULL;
+
+	return lsm_svg_marker_units_strings[units];
+}
+
+LsmSvgMarkerUnits
+lsm_svg_marker_units_from_string (const char *string)
+{
+	return lsm_enum_value_from_string (string, lsm_svg_marker_units_strings,
+					   G_N_ELEMENTS (lsm_svg_marker_units_strings));
+}
+
+static const char *lsm_svg_spread_method_strings[] = {
+	"pad",
+	"reflect",
+	"repeat"
+};
+
+const char *
+lsm_svg_spread_method_to_string (LsmSvgSpreadMethod units)
+{
+	if (units < 0 || units > LSM_SVG_SPREAD_METHOD_REPEAT)
+		return NULL;
+
+	return lsm_svg_spread_method_strings[units];
+}
+
+LsmSvgSpreadMethod
+lsm_svg_spread_method_from_string (const char *string)
+{
+	return lsm_enum_value_from_string (string, lsm_svg_spread_method_strings,
+					 G_N_ELEMENTS (lsm_svg_spread_method_strings));
+}
+
+static const char *lsm_svg_align_strings[] = {
+	"none",
+	"xMinYMin",
+	"xMidYMin",
+	"xMaxYMin",
+	"xMinYMid",
+	"xMidYMid",
+	"xMaxYMid",
+	"xMinYMax",
+	"xMidYMax",
+	"xMaxYMax"
+};
+
+const char *
+lsm_svg_align_to_string (LsmSvgAlign align)
+{
+	if (align < 0 || align > LSM_SVG_ALIGN_X_MAX_Y_MAX)
+		return NULL;
+
+	return lsm_svg_align_strings[align];
+}
+
+LsmSvgAlign
+lsm_svg_align_from_string (const char *string)
+{
+	return lsm_enum_value_from_string (string, lsm_svg_align_strings,
+					   G_N_ELEMENTS (lsm_svg_align_strings));
+}
+
+static const char *lsm_svg_meet_or_slice_strings[] = {
+	"meet",
+	"slice"
+};
+
+const char *
+lsm_svg_meet_or_slice_to_string (LsmSvgMeetOrSlice meet_or_slice)
+{
+	if (meet_or_slice < 0 || meet_or_slice > LSM_SVG_MEET_OR_SLICE_SLICE)
+		return NULL;
+
+	return lsm_svg_meet_or_slice_strings[meet_or_slice];
+}
+
+LsmSvgMeetOrSlice
+lsm_svg_meet_or_slice_from_string (const char *string)
+{
+	return lsm_enum_value_from_string (string, lsm_svg_meet_or_slice_strings,
+					  G_N_ELEMENTS (lsm_svg_meet_or_slice_strings));
+}
+
+static const char *lsm_svg_comp_op_strings[] = {
+	"clear",
+	"src",
+	"dst",
+	"src-over",
+	"dst-over",
+	"src-in",
+	"dst-in",
+	"src-out",
+	"dst-out",
+	"src-atop",
+	"dst-atop",
+	"xor",
+	"plus",
+	"multiply",
+	"screen",
+	"overlay",
+	"darken",
+	"lighten",
+	"color-dodge",
+	"color-burn",
+	"hard-light",
+	"soft-light",
+	"difference",
+	"exclusion"
+};
+
+const char *
+lsm_svg_comp_op_to_string (LsmSvgCompOp comp_op)
+{
+	if (comp_op < 0 || comp_op > LSM_SVG_COMP_OP_EXCLUSION)
+		return NULL;
+
+	return lsm_svg_comp_op_strings[comp_op];
+}
+
+LsmSvgCompOp
+lsm_svg_comp_op_from_string (const char *string)
+{
+	return lsm_enum_value_from_string (string, lsm_svg_comp_op_strings,
+					  G_N_ELEMENTS (lsm_svg_comp_op_strings));
+}
+
+static const char *lsm_svg_font_stretch_strings[] = {
+	"normal",
+	"ultra-condensed",
+	"extra-condensed",
+	"condensed",
+	"semi-condensed",
+	"semi-expanded",
+	"expanded",
+	"extra-expanded",
+	"ultra-expanded"
+};
+
+const char *
+lsm_svg_font_stretch_to_string (LsmSvgFontStretch font_stretch)
+{
+	if (font_stretch < 0 || font_stretch > LSM_SVG_FONT_STRETCH_ULTRA_EXPANDED)
+		return NULL;
+
+	return lsm_svg_font_stretch_strings[font_stretch];
+}
+
+LsmSvgFontStretch
+lsm_svg_font_stretch_from_string (const char *string)
+{
+	return lsm_enum_value_from_string (string, lsm_svg_font_stretch_strings,
+					  G_N_ELEMENTS (lsm_svg_font_stretch_strings));
+}
+
+static const char *lsm_svg_font_style_strings[] = {
+	"normal",
+	"oblique",
+	"italic"
+};
+
+const char *
+lsm_svg_font_style_to_string (LsmSvgFontStyle font_style)
+{
+	if (font_style < 0 || font_style > LSM_SVG_FONT_STYLE_ITALIC)
+		return NULL;
+
+	return lsm_svg_font_style_strings[font_style];
+}
+
+LsmSvgFontStyle
+lsm_svg_font_style_from_string (const char *string)
+{
+	return lsm_enum_value_from_string (string, lsm_svg_font_style_strings,
+					  G_N_ELEMENTS (lsm_svg_font_style_strings));
+}
+
+static const char *lsm_svg_font_weight_strings[] = {
+	"normal",
+	"bold"
+};
+
+const char *
+lsm_svg_font_weight_to_string (LsmSvgFontWeight font_weight)
+{
+	switch (font_weight) {
+		case LSM_SVG_FONT_WEIGHT_NORMAL:
+			return lsm_svg_font_weight_strings[0];
+		case LSM_SVG_FONT_WEIGHT_BOLD:
+			return lsm_svg_font_weight_strings[1];
+		default:
+			return NULL;
+	}
+}
+
+LsmSvgFontWeight
+lsm_svg_font_weight_from_string (const char *string)
+{
+	int index;
+
+	index = lsm_enum_value_from_string (string, lsm_svg_font_weight_strings,
+					   G_N_ELEMENTS (lsm_svg_font_weight_strings));
+
+	switch (index) {
+		case 0:
+			return LSM_SVG_FONT_WEIGHT_NORMAL;
+		case 1:
+			return LSM_SVG_FONT_WEIGHT_BOLD;
+		default:
+			return -1;
+	}
+}
+
+static const char *lsm_svg_text_anchor_strings[] = {
+	"start",
+	"middle",
+	"end"
+};
+
+const char *
+lsm_svg_text_anchor_to_string (LsmSvgTextAnchor text_anchor)
+{
+	if (text_anchor < 0 || text_anchor > LSM_SVG_TEXT_ANCHOR_MIDDLE)
+		return NULL;
+
+	return lsm_svg_text_anchor_strings[text_anchor];
+}
+
+LsmSvgTextAnchor
+lsm_svg_text_anchor_from_string (const char *string)
+{
+	return lsm_enum_value_from_string (string, lsm_svg_text_anchor_strings,
+					   G_N_ELEMENTS (lsm_svg_text_anchor_strings));
+}
+
+static const char *lsm_svg_display_strings[] = {
+	"none",
+	"inline",
+	"block",
+	"list-item",
+	"run-in",
+	"compact",
+	"marker",
+	"table",
+	"inline-table",
+	"table-row-group",
+	"table-header-group",
+	"table-footer-group",
+	"table-row",
+	"table-column-group",
+	"table-column",
+	"table-cell",
+	"table-caption",
+};
+
+const char *
+lsm_svg_display_to_string (LsmSvgDisplay display)
+{
+	if (display < 0 || display > LSM_SVG_DISPLAY_TABLE_CAPTION)
+		return NULL;
+
+	return lsm_svg_display_strings[display];
+}
+
+LsmSvgDisplay
+lsm_svg_display_from_string (const char *string)
+{
+	return lsm_enum_value_from_string (string, lsm_svg_display_strings,
+					   G_N_ELEMENTS (lsm_svg_display_strings));
+}
+
+static const char *lsm_svg_visibility_strings[] = {
+	"visible",
+	"hidden",
+	"collapse"
+};
+
+const char *
+lsm_svg_visibility_to_string (LsmSvgVisibility visibility)
+{
+	if (visibility < 0 || visibility > LSM_SVG_VISIBILITY_HIDDEN)
+		return NULL;
+
+	return lsm_svg_visibility_strings[visibility];
+}
+
+LsmSvgVisibility
+lsm_svg_visibility_from_string (const char *string)
+{
+	return lsm_enum_value_from_string (string, lsm_svg_visibility_strings,
+					   G_N_ELEMENTS (lsm_svg_visibility_strings));
+}
+
+static const char *lsm_svg_writing_mode_strings[] = {
+	"lr-tb",
+	"rl-tb",
+	"tb-rl",
+	"lr",
+	"rl",
+	"tb"
+};
+
+const char *
+lsm_svg_writing_mode_to_string (LsmSvgWritingMode writing_mode)
+{
+	if (writing_mode < 0 || writing_mode > LSM_SVG_WRITING_MODE_TB)
+		return NULL;
+
+	return lsm_svg_writing_mode_strings[writing_mode];
+}
+
+LsmSvgWritingMode
+lsm_svg_writing_mode_from_string (const char *string)
+{
+	return lsm_enum_value_from_string (string, lsm_svg_writing_mode_strings,
+					   G_N_ELEMENTS (lsm_svg_writing_mode_strings));
+}
+