mathematical 1.6.17 → 1.6.20

data/ext/mathematical/lasem/src/lsmmathmlitexelement.c

@@ -0,0 +1,189 @@
+/* Lasem
+ *
+ * Copyright © 2010 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1335, USA.
+ *
+ * Author:
+ * 	Emmanuel Pacaud <emmanuel@gnome.org>
+ */
+
+#include <lsmmathmlitexelement.h>
+#include <lsmmathmlview.h>
+#include <lsmdomtext.h>
+#include <lsmdebug.h>
+#include <lsmmisc.h>
+
+static GObjectClass *parent_class;
+
+/* GdomNode implementation */
+
+static const char *
+lsm_mathml_itex_element_get_node_name (LsmDomNode *node)
+{
+	return "lasem:itex";
+}
+
+static gboolean
+lsm_mathml_itex_can_append_child (LsmDomNode *self, LsmDomNode *child)
+{
+	return (LSM_IS_DOM_TEXT (child));
+}
+
+/* LsmMathmlElement implementation */
+
+static void
+_update (LsmMathmlElement *self, LsmMathmlStyle *style)
+{
+	LsmMathmlItexElement *itex_element = LSM_MATHML_ITEX_ELEMENT (self);
+	LsmDomNode *node;
+	GString *string;
+	gboolean need_conversion;
+
+	if (style->display == LSM_MATHML_DISPLAY_INLINE)
+		string = g_string_new ("$");
+	else
+		string = g_string_new ("$$");
+
+	for (node = LSM_DOM_NODE (self)->first_child; node != NULL; node = node->next_sibling) {
+		if (LSM_IS_DOM_TEXT (node)) {
+			g_string_append (string, lsm_dom_node_get_node_value (node));
+		}
+	}
+
+	if (style->display == LSM_MATHML_DISPLAY_INLINE)
+		g_string_append (string, "$");
+	else
+		g_string_append (string, "$$");
+
+	need_conversion = g_strcmp0 (itex_element->itex, string->str) != 0;
+
+	lsm_debug_update ("[MathmlItex::update] itex = '%s'", itex_element->itex);
+
+	if (need_conversion) {
+		LsmMathmlDocument *document;
+		size_t length;
+
+		g_free (itex_element->itex);
+		length = string->len;
+		itex_element->itex = lsm_g_string_free_and_steal (string);
+
+		lsm_debug_update ("[MathmlItex::update] need conversion");
+
+		document = lsm_mathml_document_new_from_itex (itex_element->itex, length, NULL);
+		if (document != NULL) {
+			if (itex_element->math != NULL)
+				g_object_unref (lsm_dom_node_get_owner_document (LSM_DOM_NODE (itex_element->math)));
+
+			itex_element->math = LSM_MATHML_ELEMENT (lsm_mathml_document_get_root_element (document));
+		}
+	} else {
+		g_string_free (string, TRUE);
+	}
+
+	if (itex_element->math != NULL) {
+		lsm_dom_node_changed (LSM_DOM_NODE (itex_element->math));
+		self->need_measure = lsm_mathml_element_update (itex_element->math, style);
+	}
+}
+
+static const LsmMathmlBbox *
+_measure (LsmMathmlElement *self, LsmMathmlView *view, const LsmMathmlBbox *bbox)
+{
+	LsmMathmlItexElement *itex_element = LSM_MATHML_ITEX_ELEMENT (self);
+
+	if (itex_element->math != NULL)
+		return lsm_mathml_element_measure (itex_element->math, view, bbox);
+
+	self->bbox.width = 0.0;
+	self->bbox.height = 0.0;
+	self->bbox.depth = 0.0;
+
+	return &self->bbox;
+}
+
+static void
+_layout (LsmMathmlElement *self, LsmMathmlView *view,
+	 double x, double y, const LsmMathmlBbox *bbox)
+{
+	LsmMathmlItexElement *itex_element = LSM_MATHML_ITEX_ELEMENT (self);
+
+	if (itex_element->math != NULL)
+		lsm_mathml_element_layout (itex_element->math, view, x, y, bbox);
+}
+
+static void
+_render (LsmMathmlElement *self, LsmMathmlView *view)
+{
+	LsmMathmlItexElement *itex_element = LSM_MATHML_ITEX_ELEMENT (self);
+
+	if (itex_element->math != NULL)
+		lsm_mathml_element_render (itex_element->math, view);
+}
+
+/* LsmMathmlItexElement implementation */
+
+LsmDomNode *
+lsm_mathml_itex_element_new (void)
+{
+	return g_object_new (LSM_TYPE_MATHML_ITEX_ELEMENT, NULL);
+}
+
+static void
+lsm_mathml_itex_element_init (LsmMathmlItexElement *self)
+{
+	self->itex = NULL;
+	self->math = NULL;
+}
+
+static void
+lsm_mathml_itex_element_finalize (GObject *object)
+{
+	LsmMathmlItexElement *itex_element = LSM_MATHML_ITEX_ELEMENT (object);
+
+	g_free (itex_element->itex);
+	itex_element->itex = NULL;
+
+	if (itex_element->math != NULL)
+		g_object_unref (lsm_dom_node_get_owner_document (LSM_DOM_NODE (itex_element->math)));
+	itex_element->math = NULL;
+
+	parent_class->finalize (object);
+}
+
+/* LsmMathmlItexElement class */
+
+static void
+lsm_mathml_itex_element_class_init (LsmMathmlItexElementClass *itex_class)
+{
+	GObjectClass *object_class = G_OBJECT_CLASS (itex_class);
+	LsmDomNodeClass *d_node_class = LSM_DOM_NODE_CLASS (itex_class);
+	LsmMathmlElementClass *m_element_class = LSM_MATHML_ELEMENT_CLASS (itex_class);
+
+	parent_class = g_type_class_peek_parent (itex_class);
+
+	object_class->finalize = lsm_mathml_itex_element_finalize;
+
+	d_node_class->get_node_name = lsm_mathml_itex_element_get_node_name;
+	d_node_class->can_append_child = lsm_mathml_itex_can_append_child;
+
+	m_element_class->update = _update;
+	m_element_class->measure = _measure;
+	m_element_class->layout = _layout;
+	m_element_class->render = _render;
+}
+
+G_DEFINE_TYPE (LsmMathmlItexElement, lsm_mathml_itex_element, LSM_TYPE_MATHML_ELEMENT)

