mathematical 0.6.2 → 1.0.0

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

@@ -166,7 +166,7 @@ typedef enum {
 	LSM_MATHML_LINE_DASHED
 } LsmMathmlLine;
 
-const char *		lsm_mathml_line_to_string			(LsmMathmlLine line);
+const char *		lsm_mathml_line_to_string		(LsmMathmlLine line);
 LsmMathmlLine		lsm_mathml_line_from_string		(const char *string);
 
 typedef enum {
@@ -176,6 +176,30 @@ typedef enum {
 	LSM_MATHML_SCRIPT_LEVEL_SIGN_MINUS
 } LsmMathmlScriptLevelSign;
 
+typedef enum {
+	LSM_MATHML_NOTATION_ERROR = -1,
+	LSM_MATHML_NOTATION_LONGDIV,
+	LSM_MATHML_NOTATION_ACTUARIAL,
+	LSM_MATHML_NOTATION_RADICAL,
+	LSM_MATHML_NOTATION_BOX,
+	LSM_MATHML_NOTATION_ROUNDED_BOX,
+	LSM_MATHML_NOTATION_CIRCLE,
+	LSM_MATHML_NOTATION_LEFT,
+	LSM_MATHML_NOTATION_RIGHT,
+	LSM_MATHML_NOTATION_TOP,
+	LSM_MATHML_NOTATION_BOTTOM,
+	LSM_MATHML_NOTATION_UP_DIAGONAL_STRIKE,
+	LSM_MATHML_NOTATION_DOWN_DIAGONAL_STRIKE,
+	LSM_MATHML_NOTATION_VERTICAL_STRIKE,
+	LSM_MATHML_NOTATION_HORIZONTAL_STRIKE,
+	LSM_MATHML_NOTATION_MADRUWB,
+	LSM_MATHML_NOTATION_UP_DIAGONAL_ARROW,
+	LSM_MATHML_NOTATION_LAST
+} LsmMathmlNotation;
+
+const char *		lsm_mathml_notation_to_string		(LsmMathmlNotation notation);
+LsmMathmlNotation	lsm_mathml_notation_from_string		(const char *string);
+
 G_END_DECLS
 
 #endif

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

@@ -23,6 +23,8 @@
 
 #include <lsmmathmlpaddedelement.h>
 
+static GObjectClass *parent_class;
+
 /* LsmDomNode implementation */
 
 static const char *
@@ -31,6 +33,44 @@ lsm_mathml_padded_element_get_node_name (LsmDomNode *node)
 	return "mpadded";
 }
 
+/* LsmMathmlElement implementation */
+
+static const LsmMathmlLength length_default = {0.0, LSM_MATHML_UNIT_PT};
+
+static void
+_update (LsmMathmlElement *self, LsmMathmlStyle *style)
+{
+	LsmMathmlPaddedElement *padded = LSM_MATHML_PADDED_ELEMENT (self);
+
+	lsm_mathml_length_attribute_normalize (&padded->height, 0.0, &length_default, style);
+	lsm_mathml_length_attribute_normalize (&padded->depth, 0.0, &length_default, style);
+	lsm_mathml_length_attribute_normalize (&padded->width, 0.0, &length_default, style);
+	lsm_mathml_length_attribute_normalize (&padded->left_space, 0.0, &length_default, style);
+}
+
+static const LsmMathmlBbox *
+_measure (LsmMathmlElement *self, LsmMathmlView *view, const LsmMathmlBbox *bbox)
+{
+	LsmMathmlPaddedElement *padded = LSM_MATHML_PADDED_ELEMENT (self);
+
+	LSM_MATHML_ELEMENT_CLASS (parent_class)->measure (self, view, bbox);
+
+	self->bbox.height += padded->height.value;
+	self->bbox.depth += padded->depth.value;
+	self->bbox.width += padded->width.value + padded->left_space.value;
+
+	return &self->bbox;
+}
+
+static void
+_layout (LsmMathmlElement *self, LsmMathmlView *view,
+	 double x, double y, const LsmMathmlBbox *bbox)
+{
+	LsmMathmlPaddedElement *padded = LSM_MATHML_PADDED_ELEMENT (self);
+
+	LSM_MATHML_ELEMENT_CLASS (parent_class)->layout (self, view, x + padded->left_space.value, y, bbox);
+}
+
 /* LsmMathmlPaddedElement implementation */
 
 LsmDomNode *
