mathematical 1.4.2 → 1.5.0

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

@@ -0,0 +1,96 @@
+
+/* Generated data (by glib-mkenums) */
+
+#ifndef LSM_MATHML_ENUM_TYPES_H
+#define LSM_MATHML_ENUM_TYPES_H
+
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+/* Enumerations from "lsmmathmlenums.h" */
+
+#define LSM_TYPE_MATHML_CSS_TYPE	(lsm_mathml_css_type_get_type())
+GType lsm_mathml_css_type_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_MATHML_MODE	(lsm_mathml_mode_get_type())
+GType lsm_mathml_mode_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_MATHML_DISPLAY	(lsm_mathml_display_get_type())
+GType lsm_mathml_display_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_MATHML_SPACE_NAME	(lsm_mathml_space_name_get_type())
+GType lsm_mathml_space_name_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_MATHML_UNIT	(lsm_mathml_unit_get_type())
+GType lsm_mathml_unit_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_MATHML_FONT_STYLE	(lsm_mathml_font_style_get_type())
+GType lsm_mathml_font_style_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_MATHML_FONT_WEIGHT	(lsm_mathml_font_weight_get_type())
+GType lsm_mathml_font_weight_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_MATHML_VARIANT	(lsm_mathml_variant_get_type())
+GType lsm_mathml_variant_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_MATHML_FORM	(lsm_mathml_form_get_type())
+GType lsm_mathml_form_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_MATHML_ROW_ALIGN	(lsm_mathml_row_align_get_type())
+GType lsm_mathml_row_align_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_MATHML_COLUMN_ALIGN	(lsm_mathml_column_align_get_type())
+GType lsm_mathml_column_align_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_MATHML_LINE	(lsm_mathml_line_get_type())
+GType lsm_mathml_line_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_MATHML_SCRIPT_LEVEL_SIGN	(lsm_mathml_script_level_sign_get_type())
+GType lsm_mathml_script_level_sign_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_MATHML_NOTATION	(lsm_mathml_notation_get_type())
+GType lsm_mathml_notation_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_MATHML_LINEBREAK	(lsm_mathml_linebreak_get_type())
+GType lsm_mathml_linebreak_get_type	(void) G_GNUC_CONST;
+
+/* Enumerations from "lsmmathmltablerowelement.h" */
+
+#define LSM_TYPE_MATHML_TABLE_ROW_ELEMENT_TYPE	(lsm_mathml_table_row_element_type_get_type())
+GType lsm_mathml_table_row_element_type_get_type	(void) G_GNUC_CONST;
+
+/* Enumerations from "lsmmathmlradicalelement.h" */
+
+#define LSM_TYPE_MATHML_RADICAL_ELEMENT_TYPE	(lsm_mathml_radical_element_type_get_type())
+GType lsm_mathml_radical_element_type_get_type	(void) G_GNUC_CONST;
+
+/* Enumerations from "lsmmathmlscriptelement.h" */
+
+#define LSM_TYPE_MATHML_SCRIPT_ELEMENT_TYPE	(lsm_mathml_script_element_type_get_type())
+GType lsm_mathml_script_element_type_get_type	(void) G_GNUC_CONST;
+
+/* Enumerations from "lsmmathmlunderoverelement.h" */
+
+#define LSM_TYPE_MATHML_UNDER_OVER_ELEMENT_TYPE	(lsm_mathml_under_over_element_type_get_type())
+GType lsm_mathml_under_over_element_type_get_type	(void) G_GNUC_CONST;
+
+/* Enumerations from "lsmmathmlpresentationtoken.h" */
+
+#define LSM_TYPE_MATHML_PRESENTATION_TOKEN_TYPE	(lsm_mathml_presentation_token_type_get_type())
+GType lsm_mathml_presentation_token_type_get_type	(void) G_GNUC_CONST;
+
+/* Enumerations from "lsmmathmlview.h" */
+
+#define LSM_TYPE_MATHML_GLYPH_FLAGS	(lsm_mathml_glyph_flags_get_type())
+GType lsm_mathml_glyph_flags_get_type	(void) G_GNUC_CONST;
+
+#define LSM_TYPE_MATHML_FONT	(lsm_mathml_font_get_type())
+GType lsm_mathml_font_get_type	(void) G_GNUC_CONST;
+
+G_END_DECLS
+
+#endif /* LSM_MATHML_ENUM_TYPES_H */
+
+/* Generated data ends here */
+

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