data/ext/mathematical/lasem/src/lsmmathmlitexelement.h

@@ -0,0 +1,60 @@
+/* Lasem
+ *
+ * Copyright © 2010  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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1335, USA.
+ *
+ * Author:
+ * 	Emmanuel Pacaud <emmanuel@gnome.org>
+ */
+
+#ifndef LSM_MATHML_ITEX_ELEMENT_H
+#define LSM_MATHML_ITEX_ELEMENT_H
+
+#include <lsmmathmltypes.h>
+#include <lsmmathmlelement.h>
+#include <lsmmathmldocument.h>
+
+G_BEGIN_DECLS
+
+#define LSM_TYPE_MATHML_ITEX_ELEMENT             (lsm_mathml_itex_element_get_type ())
+#define LSM_MATHML_ITEX_ELEMENT(obj)             (G_TYPE_CHECK_INSTANCE_CAST ((obj), LSM_TYPE_MATHML_ITEX_ELEMENT, LsmMathmlItexElement))
+#define LSM_MATHML_ITEX_ELEMENT_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST ((klass), LSM_TYPE_MATHML_ITEX_ELEMENT, LsmMathmlItexElementClass))
+#define LSM_IS_MATHML_ITEX_ELEMENT(obj)          (G_TYPE_CHECK_INSTANCE_TYPE ((obj), LSM_TYPE_MATHML_ITEX_ELEMENT))
+#define LSM_IS_MATHML_ITEX_ELEMENT_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE ((klass), LSM_TYPE_MATHML_ITEX_ELEMENT))
+#define LSM_MATHML_ITEX_ELEMENT_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS((obj), LSM_TYPE_MATHML_ITEX_ELEMENT, LsmMathmlItexElementClass))
+
+typedef struct _LsmMathmlItexElementClass LsmMathmlItexElementClass;
+
+struct _LsmMathmlItexElement {
+	LsmMathmlElement	element;
+
+	char *itex;
+
+	LsmMathmlElement *math;
+};
+
+struct _LsmMathmlItexElementClass {
+	LsmMathmlElementClass  parent_class;
+};
+
+GType lsm_mathml_itex_element_get_type (void);
+
+LsmDomNode *		lsm_mathml_itex_element_new 		(void);
+
+G_END_DECLS
+
+#endif

