@simonklee/opentui-tex-native-source 0.2.0

package/native/vendor/microtex/lib/macro/macro_types.h

@@ -0,0 +1,48 @@
+#ifndef MICROTEX_MACRO_TYPES_H
+#define MICROTEX_MACRO_TYPES_H
+
+#include "macro/macro_decl.h"
+
+namespace microtex {
+
+inline sptr<Atom> _math_type(Parser& tp, Args& args, AtomType type) {
+  return sptrOf<TypedAtom>(type, type, Formula(tp, args[1], false)._root);
+}
+
+inline macro(mathop) {
+  auto a = _math_type(tp, args, AtomType::bigOperator);
+  a->_limitsType = LimitsType::noLimits;
+  return a;
+}
+
+inline macro(mathpunct) {
+  return _math_type(tp, args, AtomType::punctuation);
+}
+
+inline macro(mathord) {
+  return _math_type(tp, args, AtomType::ordinary);
+}
+
+inline macro(mathrel) {
+  return _math_type(tp, args, AtomType::relation);
+}
+
+inline macro(mathinner) {
+  return _math_type(tp, args, AtomType::inner);
+}
+
+inline macro(mathbin) {
+  return _math_type(tp, args, AtomType::binaryOperator);
+}
+
+inline macro(mathopen) {
+  return _math_type(tp, args, AtomType::opening);
+}
+
+inline macro(mathclose) {
+  return _math_type(tp, args, AtomType::closing);
+}
+
+}  // namespace microtex
+
+#endif  // MICROTEX_MACRO_TYPES_H

package/native/vendor/microtex/lib/macro/meson.build

@@ -0,0 +1,33 @@
+macro_src = [
+    'macro/macro_accent.cpp',
+    'macro/macro_colors.cpp',
+    'macro/macro.cpp',
+    'macro/macro_def.cpp',
+    'macro/macro_delims.cpp',
+    'macro/macro_fonts.cpp',
+    'macro/macro_frac.cpp',
+    'macro/macro_misc.cpp',
+    'macro/macro_scripts.cpp',
+    'macro/macro_space.cpp',
+    'macro/macro_styles.cpp'
+]
+
+if install_headerfiles
+    install_headers([
+        'macro_accent.h',
+        'macro_boxes.h',
+        'macro_colors.h',
+        'macro_decl.h',
+        'macro_delims.h',
+        'macro_env.h',
+        'macro_fonts.h',
+        'macro_frac.h',
+        'macro.h',
+        'macro_misc.h',
+        'macro_scripts.h',
+        'macro_sizes.h',
+        'macro_space.h',
+        'macro_styles.h',
+        'macro_types.h'
+    ], subdir: 'microtex/macro')
+endif

package/native/vendor/microtex/lib/meson.build