@@ -46,12 +86,51 @@ lsm_mathml_padded_element_init (LsmMathmlPaddedElement *element)
 
 /* LsmMathmlPaddedElement class */
 
+static const LsmAttributeInfos _attribute_infos[] = {
+	{
+		.name = "height",
+		.attribute_offset = offsetof (LsmMathmlPaddedElement, height),
+		.trait_class = &lsm_mathml_length_trait_class,
+		.trait_default = &length_default
+	},
+	{
+		.name = "depth",
+		.attribute_offset = offsetof (LsmMathmlPaddedElement, depth),
+		.trait_class = &lsm_mathml_length_trait_class,
+		.trait_default = &length_default
+	},
+	{
+		.name = "width",
+		.attribute_offset = offsetof (LsmMathmlPaddedElement, width),
+		.trait_class = &lsm_mathml_length_trait_class,
+		.trait_default = &length_default
+	},
+	{
+		.name = "lspace",
+		.attribute_offset = offsetof (LsmMathmlPaddedElement, left_space),
+		.trait_class = &lsm_mathml_length_trait_class,
+		.trait_default = &length_default
+	}
+};
+
 static void
 lsm_mathml_padded_element_class_init (LsmMathmlPaddedElementClass *klass)
 {
 	LsmDomNodeClass *d_node_class = LSM_DOM_NODE_CLASS (klass);
+	LsmMathmlElementClass *m_element_class = LSM_MATHML_ELEMENT_CLASS (klass);
+
+	parent_class = g_type_class_peek_parent (klass);
 
 	d_node_class->get_node_name = lsm_mathml_padded_element_get_node_name;
+
+	m_element_class->attribute_manager = lsm_attribute_manager_duplicate (m_element_class->attribute_manager);
+	m_element_class->update = _update;
+	m_element_class->measure = _measure;
+	m_element_class->layout = _layout;
+
+	lsm_attribute_manager_add_attributes (m_element_class->attribute_manager,
+					      G_N_ELEMENTS (_attribute_infos),
+					      _attribute_infos);
 }
 
 G_DEFINE_TYPE (LsmMathmlPaddedElement, lsm_mathml_padded_element, LSM_TYPE_MATHML_PRESENTATION_CONTAINER)

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

@@ -40,6 +40,11 @@ typedef struct _LsmMathmlPaddedElementClass LsmMathmlPaddedElementClass;
 
 struct _LsmMathmlPaddedElement {
 	LsmMathmlPresentationContainer presentation_container;
+
+	LsmMathmlLengthAttribute height;
+	LsmMathmlLengthAttribute depth;
+	LsmMathmlLengthAttribute width;
+	LsmMathmlLengthAttribute left_space;
 };
 
 struct _LsmMathmlPaddedElementClass {

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

@@ -262,6 +262,12 @@ static const LsmAttributeInfos _attribute_infos[] = {
 		.attribute_offset = offsetof (LsmMathmlStyleElement, math_family),
 		.trait_class = &lsm_mathml_string_trait_class
 	},
+	{
+		.name = "fontsize",
+		.attribute_offset = offsetof (LsmMathmlStyleElement, math_size),
+		.trait_class = &lsm_mathml_length_trait_class,
+		.trait_default = &length_default
+	},
 	{
 		.name = "fontstyle",
 		.attribute_offset = offsetof (LsmMathmlStyleElement, font_style),

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

@@ -390,11 +390,11 @@ lsm_mathml_table_element_render (LsmMathmlElement *self, LsmMathmlView *view)
 		spacing = table->column_spacing.values[MIN (i, table->column_spacing.n_values - 1)];
 		x = position + 0.5 * (spacing + table->line_width);
 		lsm_mathml_view_show_line (view, &self->style,
-					x, y0, x, y1,
-					table->column_lines.enum_list.values[MIN (i,
-										  table->column_lines.enum_list.n_values
-										  - 1)],
-					table->line_width);
+					   x, y0, x, y1,
+					   table->column_lines.enum_list.values[MIN (i,
+										     table->column_lines.enum_list.n_values
+										     - 1)],
+					   table->line_width);
 		position += spacing + table->line_width;
 	}
 

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