data/ext/mathematical/lasem/src/lsmmathmllayoututils.c

@@ -0,0 +1,191 @@
+/* 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1335, USA.
+ *
+ * Author:
+ * 	Emmanuel Pacaud <emmanuel@gnome.org>
+ */
+
+#include <lsmmathmllayoututils.h>
+#include <lsmmathmloperatorelement.h>
+#include <math.h>
+
+void
+lsm_mathml_measure_sub_sup (LsmMathmlElement *parent,
+			 LsmMathmlView *view,
+			 LsmMathmlElement *base,
+			 LsmMathmlElement *subscript,
+			 LsmMathmlElement *superscript,
+			 double subscript_offset_min,
+			 double superscript_offset_min,
+			 LsmMathmlDisplay display,
+			 const LsmMathmlBbox *stretch_bbox,
+			 LsmMathmlBbox *bbox,
+			 double *subscript_offset,
+			 double *superscript_offset)
+{
+	LsmMathmlBbox const *base_bbox = NULL;
+	LsmMathmlBbox const *subscript_bbox = NULL;
+	LsmMathmlBbox const *superscript_bbox = NULL;
+	LsmMathmlBbox children_bbox = lsm_mathml_bbox_null;
+	LsmMathmlOperatorElement *embellished_core;
+	double axis_offset, ascent, descent;
+	double v_space;
+	gboolean is_operator;
+
+	*bbox = lsm_mathml_bbox_null;
+
+	if (base == NULL)
+		return;
+
+	embellished_core = lsm_mathml_element_get_embellished_core (base);
+	is_operator = embellished_core != NULL;
+
+	/* TODO
+	double slant;
+	slant = is_operator ? lsm_mathml_operator_element_get_slant (embellished_core, view) : 0.0;
+	*/
+
+	axis_offset = lsm_mathml_view_measure_axis_offset (view, parent->style.math_size);
+	v_space = parent->style.math_size * LSM_MATHML_SPACE_EM_THIN;
+	lsm_mathml_view_get_font_metrics (view, &parent->style, &ascent, &descent);
+
+	if (display == LSM_MATHML_DISPLAY_INLINE)
+		descent /= 2.0;
+
+	base_bbox = lsm_mathml_element_measure (LSM_MATHML_ELEMENT (base), view, stretch_bbox);
+
+	*bbox = *base_bbox;
+
+	subscript_bbox = subscript != NULL ? lsm_mathml_element_measure (subscript, view, NULL) : NULL;
+	superscript_bbox = superscript != NULL ? lsm_mathml_element_measure (superscript, view, NULL) : NULL;
+
+	if (subscript_bbox != NULL) {
+		if (is_operator) {
+			*subscript_offset = base_bbox->depth +
+				0.5 * lsm_mathml_view_measure_axis_offset (view, subscript->style.math_size);
+		} else {
+			*subscript_offset = descent;
+
+			if (base_bbox->depth > descent)
+				*subscript_offset += base_bbox->depth - descent;
+			if (subscript_bbox->height - *subscript_offset > axis_offset)
+				*subscript_offset = subscript_bbox->height - axis_offset;
+		}
+	} else
+		*subscript_offset = 0.0;
+
+	if (superscript_bbox != NULL) {
+		if (is_operator) {
+			*superscript_offset = base_bbox->height -
+				1.5 * lsm_mathml_view_measure_axis_offset (view, superscript->style.math_size);
+		} else {
+			if (display == LSM_MATHML_DISPLAY_INLINE)
+				*superscript_offset = axis_offset;
+			else {
+				double superscript_descent;
+
+				lsm_mathml_view_get_font_metrics (view, &superscript->style,
+							       NULL, &superscript_descent);
+				*superscript_offset = axis_offset + superscript_descent;
+			}
+
+			if (base_bbox->height > ascent)
+				*superscript_offset += base_bbox->height - ascent;
+			if (*superscript_offset - superscript_bbox->depth < axis_offset)
+				*superscript_offset = axis_offset + superscript_bbox->depth;
+		}
+	} else
+		*superscript_offset = 0.0;
+
+	if (superscript_bbox != NULL && subscript_bbox != NULL) {
+		double delta = (*superscript_offset + *subscript_offset) -
+			(superscript_bbox->depth + subscript_bbox->height);
+		if (delta < v_space) {
+			*superscript_offset += fabs (delta - v_space) * 0.5;
+			*subscript_offset   += fabs (delta - v_space) * 0.5;
+		}
+	}
+
+	*superscript_offset = MAX (*superscript_offset, superscript_offset_min);
+	*subscript_offset = MAX (*subscript_offset, subscript_offset_min);
+
+	if (subscript_bbox != NULL)
+		lsm_mathml_bbox_merge_vertically (&children_bbox, subscript_bbox, -*subscript_offset);
+	if (superscript_bbox != NULL)
+		lsm_mathml_bbox_merge_vertically (&children_bbox, superscript_bbox, *superscript_offset);
+
+	lsm_mathml_bbox_add_horizontally (bbox, &children_bbox);
+}
+
+void
+lsm_mathml_layout_sub_sup (LsmMathmlElement *parent,
+			LsmMathmlView *view,
+			double x,
+			double y,
+			LsmMathmlElement *base,
+			LsmMathmlElement *subscript,
+			LsmMathmlElement *superscript,
+			double subscript_offset,
+			double superscript_offset)
+{
+	const LsmMathmlBbox *base_bbox;
+	const LsmMathmlOperatorElement *embellished_core;
+	double slant;
+	double slant_offset;
+	gboolean is_operator;
+
+	if (base == NULL)
+		return;
+
+	embellished_core = lsm_mathml_element_get_embellished_core (base);
+	is_operator = embellished_core != NULL;
+
+	slant = is_operator ? lsm_mathml_operator_element_get_slant (embellished_core, view) : 0.0;
+
+	base_bbox = lsm_mathml_element_get_bbox (base);
+
+	lsm_mathml_element_layout (base, view, x, y, base_bbox);
+
+	if (subscript) {
+		const LsmMathmlBbox *subscript_bbox;
+
+		subscript_bbox = lsm_mathml_element_get_bbox (subscript);
+
+		slant_offset = slant < 0.0 ? (base_bbox->height + subscript_offset -
+					      subscript_bbox->height) * sin (slant) : 0.0;
+
+		lsm_mathml_element_layout (subscript, view,
+					x + base_bbox->width + slant_offset,
+					y + subscript_offset,
+					lsm_mathml_element_get_bbox (subscript));
+	}
+	if (superscript) {
+		const LsmMathmlBbox *superscript_bbox;
+
+		superscript_bbox = lsm_mathml_element_get_bbox (superscript);
+
+		slant_offset = slant > 0.0 ? (base_bbox->depth + superscript_offset -
+					      superscript_bbox->depth) * sin (-slant) : 0.0;
+
+		lsm_mathml_element_layout (superscript, view,
+					x + base_bbox->width,
+					y - superscript_offset,
+					lsm_mathml_element_get_bbox (superscript));
+	}
+}