@@ -0,0 +1,102 @@
+src = []
+inc = []
+
+install_headerfiles = get_option('TARGET_DEVEL')
+
+microtex_src = ['microtex.cpp']
+src += microtex_src
+
+microtex_inc = include_directories('.')
+inc += microtex_inc
+
+subdir('atom')
+src += atom_src
+
+subdir('box')
+src += box_src
+
+subdir('core')
+src += core_src
+
+subdir('env')
+src += env_src
+
+subdir('graphic')
+src += graphic_src
+
+subdir('macro')
+src += macro_src
+
+subdir('otf')
+src += otf_src
+
+subdir('unimath')
+src += unimath_src
+
+subdir('utils')
+src += utils_src
+
+subdir('render')
+src += render_src
+
+microtex_version = meson.project_version().split('.')
+config_h = configure_file(
+    input: 'microtexconfig.h.in',
+    output: 'microtexconfig.h',
+    configuration: {
+        'PROJECT_VERSION_MAJOR': microtex_version[0],
+        'PROJECT_VERSION_MINOR': microtex_version[1],
+        'PROJECT_VERSION_PATCH': microtex_version[2],
+        'HAVE_AUTO_FONT_FIND': get_option('HAVE_AUTO_FONT_FIND'),
+    },
+    format: 'cmake@'
+)
+
+fs_lib = []
+if cpp.has_link_argument('-lstdc++fs')
+	fs_lib += cpp.find_library('stdc++fs')
+elif cpp.has_link_argument('-lc++fs')
+	fs_lib += cpp.find_library('c++fs')
+elif cpp.has_link_argument('-lc++experimental')
+	fs_lib += cpp.find_library('c++experimental')
+endif
+
+if not cpp.has_header('filesystem')
+	if cpp.has_header('experimental/filesystem')
+		add_project_arguments('-DUSE_EXPERIMENTAL_FILESYSTEM', language: 'cpp')
+	else
+		error('outdated stdlib')
+	endif
+endif
+
+microtex_lib = library('microtex', src,
+	dependencies: fs_lib,
+	include_directories: inc,
+	version: meson.project_version(),
+	soversion: microtex_api_version,
+	install: true
+)
+
+microtex_dep = declare_dependency(
+	link_with: microtex_lib,
+	include_directories: inc,
+	version: meson.project_version()
+)
+
+if get_option('TARGET_DEVEL')
+    pkgconfig.generate(microtex_lib,
+        version: meson.project_version(),
+        name: 'microtex',
+        filebase: 'microtex',
+        subdirs: 'microtex',
+        description: 'A micro, fast, cross-platform, and embeddable LaTeX rendering library'
+    )
+endif
+
+if install_headerfiles
+	install_headers([
+		'microtexexport.h',
+		'microtex.h',
+		config_h
+	], subdir: 'microtex')
+endif

package/native/vendor/microtex/lib/microtex.cpp