@@ -59,11 +59,17 @@ static const LsmMathmlBbox *
 lsm_mathml_space_element_measure (LsmMathmlElement *self, LsmMathmlView *view, const LsmMathmlBbox *bbox)
 {
 	LsmMathmlSpaceElement *space_element = LSM_MATHML_SPACE_ELEMENT (self);
+	LsmMathmlLinebreak linebreak;
 
 	self->bbox.width = space_element->width.value;
 	self->bbox.height = space_element->height.value;
 	self->bbox.depth = space_element->depth.value;
 	self->bbox.is_defined = TRUE;
+	linebreak = space_element->linebreak.value;
+
+	if (linebreak == LSM_MATHML_LINEBREAK_NEWLINE) {
+
+	}
 
 	return &self->bbox;
 }
@@ -85,6 +91,7 @@ lsm_mathml_space_element_new (void)
 
 static const LsmMathmlSpace space_default = {LSM_MATHML_SPACE_NAME_ERROR, {0.0, LSM_MATHML_UNIT_EM}};
 static const LsmMathmlLength length_default = {1.0, LSM_MATHML_UNIT_NONE};
+static const LsmMathmlLinebreak linebreak_default = LSM_MATHML_LINEBREAK_AUTO;
 
 static void
 lsm_mathml_space_element_init (LsmMathmlSpaceElement *self)
@@ -92,6 +99,7 @@ lsm_mathml_space_element_init (LsmMathmlSpaceElement *self)
 	self->width.space = space_default;
 	self->height.length = length_default;
 	self->depth.length = length_default;
+	self->linebreak.value = linebreak_default;
 }
 
 /* LsmMathmlSpaceElement class */
@@ -114,6 +122,12 @@ static const LsmAttributeInfos _attribute_infos[] = {
 		.attribute_offset = offsetof (LsmMathmlSpaceElement, height),
 		.trait_class = &lsm_mathml_length_trait_class,
 		.trait_default = &length_default
+	},
+	{
+		.name = "linebreak",
+		.attribute_offset = offsetof (LsmMathmlSpaceElement, linebreak),
+		.trait_class = &lsm_mathml_linebreak_trait_class,
+		.trait_default = &linebreak_default
 	}
 };
 

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

