@simonklee/opentui-tex-native-source 0.2.0

package/native/vendor/microtex/platform/flutter/microtex/lib/src/render.dart

@@ -0,0 +1,291 @@
+import 'dart:convert';
+import 'dart:ffi';
+import 'dart:typed_data';
+import 'dart:ui';
+
+import 'package:flutter/rendering.dart';
+import 'package:microtex/microtex.dart';
+import 'package:microtex/src/bindings.dart';
+import 'package:microtex/src/pathcache.dart';
+import 'package:microtex/src/textlayout.dart';
+
+class Render {
+  final NativeBindings _bindings;
+  final Pointer _nativeInstance;
+  final Endian _endian;
+
+  /// If filter is enabled, using a bluring to simulate the 'grid fitting' on glyhs
+  /// drawing to get a much clear rendering, but it is expensive, especially for
+  /// complex formulas.
+  /// See [https://github.com/flutter/flutter/issues/104017].
+  Blur? blur;
+
+  Render(this._bindings, this._nativeInstance, bool isLittleEndian)
+      : _endian = isLittleEndian ? Endian.little : Endian.big;
+
+  /// The width of this render.
+  int get width => _bindings.getRenderWidth(_nativeInstance);
+
+  /// The height of this render, equals to ascent + descent (or namely [depth],
+  /// distance below the baseline).
+  int get height => _bindings.getRenderHeight(_nativeInstance);
+
+  /// The distance below the baseline, in positive.
+  int get depth => _bindings.getRenderDepth(_nativeInstance);
+
+  /// Test if this render is split to multi-lines.
+  bool get isSplit => _bindings.isRenderSplit(_nativeInstance);
+
+  void release() {
+    _bindings.deleteRender(_nativeInstance);
+  }
+
+  /// Set the text size to draw. The dimension ([width], [height], [depth]) will be
+  /// changed following the text size change.
+  void setTextSize(double textSize) {
+    _bindings.setRenderTextSize(_nativeInstance, textSize);
+  }
+
+  /// Set the foreground color to draw.
+  void setColor(int color) {
+    _bindings.setRenderForground(_nativeInstance, color);
+  }
+
+  /// If this render is use path to render glyphs.
+  ///
+  /// Unlike the [MicroTeX.isRenderGlyphUsePath], this is for every particular renders.
+  bool isRenderGlyphUsePath = false;
+
+  static const _caps = [StrokeCap.butt, StrokeCap.round, StrokeCap.square];
+  static const _joins = [StrokeJoin.bevel, StrokeJoin.round, StrokeJoin.miter];
+
+  final _paint = Paint()..isAntiAlias = true;
+  final _argBuf = Float32List(8);
+
+  void draw(Canvas canvas) {
+    print("Render.draw");
+    // it is OK to change the value of the property [MicroTeX.isRenderGlyphUsePath] when
+    // drawing every renders, since draw runs in UI thread.
+    final prevIsRenderGlyphUsePath = MicroTeX().isRenderGlyphUsePath();
+    MicroTeX().setRenderGlyphUsePath(isRenderGlyphUsePath);
+    // get the drawing commands from native render
+    final drawingData = _bindings.getDrawingData(_nativeInstance, 0, 0);
+    // the first 4 bytes is the total count of byte used
+    final n = drawingData.asTypedList(4);
+    final len = n.buffer.asByteData().getUint32(0, _endian);
+
+    // make a view to iterate over the drawing commands
+    final v = drawingData.asTypedList(len).buffer.asByteData();
+    var offset = 0;
+
+    int getU8() {
+      final x = v.getUint8(offset);
+      offset += 1;
+      return x;
+    }
+
+    T getNum<T>(int size, T Function(int offset) f) {
+      final x = f(offset);
+      offset += size;
+      return x;
+    }
+
+    String getString() {
+      final utf8 = <int>[];
+      var byte = getU8();
+      while (byte != 0) {
+        utf8.add(byte);
+        byte = getU8();
+      }
+      return const Utf8Decoder().convert(utf8);
+    }
+
+    int getU16() => getNum(2, (offset) => v.getUint16(offset, _endian));
+    int getI32() => getNum(4, (offset) => v.getInt32(offset, _endian));
+    int getU32() => getNum(4, (offset) => v.getUint32(offset, _endian));
+    double getF32() => getNum(4, (offset) => v.getFloat32(offset, _endian));
+
+    Float32List getF32s(int cnt) {
+      for (var i = 0; i < cnt; i++) {
+        _argBuf[i] = v.getFloat32(offset, _endian);
+        offset += 4;
+      }
+      return _argBuf;
+    }
+
+    // consume the first 4 bytes
+    getU32();
+    var sx = 1.0, sy = 1.0;
+    var path = Path();
+
+    var fontFamily = "";
+    var fontSize = 0.0;
+
+    while (offset < len) {
+      final cmd = getU8();
+      switch (cmd) {
+        case 0: // setColor
+          final color = getU32();
+          _paint.color = Color(color);
+          break;
+        case 1: // setStroke
+          final lineWidth = getF32();
+          final miterLimit = getF32();
+          final cap = getU32();
+          final join = getU32();
+          _paint
+            ..strokeWidth = lineWidth
+            ..strokeMiterLimit = miterLimit
+            ..strokeCap = _caps[cap]
+            ..strokeJoin = _joins[join];
+          break;
+        case 2: // setDash
+          final hasDash = getU8() == 1;
+          final dash = hasDash ? [5 / sx, 5 / sx] : [];
+          // FIXME
+          // Flutter does not support dashing lines
+          break;
+        case 3: // setFont
+          // TODO
+          final family = getString();
+          fontFamily = family;
+          break;
+        case 4: // setFontSize
+          // TODO
+          final size = getF32();
+          fontSize = size;
+          break;
+        case 5: // translate
+          final t = getF32s(2);
+          canvas.translate(t[0], t[1]);
+          break;
+        case 6: // scale
+          final s = getF32s(2);
+          sx *= s[0];
+          sy *= s[1];
+          canvas.scale(s[0], s[1]);
+          break;
+        case 7: // rotate
+          final r = getF32s(3);
+          canvas.translate(r[1], r[2]);
+          canvas.rotate(r[0]);
+          canvas.translate(-r[1], -r[2]);
+          break;
+        case 8: // reset
+          canvas.transform(Matrix4.identity().storage);
+          break;
+        case 9: // drawGlyph
+          // TODO
+          final glyph = getU16();
+          final xy = getF32s(2);
+          final run = GlyphRun(
+            glyphs: Uint16List.fromList([glyph]),
+            positions: [Offset(xy[0], xy[1])],
+            fontFamily: fontFamily,
+            fontSize: fontSize,
+          );
+          canvas.drawGlyphRun(run, const Offset(0, 0), _paint);
+          break;
+        case 10: // beginPath
+          final pid = getI32();
+          final p = PathCache()[pid];
+          path = p ?? Path();
+          break;
+        case 11: // moveTo
+          final m = getF32s(2);
+          path.moveTo(m[0], m[1]);
+          break;
+        case 12: // lineTo
+          final l = getF32s(2);
+          path.lineTo(l[0], l[1]);
+          break;
+        case 13: // cubicTo
+          final c = getF32s(6);
+          path.cubicTo(c[0], c[1], c[2], c[3], c[4], c[5]);
+          break;
+        case 14: // quadTo
+          final q = getF32s(4);
+          path.quadraticBezierTo(q[0], q[1], q[2], q[3]);
+          break;
+        case 15: // closePath
+          path.close();
+          break;
+        case 16: // fillPath
+          final pid = getI32();
+          _paint.style = PaintingStyle.fill;
+          final b = blur;
+          final p = b == null ? _paint : (_paint.copy()..maskFilter = MaskFilter.blur(b.style, b.sigma / sx));
+          PathCache()[pid] = path;
+          canvas.drawPath(path, p);
+          break;
+        case 17: // drawLine
+          final dl = getF32s(4);
+          canvas.drawLine(Offset(dl[0], dl[1]), Offset(dl[2], dl[3]), _paint);
+          break;
+        case 18: // drawRect
+          final dr = getF32s(4);
+          _paint.style = PaintingStyle.stroke;
+          canvas.drawRect(Rect.fromLTWH(dr[0], dr[1], dr[2], dr[3]), _paint);
+          break;
+        case 19: // fillRect
+          final fr = getF32s(4);
+          _paint.style = PaintingStyle.fill;
+          canvas.drawRect(Rect.fromLTWH(fr[0], fr[1], fr[2], fr[3]), _paint);
+          break;
+        case 20: // drawRoundRect
+          final rr = getF32s(6);
+          _paint.style = PaintingStyle.stroke;
+          canvas.drawRRect(
+            RRect.fromRectXY(Rect.fromLTWH(rr[0], rr[1], rr[2], rr[3]), rr[4], rr[5]),
+            _paint,
+          );
+          break;
+        case 21: // fillRoundRect
+          final rf = getF32s(6);
+          _paint.style = PaintingStyle.fill;
+          canvas.drawRRect(
+            RRect.fromRectXY(Rect.fromLTWH(rf[0], rf[1], rf[2], rf[3]), rf[4], rf[5]),
+            _paint,
+          );
+          break;
+        case 22: // drawTextLayout
+          final id = getU32();
+          final xy = getF32s(2);
+          TextLayout.draw(id, canvas, xy[0], xy[1], _paint.color);
+          break;
+        default:
+          // invalid drawing command
+          break;
+      }
+    }
+    // delete the drawing data
+    _bindings.deleteDrawingData(drawingData);
+    // reset the property
+    MicroTeX().setRenderGlyphUsePath(prevIsRenderGlyphUsePath);
+  }
+
+  @override
+  String toString() {
+    return "Render{$width, $height, $depth}";
+  }
+}
+
+extension _PaintExt on Paint {
+  Paint copy() {
+    return Paint()
+      ..isAntiAlias = isAntiAlias
+      ..color = color
+      ..blendMode = blendMode
+      ..style = style
+      ..strokeWidth = strokeWidth
+      ..strokeCap = strokeCap
+      ..strokeJoin = strokeJoin
+      ..strokeMiterLimit = strokeMiterLimit
+      ..maskFilter = maskFilter
+      ..filterQuality = filterQuality
+      ..shader = shader
+      ..colorFilter = colorFilter
+      ..imageFilter = imageFilter
+      ..invertColors = invertColors;
+  }
+}