@@ -0,0 +1,208 @@
+#include "microtex.h"
+
+#include "core/formula.h"
+#include "otf/fontsense.h"
+#include "macro/macro.h"
+#include "utils/exceptions.h"
+#include "utils/string_utils.h"
+#include "render/builder.h"
+
+#include <clocale>
+
+using namespace std;
+using namespace microtex;
+
+namespace microtex {
+
+struct Config {
+  bool isInited;
+  bool isPrivilegedEnvironment;
+  std::string defaultMainFontFamily;
+  std::string defaultMathFontName;
+  bool renderGlyphUsePath;
+  bool enableOverrideTeXStyle;
+  TexStyle overrideTeXStyle;
+};
+
+static Config MICROTEX_CONFIG{false, false, "", "", false, false, TexStyle::text};
+
+} // namespace microtex
+
+Config* MicroTeX::_config = &microtex::MICROTEX_CONFIG;
+
+std::string MicroTeX::version() {
+  static const auto ver = std::to_string(MICROTEX_VERSION_MAJOR) + "."
+     + std::to_string(MICROTEX_VERSION_MINOR) + "."
+     + std::to_string(MICROTEX_VERSION_PATCH);
+  return ver;
+}
+
+#ifdef HAVE_AUTO_FONT_FIND
+
+struct InitVisitor {
+
+  FontMeta operator()(const FontSrc* src) {
+    auto meta = FontContext::addFont(*src);
+    if (!meta.isMathFont) {
+      throw ex_invalid_param("'" + meta.name + "' is not a math font!");
+    }
+    return meta;
+  }
+
+  FontMeta operator()(const string& name) {
+    fontsenseLookup();
+    if (!FontContext::isMathFontExists(name)) {
+      throw ex_invalid_param("Math font '" + name + "' does not exists!");
+    }
+    return FontContext::mathFontMetaOf(name);
+  }
+
+  FontMeta operator()(const InitFontSenseAuto& sense) {
+    auto mathFont = fontsenseLookup();
+    if (!mathFont.has_value()) {
+      throw ex_invalid_param("No math font found by font-sense.");
+    }
+    return mathFont.value();
+  }
+};
+
+FontMeta MicroTeX::init(const Init& init) {
+  if (_config->isInited) return {};
+  std::setlocale(LC_NUMERIC, "C"); // workaround for decimal parsing on German (decimal comma) systems
+  auto meta = std::visit(InitVisitor(), init);
+  _config->defaultMathFontName = meta.name;
+  _config->isInited = true;
+  _config->isPrivilegedEnvironment = false;
+  NewCommandMacro::_init_();
+  return meta;
+}
+
+#endif // HAVE_AUTO_FONT_FIND
+
+FontMeta MicroTeX::init(const FontSrc& mathFontSrc) {
+  if (_config->isInited) return {};
+  std::setlocale(LC_NUMERIC, "C"); // workaround for decimal parsing on German (decimal comma) systems
+  auto meta = FontContext::addFont(mathFontSrc);
+  if (!meta.isMathFont) {
+    throw ex_invalid_param("'" + meta.name + "' is not a math font!");
+  }
+  _config->defaultMathFontName = meta.name;
+  _config->isInited = true;
+  _config->isPrivilegedEnvironment = false;
+  NewCommandMacro::_init_();
+  return meta;
+}
+
+bool MicroTeX::isInited() {
+  return _config->isInited;
+}
+
+void MicroTeX::release() {
+  MacroInfo::_free_();
+  NewCommandMacro::_free_();
+}
+
+bool MicroTeX::isPrivilegedEnvironment() {
+	return _config->isPrivilegedEnvironment;
+}
+
+void MicroTeX::setPrivilegedEnvironment(bool privileged) {
+	_config->isPrivilegedEnvironment = privileged;
+}
+
+FontMeta MicroTeX::addFont(const FontSrc& src) {
+  auto meta = FontContext::addFont(src);
+  if (meta.isMathFont && _config->defaultMathFontName.empty()) {
+    _config->defaultMathFontName = meta.name;
+  }
+  if (!meta.isMathFont && _config->defaultMainFontFamily.empty()) {
+    _config->defaultMainFontFamily = meta.family;
+  }
+  return meta;
+}
+
+bool MicroTeX::setDefaultMathFont(const std::string& name) {
+  if (!FontContext::isMathFontExists(name)) return false;
+  _config->defaultMathFontName = name;
+  return true;
+}
+
+bool MicroTeX::setDefaultMainFont(const std::string& family) {
+  if (family.empty() || FontContext::isMainFontExists(family)) {
+    _config->defaultMainFontFamily = family;
+    return true;
+  }
+  return false;
+}
+
+std::vector<std::string> MicroTeX::mathFontNames() {
+  return FontContext::mathFontNames();
+}
+
+std::vector<std::string> MicroTeX::mainFontFamilies() {
+  return FontContext::mainFontFamilies();
+}
+
+void MicroTeX::overrideTexStyle(bool enable, TexStyle style) {
+  _config->enableOverrideTeXStyle = enable;
+  _config->overrideTeXStyle = style;
+}
+
+bool MicroTeX::hasGlyphPathRender() {
+#ifdef HAVE_GLYPH_RENDER_PATH
+  return true;
+#else
+  return false;
+#endif
+}
+
+void MicroTeX::setRenderGlyphUsePath(bool use) {
+#if GLYPH_RENDER_TYPE == GLYPH_RENDER_TYPE_BOTH
+  _config->renderGlyphUsePath = use;
+#endif
+}
+
+bool MicroTeX::isRenderGlyphUsePath() {
+#if GLYPH_RENDER_TYPE == GLYPH_RENDER_TYPE_BOTH
+  return _config->renderGlyphUsePath;
+#elif GLYPH_RENDER_TYPE == GLYPH_RENDER_TYPE_PATH
+  return true;
+#else
+  return false;
+#endif
+}
+
+Render* MicroTeX::parse(
+  const string& latex, float width, float textSize, float lineSpace, color fg,
+  bool fillWidth, const OverrideTeXStyle& overrideTeXStyle,
+  const string& mathFontName, const string& mainFontFamily
+) {
+  Formula formula(latex);
+  const auto isInline = !startsWith(latex, "$$") && !startsWith(latex, "\\[");
+  const auto align = isInline ? Alignment::left : Alignment::center;
+  TexStyle style = isInline ? TexStyle::text : TexStyle::display;
+  if (overrideTeXStyle.enable) {
+    style = overrideTeXStyle.style;
+  } else if (_config->enableOverrideTeXStyle) {
+    style = _config->overrideTeXStyle;
+  }
+  Render* render = RenderBuilder()
+    .setStyle(style)
+    .setTextSize(textSize)
+    .setMathFontName(
+      mathFontName.empty()
+      ? _config->defaultMathFontName
+      : mathFontName
+    )
+    .setMainFontName(
+      mainFontFamily.empty()
+      ? _config->defaultMainFontFamily
+      : mainFontFamily
+    )
+    .setWidth({width, UnitType::pixel}, align)
+    .setFillWidth(!isInline && fillWidth)
+    .setLineSpace({lineSpace, UnitType::pixel})
+    .setForeground(fg)
+    .build(formula);
+  return render;
+}