data/ext/mathematical/lasem/src/lsmmathmllayoututils.h

@@ -0,0 +1,58 @@
+/* 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1335, USA.
+ *
+ * Author:
+ * 	Emmanuel Pacaud <emmanuel@gnome.org>
+ */
+
+#ifndef LSM_MATHML_LAYOUT_UTILS_H
+#define LSM_MATHML_LAYOUT_UTILS_H
+
+#include <lsmmathmltypes.h>
+#include <lsmmathmlview.h>
+
+G_BEGIN_DECLS
+
+void 		lsm_mathml_measure_sub_sup 	(LsmMathmlElement *parent,
+						 LsmMathmlView *view,
+						 LsmMathmlElement *base,
+						 LsmMathmlElement *subscript,
+						 LsmMathmlElement *superscript,
+						 double subscript_offset_min,
+						 double superscript_offset_min,
+						 LsmMathmlDisplay display,
+						 const LsmMathmlBbox *stretch_bbox,
+						 LsmMathmlBbox *bbox,
+						 double *subscript_offset,
+						 double *superscript_offset);
+
+void		lsm_mathml_layout_sub_sup 		(LsmMathmlElement *parent,
+						 LsmMathmlView *view,
+						 double x,
+						 double y,
+						 LsmMathmlElement *base,
+						 LsmMathmlElement *subscript,
+						 LsmMathmlElement *superscript,
+						 double subscript_offset,
+						 double superscript_offset);
+
+G_END_DECLS
+
+#endif
+

