@simonklee/opentui-tex-native-source 0.2.0

package/native/vendor/microtex/platform/gtk/microtexequation.cpp

@@ -0,0 +1,708 @@
+#include "microtexequation.h"
+
+#include <cairo-svg.h>
+#include <cairo.h>
+#include <graphic_cairo.h>
+#include <microtex.h>
+#include <utils/exceptions.h>
+#include <utils/nums.h>
+namespace tex = microtex;
+
+class MicroTeXErrorState {
+public:
+  tex::ex_tex exception;
+
+  void (*ui_handler)(cairo_t*);
+
+  gint width;
+  gint height;
+  gint baseline;
+
+  MicroTeXErrorState(
+    tex::ex_tex& exception,
+    void (*fun)(cairo_t*),
+    gint width = 128,
+    gint height = 16,
+    gint baseline = 0
+  )
+      : exception(std::move(exception)),
+        ui_handler(fun),
+        width(width),
+        height(height),
+        baseline(baseline) {}
+};
+
+/**
+ * MicroTexEquation:
+ *
+ * `MicroTexEquation` renders a LaTeX equation using
+ * [µTeX](https://github.com/NanoMichael/MicroTeX)
+ *
+ * A basic implementation could be as simple as
+ * ```c
+ * // allocate this widget
+ * GtkWidget* equation = microtex_equation_new();
+ * // set the width used to determine when to linebreak (0 means no breaking)
+ * microtex_equation_set_width(equation, 0.f);
+ * // set the LaTeX string that will be rendered
+ * microtex_equation_set_equation(equation, "\\LaTeX");
+ * // insert widget into parent: e.g.
+ * gtk_box_append(GTK_BOX(parent), equation);
+ * ```
+ *
+ * A far more in-depth demo application / example is available in the
+ * [µTeX github repository](https://github.com/NanoMichael/MicroTeX)
+ * under `example/gtk/`.
+ */
+
+typedef struct {
+  gboolean shown;
+
+  tex::Render* microtex;
+  MicroTeXErrorState* error;
+
+  gchar* equation;
+  gfloat width;
+
+  gfloat text_size;
+  guint32 color;
+
+} MicroTexEquationPrivate;
+
+G_DEFINE_TYPE_WITH_PRIVATE(MicroTexEquation, microtex_equation, GTK_TYPE_WIDGET)
+
+#define MICROTEX_EQUATION_GET_PRIVATE(obj)                         \
+  static_cast<MicroTexEquationPrivate*>(                           \
+    microtex_equation_get_instance_private(MICROTEX_EQUATION(obj)) \
+  )
+
+enum { PROP_EQUATION = 1, PROP_WIDTH, PROP_TEXT_SIZE, PROP_COLOR, N_PROPERTIES };
+
+static GParamSpec* obj_properties[N_PROPERTIES] = {
+  NULL,
+};
+
+static void
+microtex_equation_get_property(GObject* object, guint prop_id, GValue* value, GParamSpec* pspec) {
+  MicroTexEquation* self = MICROTEX_EQUATION(object);
+
+  switch (prop_id) {
+    case PROP_EQUATION: g_value_set_string(value, microtex_equation_get_equation(self)); break;
+    case PROP_WIDTH: g_value_set_float(value, microtex_equation_get_width(self)); break;
+    case PROP_TEXT_SIZE: g_value_set_float(value, microtex_equation_get_text_size(self)); break;
+    case PROP_COLOR: g_value_set_uint(value, microtex_equation_get_color(self)); break;
+    default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
+  }
+}
+
+static void microtex_equation_set_property(
+  GObject* object,
+  guint prop_id,
+  const GValue* value,
+  GParamSpec* pspec
+) {
+  MicroTexEquation* self = MICROTEX_EQUATION(object);
+
+  switch (prop_id) {
+    case PROP_EQUATION: microtex_equation_set_equation(self, g_value_get_string(value)); break;
+    case PROP_WIDTH: microtex_equation_set_width(self, g_value_get_float(value)); break;
+    case PROP_TEXT_SIZE: microtex_equation_set_text_size(self, g_value_get_float(value)); break;
+    case PROP_COLOR: microtex_equation_set_color(self, g_value_get_uint(value)); break;
+    default: G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
+  }
+}
+
+static void microtex_equation_dispose(GObject* object) {
+  MicroTexEquationPrivate* priv = MICROTEX_EQUATION_GET_PRIVATE(object);
+
+  if (priv->microtex) delete priv->microtex;
+  if (priv->error) delete priv->error;
+  if (priv->equation) g_free(priv->equation);
+
+  G_OBJECT_CLASS(microtex_equation_parent_class)->dispose(object);
+}
+
+static GtkSizeRequestMode microtex_equation_get_request_mode(GtkWidget* widget) {
+  return GTK_SIZE_REQUEST_CONSTANT_SIZE;
+}
+static void microtex_equation_measure(
+  GtkWidget* widget,
+  GtkOrientation orientation,
+  int for_size,
+  int* min,
+  int* nat,
+  int* min_baseline,
+  int* nat_baseline
+) {
+  MicroTexEquationPrivate* priv = MICROTEX_EQUATION_GET_PRIVATE(widget);
+  if (!priv->microtex) {
+    g_info("uninitialized microtex\n");
+    if (!priv->error) {
+      g_critical("uninitialized microtex and error state\n");
+      return;
+    }
+
+    if (orientation == GTK_ORIENTATION_HORIZONTAL) {
+      *min = priv->error->width;
+      *nat = priv->error->width;
+    }
+    if (orientation == GTK_ORIENTATION_VERTICAL) {
+      *min = priv->error->height;
+      *nat = priv->error->height;
+      *min_baseline = priv->error->baseline;
+      *nat_baseline = priv->error->baseline;
+    }
+    return;
+  }
+
+  if (orientation == GTK_ORIENTATION_HORIZONTAL) {
+    *min = priv->microtex->getWidth() + 1;
+    *nat = priv->microtex->getWidth() + 1;
+  }
+  if (orientation == GTK_ORIENTATION_VERTICAL) {
+    *min = priv->microtex->getHeight() + 1;
+    *nat = priv->microtex->getHeight() + 1;
+    if (priv->microtex->getBaseline() == microtex::F_MIN || std::isnan(priv->microtex->getBaseline()))
+      return;
+    /* *min_baseline = priv->microtex->getBaseline();
+    *nat_baseline = priv->microtex->getBaseline();
+    // when there is no rendered LaTeX, µTeX sets baseline to -F_MAX
+    if (*min_baseline == G_MININT32)
+            *min_baseline = 0;
+    if (*nat_baseline == G_MININT32)
+            *nat_baseline = 0;*/
+    gint baseline = (gint)round(0 + *min * (1.0f - priv->microtex->getBaseline()));
+    *min_baseline = baseline;
+    *nat_baseline = baseline;
+  }
+}
+static void microtex_equation_snapshot(GtkWidget* widget, GtkSnapshot* snapshot) {
+  MicroTexEquationPrivate* priv = MICROTEX_EQUATION_GET_PRIVATE(widget);
+
+  gdouble width = gtk_widget_get_allocated_width(widget),
+          height = gtk_widget_get_allocated_height(widget);
+
+  graphene_rect_t rectangle;
+  graphene_rect_t* rect = graphene_rect_init(&rectangle, 0, 0, width, height);
+  // do I have to free this?
+
+  cairo_t* ctx = gtk_snapshot_append_cairo(snapshot, rect);
+
+  if (!priv->microtex) {
+    g_info("uninitialized microtex\n");
+    if (!priv->error) {
+      g_critical("uninitialized microtex and error state\n");
+      goto cairo_ctx_free;
+    }
+    priv->error->ui_handler(ctx);
+  } else {
+    microtex::Graphics2D_cairo g2(ctx);
+    priv->microtex->draw(g2, 0, 0);
+  }
+cairo_ctx_free:
+  cairo_destroy(ctx);
+}
+
+static void microtex_equation_create_render(MicroTexEquation* self) {
+  MicroTexEquationPrivate* priv = MICROTEX_EQUATION_GET_PRIVATE(self);
+  GtkWidget* widget = GTK_WIDGET(self);
+
+  if (!priv->shown) return;
+
+  if (priv->microtex) delete priv->microtex;
+
+  if (priv->error) {
+    delete priv->error;
+    priv->error = NULL;
+  }
+
+  if (priv->equation) try {
+      priv->microtex = tex::MicroTeX::parse(
+        std::string(priv->equation),
+        microtex_equation_get_width(self),
+        microtex_equation_get_text_size(self),
+        microtex_equation_get_text_size(self) / 3.f,
+        microtex_equation_get_color(self)
+      );
+
+      if (gtk_widget_get_has_tooltip(widget)) gtk_widget_set_has_tooltip(widget, FALSE);
+
+    } catch (tex::ex_parse& e) {
+      g_warning("MicroTeX parsing error: %s\n", e.what());
+
+      gtk_widget_set_tooltip_text(widget, e.what());
+
+      priv->error = new MicroTeXErrorState(
+        e,
+        +[](cairo_t* ctx) {
+          cairo_set_source_rgb(ctx, 1, 0, 0);
+          cairo_set_font_size(ctx, 10);
+          cairo_move_to(ctx, 0, 14);
+          cairo_show_text(ctx, "LaTeX parse failed");
+
+          cairo_fill(ctx);
+        }
+      );
+
+      priv->microtex = NULL;
+    } catch (tex::ex_invalid_state& e) {
+      g_warning("MicroTeX rendering error: %s\n", e.what());
+
+      gtk_widget_set_tooltip_text(widget, e.what());
+
+      priv->error = new MicroTeXErrorState(
+        e,
+        +[](cairo_t* ctx) {
+          cairo_set_source_rgb(ctx, 1, 0, 0);
+          cairo_set_font_size(ctx, 10);
+          cairo_move_to(ctx, 0, 14);
+          cairo_show_text(ctx, "LaTeX render failed");
+
+          cairo_fill(ctx);
+        }
+      );
+
+      priv->microtex = NULL;
+    } catch (tex::ex_tex& e) {
+      g_warning("Unknown MicroTeX error: %s\n", e.what());
+
+      gtk_widget_set_tooltip_text(widget, e.what());
+
+      priv->error = new MicroTeXErrorState(
+        e,
+        +[](cairo_t* ctx) {
+          cairo_set_source_rgb(ctx, 1, 0, 0);
+          cairo_set_font_size(ctx, 10);
+          cairo_move_to(ctx, 0, 14);
+          cairo_show_text(ctx, "Unknown MicroTeX error");
+
+          cairo_fill(ctx);
+        }
+      );
+
+      priv->microtex = NULL;
+    }
+  else
+    priv->microtex = NULL;
+
+  gtk_widget_queue_resize(GTK_WIDGET(self));
+}
+
+void microtex_equation_show(GtkWidget* widget) {
+  MicroTexEquationPrivate* priv = MICROTEX_EQUATION_GET_PRIVATE(widget);
+  priv->shown = TRUE;
+  microtex_equation_create_render(MICROTEX_EQUATION(widget));
+  GTK_WIDGET_CLASS(microtex_equation_parent_class)->show(widget);
+}
+void microtex_equation_hide(GtkWidget* widget) {
+  MicroTexEquationPrivate* priv = MICROTEX_EQUATION_GET_PRIVATE(widget);
+  priv->shown = FALSE;
+  GTK_WIDGET_CLASS(microtex_equation_parent_class)->hide(widget);
+}
+
+static void microtex_equation_class_init(MicroTexEquationClass* klass) {
+  GObjectClass* object_class = G_OBJECT_CLASS(klass);
+  GtkWidgetClass* widget_class = GTK_WIDGET_CLASS(klass);
+
+  object_class->get_property = microtex_equation_get_property;
+  object_class->set_property = microtex_equation_set_property;
+  object_class->dispose = microtex_equation_dispose;
+
+  widget_class->get_request_mode = microtex_equation_get_request_mode;
+  widget_class->measure = microtex_equation_measure;
+  widget_class->snapshot = microtex_equation_snapshot;
+
+  widget_class->show = microtex_equation_show;
+  widget_class->hide = microtex_equation_hide;
+
+  // clang-format off
+  /**
+   * MicroTexEquation:latex: (attributes org.gtk.Property.get=microtex_equation_get_equation org.gtk.Property.set=microtex_equation_set_equation)
+   *
+   * The (La)TeX string that the widget will render and display.
+   */
+  // clang-format on
+  obj_properties[PROP_EQUATION] = g_param_spec_string(
+    "latex",
+    "LaTeX",
+    "LaTeX equation",
+    "",
+    (GParamFlags)(G_PARAM_READWRITE | G_PARAM_CONSTRUCT)
+  );
+  // clang-format off
+  /**
+   * MicroTexEquation:width: (attributes org.gtk.Property.get=microtex_equation_get_width org.gtk.Property.set=microtex_equation_set_width)
+   *
+   * the width of the 2D graphics context (in pixel) to limit the
+   * formula layout, the engine will trying to wrap the layout if it
+   * overflows the width, but will fails if formula cannot be split.
+   */
+  // clang-format on
+  obj_properties[PROP_WIDTH] = g_param_spec_float(
+    "width",
+    "Width",
+    "The maximal width the LaTeX equation may use horizontally",
+    -1,
+    G_MAXFLOAT,
+    -1,
+    (GParamFlags)(G_PARAM_READWRITE | G_PARAM_CONSTRUCT)
+  );
+  // clang-format off
+  /**
+   * MicroTexEquation:text-size: (attributes org.gtk.Property.get=microtex_equation_get_text_size org.gtk.Property.set=microtex_equation_set_text_size)
+   *
+   * the text size that the widget will be rendered with.
+   */
+  // clang-format on
+  obj_properties[PROP_TEXT_SIZE] = g_param_spec_float(
+    "text-size",
+    "Textsize",
+    "The text size to draw",
+    6,
+    G_MAXFLOAT,
+    18,
+    (GParamFlags)(G_PARAM_READWRITE | G_PARAM_CONSTRUCT)
+  );
+  // clang-format off
+  /**
+   * MicroTexEquation:color: (attributes org.gtk.Property.get=microtex_equation_get_color org.gtk.Property.set=microtex_equation_set_color)
+   *
+   * the foreground color, in which the equation (unless specifically
+   * set otherweise) will be rendered with.
+   *
+   * The color is saved in an unsigned 32bit (4 bytes) integer in the following format:
+   * ```c
+   * struct Color {
+   *     guint8 alpha;
+   *     guint8 red;
+   *     guint8 green;
+   *     guint8 blue;
+   * };
+   * ```
+   * with `0xFF` representing the full channel and `0x00` none.
+   * Converting from GdkRGBA could look like this:
+   * ```c
+   * guint32 color_from_rgba(GdkRGBA color) {
+   *     return
+   * (guint8)(color.alpha*255)<<24|(guint8)(color.red*255)<<16|(guint8)(color.green*255)<<8|(guint8)(color.blue*255);
+   * }
+   * ```
+   */
+  // clang-format on
+  obj_properties[PROP_COLOR] = g_param_spec_uint(
+    "color",
+    "Color",
+    "The foreground color to draw",
+    0,
+    G_MAXUINT32,
+    0xff000000,
+    (GParamFlags)(G_PARAM_READWRITE | G_PARAM_CONSTRUCT)
+  );
+  g_object_class_install_properties(object_class, N_PROPERTIES, obj_properties);
+}
+
+static void microtex_equation_init(MicroTexEquation* self) {
+  MicroTexEquationPrivate* priv = MICROTEX_EQUATION_GET_PRIVATE(self);
+  priv->shown = TRUE;
+  priv->equation = NULL;
+  priv->microtex = NULL;
+  priv->width = -1;
+  priv->text_size = 18;
+  priv->color = 0xff000000;
+
+  microtex_equation_init_tex();
+}
+
+extern "C" {
+/**
+ * microtex_equation_new:
+ *
+ * Creates a new `MicroTexEquation` widget.
+ *
+ * Returns (transfer full): a new `MicroTexEquation`
+ */
+GtkWidget* microtex_equation_new(void) {
+  return static_cast<GtkWidget*>(g_object_new(MICROTEX_TYPE_EQUATION, NULL));
+}
+
+/**
+ * microtex_equation_get_equation: (attributes org.gtk.Method.get_property=latex)
+ * @self: a `MicroTexEquation`
+ *
+ * Returns the equation (La)TeX string being displayed by this widget.
+ *
+ * The reference count on the buffer is not incremented; the caller
+ * of this function won’t own a new reference.
+ *
+ * Returns: (nullable) (transfer none): an UTF-8 string. This string is
+ * owned by the widget and must not be modified or freed.
+ */
+const gchar* microtex_equation_get_equation(MicroTexEquation* self) {
+  MicroTexEquationPrivate* priv;
+  g_return_val_if_fail(MICROTEX_IS_EQUATION(self), NULL);
+  priv = MICROTEX_EQUATION_GET_PRIVATE(self);
+
+  return priv->equation;
+}
+/**
+ * microtex_equation_set_equation: (attributes org.gtk.Method.set_property=latex)
+ * @self: a `MicroTexEquation`
+ * @equation: a valid (La)TeX equation as UTF-8 string
+ *
+ * Sets the rendered equation of the widget to @equation.
+ *
+ * This will override any previously set equations.
+ */
+void microtex_equation_set_equation(MicroTexEquation* self, const gchar* equation) {
+  MicroTexEquationPrivate* priv;
+  g_return_if_fail(MICROTEX_IS_EQUATION(self));
+  priv = MICROTEX_EQUATION_GET_PRIVATE(self);
+
+  if (priv->equation == equation) return;
+
+  if (g_strcmp0(priv->equation, equation) == 0) return;
+
+  if (priv->equation) g_free(priv->equation);
+
+  priv->equation = g_strdup(equation);
+
+  microtex_equation_create_render(self);
+
+  g_object_notify_by_pspec(G_OBJECT(self), obj_properties[PROP_EQUATION]);
+}
+
+/**
+ * microtex_equation_get_width: (attributes org.gtk.Method.get_property=width)
+ * @self: a `MicroTexEquation`
+ *
+ * Returns the width that the graphic context uses to determine when to
+ * break the line within the equation.
+ *
+ * See [property@MicroTex.Equation:width].
+ *
+ * Returns: an IEEE 764 floating point number. `0` when infinitly long
+ */
+gfloat microtex_equation_get_width(MicroTexEquation* self) {
+  MicroTexEquationPrivate* priv;
+  g_return_val_if_fail(MICROTEX_IS_EQUATION(self), NAN);
+  priv = MICROTEX_EQUATION_GET_PRIVATE(self);
+
+  return priv->width;
+}
+
+/**
+ * microtex_equation_set_width: (attributes org.gtk.Method.set_property=width)
+ * @self: a `MicroTexEquation`
+ * @width: width in IEEE 754 floating point format
+ *
+ * Sets the width that the context uses to determine when to linebreak.
+ *
+ * See [property@MicroTex.Equation:width].
+ */
+void microtex_equation_set_width(MicroTexEquation* self, gfloat width) {
+  MicroTexEquationPrivate* priv;
+  g_return_if_fail(MICROTEX_IS_EQUATION(self));
+  priv = MICROTEX_EQUATION_GET_PRIVATE(self);
+
+  if (priv->width == width) return;
+
+  priv->width = width;
+
+  microtex_equation_create_render(self);
+
+  g_object_notify_by_pspec(G_OBJECT(self), obj_properties[PROP_WIDTH]);
+}
+
+/**
+ * microtex_equation_get_text_size: (attributes org.gtk.Method.get_property=text-size)
+ * @self: a `MicroTexEquation`
+ *
+ * Returns the current text size.
+ *
+ * See [property@MicroTex.Equation:text-size].
+ *
+ * Returns: an IEEE 764 floating point number representing the text
+ * size
+ */
+gfloat microtex_equation_get_text_size(MicroTexEquation* self) {
+  MicroTexEquationPrivate* priv;
+  g_return_val_if_fail(MICROTEX_IS_EQUATION(self), NAN);
+  priv = MICROTEX_EQUATION_GET_PRIVATE(self);
+
+  return priv->text_size;
+}
+
+/**
+ * microtex_equation_set_text_size: (attributes org.gtk.Method.set_property=text-size)
+ * @self: a `MicroTexEquation`
+ * @text_size: text size in IEEE 754 floating point format
+ *
+ * Sets the text size
+ *
+ * See [property@MicroTex.Equation:text-size].
+ */
+void microtex_equation_set_text_size(MicroTexEquation* self, gfloat text_size) {
+  MicroTexEquationPrivate* priv;
+  g_return_if_fail(MICROTEX_IS_EQUATION(self));
+  priv = MICROTEX_EQUATION_GET_PRIVATE(self);
+
+  if (priv->text_size == text_size) return;
+
+  priv->text_size = text_size;
+
+  if (priv->microtex) {
+    priv->microtex->setTextSize(priv->text_size);
+    gtk_widget_queue_resize(GTK_WIDGET(self));
+  }
+
+  g_object_notify_by_pspec(G_OBJECT(self), obj_properties[PROP_TEXT_SIZE]);
+}
+
+/**
+ * microtex_equation_get_color: (attributes org.gtk.Method.get_property=color)
+ * @self: a `MicroTexEquation`
+ *
+ * Returns the current color of the equation.
+ *
+ * See [property@MicroTex.Equation:color] for the format.
+ *
+ * Returns: an unsigned 32bit integer. The format is defined in
+ * [property@MicroTex.Equation:color].
+ */
+guint32 microtex_equation_get_color(MicroTexEquation* self) {
+  MicroTexEquationPrivate* priv;
+  g_return_val_if_fail(MICROTEX_IS_EQUATION(self), 0xff000000);
+  priv = MICROTEX_EQUATION_GET_PRIVATE(self);
+
+  return priv->color;
+}
+
+/**
+ * microtex_equation_set_color: (attributes org.gtk.Method.set_property=color)
+ * @self: a `MicroTexEquation`
+ * @color: color in the format specified in [property@MicroTex.Equation:color]
+ *
+ * Sets the color
+ *
+ * See [property@MicroTex.Equation:color].
+ */
+void microtex_equation_set_color(MicroTexEquation* self, guint32 color) {
+  MicroTexEquationPrivate* priv;
+  g_return_if_fail(MICROTEX_IS_EQUATION(self));
+  priv = MICROTEX_EQUATION_GET_PRIVATE(self);
+
+  if (priv->color == color) return;
+
+  priv->color = color;
+
+  if (priv->microtex) {
+    priv->microtex->setForeground(priv->color);
+    gtk_widget_queue_draw(GTK_WIDGET(self));
+  }
+
+  g_object_notify_by_pspec(G_OBJECT(self), obj_properties[PROP_COLOR]);
+}
+
+/**
+ * microtex_equation_get_baseline:
+ * @self: a `MicroTexEquation`
+ *
+ * Gets the baseline of the rendered Equation in GTK format
+ *
+ * Returns: the baseline as signed 64bit integer
+ */
+gint64 microtex_equation_get_baseline(MicroTexEquation* self) {
+  MicroTexEquationPrivate* priv;
+  g_return_val_if_fail(MICROTEX_IS_EQUATION(self), -1);
+  priv = MICROTEX_EQUATION_GET_PRIVATE(self);
+
+  if (!priv->microtex) return -1;
+
+  int height = priv->microtex->getHeight();
+  gint64 baseline = (gint64)round(0 + height * (1.0f - priv->microtex->getBaseline()));
+
+  // workaround for not entirely correct baseline arithmetic
+  if (height > 12) baseline += 1;
+
+  return baseline;
+}
+
+static cairo_status_t array_writer_fun(GArray** array, const guint8* data, uint len) {
+  *array = g_array_append_vals(*array, data, len);
+  return CAIRO_STATUS_SUCCESS;
+}
+/**
+ * microtex_equation_to_svg:
+ * @self: a `MicroTexEquation`
+ * @success (nullable): stores %TRUE if the rendered equation was valid
+ *
+ * Converts the equation to svg format.
+ *
+ * Keep in mind, that this method can store %FALSE in `@success` and
+ * still return a `GBytes`. In these cases the svg will contain the
+ * same error message that the widget itself also renders.
+ * It is up to the discretion of the implementor whether to continue
+ * working with the image or to discard (and free) it.
+ *
+ * Returns (nullable) (transfer full): the SVG as `GBytes` for future consumption
+ */
+GBytes* microtex_equation_to_svg(MicroTexEquation* self, gboolean* success) {
+  MicroTexEquationPrivate* priv;
+  g_return_val_if_fail(MICROTEX_IS_EQUATION(self), NULL);
+  priv = MICROTEX_EQUATION_GET_PRIVATE(self);
+
+  GByteArray* array = g_byte_array_new();
+  cairo_surface_t* svg = cairo_svg_surface_create_for_stream(
+    (cairo_write_func_t)array_writer_fun,
+    &array,
+    (double)priv->microtex->getWidth(),
+    (double)priv->microtex->getHeight()
+  );
+  cairo_t* ctx = cairo_create(svg);
+
+  if (!priv->microtex) {
+    g_info("uninitialized microtex\n");
+    if (success) *success = FALSE;
+    if (!priv->error) {
+      g_critical("uninitialized microtex and error state\n");
+      cairo_destroy(ctx);
+      cairo_surface_destroy(svg);
+      g_byte_array_unref(array);
+      return NULL;
+    }
+    priv->error->ui_handler(ctx);
+  } else {
+    microtex::Graphics2D_cairo g2(ctx);
+    priv->microtex->draw(g2, 0, 0);
+    if (success) *success = TRUE;
+  }
+
+  cairo_destroy(ctx);
+  cairo_surface_destroy(svg);
+
+  return g_byte_array_free_to_bytes(array);
+}
+
+/**
+ * microtex_equation_init_tex:
+ *
+ * Initializes the µTeX renderer
+ *
+ * `MicroTexEquation` will call this function during init, so you
+ * typically don't need to call this function yourself.
+ */
+gboolean microtex_equation_init_tex() {
+  if (tex::MicroTeX::isInited()) {
+    g_info("MicroTeX already initialized\n");
+    return FALSE;
+  }
+
+  tex::InitFontSenseAuto autoinit;
+  tex::MicroTeX::init(autoinit);
+  tex::PlatformFactory::registerFactory("gtk", std::make_unique<tex::PlatformFactory_cairo>());
+  tex::PlatformFactory::activate("gtk");
+  tex::MicroTeX::overrideTexStyle(true, tex::TexStyle::display);
+
+  return TRUE;
+}
+}