@simonklee/opentui-tex-native-source 0.2.0

package/native/vendor/microtex/platform/flutter/microtex/example/windows/runner/win32_window.h

@@ -0,0 +1,98 @@
+#ifndef RUNNER_WIN32_WINDOW_H_
+#define RUNNER_WIN32_WINDOW_H_
+
+#include <windows.h>
+
+#include <functional>
+#include <memory>
+#include <string>
+
+// A class abstraction for a high DPI-aware Win32 Window. Intended to be
+// inherited from by classes that wish to specialize with custom
+// rendering and input handling
+class Win32Window {
+ public:
+  struct Point {
+    unsigned int x;
+    unsigned int y;
+    Point(unsigned int x, unsigned int y) : x(x), y(y) {}
+  };
+
+  struct Size {
+    unsigned int width;
+    unsigned int height;
+    Size(unsigned int width, unsigned int height)
+        : width(width), height(height) {}
+  };
+
+  Win32Window();
+  virtual ~Win32Window();
+
+  // Creates and shows a win32 window with |title| and position and size using
+  // |origin| and |size|. New windows are created on the default monitor. Window
+  // sizes are specified to the OS in physical pixels, hence to ensure a
+  // consistent size to will treat the width height passed in to this function
+  // as logical pixels and scale to appropriate for the default monitor. Returns
+  // true if the window was created successfully.
+  bool CreateAndShow(const std::wstring& title,
+                     const Point& origin,
+                     const Size& size);
+
+  // Release OS resources associated with window.
+  void Destroy();
+
+  // Inserts |content| into the window tree.
+  void SetChildContent(HWND content);
+
+  // Returns the backing Window handle to enable clients to set icon and other
+  // window properties. Returns nullptr if the window has been destroyed.
+  HWND GetHandle();
+
+  // If true, closing this window will quit the application.
+  void SetQuitOnClose(bool quit_on_close);
+
+  // Return a RECT representing the bounds of the current client area.
+  RECT GetClientArea();
+
+ protected:
+  // Processes and route salient window messages for mouse handling,
+  // size change and DPI. Delegates handling of these to member overloads that
+  // inheriting classes can handle.
+  virtual LRESULT MessageHandler(HWND window,
+                                 UINT const message,
+                                 WPARAM const wparam,
+                                 LPARAM const lparam) noexcept;
+
+  // Called when CreateAndShow is called, allowing subclass window-related
+  // setup. Subclasses should return false if setup fails.
+  virtual bool OnCreate();
+
+  // Called when Destroy is called.
+  virtual void OnDestroy();
+
+ private:
+  friend class WindowClassRegistrar;
+
+  // OS callback called by message pump. Handles the WM_NCCREATE message which
+  // is passed when the non-client area is being created and enables automatic
+  // non-client DPI scaling so that the non-client area automatically
+  // responsponds to changes in DPI. All other messages are handled by
+  // MessageHandler.
+  static LRESULT CALLBACK WndProc(HWND const window,
+                                  UINT const message,
+                                  WPARAM const wparam,
+                                  LPARAM const lparam) noexcept;
+
+  // Retrieves a class instance pointer for |window|
+  static Win32Window* GetThisFromHandle(HWND const window) noexcept;
+
+  bool quit_on_close_ = false;
+
+  // window handle for top level window.
+  HWND window_handle_ = nullptr;
+
+  // window handle for hosted content.
+  HWND child_content_ = nullptr;
+};
+
+#endif  // RUNNER_WIN32_WINDOW_H_

package/native/vendor/microtex/platform/flutter/microtex/ios/Classes/MicrotexPlugin.h

@@ -0,0 +1,4 @@
+#import <Flutter/Flutter.h>
+
+@interface MicrotexPlugin : NSObject<FlutterPlugin>
+@end

package/native/vendor/microtex/platform/flutter/microtex/ios/Classes/MicrotexPlugin.m