package/native/vendor/microtex/lib/microtex.h

@@ -0,0 +1,225 @@
+#ifndef MICROTEX_MICROTEX_H
+#define MICROTEX_MICROTEX_H
+
+#include <string>
+#include <vector>
+
+#include "microtexconfig.h"
+#include "microtexexport.h"
+#include "render/render.h"
+#include "unimath/font_meta.h"
+#include "unimath/font_src.h"
+
+#ifdef HAVE_AUTO_FONT_FIND
+
+#include <variant>
+
+namespace microtex {
+
+struct MICROTEX_EXPORT InitFontSenseAuto {};
+
+/**
+ * MicroTeX context initialization.
+ * <ol>
+ *  <li> If a FontSrc presents, the context will load math font from the given font source.
+ *  <li> If a InitFontSenseAuto presents, fill the search dirs by following rules:
+ *    <ul>
+ *      <li> If environment variable `MICROTEX_FONTDIR` is set, add it into search dirs.
+ *      <li> If environment variable `XDG_DATA_HOME` is set, add `${XDG_DATA_HOME}/microtex` into
+ *           search dirs.
+ *      <li> If environment variable `XDG_DATA_DIRS` is set, iterate over the list and add the sub
+ *           dir `microtex` of each item into search dirs.
+ *      <li> If the current platform is WIN32, add the dir `share/microtex` where its parent is the
+ *           executable running dir into search dirs.
+ *      <li> Otherwise, try the following ways:
+ *      <ul>
+ *        <li> If environment variable `HOME` is set, add dir `${HOME}/.local/share/microtex` into
+ *             search dirs.
+ *        <li> Add `/usr/local/share/microtex` into search dirs.
+ *        <li> Add `/usr/share/microtex` into search dirs.
+ *      </ul>
+ *    </ul>
+ *    And then iterate over the search dirs, add all found fonts to context, and select the first
+ *    found math font as the default.
+ *  <li> If a string presents, follow the above way to init the context but select the math font
+ *       which its name was given by this string as the default.
+ * </ol>
+ */
+using Init = std::variant<const FontSrc*, const std::string, InitFontSenseAuto>;
+
+}  // namespace microtex
+
+#endif  // HAVE_AUTO_FONT_FIND
+
+namespace microtex {
+
+struct Config;
+
+struct MICROTEX_EXPORT OverrideTeXStyle {
+  bool enable;
+  TexStyle style;
+};
+
+class MICROTEX_EXPORT MicroTeX {
+private:
+  static Config* _config;
+
+public:
+  /** The version of the library */
+  static std::string version();
+
+#ifdef HAVE_AUTO_FONT_FIND
+
+  /**
+   * Initialize MicroTeX context by given Init, at least we need a math font
+   * to layout formulas.
+   *
+   * @returns the math font meta info
+   */
+  static FontMeta init(const Init& init);
+
+#endif  // HAVE_AUTO_FONT_FIND
+
+  /**
+   * Initialize the context with given math font source, at least we need a
+   * math font to layout formulas.
+   *
+   * @param mathFontSrc the font source to load
+   * @returns the math font meta info
+   */
+  static FontMeta init(const FontSrc& mathFontSrc);
+
+  /** Check if context is initialized */
+  static bool isInited();
+
+  /**
+   * Check if the current setup has privileged execution access.
+   * By default, this is set to false, but can be enabled by calling
+   * ::setPrivilegedEnvironment"("true")".
+   *
+   * @returns true if it has, false otherwise
+   */
+  static bool isPrivilegedEnvironment();
+
+  /**
+   * Set privileged execution access for the current setup.
+   * If privileged access in enabled, TeX macros are allowed
+   * to access the filesystem, invoke external binaries, etc.
+   *
+   * Macros affected by this:
+   * <ul>
+   *  <li>`addfont`</li>
+   * </ul>
+   *
+   * @param privileged whether to allow privileged access or not
+	 */
+  static void setPrivilegedEnvironment(bool privileged);
+
+  /** Add a font to context, returns its meta info. */
+  static FontMeta addFont(const FontSrc& src);
+
+  /**
+   * Set the default math font to show formulas, if no math font was given
+   * when parsing, the context will use the given default math font. If it
+   * is not exists, this function takes no effect.
+   *
+   * @param name the math font name
+   * @returns true if given math font exists, false otherwise
+   */
+  static bool setDefaultMathFont(const std::string& name);
+
+  /**
+   * Set the default main font to show formulas, if no main font was given
+   * when parsing, the context will use the given default main font. However,
+   * if no main font was loaded, the context will use the math font to render
+   * the glyphs wrapped by command `text*`.
+   *
+   * @param family the main font family, if it is empty, that means fallback to
+   * the math font
+   * @returns true if given font exists (special case: always returns true if
+   * given family is empty), false otherwise.
+   */
+  static bool setDefaultMainFont(const std::string& family);
+
+  /** Get all the loaded math font names. */
+  static std::vector<std::string> mathFontNames();
+
+  /** Get all the loaded main font family names. */
+  static std::vector<std::string> mainFontFamilies();
+
+  /**
+   * Override the style to display formulas. If #enable is true, the '$', '$$',
+   * '\(' and '\[' will be ignored, and force to use the given overridden style.
+   *
+   * @param enable whether enable the overridden style, false to cancel
+   * @param style the target style
+   */
+  static void overrideTexStyle(bool enable, TexStyle style = TexStyle::text);
+
+  /** Test if has the ability to use path to render glyphs. */
+  static bool hasGlyphPathRender();
+
+  /**
+   * Set if use path to render glyphs, only works when compile option
+   * GLYPH_RENDER_TYPE is GLYPH_RENDER_TYPE_BOTH (equals to 0, that means render
+   * glyphs use font and path both), otherwise this function takes no effect.
+   */
+  static void setRenderGlyphUsePath(bool use);
+
+  /**
+   * Test if currently use path to render glyphs.
+   *
+   * If compile option GLYPH_RENDER_TYPE is GLYPH_RENDER_TYPE_BOTH, it depends
+   * on your setting (via function [setRenderGlyphUsePath]). If your setting
+   * is true and current `clm data` does not support path rendering, this function
+   * also returns true, but will gives you a warn message if you have compile
+   * option HAVE_LOG is ON.
+   *
+   * If compile option GLYPH_RENDER_TYPE is GLYPH_RENDER_TYPE_PATH (equals to 1),
+   * always returns true.
+   *
+   * Otherwise (GLYPH_RENDER_TYPE is GLYPH_RENDER_TYPE_TYPEFACE, equals to 2),
+   * always returns false.
+   */
+  static bool isRenderGlyphUsePath();
+
+  /**
+   * Parse (La)TeX string to Render.
+   *
+   * @param tex the (La)TeX string to parse (in UTF-8 encoding)
+   * @param 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. Pass 0 if it is
+   * unlimited.
+   * @param textSize the text size in pixel
+   * @param lineSpace the line space in pixel
+   * @param fg the foreground color
+   * @param fillWidth whether fill the graphics context if is in inter-line mode,
+   * defaults to true. If the given width is unlimited, the engine will not trying
+   * to split the formula, and the parsed Render will has its own intrinsic width.
+   * @param overrideTeXStyle whether override the preset TeX style
+   * @param mathFontName the math font name, empty to use the preset (the font
+   * passed in method [init] and [setDefaultMathFont]) math font.
+   * @param mainFontFamily the main font family name, empty to use the preset (the
+   * font passed in method [setDefaultMainFont] or math font if not given) main
+   * font family.
+   */
+  static Render* parse(
+    const std::string& tex,
+    float width,
+    float textSize,
+    float lineSpace,
+    color fg,
+    bool fillWidth = true,
+    const OverrideTeXStyle& overrideTeXStyle = {false, TexStyle::text},
+    const std::string& mathFontName = "",
+    const std::string& mainFontFamily = ""
+  );
+
+  /** Release the MicroTeX context */
+  static void release();
+};
+
+}  // namespace microtex
+
+#endif  // MICROTEX_MICROTEX_H