@@ -251,6 +251,30 @@ const LsmTraitClass lsm_mathml_form_trait_class = {
 	.to_string = lsm_mathml_form_trait_to_string
 };
 
+static gboolean
+lsm_mathml_notation_trait_from_string (LsmTrait *abstract_trait, char *string)
+{
+	LsmMathmlNotation *value = (LsmMathmlNotation *) abstract_trait;
+
+	*value = lsm_mathml_notation_from_string (string);
+
+	return *value >= 0;
+}
+
+static char *
+lsm_mathml_notation_trait_to_string (LsmTrait *abstract_trait)
+{
+	LsmMathmlNotation *value = (LsmMathmlNotation *) abstract_trait;
+
+	return g_strdup (lsm_mathml_notation_to_string (*value));
+}
+
+const LsmTraitClass lsm_mathml_notation_trait_class = {
+	.size = sizeof (int),
+	.from_string = lsm_mathml_notation_trait_from_string,
+	.to_string = lsm_mathml_notation_trait_to_string
+};
+
 typedef int (*LsmMathmlEnumFromString) (const char *string);
 typedef char * (*LsmMathmlEnumToString) (unsigned int value);
 

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

@@ -98,6 +98,7 @@ extern const LsmTraitClass lsm_mathml_font_style_trait_class;
 extern const LsmTraitClass lsm_mathml_font_weight_trait_class;
 extern const LsmTraitClass lsm_mathml_variant_trait_class;
 extern const LsmTraitClass lsm_mathml_form_trait_class;
+extern const LsmTraitClass lsm_mathml_notation_trait_class;
 
 extern const LsmTraitClass lsm_mathml_row_align_list_trait_class;
 extern const LsmTraitClass lsm_mathml_column_align_list_trait_class;

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

@@ -48,6 +48,7 @@ typedef struct _LsmMathmlStringElement LsmMathmlStringElement;
 typedef struct _LsmMathmlPresentationContainer LsmMathmlPresentationContainer;
 typedef struct _LsmMathmlStyleElement LsmMathmlStyleElement;
 typedef struct _LsmMathmlRowElement LsmMathmlRowElement;
+typedef struct _LsmMathmlEncloseElement LsmMathmlEncloseElement;
 typedef struct _LsmMathmlFencedElement LsmMathmlFencedElement;
 typedef struct _LsmMathmlPaddedElement LsmMathmlPaddedElement;
 typedef struct _LsmMathmlErrorElement LsmMathmlErrorElement;

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

@@ -35,15 +35,22 @@ typedef struct {
 	gboolean is_defined;
 } LsmMathmlBbox;
 
+typedef struct {
+	double left;
+	double right;
+	double top;
+	double bottom;
+} LsmMathmlPadding;
+
 extern const LsmMathmlBbox lsm_mathml_bbox_null;
 
 void 	lsm_mathml_bbox_add_horizontally 		(LsmMathmlBbox *bbox, const LsmMathmlBbox *new_bbox);
 void 	lsm_mathml_bbox_add_over 			(LsmMathmlBbox *self, const LsmMathmlBbox *bbox);
 void 	lsm_mathml_bbox_add_under 			(LsmMathmlBbox *self, const LsmMathmlBbox *bbox);
 void 	lsm_mathml_bbox_merge_vertically 		(LsmMathmlBbox *self, const LsmMathmlBbox *bbox, double offset);
-void 	lsm_mathml_bbox_stretch			(LsmMathmlBbox *self, const LsmMathmlBbox *bbox);
+void 	lsm_mathml_bbox_stretch				(LsmMathmlBbox *self, const LsmMathmlBbox *bbox);
 void 	lsm_mathml_bbox_stretch_vertically		(LsmMathmlBbox *self, const LsmMathmlBbox *bbox);
-void 	lsm_mathml_bbox_stretch_horizontally	(LsmMathmlBbox *self, const LsmMathmlBbox *bbox);
+void 	lsm_mathml_bbox_stretch_horizontally		(LsmMathmlBbox *self, const LsmMathmlBbox *bbox);
 
 G_END_DECLS
 

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