package/native/vendor/microtex/platform/flutter/microtex/lib/src/texstyle.dart

@@ -0,0 +1,11 @@
+/// Keep in sync with [nativelib/lib/utils/types.h]
+enum TeXStyle {
+  display,
+  display1,
+  text,
+  text1,
+  script,
+  script1,
+  scriptScript,
+  scriptScript1,
+}

package/native/vendor/microtex/platform/flutter/microtex/lib/src/textlayout.dart

@@ -0,0 +1,93 @@
+import 'package:flutter/material.dart';
+import 'package:flutter/painting.dart';
+import 'package:microtex/src/context.dart';
+import 'package:microtex/src/fontdesc.dart';
+
+class TextLayout {
+  TextLayout._();
+
+  static String _serif = "";
+  static String _sansSerif = "";
+  static String _monospace = "";
+
+  static int _id = 0;
+  static final _texts = <int, Txt>{};
+
+  static void setFontFamily(String serif, String sansSerif, String monospace) {
+    _serif = serif;
+    _sansSerif = sansSerif;
+    _monospace = monospace;
+  }
+
+  static int create(String text, FontDesc font) {
+    _id++;
+    _texts[_id] = Txt(text, font);
+    return _id;
+  }
+
+  /// FIXME
+  /// Because TextStyle cannot be modified, we need to create 2 painters in
+  /// method [getBounds] to retrieve the metrics and method [draw] to
+  /// change the color to draw
+  static TextPainter _createPainter(Txt t, [Color? color]) {
+    return TextPainter(
+      text: TextSpan(
+        text: t.txt,
+        style: TextStyle(
+          fontSize: t.fontSize,
+          fontWeight: t.fontWeight,
+          fontStyle: t.fontStyle,
+          fontFamily: t.fontFamily,
+          color: color,
+        ),
+      ),
+      textDirection: TextDirection.ltr,
+    );
+  }
+
+  static List<double> getBounds(int id) {
+    final t = _texts[id];
+    if (t == null) return [0, 0, 0];
+    final painter = _createPainter(t)..layout();
+    final m = painter.computeLineMetrics().first;
+    t.ascent = m.ascent;
+    return [m.width, m.ascent + m.descent, -m.ascent];
+  }
+
+  static void draw(int id, Canvas canvas, double x, double y, Color color) {
+    final t = _texts[id];
+    if (t == null) return;
+    _createPainter(t, color)
+      ..layout()
+      ..paint(canvas, Offset(x, y - t.ascent));
+  }
+
+  static void release(int id) {
+    if (debugMicroTeX) {
+      print('TextLayout.relase($id)');
+    }
+    _texts.remove(id);
+  }
+}
+
+class Txt {
+  final String txt;
+  final double fontSize;
+  late final FontWeight fontWeight;
+  late final FontStyle fontStyle;
+  late final String fontFamily;
+
+  double ascent = 0;
+
+  Txt(this.txt, FontDesc font) : fontSize = font.fontSize {
+    if (font.isSansSerif) {
+      fontFamily = TextLayout._sansSerif;
+    } else if (font.isMonospace) {
+      fontFamily = TextLayout._monospace;
+    } else {
+      fontFamily = TextLayout._serif;
+    }
+    fontWeight = font.isBold ? FontWeight.bold : FontWeight.normal;
+    fontStyle = font.isItalic ? FontStyle.italic : FontStyle.normal;
+  }
+}