package/native/vendor/microtex/lib/microtexConfig.cmake.in

@@ -0,0 +1,2 @@
+include(CMakeFindDependencyMacro)
+include("${CMAKE_CURRENT_LIST_DIR}/microtexTargets.cmake")

package/native/vendor/microtex/lib/microtexapi.h

@@ -0,0 +1,22 @@
+#ifndef MICROTEX_API_H
+#define MICROTEX_API_H
+
+/** All-in-one header */
+
+#include "graphic/font_style.h"
+#include "graphic/graphic.h"
+#include "graphic/graphic_basic.h"
+#include "microtex.h"
+#include "microtexconfig.h"
+#include "microtexexport.h"
+#include "render/render.h"
+#include "unimath/font_src.h"
+#include "utils/types.h"
+
+#ifdef HAVE_CWRAPPER
+
+#include "wrapper/cwrapper.h"
+
+#endif
+
+#endif  // MICROTEX_API_H

package/native/vendor/microtex/lib/microtexconfig.h.in

@@ -0,0 +1,7 @@
+#pragma once
+
+#cmakedefine HAVE_AUTO_FONT_FIND
+
+#define MICROTEX_VERSION_MAJOR @PROJECT_VERSION_MAJOR@
+#define MICROTEX_VERSION_MINOR @PROJECT_VERSION_MINOR@
+#define MICROTEX_VERSION_PATCH @PROJECT_VERSION_PATCH@

package/native/vendor/microtex/lib/microtexexport.h

@@ -0,0 +1,31 @@
+#ifndef MICROTEX_MICROTEXEXPORT_H
+#define MICROTEX_MICROTEXEXPORT_H
+
+#ifdef _MSC_VER
+#include "vcruntime.h"
+#endif
+
+// msvc
+#ifdef _MSC_VER
+#   if defined(MICROTEX_LIBRARY)
+#       define MICROTEX_EXPORT __declspec(dllexport)
+#   else
+#       define MICROTEX_EXPORT __declspec(dllimport)
+#   endif
+// gnuc and clang
+#elif defined(__GNUC__) || defined(__GNUG__) || defined(__clang__)
+#   define MICROTEX_EXPORT __attribute((visibility("default")))
+// otherwise...
+#else
+#   define MICROTEX_EXPORT
+#endif
+
+// emscripten
+#if defined(__EMSCRIPTEN__)
+#   include <emscripten.h>
+#   define MICROTEX_CAPI EMSCRIPTEN_KEEPALIVE
+#else
+#   define MICROTEX_CAPI MICROTEX_EXPORT
+#endif
+
+#endif //MICROTEX_MICROTEXEXPORT_H