@@ -44,6 +44,7 @@ struct _LsmMathmlSpaceElement {
 	LsmMathmlSpaceAttribute width;
 	LsmMathmlLengthAttribute height;
 	LsmMathmlLengthAttribute depth;
+	LsmMathmlEnumAttribute linebreak;
 };
 
 struct _LsmMathmlSpaceElementClass {
@@ -57,4 +58,3 @@ LsmDomNode * 	lsm_mathml_space_element_new 	(void);
 G_END_DECLS
 
 #endif
-

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

@@ -275,6 +275,30 @@ const LsmTraitClass lsm_mathml_notation_trait_class = {
 	.to_string = lsm_mathml_notation_trait_to_string
 };
 
+static gboolean
+lsm_mathml_linebreak_trait_from_string (LsmTrait *abstract_trait, char *string)
+{
+	LsmMathmlLinebreak *value = (LsmMathmlLinebreak *) abstract_trait;
+
+	*value = lsm_mathml_linebreak_from_string (string);
+
+	return *value >= 0;
+}
+
+static char *
+lsm_mathml_linebreak_trait_to_string (LsmTrait *abstract_trait)
+{
+	LsmMathmlLinebreak *value = (LsmMathmlLinebreak *) abstract_trait;
+
+	return g_strdup (lsm_mathml_linebreak_to_string (*value));
+}
+
+const LsmTraitClass lsm_mathml_linebreak_trait_class = {
+	.size = sizeof (int),
+	.from_string = lsm_mathml_linebreak_trait_from_string,
+	.to_string = lsm_mathml_linebreak_trait_to_string
+};
+
 typedef int (*LsmMathmlEnumFromString) (const char *string);
 typedef char * (*LsmMathmlEnumToString) (unsigned int value);
 

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

@@ -107,6 +107,7 @@ 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_linebreak_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/lsmsvgattributes.h

@@ -38,6 +38,16 @@ typedef struct {
 	LsmSvgBlendingMode value;
 } LsmSvgBlendingModeAttribute;
 
+typedef struct {
+	LsmAttribute base;
+	gboolean value;
+} LsmSvgBooleanAttribute;
+
+typedef struct {
+	LsmAttribute base;
+	int value;
+} LsmSvgIntegerAttribute;
+
 typedef struct {
 	LsmAttribute base;
 	double value;
@@ -48,6 +58,11 @@ typedef struct {
 	LsmSvgOneOrTwoDouble value;
 } LsmSvgOneOrTwoDoubleAttribute;
 
+typedef struct {
+	LsmAttribute base;
+	LsmSvgVector value;
+} LsmSvgVectorAttribute;
+
 typedef struct {
 	LsmAttribute base;
 	LsmSvgDashArray *value;
@@ -108,11 +123,46 @@ typedef struct {
 	LsmSvgMarkerUnits value;
 } LsmSvgMarkerUnitsAttribute;
 
+typedef struct {
+	LsmAttribute base;
+	LsmSvgColorFilterType value;
+} LsmSvgColorFilterTypeAttribute;
+
 typedef struct {
 	LsmAttribute base;
 	LsmSvgAngle value;
 } LsmSvgAngleAttribute;
 
+typedef struct {
+	LsmAttribute base;
+	LsmSvgMorphologyOperator value;
+} LsmSvgMorphologyOperatorAttribute;
+
+typedef struct {
+	LsmAttribute base;
+	LsmSvgEdgeMode value;
+} LsmSvgEdgeModeAttribute;
+
+typedef struct {
+	LsmAttribute base;
+	LsmSvgOneOrTwoInteger value;
+} LsmSvgOneOrTwoIntegerAttribute;
+
+typedef struct {
+	LsmAttribute base;
+	LsmSvgStitchTiles value;
+} LsmSvgStitchTilesAttribute;
+
+typedef struct {
+	LsmAttribute base;
+	LsmSvgTurbulenceType value;
+} LsmSvgTurbulenceTypeAttribute;
+
+typedef struct {
+	LsmAttribute base;
+	LsmSvgChannelSelector value;
+} LsmSvgChannelSelectorAttribute;
+
 G_END_DECLS
 
 #endif

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

@@ -30,13 +30,19 @@
 #include <lsmsvgellipseelement.h>
 #include <lsmsvgfilterelement.h>
 #include <lsmsvgfilterblend.h>
+#include <lsmsvgfiltercolormatrix.h>
 #include <lsmsvgfiltercomposite.h>
+#include <lsmsvgfilterconvolvematrix.h>
+#include <lsmsvgfilterdisplacementmap.h>
 #include <lsmsvgfilterflood.h>
 #include <lsmsvgfiltergaussianblur.h>
+#include <lsmsvgfilterimage.h>
 #include <lsmsvgfilteroffset.h>
 #include <lsmsvgfiltermerge.h>
 #include <lsmsvgfiltermergenode.h>
+#include <lsmsvgfiltermorphology.h>
 #include <lsmsvgfilterspecularlighting.h>
+#include <lsmsvgfilterturbulence.h>
 #include <lsmsvgfiltertile.h>
 #include <lsmsvggelement.h>
 #include <lsmsvgimageelement.h>
@@ -154,20 +160,32 @@ _create_element (LsmDomDocument *document, const char *tag_name)
 		node = lsm_svg_filter_blend_new ();
 	else if (strcmp (tag_name, "feComposite") == 0)
 		node = lsm_svg_filter_composite_new ();
+	else if (strcmp (tag_name, "feColorMatrix") == 0)
+		node = lsm_svg_filter_color_matrix_new ();
+	else if (strcmp (tag_name, "feConvolveMatrix") == 0)
+		node = lsm_svg_filter_convolve_matrix_new ();
+	else if (strcmp (tag_name, "feDisplacementMap") == 0)
+		node = lsm_svg_filter_displacement_map_new ();
 	else if (strcmp (tag_name, "feFlood") == 0)
 		node = lsm_svg_filter_flood_new ();
 	else if (strcmp (tag_name, "feGaussianBlur") == 0)
 		node = lsm_svg_filter_gaussian_blur_new ();
+	else if (strcmp (tag_name, "feImage") == 0)
+		node = lsm_svg_filter_image_new ();
 	else if (strcmp (tag_name, "feMerge") == 0)
 		node = lsm_svg_filter_merge_new ();
 	else if (strcmp (tag_name, "feMergeNode") == 0)
 		node = lsm_svg_filter_merge_node_new ();
+	else if (strcmp (tag_name, "feMorphology") == 0)
+		node = lsm_svg_filter_morphology_new ();
 	else if (strcmp (tag_name, "feOffset") == 0)
 		node = lsm_svg_filter_offset_new ();
 	else if (strcmp (tag_name, "feSpecularLighting") == 0)
 		node = lsm_svg_filter_specular_lighting_new ();
 	else if (strcmp (tag_name, "feTile") == 0)
 		node = lsm_svg_filter_tile_new ();
+	else if (strcmp (tag_name, "feTurbulence") == 0)
+		node = lsm_svg_filter_turbulence_new ();
 
 	if (node != NULL)
 		lsm_debug_dom ("[LsmSvgDocument::create_element] Create a %s element", tag_name);

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

@@ -542,3 +542,133 @@ lsm_svg_writing_mode_from_string (const char *string)
 					   G_N_ELEMENTS (lsm_svg_writing_mode_strings));
 }
 
+static const char *lsm_svg_color_filter_type_strings[] = {
+	"matrix",
+	"saturate",
+	"hueRotate",
+	"luminanceToAlpha"
+};
+
+const char *
+lsm_svg_color_filter_type_to_string (LsmSvgColorFilterType color_filter_type)
+{
+	if (color_filter_type < 0 || color_filter_type > LSM_SVG_COLOR_FILTER_TYPE_LUMINANCE_TO_ALPHA)
+		return NULL;
+
+	return lsm_svg_color_filter_type_strings[color_filter_type];
+}
+
+LsmSvgColorFilterType
+lsm_svg_color_filter_type_from_string (const char *string)
+{
+	return lsm_enum_value_from_string (string, lsm_svg_color_filter_type_strings,
+					   G_N_ELEMENTS (lsm_svg_color_filter_type_strings));
+}
+
+static const char *lsm_svg_morphology_operator_strings[] = {
+	"erode",
+	"dilate"
+};
+
+const char *
+lsm_svg_morphology_operator_to_string (LsmSvgMorphologyOperator morphology_operator)
+{
+	if (morphology_operator < 0 || morphology_operator > LSM_SVG_MORPHOLOGY_OPERATOR_DILATE)
+		return NULL;
+
+	return lsm_svg_morphology_operator_strings[morphology_operator];
+}
+
+LsmSvgMorphologyOperator
+lsm_svg_morphology_operator_from_string (const char *string)
+{
+	return lsm_enum_value_from_string (string, lsm_svg_morphology_operator_strings,
+					   G_N_ELEMENTS (lsm_svg_morphology_operator_strings));
+}
+
+static const char *lsm_svg_edge_mode_strings[] = {
+	"duplicate",
+	"wrap",
+	"none"
+};
+
+const char *
+lsm_svg_edge_mode_to_string (LsmSvgEdgeMode edge_mode)
+{
+	if (edge_mode < 0 || edge_mode > LSM_SVG_EDGE_MODE_NONE)
+		return NULL;
+
+	return lsm_svg_edge_mode_strings[edge_mode];
+}
+
+LsmSvgEdgeMode
+lsm_svg_edge_mode_from_string (const char *string)
+{
+	return lsm_enum_value_from_string (string, lsm_svg_edge_mode_strings,
+					   G_N_ELEMENTS (lsm_svg_edge_mode_strings));
+}
+
+static const char *lsm_svg_stitch_tiles_strings[] = {
+	"noStitch",
+	"stitch"
+};
+
+const char *
+lsm_svg_stitch_tiles_to_string (LsmSvgStitchTiles stitch_tiles)
+{
+	if (stitch_tiles < 0 || stitch_tiles > LSM_SVG_STITCH_TILES_STITCH)
+		return NULL;
+
+	return lsm_svg_stitch_tiles_strings[stitch_tiles];
+}
+
+LsmSvgStitchTiles
+lsm_svg_stitch_tiles_from_string (const char *string)
+{
+	return lsm_enum_value_from_string (string, lsm_svg_stitch_tiles_strings,
+					   G_N_ELEMENTS (lsm_svg_stitch_tiles_strings));
+}
+
+static const char *lsm_svg_turbulence_type_strings[] = {
+	"turbulence",
+	"fractalNoise"
+};
+
+const char *
+lsm_svg_turbulence_type_to_string (LsmSvgTurbulenceType turbulence_type)
+{
+	if (turbulence_type < 0 || turbulence_type > LSM_SVG_TURBULENCE_TYPE_FRACTAL_NOISE)
+		return NULL;
+
+	return lsm_svg_turbulence_type_strings[turbulence_type];
+}
+
+LsmSvgTurbulenceType
+lsm_svg_turbulence_type_from_string (const char *string)
+{
+	return lsm_enum_value_from_string (string, lsm_svg_turbulence_type_strings,
+					   G_N_ELEMENTS (lsm_svg_turbulence_type_strings));
+}
+
+static const char *lsm_svg_channel_selector_strings[] = {
+	"R",
+	"G",
+	"B",
+	"A"
+};
+
+const char *
+lsm_svg_channel_selector_to_string (LsmSvgChannelSelector channel_selector)
+{
+	if (channel_selector < 0 || channel_selector > LSM_SVG_CHANNEL_SELECTOR_ALPHA)
+		return NULL;
+
+	return lsm_svg_channel_selector_strings[channel_selector];
+}
+
+LsmSvgChannelSelector
+lsm_svg_channel_selector_from_string (const char *string)
+{
+	return lsm_enum_value_from_string (string, lsm_svg_channel_selector_strings,
+					   G_N_ELEMENTS (lsm_svg_channel_selector_strings));
+}

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

@@ -352,6 +352,65 @@ typedef enum {
 const char * 		lsm_svg_writing_mode_to_string 		(LsmSvgWritingMode writing_mode);
 LsmSvgWritingMode	lsm_svg_writing_mode_from_string	(const char *string);
 
+typedef enum {
+	LSM_SVG_COLOR_FILTER_TYPE_ERROR = -1,
+	LSM_SVG_COLOR_FILTER_TYPE_MATRIX,
+	LSM_SVG_COLOR_FILTER_TYPE_SATURATE,
+	LSM_SVG_COLOR_FILTER_TYPE_HUE_ROTATE,
+	LSM_SVG_COLOR_FILTER_TYPE_LUMINANCE_TO_ALPHA
+} LsmSvgColorFilterType;
+
+const char * 		lsm_svg_color_filter_type_to_string 	(LsmSvgColorFilterType type);
+LsmSvgColorFilterType	lsm_svg_color_filter_type_from_string	(const char *string);
+
+typedef enum {
+	LSM_SVG_MORPHOLOGY_OPERATOR_ERROR = -1,
+	LSM_SVG_MORPHOLOGY_OPERATOR_ERODE,
+	LSM_SVG_MORPHOLOGY_OPERATOR_DILATE
+} LsmSvgMorphologyOperator;
+
+const char * 			lsm_svg_morphology_operator_to_string 	(LsmSvgMorphologyOperator morpholoy_operator);
+LsmSvgMorphologyOperator	lsm_svg_morphology_operator_from_string	(const char *string);
+
+typedef enum {
+	LSM_SVG_EDGE_MODE_ERROR = -1,
+	LSM_SVG_EDGE_MODE_DUPLICATE,
+	LSM_SVG_EDGE_MODE_WRAP,
+	LSM_SVG_EDGE_MODE_NONE
+} LsmSvgEdgeMode;
+
+const char * 		lsm_svg_edge_mode_to_string 	(LsmSvgEdgeMode edge_mode);
+LsmSvgEdgeMode		lsm_svg_edge_mode_from_string	(const char *string);
+
+typedef enum {
+	LSM_SVG_STITCH_TILES_ERROR = -1,
+	LSM_SVG_STITCH_TILES_NO_STITCH,
+	LSM_SVG_STITCH_TILES_STITCH
+} LsmSvgStitchTiles;
+
+const char * 		lsm_svg_stitch_tiles_to_string 		(LsmSvgStitchTiles stitch_tiles);
+LsmSvgStitchTiles	lsm_svg_stitch_tiles_from_string	(const char *string);
+
+typedef enum {
+	LSM_SVG_TURBULENCE_TYPE_ERROR = -1,
+	LSM_SVG_TURBULENCE_TYPE_TURBULENCE,
+	LSM_SVG_TURBULENCE_TYPE_FRACTAL_NOISE
+} LsmSvgTurbulenceType;
+
+const char * 		lsm_svg_turbulence_type_to_string 	(LsmSvgTurbulenceType turbulence_type);
+LsmSvgTurbulenceType	lsm_svg_turbulence_type_from_string	(const char *string);
+
+typedef enum {
+	LSM_SVG_CHANNEL_SELECTOR_ERROR = -1,
+	LSM_SVG_CHANNEL_SELECTOR_RED,
+	LSM_SVG_CHANNEL_SELECTOR_GREEN,
+	LSM_SVG_CHANNEL_SELECTOR_BLUE,
+	LSM_SVG_CHANNEL_SELECTOR_ALPHA
+} LsmSvgChannelSelector;
+
+const char * 		lsm_svg_channel_selector_to_string 	(LsmSvgChannelSelector channel_selector);
+LsmSvgChannelSelector	lsm_svg_channel_selector_from_string	(const char *string);
+
 G_END_DECLS
 
 #endif