package/native/vendor/microtex/platform/flutter/microtex/lib/src/widget.dart

@@ -0,0 +1,163 @@
+import 'package:flutter/material.dart';
+import 'package:microtex/microtex.dart';
+
+class Blur {
+  final BlurStyle style;
+  final double sigma;
+
+  const Blur(this.style, this.sigma);
+
+  @override
+  bool operator ==(Object other) {
+    return other is Blur && style == other.style && sigma == other.sigma;
+  }
+
+  @override
+  int get hashCode => hashValues(style, sigma);
+}
+
+class LaTeX extends LeafRenderObjectWidget {
+  final String latex;
+  final double textSize;
+  final Color color;
+  final bool isRenderGlyphUsePath;
+  final TeXStyle? style;
+  final Blur? blur;
+
+  const LaTeX({
+    Key? key,
+    required this.latex,
+    this.textSize = 20,
+    this.color = const Color(0xFF424242),
+    this.style,
+    this.blur,
+    this.isRenderGlyphUsePath = false,
+  }) : super(key: key);
+
+  @override
+  RenderObject createRenderObject(BuildContext context) {
+    return RenderLaTeX(latex, textSize, color, style, blur, isRenderGlyphUsePath);
+  }
+
+  @override
+  void updateRenderObject(BuildContext context, covariant RenderLaTeX renderObject) {
+    renderObject.update(latex, textSize, color, style, blur, isRenderGlyphUsePath);
+  }
+}
+
+class RenderLaTeX extends RenderBox {
+  String _latex;
+  double _textSize;
+  Color _color;
+  bool _isRenderGlyphUsePath;
+  TeXStyle? _style;
+  Blur? _blur;
+
+  double _lastMaxWidth = 0;
+  Render? _render;
+
+  RenderLaTeX(this._latex, this._textSize, this._color, this._style, this._blur, this._isRenderGlyphUsePath);
+
+  void update(String latex, double textSize, Color color, TeXStyle? style, Blur? blur, bool isRenderUsePath) {
+    var needParse = false;
+    if (_latex != latex || _style != style) {
+      _latex = latex;
+      _style = style;
+      needParse = true;
+    }
+    var needLayout = false;
+    if (_textSize != textSize) {
+      _textSize = textSize;
+      _render?.setTextSize(textSize);
+      needLayout = true;
+    }
+    var needPaint = false;
+    if (_color != color || _blur != blur || _isRenderGlyphUsePath != isRenderUsePath) {
+      _color = color;
+      _blur = blur;
+      _isRenderGlyphUsePath = isRenderUsePath;
+      _render
+        ?..setColor(color.value)
+        ..blur = blur
+        ..isRenderGlyphUsePath = isRenderUsePath;
+      needPaint = true;
+    }
+    if (debugMicroTeX) {
+      print(
+        'RenderLaTeX.update'
+        '{parse: $needParse, layout: $needLayout, paint: $needPaint}',
+      );
+    }
+    if (needParse) {
+      _render?.release();
+      _render = null;
+      markNeedsLayout();
+      return;
+    }
+    if (needLayout) {
+      markNeedsLayout();
+      return;
+    }
+    if (needPaint) markNeedsPaint();
+  }
+
+  @override
+  bool get isRepaintBoundary => true;
+
+  @override
+  void dispose() {
+    super.dispose();
+    _render?.release();
+  }
+
+  @override
+  void performLayout() {
+    var r = _render;
+    var reparse = false;
+    final maxWidth = constraints.maxWidth;
+    if (r != null && _lastMaxWidth != maxWidth) {
+      // If max width changed, it might need to re-parse
+      reparse = r.isSplit;
+    }
+    _lastMaxWidth = maxWidth;
+    if (r == null || reparse) {
+      if (debugMicroTeX) {
+        print(
+          'RenderLaTeX.performLayout'
+          '{render: $r, reparse: $reparse}',
+        );
+      }
+      r = MicroTeX().parse(
+        tex: _latex,
+        width: _lastMaxWidth == double.infinity ? 0 : _lastMaxWidth.toInt(),
+        textSize: _textSize,
+        lineSpace: _textSize / 3,
+        color: _color,
+        // never fill the width, if you want to, wrap a Container or something like that
+        fillWidth: false,
+        overrideTeXStyle: _style != null,
+        style: _style ?? TeXStyle.text,
+      );
+      r.blur = _blur;
+      r.isRenderGlyphUsePath = _isRenderGlyphUsePath;
+      _render = r;
+    }
+    size = Size(r.width.toDouble(), r.height.toDouble());
+  }
+
+  @override
+  double? computeDistanceToActualBaseline(TextBaseline baseline) {
+    final r = _render;
+    if (r == null) return null;
+    return (r.height - r.depth).toDouble();
+  }
+
+  @override
+  void paint(PaintingContext context, Offset offset) {
+    final r = _render;
+    if (r == null) return;
+    context.canvas.translate(offset.dx, offset.dy);
+    r.draw(context.canvas);
+    context.canvas.translate(-offset.dx, -offset.dy);
+  }
+}