@@ -0,0 +1,19 @@
+#import "MicrotexPlugin.h"
+#if __has_include(<microtex/microtex-Swift.h>)
+#import <microtex/microtex-Swift.h>
+#else
+// Support project import fallback if the generated compatibility header
+// is not copied when this plugin is created as a library.
+// https://forums.swift.org/t/swift-static-libraries-dont-copy-generated-objective-c-header/19816
+#import "microtex-Swift.h"
+#endif
+
+#import "dummy.h"
+
+@implementation MicrotexPlugin
++ (void)registerWithRegistrar:(NSObject<FlutterPluginRegistrar>*)registrar {
+  [SwiftMicrotexPlugin registerWithRegistrar:registrar];
+  // dummy function call to keep microtex lib
+  microtex_isLittleEndian();
+}
+@end

package/native/vendor/microtex/platform/flutter/microtex/ios/Classes/SwiftMicrotexPlugin.swift

@@ -0,0 +1,14 @@
+import Flutter
+import UIKit
+
+public class SwiftMicrotexPlugin: NSObject, FlutterPlugin {
+  public static func register(with registrar: FlutterPluginRegistrar) {
+    let channel = FlutterMethodChannel(name: "microtex", binaryMessenger: registrar.messenger())
+    let instance = SwiftMicrotexPlugin()
+    registrar.addMethodCallDelegate(instance, channel: channel)
+  }
+
+  public func handle(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
+    result("iOS " + UIDevice.current.systemVersion)
+  }
+}

package/native/vendor/microtex/platform/flutter/microtex/ios/Classes/dummy.h

@@ -0,0 +1,4 @@
+// dummy decl to keep the microtex lib
+// if there is no reference to the static lib, the compiler will
+// ignore it
+bool microtex_isLittleEndian();

package/native/vendor/microtex/platform/flutter/microtex/ios/microtex.podspec

@@ -0,0 +1,27 @@
+#
+# To learn more about a Podspec see http://guides.cocoapods.org/syntax/podspec.html.
+# Run `pod lib lint microtex.podspec` to validate before publishing.
+#
+Pod::Spec.new do |s|
+  s.name             = 'microtex'
+  s.version          = '0.0.1'
+  s.summary          = 'A micro, fast, cross-platform, and embeddable LaTeX rendering library.'
+  s.description      = <<-DESC
+A micro, fast, cross-platform, and embeddable LaTeX rendering library.
+                       DESC
+  s.homepage         = 'http://example.com'
+  s.license          = { :file => '../LICENSE' }
+  s.author           = { 'Your Company' => 'email@example.com' }
+  s.source           = { :path => '.' }
+  s.source_files = 'Classes/**/*'
+  s.dependency 'Flutter'
+  s.platform = :ios, '9.0'
+
+  s.libraries = 'c++'
+  s.vendored_libraries = 'libs/libmicrotex.a'
+
+  # Flutter.framework does not contain a i386 slice.
+  s.pod_target_xcconfig = { 'DEFINES_MODULE' => 'YES', 'EXCLUDED_ARCHS[sdk=iphonesimulator*]' => 'i386 arm64' }
+  s.user_target_xcconfig = { 'EXCLUDED_ARCHS[sdk=iphonesimulator*]' => 'arm64' }
+  s.swift_version = '5.0'
+end

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

@@ -0,0 +1,7 @@
+library microtex;
+
+export 'src/context.dart';
+export 'src/fontmeta.dart';
+export 'src/render.dart';
+export 'src/texstyle.dart';
+export 'src/widget.dart' show LaTeX, Blur;

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