@@ -33,6 +33,13 @@
 #include <math.h>
 #include <string.h>
 
+typedef enum {
+	_GMATHML_STROKE_WIDTH_EVEN,
+	_GMATHML_STROKE_WIDTH_ODD,
+	_GMATHML_STROKE_WIDTH_NULL,
+	_GMATHML_STROKE_WIDTH_VECTOR
+} _LsmMathmlStrokeWidth;
+
 #define LSM_MATHML_LARGE_OP_SCALE	1.6
 
 static const char *lsm_mathml_font_names[] = {
@@ -68,6 +75,26 @@ static const struct {
 
 static GObjectClass *parent_class;
 
+static void
+_debug_element_style (const char *format, const LsmMathmlElementStyle *style) {
+	if (lsm_debug_check (&lsm_debug_category_render, LSM_DEBUG_LEVEL_DEBUG)) {
+		char *string;
+
+		string = g_strdup_printf ("%s %s %gpt (c:%02X%02X%02X b:%02X%02X%02X)",
+					  style->math_family,
+					  lsm_mathml_variant_to_string (style->math_variant),
+					  style->math_size,
+					  (int) (255.0 * style->math_color.red),
+					  (int) (255.0 * style->math_color.green),
+					  (int) (255.0 * style->math_color.blue),
+					  (int) (255.0 * style->math_background.red),
+					  (int) (255.0 * style->math_background.green),
+					  (int) (255.0 * style->math_background.blue));
+		lsm_debug_render ("[LsmMathmlView::render] Show notation %s", string);
+		g_free (string);
+	}
+}
+
 static void
 lsm_mathml_view_apply_style_to_font_description (PangoFontDescription *font_description,
 						 const LsmMathmlElementStyle *style,
@@ -610,9 +637,9 @@ lsm_mathml_view_get_operator_slant (LsmMathmlView *view,
 
 void
 lsm_mathml_view_measure_radical (LsmMathmlView *view,
-			      const LsmMathmlElementStyle *style,
-			      const LsmMathmlBbox *stretch_bbox,
-			      LsmMathmlBbox *bbox, double *x_offset, double *y_offset)
+				 const LsmMathmlElementStyle *style,
+				 const LsmMathmlBbox *stretch_bbox,
+				 LsmMathmlBbox *bbox, double *x_offset, double *y_offset)
 {
 	LsmMathmlBbox radical_stretch_bbox;
 	double thickness;
@@ -631,7 +658,7 @@ lsm_mathml_view_measure_radical (LsmMathmlView *view,
 	radical_stretch_bbox.depth += LSM_MATHML_SPACE_EM_THICK * style->math_size;
 
 	lsm_mathml_view_measure_operator (view, style, LSM_MATHML_RADICAL_UTF8,
-				       FALSE, FALSE, 0.0, &radical_stretch_bbox, bbox);
+					  FALSE, FALSE, 0.0, &radical_stretch_bbox, bbox);
 
 	if (x_offset != NULL) {
 		*x_offset = bbox->width * LSM_MATHML_RADICAL_ORDER_X_OFFSET;
@@ -715,13 +742,6 @@ lsm_mathml_view_show_radical (LsmMathmlView *view,
 	cairo_restore (cairo);
 }
 
-typedef enum {
-	_GMATHML_STROKE_WIDTH_EVEN,
-	_GMATHML_STROKE_WIDTH_ODD,
-	_GMATHML_STROKE_WIDTH_NULL,
-	_GMATHML_STROKE_WIDTH_VECTOR
-} _LsmMathmlStrokeWidth;
-
 static void
 _round_rectangle_coordinates (cairo_t *cairo,
 			      _LsmMathmlStrokeWidth stroke_width,
@@ -809,6 +829,256 @@ _emit_stroke_attributes (LsmMathmlView *view, LsmMathmlLine line, double line_wi
 	return stroke_width;
 }
 
+const LsmMathmlPadding notation_padding[] = {
+	{	.left = 0.0,	.right = 0.0,	.top = 1.0,	.bottom = 0.0 },	/* longdiv */
+	{	.left = 1.0,	.right = 1.0,	.top = 1.0,	.bottom = 1.0 },	/* actuarial */
+	{	.left = 0.0,	.right = 0.0,	.top = 0.0,	.bottom = 0.0 },	/* radical */
+	{	.left = 1.0,	.right = 1.0,	.top = 1.0,	.bottom = 1.0 },	/* box */
+	{	.left = 1.0,	.right = 1.0,	.top = 1.0,	.bottom = 1.0 },	/* boundedbox */
+	{	.left = 2.0,	.right = 2.0,	.top = 2.0,	.bottom = 2.0 },	/* circle */
+	{	.left = 1.0,	.right = 0.0,	.top = 1.0,	.bottom = 1.0 },	/* left */
+	{	.left = 0.0,	.right = 1.0,	.top = 1.0,	.bottom = 1.0 },	/* right */
+	{	.left = 1.0,	.right = 1.0,	.top = 1.0,	.bottom = 0.0 },	/* top */
+	{	.left = 1.0,	.right = 1.0,	.top = 0.0,	.bottom = 1.0 },	/* bottom */
+	{	.left = 0.0,	.right = 0.0,	.top = 1.0,	.bottom = 1.0 },	/* updiagonalstrike */
+	{	.left = 0.0,	.right = 0.0,	.top = 1.0,	.bottom = 1.0 },	/* downdiagonalstrike */
+	{	.left = 0.0,	.right = 0.0,	.top = 1.0,	.bottom = 1.0 },	/* verticalstrike */
+	{	.left = 1.0,	.right = 1.0,	.top = 0.0,	.bottom = 0.0 },	/* horizontalstrike */
+	{	.left = 1.0,	.right = 1.0,	.top = 1.0,	.bottom = 1.0 },	/* madruwb */
+	{	.left = 0.0,	.right = 5.0,	.top = 1.0,	.bottom = 1.0 }		/* updiagonalarrow */
+};
+
+void
+lsm_mathml_view_measure_notation (LsmMathmlView *view,
+				  const LsmMathmlElementStyle *style,
+				  LsmMathmlNotation notation,
+				  const LsmMathmlBbox *stretch_bbox,
+				  LsmMathmlBbox *bbox,
+				  double *x_child_offset)
+{
+	LsmMathmlLength padding_x = {.value = 0.5, .unit = LSM_MATHML_UNIT_EX};
+	LsmMathmlLength padding_y = {.value = 0.4, .unit = LSM_MATHML_UNIT_EM};
+	double base_x;
+	double base_y;
+
+	g_return_if_fail (LSM_IS_MATHML_VIEW (view));
+	g_return_if_fail (style != NULL);
+	g_return_if_fail (stretch_bbox != NULL);
+	g_return_if_fail (bbox != NULL);
+
+	if (notation == LSM_MATHML_NOTATION_RADICAL) {
+		lsm_mathml_view_measure_radical (view, style, stretch_bbox, bbox, NULL, NULL);
+		if (x_child_offset != NULL)
+			*x_child_offset = bbox->width;
+		lsm_mathml_bbox_add_horizontally (bbox, stretch_bbox);
+		return;
+	}
+
+	base_x = lsm_mathml_length_normalize (&padding_x, 0.0, style->math_size);
+	base_y = lsm_mathml_length_normalize (&padding_y, 0.0, style->math_size);
+
+	*bbox = *stretch_bbox;
+
+	if (notation >= 0 && notation < LSM_MATHML_NOTATION_LAST) {
+		bbox->width += base_x * (notation_padding[notation].left + notation_padding[notation].right);
+		bbox->height += base_y * notation_padding[notation].top;
+		bbox->depth += base_y * notation_padding[notation].bottom;
+
+		if (notation == LSM_MATHML_NOTATION_LONGDIV) {
+			bbox->width += bbox->height / 2.0;
+			if (x_child_offset != NULL)
+				*x_child_offset = bbox->height / 2.0;
+		} else {
+			if (x_child_offset != NULL)
+				*x_child_offset = base_x * notation_padding[notation].left;
+		}
+	} else {
+		if (x_child_offset != NULL)
+			*x_child_offset = 0;
+	}
+}
+
+static void
+_cairo_arrow (cairo_t *cairo, double scale, double x0, double y0, double x1, double y1)
+{
+	double angle;
+	double x2, y2;
+
+	if ((y1 - y0) == 0 && (x1 - x0) == 0)
+		return;
+
+	angle = atan2 (y1 - y0, x1 - x0);
+	x2 = x1 - scale * cos (angle) / 2.0;
+	y2 = y1 - scale * sin (angle) / 2.0;
+
+	cairo_move_to (cairo, x0, y0);
+	cairo_line_to (cairo, x2, y2);
+	cairo_stroke (cairo);
+
+	cairo_save (cairo);
+
+	cairo_translate (cairo, x1, y1);
+	cairo_scale (cairo, scale, scale);
+	cairo_rotate (cairo, angle);
+
+	cairo_move_to (cairo, -1.0, 0.3);
+	cairo_line_to (cairo, 0.0, 0.0);
+	cairo_line_to (cairo, -1.0, -0.3);
+	cairo_line_to (cairo, -0.9, 0.0);
+	cairo_close_path (cairo);
+
+	cairo_restore (cairo);
+
+	cairo_fill (cairo);
+}  
+
+static void
+_cairo_rounded_rectangle (cairo_t *cairo, double radius, double x0, double y0, double x1, double y1)
+{
+	cairo_new_path (cairo);
+
+	cairo_arc (cairo, x0 + radius, y0 - radius, radius, M_PI / 2.0, -M_PI);
+	cairo_arc (cairo, x0 + radius, y1 + radius, radius, M_PI, -M_PI / 2.0);
+	cairo_arc (cairo, x1 - radius, y1 + radius, radius, -M_PI / 2.0, 0.0);
+	cairo_arc (cairo, x1 - radius, y0 - radius, radius, 0.0, M_PI / 2.0);
+	cairo_close_path (cairo);
+
+	cairo_stroke (cairo);
+}
+
+void
+lsm_mathml_view_show_notation (LsmMathmlView *view,
+			       const LsmMathmlElementStyle *style,
+			       LsmMathmlNotation notation,
+			       double x, double y,
+			       const LsmMathmlBbox *bbox,
+			       double x_child_offset)
+{
+	LsmMathmlBbox stretch_bbox;
+	LsmMathmlLength padding_x = {.value = 0.5, .unit = LSM_MATHML_UNIT_EX};
+	_LsmMathmlStrokeWidth stroke_width;
+	cairo_t *cairo;
+	double x1, y1;
+	double base_x;
+
+	g_return_if_fail (LSM_IS_MATHML_VIEW (view));
+	g_return_if_fail (style != NULL);
+	g_return_if_fail (bbox != NULL);
+
+	stroke_width = _emit_stroke_attributes (view, LSM_MATHML_LINE_SOLID, 1.0, &style->math_color);
+
+	_debug_element_style ("[LsmMathmlView::render] Show notation %s", style);
+
+	if (stroke_width == _GMATHML_STROKE_WIDTH_NULL)
+		return;
+
+	base_x = lsm_mathml_length_normalize (&padding_x, 0.0, style->math_size);
+
+	y = y + bbox->depth;
+	x1 = x + bbox->width;
+	y1 = y - bbox->height - bbox->depth;
+
+	cairo = view->dom_view.cairo;
+
+	_round_rectangle_coordinates (cairo, stroke_width, &x, &y, &x1, &y1);
+
+	cairo_new_path (cairo);
+
+	switch (notation) {
+		case LSM_MATHML_NOTATION_ACTUARIAL:
+			cairo_move_to (cairo, x, y1);
+			cairo_line_to (cairo, x1, y1);
+			cairo_line_to (cairo, x1, y);
+			cairo_stroke (cairo);
+			break;
+		case LSM_MATHML_NOTATION_RADICAL:
+			stretch_bbox = *bbox;
+			stretch_bbox.width = x_child_offset;
+			lsm_mathml_view_show_radical (view, style, x, y - bbox->depth,
+						      bbox->width - x_child_offset, &stretch_bbox);
+			break;
+		case LSM_MATHML_NOTATION_BOX:
+			cairo_move_to (cairo, x, y);
+			cairo_line_to (cairo, x, y1);
+			cairo_line_to (cairo, x1, y1);
+			cairo_line_to (cairo, x1, y);
+			cairo_close_path (cairo);
+			cairo_stroke (cairo);
+			break;
+		case LSM_MATHML_NOTATION_ROUNDED_BOX:
+			_cairo_rounded_rectangle (cairo, base_x, x, y, x1, y1);
+			break;
+		case LSM_MATHML_NOTATION_CIRCLE:
+			cairo_save (cairo);
+			cairo_translate (cairo, (x + x1) / 2.0, (y + y1) / 2.0);
+			cairo_scale (cairo, (x - x1) / 2.0, (y - y1) / 2.0);
+			cairo_arc (cairo, 0., 0., 1., 0., 2 * M_PI);
+			cairo_restore (cairo);
+			cairo_stroke (cairo);
+			break;
+		case LSM_MATHML_NOTATION_LEFT:
+			cairo_move_to (cairo, x, y);
+			cairo_line_to (cairo, x, y1);
+			cairo_stroke (cairo);
+			break;
+		case LSM_MATHML_NOTATION_RIGHT:
+			cairo_move_to (cairo, x1, y);
+			cairo_line_to (cairo, x1, y1);
+			cairo_stroke (cairo);
+			break;
+		case LSM_MATHML_NOTATION_TOP:
+			cairo_move_to (cairo, x, y1);
+			cairo_line_to (cairo, x1, y1);
+			cairo_stroke (cairo);
+			break;
+		case LSM_MATHML_NOTATION_BOTTOM:
+			cairo_move_to (cairo, x, y);
+			cairo_line_to (cairo, x1, y);
+			cairo_stroke (cairo);
+			break;
+		case LSM_MATHML_NOTATION_UP_DIAGONAL_STRIKE:
+			cairo_move_to (cairo, x, y);
+			cairo_line_to (cairo, x1, y1);
+			cairo_stroke (cairo);
+			break;
+		case LSM_MATHML_NOTATION_DOWN_DIAGONAL_STRIKE:
+			cairo_move_to (cairo, x, y1);
+			cairo_line_to (cairo, x1, y);
+			cairo_stroke (cairo);
+			break;
+		case LSM_MATHML_NOTATION_HORIZONTAL_STRIKE:
+			cairo_move_to (cairo, x, (y + y1) / 2.0);
+			cairo_line_to (cairo, x1,(y + y1) / 2.0);
+			cairo_stroke (cairo);
+			break;
+		case LSM_MATHML_NOTATION_VERTICAL_STRIKE:
+			cairo_move_to (cairo, (x + x1) / 2.0, y);
+			cairo_line_to (cairo, (x + x1) / 2.0, y1);
+			cairo_stroke (cairo);
+			break;
+		case LSM_MATHML_NOTATION_MADRUWB:
+			cairo_move_to (cairo, x, y);
+			cairo_line_to (cairo, x1, y);
+			cairo_line_to (cairo, x1, y1);
+			cairo_stroke (cairo);
+			break;
+		case LSM_MATHML_NOTATION_UP_DIAGONAL_ARROW:
+			_cairo_arrow (cairo, 4.0 * base_x, x, y, x1, y1);
+			break;
+		case LSM_MATHML_NOTATION_ERROR:
+		case LSM_MATHML_NOTATION_LONGDIV:
+		default:
+			cairo_move_to (cairo, x, y);
+			cairo_curve_to (cairo, 
+					x + bbox->height / 4.0, y - bbox->height / 4.0,
+					x + bbox->height / 4.0, y1 + bbox->height / 4.0,
+					x, y1);
+			cairo_line_to (cairo, x1, y1);
+			cairo_stroke (cairo);
+			break;
+	}
+}
+
 void
 lsm_mathml_view_show_background (LsmMathmlView *view,
 			      const LsmMathmlElementStyle *style,
@@ -928,6 +1198,8 @@ lsm_mathml_view_show_fraction_line (LsmMathmlView *view,
 
 	stroke_width = _emit_stroke_attributes (view, LSM_MATHML_LINE_SOLID, thickness, &style->math_color);
 
+	_debug_element_style ("[LsmMathmlView::render] Show fraction line %s", style);
+
 	if (stroke_width == _GMATHML_STROKE_WIDTH_NULL)
 		return;