package/native/vendor/microtex/platform/flutter/microtex/linux/CMakeLists.txt

@@ -0,0 +1,33 @@
+cmake_minimum_required(VERSION 3.10)
+set(PROJECT_NAME "microtex")
+project(${PROJECT_NAME} LANGUAGES CXX)
+
+# This value is used when generating builds using this plugin, so it must
+# not be changed
+set(PLUGIN_NAME "microtex_plugin")
+
+add_library(
+    ${PLUGIN_NAME} SHARED
+    "microtex_plugin.cc"
+)
+apply_standard_settings(${PLUGIN_NAME})
+set_target_properties(
+    ${PLUGIN_NAME} PROPERTIES
+    CXX_VISIBILITY_PRESET hidden
+)
+target_compile_definitions(${PLUGIN_NAME} PRIVATE FLUTTER_PLUGIN_IMPL)
+target_include_directories(
+    ${PLUGIN_NAME} INTERFACE
+    "${CMAKE_CURRENT_SOURCE_DIR}/include"
+)
+target_link_libraries(${PLUGIN_NAME} PRIVATE flutter)
+target_link_libraries(${PLUGIN_NAME} PRIVATE PkgConfig::GTK)
+
+add_subdirectory(nativelib)
+
+# List of absolute paths to libraries that should be bundled with the plugin
+set(
+    microtex_bundled_libraries
+    "${CMAKE_CURRENT_BINARY_DIR}/nativelib/lib/libmicrotex.so"
+    PARENT_SCOPE
+)