@@ -0,0 +1,218 @@
+import 'dart:ffi';
+import 'dart:io';
+import 'package:ffi/ffi.dart';
+import 'package:microtex/src/context.dart';
+import 'package:microtex/src/fontdesc.dart';
+
+import 'bounds.dart';
+
+typedef NCreateTextLayout = Uint32 Function(Pointer<Utf8>, Pointer<FontDesc>);
+typedef NGetTextLayoutBounds = Void Function(Uint32, Pointer<Bounds>);
+typedef NReleaseTextLayout = Void Function(Uint32);
+typedef NIsPathExists = Bool Function(Uint32);
+typedef NRegisterCallbacks = Void Function(
+  Pointer<NativeFunction<NCreateTextLayout>>,
+  Pointer<NativeFunction<NGetTextLayoutBounds>>,
+  Pointer<NativeFunction<NReleaseTextLayout>>,
+  Pointer<NativeFunction<NIsPathExists>>,
+);
+typedef RegisterCallbacks = void Function(
+  Pointer<NativeFunction<NCreateTextLayout>>,
+  Pointer<NativeFunction<NGetTextLayoutBounds>>,
+  Pointer<NativeFunction<NReleaseTextLayout>>,
+  Pointer<NativeFunction<NIsPathExists>>,
+);
+
+typedef NativeParse = Pointer Function(Pointer<Utf8>, Int32, Float, Float, Uint32, Bool, Bool, Uint32);
+typedef Parse = Pointer Function(Pointer<Utf8>, int, double, double, int, bool, bool, int);
+
+class NativeBindings {
+  late final DynamicLibrary _nativeLib;
+
+  // context
+  late final RegisterCallbacks registerCallbacks;
+  late final Pointer Function(int, Pointer) init;
+  late final bool Function() isInited;
+  late final void Function() release;
+  late final bool Function() isLittleEndian;
+
+  // font operations
+  late final Pointer<Utf8> Function(Pointer) getFontFamily;
+  late final Pointer<Utf8> Function(Pointer) getFontName;
+  late final bool Function(Pointer) isMathFont;
+  late final void Function(Pointer) releaseFontMeta;
+  late final Pointer Function(int len, Pointer) addFont;
+
+  // setters
+  late final void Function(Pointer<Utf8>) setDefaultMathFont;
+  late final void Function(Pointer<Utf8>) setDefaultMainFont;
+
+  // parse
+  late final Parse parse;
+
+  // render
+  late final void Function(Pointer) deleteRender;
+  late final Pointer<Uint8> Function(Pointer, int, int) getDrawingData;
+  late final void Function(Pointer) deleteDrawingData;
+  late final int Function(Pointer) getRenderWidth;
+  late final int Function(Pointer) getRenderHeight;
+  late final int Function(Pointer) getRenderDepth;
+  late final bool Function(Pointer) isRenderSplit;
+  late final void Function(Pointer, double) setRenderTextSize;
+  late final void Function(Pointer, int) setRenderForground;
+
+  // glyph settings
+  late final bool Function() hasGlyphPathRender;
+  late final void Function(bool) setRenderGlyphUsePath;
+  late final bool Function() isRenderGlyphUsePath;
+
+  NativeBindings._() {
+    _init();
+  }
+
+  factory NativeBindings() => NativeBindings._();
+
+  void _init() {
+    if (Platform.isLinux || Platform.isAndroid) {
+      _nativeLib = DynamicLibrary.open('libmicrotex.so');
+    } else if (Platform.isIOS || Platform.isMacOS) {
+      _nativeLib = DynamicLibrary.process();
+    } else if (Platform.isWindows) {
+      _nativeLib = DynamicLibrary.open('microtex.dll');
+    } else {
+      // should never happen
+    }
+    if (debugMicroTeX) print(_nativeLib);
+    // context
+    registerCallbacks = _nativeLib
+        .lookup<NativeFunction<NRegisterCallbacks>>(
+          'microtex_registerCallbacks',
+        )
+        .asFunction<RegisterCallbacks>();
+    init = _nativeLib
+        .lookup<NativeFunction<Pointer Function(Uint32, Pointer)>>(
+          "microtex_init",
+        )
+        .asFunction<Pointer Function(int, Pointer)>();
+    isInited = _nativeLib
+        .lookup<NativeFunction<Bool Function()>>(
+          "microtex_isInited",
+        )
+        .asFunction();
+    release = _nativeLib
+        .lookup<NativeFunction<Void Function()>>(
+          "microtex_release",
+        )
+        .asFunction();
+    isLittleEndian = _nativeLib
+        .lookup<NativeFunction<Bool Function()>>(
+          "microtex_isLittleEndian",
+        )
+        .asFunction();
+    // FontMeta
+    getFontFamily = _nativeLib
+        .lookup<NativeFunction<Pointer<Utf8> Function(Pointer)>>(
+          "microtex_getFontFamily",
+        )
+        .asFunction();
+    getFontName = _nativeLib
+        .lookup<NativeFunction<Pointer<Utf8> Function(Pointer)>>(
+          "microtex_getFontName",
+        )
+        .asFunction();
+    isMathFont = _nativeLib
+        .lookup<NativeFunction<Bool Function(Pointer)>>(
+          "microtex_isMathFont",
+        )
+        .asFunction();
+    releaseFontMeta = _nativeLib
+        .lookup<NativeFunction<Void Function(Pointer)>>(
+          "microtex_releaseFontMeta",
+        )
+        .asFunction();
+    addFont = _nativeLib
+        .lookup<NativeFunction<Pointer Function(Uint32, Pointer)>>(
+          "microtex_addFont",
+        )
+        .asFunction();
+    // setters
+    setDefaultMathFont = _nativeLib
+        .lookup<NativeFunction<Void Function(Pointer<Utf8>)>>(
+          "microtex_setDefaultMathFont",
+        )
+        .asFunction();
+    setDefaultMainFont = _nativeLib
+        .lookup<NativeFunction<Void Function(Pointer<Utf8>)>>(
+          "microtex_setDefaultMainFont",
+        )
+        .asFunction();
+    // parse
+    parse = _nativeLib
+        .lookup<NativeFunction<NativeParse>>(
+          "microtex_parseRender",
+        )
+        .asFunction();
+    // render
+    deleteRender = _nativeLib
+        .lookup<NativeFunction<Void Function(Pointer)>>(
+          "microtex_deleteRender",
+        )
+        .asFunction();
+    getDrawingData = _nativeLib
+        .lookup<NativeFunction<Pointer<Uint8> Function(Pointer, Int32, Int32)>>(
+          "microtex_getDrawingData",
+        )
+        .asFunction();
+    deleteDrawingData = _nativeLib
+        .lookup<NativeFunction<Void Function(Pointer)>>(
+          "microtex_freeDrawingData",
+        )
+        .asFunction();
+    getRenderWidth = _nativeLib
+        .lookup<NativeFunction<Int32 Function(Pointer)>>(
+          "microtex_getRenderWidth",
+        )
+        .asFunction();
+    getRenderHeight = _nativeLib
+        .lookup<NativeFunction<Int32 Function(Pointer)>>(
+          "microtex_getRenderHeight",
+        )
+        .asFunction();
+    getRenderDepth = _nativeLib
+        .lookup<NativeFunction<Int32 Function(Pointer)>>(
+          "microtex_getRenderDepth",
+        )
+        .asFunction();
+    isRenderSplit = _nativeLib
+        .lookup<NativeFunction<Bool Function(Pointer)>>(
+          "microtex_isRenderSplit",
+        )
+        .asFunction();
+    setRenderTextSize = _nativeLib
+        .lookup<NativeFunction<Void Function(Pointer, Float)>>(
+          "microtex_setRenderTextSize",
+        )
+        .asFunction();
+    setRenderForground = _nativeLib
+        .lookup<NativeFunction<Void Function(Pointer, Uint32)>>(
+          "microtex_setRenderForeground",
+        )
+        .asFunction();
+    // glyph settings
+    hasGlyphPathRender = _nativeLib
+        .lookup<NativeFunction<Bool Function()>>(
+          "microtex_hasGlyphPathRender",
+        )
+        .asFunction();
+    setRenderGlyphUsePath = _nativeLib
+        .lookup<NativeFunction<Void Function(Bool)>>(
+          "microtex_setRenderGlyphUsePath",
+        )
+        .asFunction();
+    isRenderGlyphUsePath = _nativeLib
+        .lookup<NativeFunction<Bool Function()>>(
+          "microtex_isRenderGlyphUsePath",
+        )
+        .asFunction();
+  }
+}

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

