mathematical 0.1.0 → 0.1.1

data/ext/mathematical/lsmmathmltableelement.h

@@ -0,0 +1,78 @@
+/* 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_MATHML_TABLE_ELEMENT_H
+#define LSM_MATHML_TABLE_ELEMENT_H
+
+#include <lsmmathmltypes.h>
+#include <lsmmathmlelement.h>
+
+G_BEGIN_DECLS
+
+#define LSM_TYPE_MATHML_TABLE_ELEMENT             (lsm_mathml_table_element_get_type ())
+#define LSM_MATHML_TABLE_ELEMENT(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), LSM_TYPE_MATHML_TABLE_ELEMENT, LsmMathmlTableElement))
+#define LSM_MATHML_TABLE_ELEMENT_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), LSM_TYPE_MATHML_TABLE_ELEMENT, LsmMathmlTableElementClass))
+#define LSM_IS_MATHML_TABLE_ELEMENT(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LSM_TYPE_MATHML_TABLE_ELEMENT))
+#define LSM_IS_MATHML_TABLE_ELEMENT_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), LSM_TYPE_MATHML_TABLE_ELEMENT))
+#define LSM_MATHML_TABLE_ELEMENT_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS((obj), LSM_TYPE_MATHML_TABLE_ELEMENT, LsmMathmlTableElementClass))
+
+typedef struct _LsmMathmlTableElementClass LsmMathmlTableElementClass;
+
+struct _LsmMathmlTableElement {
+	LsmMathmlElement	element;
+
+	LsmMathmlEnumListAttribute row_align;
+	LsmMathmlEnumListAttribute column_align;
+	LsmMathmlSpaceListAttribute row_spacing;
+	LsmMathmlSpaceListAttribute column_spacing;
+	LsmMathmlEnumListAttribute row_lines;
+	LsmMathmlEnumListAttribute column_lines;
+	LsmMathmlEnumAttribute frame;
+	LsmMathmlSpaceListAttribute frame_spacing;
+
+	LsmMathmlBooleanAttribute equal_rows;
+	LsmMathmlBooleanAttribute equal_columns;
+	LsmMathmlBooleanAttribute display_style;
+
+	/* View data */
+
+	unsigned int n_columns;
+	unsigned int n_rows;
+	double *widths;
+	double *heights;
+	double *depths;
+	double line_width;
+};
+
+struct _LsmMathmlTableElementClass {
+	LsmMathmlElementClass  parent_class;
+};
+
+GType lsm_mathml_table_element_get_type (void);
+
+LsmDomNode * 	lsm_mathml_table_element_new 	(void);
+
+G_END_DECLS
+
+#endif
+

data/ext/mathematical/lsmmathmltablerowelement.c

@@ -0,0 +1,120 @@
+/* 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>
+ */
+
+#include <lsmmathmltablerowelement.h>
+#include <lsmmathmltablecellelement.h>
+
+static GObjectClass *parent_class;
+
+/* GdomNode implementation */
+
+static const char *
+lsm_mathml_table_row_get_node_name (LsmDomNode *node)
+{
+	LsmMathmlTableRowElement *row = LSM_MATHML_TABLE_ROW_ELEMENT (node);
+
+	switch (row->type) {
+		case LSM_MATHML_TABLE_ROW_ELEMENT_TYPE_LABELED_ROW:
+			return "mtr";
+			break;
+		default:
+			return "mlabeledtr";
+			break;
+	}
+}
+
+static gboolean
+lsm_mathml_table_row_can_append_child (LsmDomNode *self, LsmDomNode *child)
+{
+	return LSM_IS_MATHML_ELEMENT (child);
+}
+
+/* LsmMathmlElement implementation */
+
+static const LsmMathmlBbox *
+lsm_mathml_table_row_element_measure (LsmMathmlElement *self, LsmMathmlView *view, const LsmMathmlBbox *bbox)
+{
+	LSM_MATHML_ELEMENT_CLASS (parent_class)->measure (self, view, bbox);
+
+	return &self->bbox;
+}
+
+static void
+lsm_mathml_table_row_element_layout (LsmMathmlElement *self, LsmMathmlView *view,
+				double x, double y, const LsmMathmlBbox *bbox)
+{
+	LSM_MATHML_ELEMENT_CLASS (parent_class)->layout (self, view, x, y, bbox);
+}
+
+/* LsmMathmlTableRowElement implementation */
+
+LsmDomNode *
+lsm_mathml_table_row_element_new (void)
+{
+	LsmDomNode *node;
+
+	node = g_object_new (LSM_TYPE_MATHML_TABLE_ROW_ELEMENT, NULL);
+	g_return_val_if_fail (node != NULL, NULL);
+
+	LSM_MATHML_TABLE_ROW_ELEMENT (node)->type = LSM_MATHML_TABLE_ROW_ELEMENT_TYPE_ROW;
+
+	return node;
+}
+
+LsmDomNode *
+lsm_mathml_labeled_table_row_element_new (void)
+{
+	LsmDomNode *node;
+
+	node = g_object_new (LSM_TYPE_MATHML_TABLE_ROW_ELEMENT, NULL);
+	g_return_val_if_fail (node != NULL, NULL);
+
+	LSM_MATHML_TABLE_ROW_ELEMENT (node)->type = LSM_MATHML_TABLE_ROW_ELEMENT_TYPE_LABELED_ROW;
+
+	return node;
+}
+
+static void
+lsm_mathml_table_row_element_init (LsmMathmlTableRowElement *self)
+{
+}
+
+/* LsmMathmlTableRowElement class */
+
+static void
+lsm_mathml_table_row_element_class_init (LsmMathmlTableRowElementClass *table_row_class)
+{
+	LsmDomNodeClass *d_node_class = LSM_DOM_NODE_CLASS (table_row_class);
+	LsmMathmlElementClass *m_element_class = LSM_MATHML_ELEMENT_CLASS (table_row_class);
+
+	parent_class = g_type_class_peek_parent (table_row_class);
+
+	d_node_class->get_node_name = lsm_mathml_table_row_get_node_name;
+	d_node_class->can_append_child = lsm_mathml_table_row_can_append_child;
+
+	m_element_class->measure = lsm_mathml_table_row_element_measure;
+	m_element_class->layout = lsm_mathml_table_row_element_layout;
+	m_element_class->is_inferred_row = NULL;
+}
+
+G_DEFINE_TYPE (LsmMathmlTableRowElement, lsm_mathml_table_row_element, LSM_TYPE_MATHML_ELEMENT)