package/native/vendor/microtex/platform/flutter/microtex/linux/include/microtex/microtex_plugin.h

@@ -0,0 +1,26 @@
+#ifndef FLUTTER_PLUGIN_MICROTEX_PLUGIN_H_
+#define FLUTTER_PLUGIN_MICROTEX_PLUGIN_H_
+
+#include <flutter_linux/flutter_linux.h>
+
+G_BEGIN_DECLS
+
+#ifdef FLUTTER_PLUGIN_IMPL
+#define FLUTTER_PLUGIN_EXPORT __attribute__((visibility("default")))
+#else
+#define FLUTTER_PLUGIN_EXPORT
+#endif
+
+typedef struct _MicrotexPlugin MicrotexPlugin;
+typedef struct {
+  GObjectClass parent_class;
+} MicrotexPluginClass;
+
+FLUTTER_PLUGIN_EXPORT GType microtex_plugin_get_type();
+
+FLUTTER_PLUGIN_EXPORT void microtex_plugin_register_with_registrar(
+    FlPluginRegistrar* registrar);
+
+G_END_DECLS
+
+#endif  // FLUTTER_PLUGIN_MICROTEX_PLUGIN_H_

package/native/vendor/microtex/platform/flutter/microtex/linux/microtex_plugin.cc

@@ -0,0 +1,70 @@
+#include "include/microtex/microtex_plugin.h"
+
+#include <flutter_linux/flutter_linux.h>
+#include <gtk/gtk.h>
+#include <sys/utsname.h>
+
+#include <cstring>
+
+#define MICROTEX_PLUGIN(obj) \
+  (G_TYPE_CHECK_INSTANCE_CAST((obj), microtex_plugin_get_type(), \
+                              MicrotexPlugin))
+
+struct _MicrotexPlugin {
+  GObject parent_instance;
+};
+
+G_DEFINE_TYPE(MicrotexPlugin, microtex_plugin, g_object_get_type())
+
+// Called when a method call is received from Flutter.
+static void microtex_plugin_handle_method_call(
+    MicrotexPlugin* self,
+    FlMethodCall* method_call) {
+  g_autoptr(FlMethodResponse) response = nullptr;
+
+  const gchar* method = fl_method_call_get_name(method_call);
+
+  if (strcmp(method, "getPlatformVersion") == 0) {
+    struct utsname uname_data = {};
+    uname(&uname_data);
+    g_autofree gchar *version = g_strdup_printf("Linux %s", uname_data.version);
+    g_autoptr(FlValue) result = fl_value_new_string(version);
+    response = FL_METHOD_RESPONSE(fl_method_success_response_new(result));
+  } else {
+    response = FL_METHOD_RESPONSE(fl_method_not_implemented_response_new());
+  }
+
+  fl_method_call_respond(method_call, response, nullptr);
+}
+
+static void microtex_plugin_dispose(GObject* object) {
+  G_OBJECT_CLASS(microtex_plugin_parent_class)->dispose(object);
+}
+
+static void microtex_plugin_class_init(MicrotexPluginClass* klass) {
+  G_OBJECT_CLASS(klass)->dispose = microtex_plugin_dispose;
+}
+
+static void microtex_plugin_init(MicrotexPlugin* self) {}
+
+static void method_call_cb(FlMethodChannel* channel, FlMethodCall* method_call,
+                           gpointer user_data) {
+  MicrotexPlugin* plugin = MICROTEX_PLUGIN(user_data);
+  microtex_plugin_handle_method_call(plugin, method_call);
+}
+
+void microtex_plugin_register_with_registrar(FlPluginRegistrar* registrar) {
+  MicrotexPlugin* plugin = MICROTEX_PLUGIN(
+      g_object_new(microtex_plugin_get_type(), nullptr));
+
+  g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
+  g_autoptr(FlMethodChannel) channel =
+      fl_method_channel_new(fl_plugin_registrar_get_messenger(registrar),
+                            "microtex",
+                            FL_METHOD_CODEC(codec));
+  fl_method_channel_set_method_call_handler(channel, method_call_cb,
+                                            g_object_ref(plugin),
+                                            g_object_unref);
+
+  g_object_unref(plugin);
+}