@@ -0,0 +1,10 @@
+import 'dart:ffi';
+
+class Bounds extends Struct {
+  @Float()
+  external double width;
+  @Float()
+  external double height;
+  @Float()
+  external double ascent;
+}

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

@@ -0,0 +1,205 @@
+import 'dart:ffi';
+
+import 'package:flutter/cupertino.dart';
+import 'package:flutter/foundation.dart';
+import 'package:ffi/ffi.dart';
+import 'package:flutter/services.dart';
+import 'package:microtex/microtex.dart';
+import 'package:microtex/src/bindings.dart';
+import 'package:microtex/src/bounds.dart';
+import 'package:microtex/src/fontdesc.dart';
+import 'package:microtex/src/pathcache.dart';
+import 'package:microtex/src/textlayout.dart';
+
+bool _debugMicroTeX = false;
+
+set debugMicroTeX(bool value) => _debugMicroTeX = value;
+
+bool get debugMicroTeX => _debugMicroTeX && kDebugMode;
+
+/// The MicroTeX context wrapper for Flutter from native. You must call [initialize]
+/// to initialize the context before using.
+class MicroTeX {
+  MicroTeX._();
+
+  static final _instance = MicroTeX._();
+
+  factory MicroTeX() => _instance;
+
+  late final bool _isLittleEndian;
+  final _bindings = NativeBindings();
+  final _fonts = <FontMeta>[];
+
+  String _currentMathFontName = "";
+
+  /// The name of the math font currently in use, empty if the context was
+  /// not intialized.
+  String get currentMathFontName => _currentMathFontName;
+
+  set currentMathFontName(value) {
+    if (_currentMathFontName == value) return;
+    _currentMathFontName = value;
+    _setMathFont(value);
+  }
+
+  String _currentMainFontFamilyName = "";
+
+  /// The family name of the main font currently in use, if it is empty, that means
+  /// no main font was given, thus the context fallbacks to the math font.
+  String get currentMainFontFamilyName => _currentMainFontFamilyName;
+
+  set currentMainFontFamilyName(value) {
+    if (_currentMainFontFamilyName == value) return;
+    _currentMainFontFamilyName = value;
+    _setMainFont(value);
+  }
+
+  List<FontMeta> get mathFonts {
+    return _fonts.where((element) => element.isMathFont).toList();
+  }
+
+  List<FontMeta> get mainFonts {
+    return _fonts.where((element) => !element.isMathFont).toList();
+  }
+
+  /// Initialize the MicroTeX context.
+  Future<void> initialize({
+    required String clmAsset,
+    String textLayoutSerif = "",
+    String textLayoutSansSerif = "",
+    String textLayoutMonospace = "",
+  }) async {
+    TextLayout.setFontFamily(
+      textLayoutSerif,
+      textLayoutSansSerif,
+      textLayoutMonospace,
+    );
+    _isLittleEndian = _bindings.isLittleEndian();
+    _registerCallbacks();
+    await _initWithCLM(clmAsset);
+  }
+
+  void _registerCallbacks() {
+    final register = _bindings.registerCallbacks;
+    final a = Pointer.fromFunction<Uint32 Function(Pointer, Pointer)>(
+      _createTextLayout,
+      0,
+    );
+    final b = Pointer.fromFunction<Void Function(Uint32, Pointer)>(
+      _getTextLayoutBounds,
+    );
+    final c = Pointer.fromFunction<Void Function(Uint32)>(
+      TextLayout.release,
+    );
+    final d = Pointer.fromFunction<Bool Function(Uint32)>(
+      _isPathExists,
+      false,
+    );
+    register(a, b, c, d);
+    if (debugMicroTeX) print(register);
+  }
+
+  static int _createTextLayout(Pointer<Utf8> txt, Pointer<FontDesc> font) {
+    return TextLayout.create(txt.toDartString(), font.ref);
+  }
+
+  static void _getTextLayoutBounds(int id, Pointer<Bounds> bounds) {
+    final b = TextLayout.getBounds(id);
+    bounds.ref
+      ..width = b[0]
+      ..height = b[1]
+      ..ascent = b[2];
+  }
+
+  static bool _isPathExists(int id) => PathCache()[id] != null;
+
+  Future<FontMeta> _loadCLM(
+    String clmAsset,
+    Pointer Function(int len, Pointer<Uint8> buf) f,
+  ) async {
+    final clm = await rootBundle.load(clmAsset);
+    final len = clm.lengthInBytes;
+    // copy data to C
+    final cbuf = calloc.allocate<Uint8>(len);
+    final list = cbuf.asTypedList(len);
+    list.setAll(0, clm.buffer.asUint8List());
+    // callback
+    final m = f(len, cbuf);
+    // release buffer in C
+    calloc.free(cbuf);
+    // get font meta info from C
+    final fontFamily = _bindings.getFontFamily(m).toDartString();
+    final fontName = _bindings.getFontName(m).toDartString();
+    final isMathFont = _bindings.isMathFont(m);
+    // push to font meta list
+    final meta = FontMeta(fontFamily, fontName, isMathFont);
+    if (debugMicroTeX) print(meta);
+    if (meta.isValid) _fonts.add(meta);
+    // release meta pointer in C
+    _bindings.releaseFontMeta(m);
+    return meta;
+  }
+
+  Future<void> _initWithCLM(String clmAsset) async {
+    final meta = await _loadCLM(clmAsset, (len, buf) => _bindings.init(len, buf));
+    currentMathFontName = meta.fontName;
+  }
+
+  /// Add a clm font from assets.
+  Future<FontMeta> addFont(String clmAsset) async {
+    return _loadCLM(clmAsset, (len, buf) => _bindings.addFont(len, buf));
+  }
+
+  void _setMathFont(String name) {
+    final str = name.toNativeUtf8();
+    _bindings.setDefaultMathFont(str);
+    calloc.free(str);
+  }
+
+  void _setMainFont(String familyName) {
+    final str = familyName.toNativeUtf8();
+    _bindings.setDefaultMainFont(str);
+    calloc.free(str);
+  }
+
+  /// Test if MicroTeX has the ability to use path to render glyphs.
+  bool hasGlyphPathRender() {
+    return _bindings.hasGlyphPathRender();
+  }
+
+  /// Set if use path to render glyphs, only works if [hasGlyphPathRender] returns true,
+  /// otherwise this function takes no effects.
+  void setRenderGlyphUsePath(bool use) {
+    _bindings.setRenderGlyphUsePath(use);
+  }
+
+  /// Test if currently use path to render glyphs.
+  bool isRenderGlyphUsePath() {
+    return _bindings.isRenderGlyphUsePath();
+  }
+
+  Render parse({
+    required String tex,
+    required int width,
+    required double textSize,
+    required double lineSpace,
+    required Color color,
+    required bool fillWidth,
+    required bool overrideTeXStyle,
+    required TeXStyle style,
+  }) {
+    final str = tex.toNativeUtf8();
+    final ptr = _bindings.parse(
+      str,
+      width,
+      textSize,
+      lineSpace,
+      color.value,
+      fillWidth,
+      overrideTeXStyle,
+      style.index,
+    );
+    calloc.free(str);
+    return Render(_bindings, ptr, _isLittleEndian);
+  }
+}

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

@@ -0,0 +1,14 @@
+import 'dart:ffi';
+
+class FontDesc extends Struct {
+  @Bool()
+  external bool isBold;
+  @Bool()
+  external bool isItalic;
+  @Bool()
+  external bool isSansSerif;
+  @Bool()
+  external bool isMonospace;
+  @Float()
+  external double fontSize;
+}

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

@@ -0,0 +1,14 @@
+class FontMeta {
+  final String fontFamily;
+  final String fontName;
+  final bool isMathFont;
+
+  FontMeta(this.fontFamily, this.fontName, this.isMathFont);
+
+  bool get isValid => fontFamily.isNotEmpty && fontName.isNotEmpty;
+
+  @override
+  String toString() {
+    return "FontMeta{$fontFamily, $fontName, $isMathFont}";
+  }
+}

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

@@ -0,0 +1,17 @@
+import 'dart:ui';
+
+class PathCache {
+  static final _instance = PathCache._();
+
+  PathCache._();
+
+  factory PathCache() {
+    return _instance;
+  }
+
+  final _map = <int, Path>{};
+
+  Path? operator [](int id) => _map[id];
+
+  void operator []=(int id, Path path) => _map.putIfAbsent(id, () => path);
+}