data/ext/mathematical/lasem/src/lsmmathmlmathelement.c

@@ -0,0 +1,212 @@
+/* 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., 51 Franklin Street, Fifth Floor,
+ * Boston, MA 02110-1335, USA.
+ *
+ * Author:
+ * 	Emmanuel Pacaud <emmanuel@gnome.org>
+ */
+
+#include <lsmmathmlmathelement.h>
+#include <lsmmathmlstyleelement.h>
+#include <lsmmathmlview.h>
+
+static GObjectClass *parent_class;
+
+/* GdomNode implementation */
+
+static const char *
+lsm_mathml_math_element_get_node_name (LsmDomNode *node)
+{
+	return "math";
+}
+
+/* LsmMathmlElement implementation */
+
+static void
+_update (LsmMathmlElement *self, LsmMathmlStyle *style)
+{
+	LsmMathmlMathElement *math_element = LSM_MATHML_MATH_ELEMENT (self);
+	LsmMathmlMode default_mode;
+
+	default_mode = lsm_mathml_enum_attribute_inherit (&math_element->mode,
+							  (style->display == LSM_MATHML_DISPLAY_INLINE) ?
+							  LSM_MATHML_MODE_INLINE : LSM_MATHML_MODE_DISPLAY);
+
+	style->display = lsm_mathml_enum_attribute_inherit (&math_element->display,
+							    (default_mode == LSM_MATHML_MODE_INLINE) ?
+							    LSM_MATHML_DISPLAY_INLINE : LSM_MATHML_DISPLAY_BLOCK);
+}
+
+/* LsmMathmlMathElement implementation */
+
+LsmMathmlStyle *
+lsm_mathml_math_element_get_default_style (LsmMathmlMathElement *math_element)
+{
+	g_return_val_if_fail (LSM_IS_MATHML_MATH_ELEMENT (math_element), NULL);
+
+	return math_element->default_style;
+}
+
+void
+lsm_mathml_math_element_set_default_style (LsmMathmlMathElement *math_element, LsmMathmlStyle *style)
+{
+	g_return_if_fail (LSM_IS_MATHML_MATH_ELEMENT (math_element));
+	g_return_if_fail (style != NULL);
+
+	if (style == math_element->default_style) {
+		lsm_dom_node_changed (LSM_DOM_NODE (math_element));
+		return;
+	}
+
+	lsm_mathml_style_free (math_element->default_style);
+	math_element->default_style = lsm_mathml_style_duplicate (style);
+
+	lsm_dom_node_changed (LSM_DOM_NODE (math_element));
+}
+
+void
+lsm_mathml_math_element_update (LsmMathmlMathElement *math_element)
+{
+	lsm_mathml_element_update (LSM_MATHML_ELEMENT (math_element),
+				   lsm_mathml_math_element_get_default_style (math_element));
+}
+
+const LsmMathmlBbox *
+lsm_mathml_math_element_measure (LsmMathmlMathElement *math_element,
+			      LsmMathmlView *view)
+{
+	return lsm_mathml_element_measure (LSM_MATHML_ELEMENT (math_element), view, NULL);
+}
+
+void
+lsm_mathml_math_element_layout (LsmMathmlMathElement *math_element,
+			     LsmMathmlView *view,
+			     const LsmMathmlBbox *bbox)
+{
+	lsm_mathml_element_layout (LSM_MATHML_ELEMENT (math_element), view, 0, 0, bbox);
+}
+
+void
+lsm_mathml_math_element_render (LsmMathmlMathElement *math_element, LsmMathmlView *view)
+{
+	lsm_mathml_element_render (LSM_MATHML_ELEMENT (math_element), view);
+}
+
+LsmDomNode *
+lsm_mathml_math_element_new (void)
+{
+	return g_object_new (LSM_TYPE_MATHML_MATH_ELEMENT, NULL);
+}
+
+static void
+lsm_mathml_math_element_init (LsmMathmlMathElement *self)
+{
+	LsmMathmlStyle *style;
+
+	style = lsm_mathml_style_new ();
+	self->default_style = style;
+	g_return_if_fail (style != NULL);
+
+	style->math_size = 12.0;
+
+	style->display = LSM_MATHML_DISPLAY_INLINE;
+
+	style->script_level = 0;
+	style->script_size_multiplier = 0.71;
+	style->script_min_size = 8.0;
+
+	style->negative_very_very_thin_math_space = 	LSM_MATHML_SPACE_EM_NEGATIVE_VERY_VERY_THIN * style->math_size;
+	style->negative_very_thin_math_space = 		LSM_MATHML_SPACE_EM_NEGATIVE_VERY_THIN * style->math_size;
+	style->negative_thin_math_space = 		LSM_MATHML_SPACE_EM_NEGATIVE_THIN * style->math_size;
+	style->negative_medium_math_space = 		LSM_MATHML_SPACE_EM_NEGATIVE_MEDIUM * style->math_size;
+	style->negative_thick_math_space = 		LSM_MATHML_SPACE_EM_NEGATIVE_THICK * style->math_size;
+	style->negative_very_thick_math_space = 		LSM_MATHML_SPACE_EM_NEGATIVE_VERY_THICK * style->math_size;
+	style->negative_very_very_thick_math_space = 	LSM_MATHML_SPACE_EM_NEGATIVE_VERY_VERY_THICK * style->math_size;
+
+	style->very_very_thin_math_space = 	LSM_MATHML_SPACE_EM_VERY_VERY_THIN * style->math_size;
+	style->very_thin_math_space = 		LSM_MATHML_SPACE_EM_VERY_THIN * style->math_size;
+	style->thin_math_space = 		LSM_MATHML_SPACE_EM_THIN * style->math_size;
+	style->medium_math_space = 		LSM_MATHML_SPACE_EM_MEDIUM * style->math_size;
+	style->thick_math_space = 		LSM_MATHML_SPACE_EM_THICK * style->math_size;
+	style->very_thick_math_space = 		LSM_MATHML_SPACE_EM_VERY_THICK * style->math_size;
+	style->very_very_thick_math_space = 	LSM_MATHML_SPACE_EM_VERY_VERY_THICK * style->math_size;
+
+	style->math_family = g_strdup ("Serif");
+	style->math_variant = LSM_MATHML_VARIANT_NORMAL;
+	style->math_color.red = 0;
+	style->math_color.green = 0;
+	style->math_color.blue = 0;
+	style->math_color.alpha = 1;
+	style->math_background.red = 0;
+	style->math_background.green = 0;
+	style->math_background.blue = 0;
+	style->math_background.alpha = 0;
+
+	style->subscript_shift = 0;
+	style->superscript_shift = 0;
+
+	style->line_thickness = 0.1 * style->math_size;
+}
+
+static void
+lsm_mathml_math_element_finalize (GObject *object)
+{
+	LsmMathmlMathElement *math_element = LSM_MATHML_MATH_ELEMENT (object);
+
+	lsm_mathml_style_free (math_element->default_style);
+
+	parent_class->finalize (object);
+}
+
+/* LsmMathmlMathElement class */
+
+static const LsmAttributeInfos _attribute_infos[] = {
+	{
+		.name = "display",
+		.attribute_offset = offsetof (LsmMathmlMathElement, display),
+		.trait_class = &lsm_mathml_display_trait_class,
+	},
+	{
+		.name = "mode",
+		.attribute_offset = offsetof (LsmMathmlMathElement, mode),
+		.trait_class = &lsm_mathml_mode_trait_class,
+	}
+};
+
+static void
+lsm_mathml_math_element_class_init (LsmMathmlMathElementClass *math_class)
+{
+	GObjectClass *object_class = G_OBJECT_CLASS (math_class);
+	LsmDomNodeClass *d_node_class = LSM_DOM_NODE_CLASS (math_class);
+	LsmMathmlElementClass *m_element_class = LSM_MATHML_ELEMENT_CLASS (math_class);
+
+	parent_class = g_type_class_peek_parent (math_class);
+
+	object_class->finalize = lsm_mathml_math_element_finalize;
+
+	d_node_class->get_node_name = lsm_mathml_math_element_get_node_name;
+
+	m_element_class->update = _update;
+	m_element_class->attribute_manager = lsm_attribute_manager_duplicate (m_element_class->attribute_manager);
+
+	lsm_attribute_manager_add_attributes (m_element_class->attribute_manager,
+					      G_N_ELEMENTS (_attribute_infos),
+					      _attribute_infos);
+}
+
+G_DEFINE_TYPE (LsmMathmlMathElement, lsm_mathml_math_element, LSM_TYPE_MATHML_ELEMENT)