data/ext/mathematical/lsmmathmltablerowelement.h

@@ -0,0 +1,64 @@
+/* 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_MATHML_TABLE_ROW_ELEMENT_H
+#define LSM_MATHML_TABLE_ROW_ELEMENT_H
+
+#include <lsmmathmltypes.h>
+#include <lsmmathmlelement.h>
+
+G_BEGIN_DECLS
+
+typedef enum {
+	LSM_MATHML_TABLE_ROW_ELEMENT_TYPE_ROW,
+	LSM_MATHML_TABLE_ROW_ELEMENT_TYPE_LABELED_ROW
+} LsmMathmlTableRowElementType;
+
+#define LSM_TYPE_MATHML_TABLE_ROW_ELEMENT             (lsm_mathml_table_row_element_get_type ())
+#define LSM_MATHML_TABLE_ROW_ELEMENT(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), LSM_TYPE_MATHML_TABLE_ROW_ELEMENT, LsmMathmlTableRowElement))
+#define LSM_MATHML_TABLE_ROW_ELEMENT_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), LSM_TYPE_MATHML_TABLE_ROW_ELEMENT, LsmMathmlTableRowElementClass))
+#define LSM_IS_MATHML_TABLE_ROW_ELEMENT(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LSM_TYPE_MATHML_TABLE_ROW_ELEMENT))
+#define LSM_IS_MATHML_TABLE_ROW_ELEMENT_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), LSM_TYPE_MATHML_TABLE_ROW_ELEMENT))
+#define LSM_MATHML_TABLE_ROW_ELEMENT_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS((obj), LSM_TYPE_MATHML_TABLE_ROW_ELEMENT, LsmMathmlTableRowElementClass))
+
+typedef struct _LsmMathmlTableRowElementClass LsmMathmlTableRowElementClass;
+
+struct _LsmMathmlTableRowElement {
+	LsmMathmlElement	element;
+
+	LsmMathmlTableRowElementType type;
+};
+
+struct _LsmMathmlTableRowElementClass {
+	LsmMathmlElementClass  parent_class;
+};
+
+GType lsm_mathml_table_row_element_get_type (void);
+
+LsmDomNode * 	lsm_mathml_table_row_element_new 		(void);
+LsmDomNode * 	lsm_mathml_labeled_table_row_element_new	(void);
+
+G_END_DECLS
+
+#endif
+

data/ext/mathematical/lsmmathmltraits.c

@@ -0,0 +1,819 @@
+/* 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 <pango/pango-attributes.h>
+#include <lsmmathmltraits.h>
+#include <math.h>
+#include <string.h>
+#include <stdlib.h>
+
+static gboolean
+lsm_mathml_boolean_trait_from_string (LsmTrait *abstract_trait, char *string)
+{
+	gboolean *value = (gboolean *) abstract_trait;
+
+	if (g_strcmp0 (string, "true") == 0) {
+		*value = TRUE;
+		return TRUE;
+	} else if (g_strcmp0 (string, "false") == 0) {
+		*value = FALSE;
+		return TRUE;
+	}
+
+	*value = FALSE;
+	return FALSE;
+}
+
+static char *
+lsm_mathml_boolean_trait_to_string (LsmTrait *abstract_trait)
+{
+	gboolean *value = (gboolean *) abstract_trait;
+
+	return g_strdup_printf ("%s", *value ? "true" : "false");
+}
+
+const LsmTraitClass lsm_mathml_boolean_trait_class = {
+	.size = sizeof (gboolean),
+	.from_string = lsm_mathml_boolean_trait_from_string,
+	.to_string = lsm_mathml_boolean_trait_to_string
+};
+
+static gboolean
+lsm_mathml_unsigned_trait_from_string (LsmTrait *abstract_trait, char *string)
+{
+	unsigned int *value = (unsigned int *) abstract_trait;
+	char *end_ptr;
+
+	*value = strtol (string, &end_ptr, 10);
+
+	return end_ptr != string;
+}
+
+static char *
+lsm_mathml_unsigned_trait_to_string (LsmTrait *abstract_trait)
+{
+	unsigned int *value = (unsigned int *) abstract_trait;
+
+	return g_strdup_printf ("%u", *value);
+}
+
+const LsmTraitClass lsm_mathml_unsigned_trait_class = {
+	.size = sizeof (unsigned),
+	.from_string = lsm_mathml_unsigned_trait_from_string,
+	.to_string = lsm_mathml_unsigned_trait_to_string
+};
+
+static gboolean
+lsm_mathml_display_trait_from_string (LsmTrait *abstract_trait, char *string)
+{
+	LsmMathmlDisplay *value = (LsmMathmlDisplay *) abstract_trait;
+
+	*value = lsm_mathml_display_from_string (string);
+
+	return *value >= 0;
+}
+
+static char *
+lsm_mathml_display_trait_to_string (LsmTrait *abstract_trait)
+{
+	LsmMathmlDisplay *value = (LsmMathmlDisplay *) abstract_trait;
+
+	return g_strdup (lsm_mathml_display_to_string (*value));
+}
+
+const LsmTraitClass lsm_mathml_display_trait_class = {
+	.size = sizeof (int),
+	.from_string = lsm_mathml_display_trait_from_string,
+	.to_string = lsm_mathml_display_trait_to_string
+};
+
+static gboolean
+lsm_mathml_mode_trait_from_string (LsmTrait *abstract_trait, char *string)
+{
+	LsmMathmlMode *value = (LsmMathmlMode *) abstract_trait;
+
+	*value = lsm_mathml_mode_from_string (string);
+
+	return *value >= 0;
+}
+
+static char *
+lsm_mathml_mode_trait_to_string (LsmTrait *abstract_trait)
+{
+	LsmMathmlMode *value = (LsmMathmlMode *) abstract_trait;
+
+	return g_strdup (lsm_mathml_mode_to_string (*value));
+}
+
+const LsmTraitClass lsm_mathml_mode_trait_class = {
+	.size = sizeof (int),
+	.from_string = lsm_mathml_mode_trait_from_string,
+	.to_string = lsm_mathml_mode_trait_to_string
+};
+
+static gboolean
+lsm_mathml_line_trait_from_string (LsmTrait *abstract_trait, char *string)
+{
+	LsmMathmlLine *value = (LsmMathmlLine *) abstract_trait;
+
+	*value = lsm_mathml_line_from_string (string);
+
+	return *value >= 0;
+}
+
+static char *
+lsm_mathml_line_trait_to_string (LsmTrait *abstract_trait)
+{
+	LsmMathmlLine *value = (LsmMathmlLine *) abstract_trait;
+
+	return g_strdup (lsm_mathml_line_to_string (*value));
+}
+
+const LsmTraitClass lsm_mathml_line_trait_class = {
+	.size = sizeof (int),
+	.from_string = lsm_mathml_line_trait_from_string,
+	.to_string = lsm_mathml_line_trait_to_string
+};
+
+static gboolean
+lsm_mathml_font_style_trait_from_string (LsmTrait *abstract_trait, char *string)
+{
+	LsmMathmlFontStyle *value = (LsmMathmlFontStyle *) abstract_trait;
+
+	*value = lsm_mathml_font_style_from_string (string);
+
+	return *value >= 0;
+}
+
+static char *
+lsm_mathml_font_style_trait_to_string (LsmTrait *abstract_trait)
+{
+	LsmMathmlFontStyle *value = (LsmMathmlFontStyle *) abstract_trait;
+
+	return g_strdup (lsm_mathml_font_style_to_string (*value));
+}
+
+const LsmTraitClass lsm_mathml_font_style_trait_class = {
+	.size = sizeof (int),
+	.from_string = lsm_mathml_font_style_trait_from_string,
+	.to_string = lsm_mathml_font_style_trait_to_string
+};
+
+static gboolean
+lsm_mathml_font_weight_trait_from_string (LsmTrait *abstract_trait, char *string)
+{
+	LsmMathmlFontWeight *value = (LsmMathmlFontWeight *) abstract_trait;
+
+	*value = lsm_mathml_font_weight_from_string (string);
+
+	return *value >= 0;
+}
+
+static char *
+lsm_mathml_font_weight_trait_to_string (LsmTrait *abstract_trait)
+{
+	LsmMathmlFontWeight *value = (LsmMathmlFontWeight *) abstract_trait;
+
+	return g_strdup (lsm_mathml_font_weight_to_string (*value));
+}
+
+const LsmTraitClass lsm_mathml_font_weight_trait_class = {
+	.size = sizeof (int),
+	.from_string = lsm_mathml_font_weight_trait_from_string,
+	.to_string = lsm_mathml_font_weight_trait_to_string
+};
+
+static gboolean
+lsm_mathml_variant_trait_from_string (LsmTrait *abstract_trait, char *string)
+{
+	LsmMathmlVariant *value = (LsmMathmlVariant *) abstract_trait;
+
+	*value = lsm_mathml_variant_from_string (string);
+
+	return *value >= 0;
+}
+
+static char *
+lsm_mathml_variant_trait_to_string (LsmTrait *abstract_trait)
+{
+	LsmMathmlVariant *value = (LsmMathmlVariant *) abstract_trait;
+
+	return g_strdup (lsm_mathml_variant_to_string (*value));
+}
+
+const LsmTraitClass lsm_mathml_variant_trait_class = {
+	.size = sizeof (int),
+	.from_string = lsm_mathml_variant_trait_from_string,
+	.to_string = lsm_mathml_variant_trait_to_string
+};
+
+static gboolean
+lsm_mathml_form_trait_from_string (LsmTrait *abstract_trait, char *string)
+{
+	LsmMathmlForm *value = (LsmMathmlForm *) abstract_trait;
+
+	*value = lsm_mathml_form_from_string (string);
+
+	return *value >= 0;
+}
+
+static char *
+lsm_mathml_form_trait_to_string (LsmTrait *abstract_trait)
+{
+	LsmMathmlForm *value = (LsmMathmlForm *) abstract_trait;
+
+	return g_strdup (lsm_mathml_form_to_string (*value));
+}
+
+const LsmTraitClass lsm_mathml_form_trait_class = {
+	.size = sizeof (int),
+	.from_string = lsm_mathml_form_trait_from_string,
+	.to_string = lsm_mathml_form_trait_to_string
+};
+
+typedef int (*LsmMathmlEnumFromString) (const char *string);
+typedef char * (*LsmMathmlEnumToString) (unsigned int value);
+
+static gboolean
+lsm_mathml_enum_list_trait_from_string (LsmMathmlEnumList *enum_list,
+					LsmMathmlEnumFromString from_string,
+					char *string)
+{
+	char **items;
+	unsigned int i;
+	int enum_value;
+
+	g_free (enum_list->values);
+
+	items = g_strsplit_set (string, " ", -1);
+	enum_list->n_values = g_strv_length (items);
+
+	enum_list->values = g_new (int, enum_list->n_values);
+	for (i = 0; i < enum_list->n_values; i++) {
+		enum_value = from_string (items[i]);
+		if (enum_value < 0) {
+			g_free (enum_list->values);
+			enum_list->values = NULL;
+			enum_list->n_values = 0;
+			g_strfreev (items);
+
+			return FALSE;
+		}
+		enum_list->values[i] = enum_value;
+	}
+
+	g_strfreev (items);
+
+	return TRUE;
+}
+
+static char *
+lsm_mathml_enum_list_trait_to_string (LsmMathmlEnumList *enum_list,
+				      LsmMathmlEnumToString to_string)
+{
+	return g_strdup ("FIXME");
+}
+
+static void
+lsm_mathml_enum_list_trait_init (LsmTrait *abstract_trait,
+				 const LsmTrait *abstract_default)
+{
+	LsmMathmlEnumList *enum_list = (LsmMathmlEnumList *) abstract_trait;
+	LsmMathmlEnumList *enum_list_defaut = (LsmMathmlEnumList *) abstract_default;
+
+	enum_list->n_values = enum_list_defaut->n_values;
+	if (enum_list->n_values == 0)
+		enum_list->values = NULL;
+	else {
+		enum_list->values = g_new (int, enum_list->n_values);
+		memcpy (enum_list->values, enum_list_defaut->values, sizeof (int) * enum_list->n_values);
+	}
+}
+
+void
+lsm_mathml_enum_list_init (LsmMathmlEnumList *enum_list, const LsmMathmlEnumList *enum_list_default)
+{
+	g_return_if_fail (enum_list != NULL);
+	g_return_if_fail (enum_list_default != NULL);
+
+	lsm_mathml_enum_list_trait_init (enum_list, enum_list_default);
+}
+
+static void
+lsm_mathml_enum_list_trait_finalize (LsmTrait *abstract_trait)
+{
+	LsmMathmlEnumList *enum_list = (LsmMathmlEnumList *) abstract_trait;
+
+	g_free (enum_list->values);
+	enum_list->values = NULL;
+	enum_list->n_values = 0;
+}
+
+static gboolean
+lsm_mathml_row_align_list_trait_from_string (LsmTrait *abstract_trait,
+					     char *string)
+{
+	return lsm_mathml_enum_list_trait_from_string ((LsmMathmlEnumList *) abstract_trait,
+						       (LsmMathmlEnumFromString) lsm_mathml_row_align_from_string,
+						       string);
+}
+
+static char *
+lsm_mathml_row_align_list_trait_to_string (LsmTrait *abstract_trait)
+{
+	return lsm_mathml_enum_list_trait_to_string ((LsmMathmlEnumList *) abstract_trait,
+						     (LsmMathmlEnumToString) lsm_mathml_row_align_to_string);
+}
+
+const LsmTraitClass lsm_mathml_row_align_list_trait_class = {
+	.size = sizeof (LsmMathmlEnumList),
+	.from_string = lsm_mathml_row_align_list_trait_from_string,
+	.to_string = lsm_mathml_row_align_list_trait_to_string,
+	.init = lsm_mathml_enum_list_trait_init,
+	.finalize = lsm_mathml_enum_list_trait_finalize
+};
+
+static gboolean
+lsm_mathml_column_align_list_trait_from_string (LsmTrait *abstract_trait,
+					     char *string)
+{
+	return lsm_mathml_enum_list_trait_from_string ((LsmMathmlEnumList *) abstract_trait,
+						       (LsmMathmlEnumFromString) lsm_mathml_column_align_from_string,
+						       string);
+}
+
+static char *
+lsm_mathml_column_align_list_trait_to_string (LsmTrait *abstract_trait)
+{
+	return lsm_mathml_enum_list_trait_to_string ((LsmMathmlEnumList *) abstract_trait,
+						     (LsmMathmlEnumToString) lsm_mathml_column_align_to_string);
+}
+
+const LsmTraitClass lsm_mathml_column_align_list_trait_class = {
+	.size = sizeof (LsmMathmlEnumList),
+	.from_string = lsm_mathml_column_align_list_trait_from_string,
+	.to_string = lsm_mathml_column_align_list_trait_to_string,
+	.init = lsm_mathml_enum_list_trait_init,
+	.finalize = lsm_mathml_enum_list_trait_finalize
+};
+
+static gboolean
+lsm_mathml_line_list_trait_from_string (LsmTrait *abstract_trait,
+					     char *string)
+{
+	return lsm_mathml_enum_list_trait_from_string ((LsmMathmlEnumList *) abstract_trait,
+						       (LsmMathmlEnumFromString) lsm_mathml_line_from_string,
+						       string);
+}
+
+static char *
+lsm_mathml_line_list_trait_to_string (LsmTrait *abstract_trait)
+{
+	return lsm_mathml_enum_list_trait_to_string ((LsmMathmlEnumList *) abstract_trait,
+						     (LsmMathmlEnumToString) lsm_mathml_line_to_string);
+}
+
+const LsmTraitClass lsm_mathml_line_list_trait_class = {
+	.size = sizeof (LsmMathmlEnumList),
+	.from_string = lsm_mathml_line_list_trait_from_string,
+	.to_string = lsm_mathml_line_list_trait_to_string,
+	.init = lsm_mathml_enum_list_trait_init,
+	.finalize = lsm_mathml_enum_list_trait_finalize
+};
+
+static gboolean
+lsm_mathml_script_level_trait_from_string (LsmTrait *abstract_trait, char *string)
+{
+	LsmMathmlScriptLevel *value = (LsmMathmlScriptLevel *) abstract_trait;
+	char *end_ptr;
+
+	value->level = strtol (string, &end_ptr, 10);
+
+	if (string[0] == '+')
+		value->sign = LSM_MATHML_SCRIPT_LEVEL_SIGN_PLUS;
+	else if (string[0] == '-')
+		value->sign = LSM_MATHML_SCRIPT_LEVEL_SIGN_MINUS;
+	else
+		value->sign = LSM_MATHML_SCRIPT_LEVEL_SIGN_NONE;
+
+	return end_ptr != string;
+}
+
+static char *
+lsm_mathml_script_level_trait_to_string (LsmTrait *abstract_trait)
+{
+	LsmMathmlScriptLevel *value = (LsmMathmlScriptLevel *) abstract_trait;
+
+	if (value->sign == LSM_MATHML_SCRIPT_LEVEL_SIGN_PLUS)
+			return g_strdup_printf ("+%d", value->level);
+
+	return g_strdup_printf ("%d", value->level);
+}
+
+const LsmTraitClass lsm_mathml_script_level_trait_class = {
+	.size = sizeof (int),
+	.from_string = lsm_mathml_script_level_trait_from_string,
+	.to_string = lsm_mathml_script_level_trait_to_string
+};
+
+static gboolean
+lsm_mathml_double_trait_from_string (LsmTrait *abstract_trait, char *string)
+{
+	double *value = (double *) abstract_trait;
+	char *end_ptr;
+
+	*value = g_ascii_strtod (string, &end_ptr);
+
+	return end_ptr != string;
+}
+
+static char *
+lsm_mathml_double_trait_to_string (LsmTrait *abstract_trait)
+{
+	double *value = (double *) abstract_trait;
+
+	return g_strdup_printf ("%g", *value);
+}
+
+const LsmTraitClass lsm_mathml_double_trait_class = {
+	.size = sizeof (double),
+	.from_string = lsm_mathml_double_trait_from_string,
+	.to_string = lsm_mathml_double_trait_to_string
+};
+
+static LsmMathmlColor *
+lsm_mathml_color_copy (LsmMathmlColor *color)
+{
+	LsmMathmlColor *copy;
+
+	copy = g_new (LsmMathmlColor, 1);
+	memcpy (copy, color, sizeof (LsmMathmlColor));
+
+	return copy;
+}
+
+GType
+lsm_mathml_color_get_type (void)
+{
+	static GType our_type = 0;
+	if (our_type == 0)
+		our_type = g_boxed_type_register_static
+			("LsmMathmlColor",
+			 (GBoxedCopyFunc) lsm_mathml_color_copy,
+			 (GBoxedFreeFunc) g_free);
+	return our_type;
+}
+
+static gboolean
+lsm_mathml_color_trait_from_string (LsmTrait *abstract_trait, char *string)
+{
+	LsmMathmlColor *color = (LsmMathmlColor *) abstract_trait;
+	PangoColor pango_color;
+	gboolean result;
+
+	if (strcmp (string, "transparent") == 0) {
+		color->red = 0.0;
+		color->green = 0.0;
+		color->blue = 0.0;
+		color->alpha = 0.0;
+
+		return TRUE;
+	}
+
+	result = pango_color_parse (&pango_color, string);
+	color->alpha = 1.0;
+	color->red = pango_color.red / 65535.0;
+	color->green = pango_color.green / 65535.0;
+	color->blue = pango_color.blue / 65535.0;
+
+	return result;
+}
+
+static char *
+lsm_mathml_color_trait_to_string (LsmTrait *abstract_trait)
+{
+	LsmMathmlColor *color = (LsmMathmlColor *) abstract_trait;
+	PangoColor pango_color;
+
+	if (color->alpha <= 0.0)
+		return g_strdup ("transparent");
+
+	pango_color.red = ((int) ((double) 0.5 + 65535.0 * color->red));
+	pango_color.blue = ((int) ((double) 0.5 + 65535.0 * color->blue));
+	pango_color.green = ((int) ((double) 0.5 + 65535.0 * color->green));
+
+	return pango_color_to_string (&pango_color);
+}
+
+const LsmTraitClass lsm_mathml_color_trait_class = {
+	.size = sizeof (LsmMathmlColor),
+	.from_string = lsm_mathml_color_trait_from_string,
+	.to_string = lsm_mathml_color_trait_to_string
+};
+
+static gboolean
+lsm_mathml_string_trait_from_string (LsmTrait *abstract_trait, char *string)
+{
+	char **value = (char **) abstract_trait;
+
+	g_free (*value);
+	*value = g_strdup (string);
+
+	return TRUE;
+}
+
+static char *
+lsm_mathml_string_trait_to_string (LsmTrait *abstract_trait)
+{
+	char **value = (char **) abstract_trait;
+
+	return g_strdup (*value);
+}
+
+static void
+lsm_mathml_string_trait_init (LsmTrait *abstract_trait,
+			      const LsmTrait *abstract_default)
+{
+	char **value = (char **) abstract_trait;
+	char **default_value = (char **) abstract_default;
+
+	*value = g_strdup (*default_value);
+}
+
+static void
+lsm_mathml_string_trait_finalize (LsmTrait *abstract_trait)
+{
+	char **value = (char **) abstract_trait;
+
+	g_free (*value);
+	*value = NULL;
+}
+
+const LsmTraitClass lsm_mathml_string_trait_class = {
+	.size = sizeof (char *),
+	.from_string = lsm_mathml_string_trait_from_string,
+	.to_string = lsm_mathml_string_trait_to_string,
+	.init = lsm_mathml_string_trait_init,
+	.finalize = lsm_mathml_string_trait_finalize
+};
+
+static LsmMathmlLength *
+lsm_mathml_length_copy (LsmMathmlLength *length)
+{
+	LsmMathmlLength *copy;
+
+	copy = g_new (LsmMathmlLength, 1);
+	memcpy (copy, length, sizeof (LsmMathmlLength));
+
+	return copy;
+}
+
+GType
+lsm_mathml_length_get_type (void)
+{
+	static GType our_type = 0;
+
+	if (our_type == 0)
+		our_type = g_boxed_type_register_static
+			("LsmMathmlLength",
+			 (GBoxedCopyFunc) lsm_mathml_length_copy,
+			 (GBoxedFreeFunc) g_free);
+	return our_type;
+}
+
+static gboolean
+lsm_mathml_length_trait_from_string (LsmTrait *abstract_trait, char *string)
+{
+	LsmMathmlLength *length = (LsmMathmlLength *) abstract_trait;
+	char *unit_str;
+
+	length->value = g_ascii_strtod (string, &unit_str);
+	length->unit = lsm_mathml_unit_from_string (unit_str);
+
+	/* TODO Handle "big", "small", normal" sizes */
+
+	return unit_str != string && length->unit >= 0;
+}
+
+static char *
+lsm_mathml_length_trait_to_string (LsmTrait *abstract_trait)
+{
+	LsmMathmlLength *length = (LsmMathmlLength *) abstract_trait;
+
+	return g_strdup_printf ("%g %s", length->value,
+				lsm_mathml_unit_to_string (length->unit));
+}
+
+const LsmTraitClass lsm_mathml_length_trait_class = {
+	.size = sizeof (char *),
+	.from_string = lsm_mathml_length_trait_from_string,
+	.to_string = lsm_mathml_length_trait_to_string
+};
+
+double
+lsm_mathml_length_normalize (const LsmMathmlLength *length,
+			     double base,
+			     double font_size)
+{
+	double value;
+
+	g_return_val_if_fail (length != NULL, 0.0);
+
+	switch (length->unit) {
+		case LSM_MATHML_UNIT_PX:
+		case LSM_MATHML_UNIT_PT:
+			value = length->value;
+			break;
+		case LSM_MATHML_UNIT_PC:
+			value = length->value * 72.0 / 6.0;
+			break;
+		case LSM_MATHML_UNIT_CM:
+			value = length->value * 72.0 / 2.54;
+			break;
+		case LSM_MATHML_UNIT_MM:
+			value = length->value * 72.0 / 25.4;
+			break;
+		case LSM_MATHML_UNIT_IN:
+			value = length->value * 72.0;
+			break;
+		case LSM_MATHML_UNIT_EM:
+			value = length->value * font_size;
+			break;
+		case LSM_MATHML_UNIT_EX:
+			value = length->value * font_size * 0.5;
+			break;
+		case LSM_MATHML_UNIT_PERCENT:
+			value = length->value * base / 100.0;
+			break;
+		case LSM_MATHML_UNIT_NONE:
+			value = length->value * base;
+			break;
+		default:
+			value = 0;
+	}
+
+	return value;
+}
+
+static LsmMathmlSpace *
+lsm_mathml_space_copy (LsmMathmlSpace *space)
+{
+	LsmMathmlSpace *copy;
+
+	copy = g_new (LsmMathmlSpace, 1);
+	memcpy (copy, space, sizeof (LsmMathmlSpace));
+
+	return copy;
+}
+
+GType
+lsm_mathml_space_get_type (void)
+{
+	static GType our_type = 0;
+
+	if (our_type == 0)
+		our_type = g_boxed_type_register_static
+			("LsmMathmlSpace",
+			 (GBoxedCopyFunc) lsm_mathml_space_copy,
+			 (GBoxedFreeFunc) g_free);
+	return our_type;
+}
+
+static gboolean
+lsm_mathml_space_trait_from_string (LsmTrait *abstract_trait, char *string)
+{
+	LsmMathmlSpace *space = (LsmMathmlSpace *) abstract_trait;
+	char *unit_str;
+
+	space->name = lsm_mathml_space_name_from_string (string);
+
+	if (space->name < 0) {
+		space->length.value = g_ascii_strtod (string, &unit_str);
+		space->length.unit = lsm_mathml_unit_from_string (unit_str);
+
+		return unit_str != string && space->length.unit >= 0;
+	}
+
+	space->length.value = 0.0;
+	space->length.unit = LSM_MATHML_UNIT_PX;
+
+	return TRUE;
+}
+
+static char *
+lsm_mathml_space_trait_to_string (LsmTrait *abstract_trait)
+{
+	LsmMathmlSpace *space = (LsmMathmlSpace *) abstract_trait;
+	const char *string;
+
+	string = lsm_mathml_space_name_to_string (space->name);
+	if (string != NULL)
+		return g_strdup (string);
+
+	return g_strdup_printf ("%g %s", space->length.value,
+				lsm_mathml_unit_to_string (space->length.unit));
+}
+
+const LsmTraitClass lsm_mathml_space_trait_class = {
+	.size = sizeof (char *),
+	.from_string = lsm_mathml_space_trait_from_string,
+	.to_string = lsm_mathml_space_trait_to_string
+};
+
+static gboolean
+lsm_mathml_space_list_trait_from_string (LsmTrait *abstract_trait, char *string)
+{
+	LsmMathmlSpaceList *space_list = (LsmMathmlSpaceList *) abstract_trait;
+	char **items;
+	unsigned int i;
+
+	g_free (space_list->spaces);
+
+	items = g_strsplit_set (string, " ", -1);
+	space_list->n_spaces = g_strv_length (items);
+
+	space_list->spaces = g_new (LsmMathmlSpace, space_list->n_spaces);
+	for (i = 0; i < space_list->n_spaces; i++) {
+		if (!lsm_mathml_space_trait_from_string (&space_list->spaces[i], items[i])) {
+			g_free (space_list->spaces);
+			space_list->spaces = NULL;
+			space_list->n_spaces = 0;
+			g_strfreev (items);
+
+			return FALSE;
+		}
+	}
+
+	g_strfreev (items);
+
+	return TRUE;
+}
+
+static char *
+lsm_mathml_space_list_trait_to_string (LsmTrait *abstract_trait)
+{
+	return g_strdup ("FIXME");
+}
+
+static void
+lsm_mathml_space_list_trait_init (LsmTrait *abstract_trait,
+				  const LsmTrait *abstract_default)
+{
+	LsmMathmlSpaceList *space_list = (LsmMathmlSpaceList *) abstract_trait;
+	LsmMathmlSpaceList *space_list_defaut = (LsmMathmlSpaceList *) abstract_default;
+
+	space_list->n_spaces = space_list_defaut->n_spaces;
+	if (space_list->n_spaces == 0)
+		space_list->spaces = NULL;
+	else {
+		space_list->spaces = g_new (LsmMathmlSpace, space_list->n_spaces);
+		memcpy (space_list->spaces, space_list_defaut->spaces, sizeof (LsmMathmlSpace) * space_list->n_spaces);
+	}
+}
+
+static void
+lsm_mathml_space_list_trait_finalize (LsmTrait *abstract_trait)
+{
+	LsmMathmlSpaceList *space_list = (LsmMathmlSpaceList *) abstract_trait;
+
+	g_free (space_list->spaces);
+	space_list->spaces = NULL;
+	space_list->n_spaces = 0;
+}
+
+void
+lsm_mathml_space_list_init (LsmMathmlSpaceList *space_list, const LsmMathmlSpaceList *space_list_default)
+{
+	g_return_if_fail (space_list != NULL);
+	g_return_if_fail (space_list_default != NULL);
+
+	lsm_mathml_space_list_trait_init (space_list, space_list_default);
+}
+
+const LsmTraitClass lsm_mathml_space_list_trait_class = {
+	.size = sizeof (LsmMathmlSpaceList),
+	.from_string = lsm_mathml_space_list_trait_from_string,
+	.to_string = lsm_mathml_space_list_trait_to_string,
+	.init = lsm_mathml_space_list_trait_init,
+	.finalize = lsm_mathml_space_list_trait_finalize
+};