@simonklee/opentui-tex-native-source 0.2.0

package/native/vendor/microtex/lib/CMakeLists.txt

@@ -0,0 +1,234 @@
+if (DEFINED _BUILD_STATIC AND _BUILD_STATIC)
+    add_library(microtex STATIC "")
+else ()
+    add_library(microtex SHARED "")
+endif ()
+
+if (MSVC)
+    add_compile_options("/utf-8")
+    target_compile_features(microtex PUBLIC cxx_std_17)
+    target_compile_definitions(microtex PRIVATE -DMICROTEX_LIBRARY)
+    target_compile_definitions(microtex PUBLIC -D_HAS_STD_BYTE=1)
+else ()
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fexceptions")
+endif ()
+
+set_target_properties(
+    microtex PROPERTIES
+    CXX_VISIBILITY_PRESET hidden
+)
+
+if (NOT DEFINED _DISABLE_ALIAS AND NOT _DISABLE_ALIAS)
+    set_target_properties(
+        microtex PROPERTIES
+        VERSION ${PROJECT_VERSION}
+        SOVERSION ${MICROTEX_API_VERSION}
+    )
+endif ()
+
+set(
+    _SRCS
+    # atom folder
+    atom/atom.cpp
+    atom/atom_basic.cpp
+    atom/atom_char.cpp
+    atom/atom_misc.cpp
+    atom/atom_matrix.cpp
+    atom/atom_row.cpp
+    atom/atom_space.cpp
+    atom/atom_stack.cpp
+    atom/atom_accent.cpp
+    atom/atom_scripts.cpp
+    atom/atom_vrow.cpp
+    atom/atom_operator.cpp
+    atom/atom_zstack.cpp
+    atom/atom_sideset.cpp
+    atom/atom_font.cpp
+    atom/atom_delim.cpp
+    atom/atom_root.cpp
+    atom/atom_frac.cpp
+    atom/atom_fence.cpp
+    atom/atom_box.cpp
+    atom/atom_text.cpp
+    atom/colors_def.cpp
+    # box folder
+    box/box.cpp
+    box/box_factory.cpp
+    box/box_group.cpp
+    box/box_single.cpp
+    # core folder
+    core/split.cpp
+    core/formula.cpp
+    core/formula_def.cpp
+    core/glue.cpp
+    core/localized_num.cpp
+    core/parser.cpp
+    core/debug_config.cpp
+    # macro folder
+    macro/macro.cpp
+    macro/macro_def.cpp
+    macro/macro_misc.cpp
+    macro/macro_scripts.cpp
+    macro/macro_accent.cpp
+    macro/macro_colors.cpp
+    macro/macro_space.cpp
+    macro/macro_delims.cpp
+    macro/macro_frac.cpp
+    macro/macro_styles.cpp
+    macro/macro_fonts.cpp
+    # env folder
+    env/env.cpp
+    env/units.cpp
+    # utils folder
+    utils/string_utils.cpp
+    utils/utf.cpp
+    utils/utils.cpp
+    # otf folder
+    otf/clm.cpp
+    otf/fontsense.cpp
+    otf/glyph.cpp
+    otf/otf.cpp
+    otf/path.cpp
+    # unimath folder
+    unimath/font_src.cpp
+    unimath/math_type.cpp
+    unimath/uni_char.cpp
+    unimath/uni_font.cpp
+    unimath/uni_symbol.cpp
+    # graphic folder
+    graphic/font_style.cpp
+    graphic/graphic_basic.cpp
+    graphic/graphic.cpp
+    # render folder
+    render/render.cpp
+    render/builder.cpp
+
+    microtex.cpp
+)
+
+message(STATUS "Have cwrapper: ${HAVE_CWRAPPER}")
+if (DEFINED HAVE_CWRAPPER AND HAVE_CWRAPPER)
+    set(
+        _SRCS
+        ${_SRCS}
+        wrapper/callback.cpp
+        wrapper/graphic_wrapper.cpp
+        wrapper/cwrapper.cpp
+        wrapper/byte_seq.cpp
+    )
+    target_compile_definitions(microtex PUBLIC -DHAVE_CWRAPPER)
+endif ()
+
+# source files
+target_sources(microtex PRIVATE ${_SRCS})
+target_include_directories(
+    microtex PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+    $<INSTALL_INTERFACE:include/microtex>
+)
+
+###################
+# compile options #
+###################
+
+# compile option: if debug graphics
+option(GRAPHICS_DEBUG "If enable graphics debug" ON)
+if (GRAPHICS_DEBUG)
+    target_compile_definitions(microtex PRIVATE -DGRAPHICS_DEBUG)
+endif ()
+
+if (NOT DEFINED _HAVE_AUTO_FONT_FIND)
+    set(_HAVE_AUTO_FONT_FIND ON)
+endif ()
+# compile option: HAVE_AUTO_FONT_FIND if enable auto font find
+# this option is exported to users, will write into file 'microtexconfig.h'
+option(HAVE_AUTO_FONT_FIND "If enable auto font find" ${_HAVE_AUTO_FONT_FIND_})
+
+macro(CHECK_FS LIB_NAME)
+    if (EXISTS "${CMAKE_SOURCE_DIR}/test/has_filesystem.cpp")
+        if (${LIB_NAME} STREQUAL "none")
+            try_compile(
+                _HAS_FS
+                "${CMAKE_BINARY_DIR}/temp"
+                "${CMAKE_SOURCE_DIR}/test/has_filesystem.cpp"
+                CMAKE_FLAGS -DCMAKE_CXX_STANDARD=17 -DCMAKE_CXX_STANDARD_REQUIRED=ON
+            )
+        else ()
+            try_compile(
+                _HAS_FS
+                "${CMAKE_BINARY_DIR}/temp"
+                "${CMAKE_SOURCE_DIR}/test/has_filesystem.cpp"
+                CMAKE_FLAGS -DCMAKE_CXX_STANDARD=17 -DCMAKE_CXX_STANDARD_REQUIRED=ON
+                LINK_LIBRARIES ${LIB_NAME}
+            )
+        endif ()
+        set(_HAS_STD_FS ${_HAS_FS})
+    endif ()
+endmacro()
+
+if (HAVE_AUTO_FONT_FIND)
+    # iterate over the preset std c++ filesystem libraries
+    # `none` means there is no filesystem library to link
+    foreach (LIB IN ITEMS none;stdc++fs;c++fs;c++experimental)
+        check_fs(${LIB})
+        message(STATUS "Test for: ${LIB}, has std fs: ${_HAS_STD_FS}")
+        if (_HAS_STD_FS)
+            # special case: use the experimental filesystem
+            if (${LIB} STREQUAL "c++experimental")
+                target_compile_definitions(microtex PRIVATE -DUSE_EXPERIMENTAL_FILESYSTEM)
+            endif ()
+            if (NOT ${LIB} STREQUAL "none")
+                target_link_libraries(microtex ${LIB})
+            endif ()
+            break()
+        endif ()
+    endforeach ()
+    # oops... no std filesystem was found, use boost instead
+    if (NOT _HAS_STD_FS)
+        message(STATUS "No std c++ filesystem was found, use boost filesystem instead")
+        find_package(Boost REQUIRED COMPONENTS filesystem)
+        target_link_libraries(microtex PRIVATE Boost::filesystem)
+        target_compile_definitions(microtex PRIVATE USE_BOOST_FILESYSTEM)
+    endif ()
+endif ()
+
+if (NOT DEFINED _GLYPH_RENDER_TYPE)
+    set(_GLYPH_RENDER_TYPE 0)
+endif ()
+if (DEFINED GLYPH_RENDER_TYPE)
+    set(_GLYPH_RENDER_TYPE ${GLYPH_RENDER_TYPE})
+endif ()
+# compile option: GLYPH_RENDER_TYPE the glyph render type
+# 0: use path and typeface both
+# 1: use path only
+# 2: use typeface only
+target_compile_definitions(microtex PRIVATE -DGLYPH_RENDER_TYPE=${_GLYPH_RENDER_TYPE})
+
+configure_file(microtexconfig.h.in microtexconfig.h @ONLY)
+target_include_directories(microtex PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>)
+
+################
+# installation #
+################
+if (_HAS_MICROTEX_INSTALL)
+    microtex_install_target(microtex)
+    microtex_install_headers(
+        microtex
+        HEADERS ${CMAKE_CURRENT_BINARY_DIR}/microtexconfig.h microtexexport.h microtex.h microtexapi.h
+    )
+    microtex_install_headers(microtex PREFIX utils HEADERS utils/types.h)
+    microtex_install_headers(microtex PREFIX render HEADERS render/render.h)
+    microtex_install_headers(microtex PREFIX unimath HEADERS unimath/font_src.h unimath/font_meta.h)
+    microtex_install_headers(
+        microtex
+        PREFIX graphic
+        HEADERS graphic/graphic.h graphic/font_style.h graphic/graphic_basic.h
+    )
+    if (DEFINED HAVE_CWRAPPER AND HAVE_CWRAPPER)
+        microtex_install_headers(
+            microtex
+            PREFIX wrapper
+            HEADERS wrapper/callback.h wrapper/cwrapper.h
+        )
+    endif ()
+endif ()

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

@@ -0,0 +1,14 @@
+#include "atom/atom.h"
+#include "atom/atom_basic.h"
+
+using namespace microtex;
+
+WrapAtom::WrapAtom(const sptr<Atom>& base) {
+    if (base) {
+      _type = base->_type;
+      _base = base;
+    } else {
+      _type = AtomType::ordinary;
+      _base = sptrOf<EmptyAtom>();
+    }
+}

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

@@ -0,0 +1,96 @@
+#ifndef ATOM_H_INCLUDED
+#define ATOM_H_INCLUDED
+
+#include "box/box.h"
+
+namespace microtex {
+
+class Env;
+
+/**
+ * An abstract superclass for all logical mathematical constructions that can be a part
+ * of a Formula. The abstract method [createBox(Env)] transforms this logical unit into
+ * a concrete box (that can be painted).
+ *
+ * It also defines its type, used for determining what glue to use between adjacent atoms
+ * in a "row construction". That can be one single type by assigning one of the type
+ * constants to the [_type] field. But they can also be defined as having two types: a
+ * "left type" and a "right type". This can be done by implementing the methods
+ * [leftType()] and [rightType()]. The left type will then be used for determining the
+ * glue between this atom and the previous one (in a row, if any) and the right type for
+ * the glue between this atom and the following one (in a row, if any).
+ *
+ * And the [_limitsType] used for determining what variant to use when constructing scripts,
+ * defaults to [LimitsType::noLimits].
+ */
+class Atom {
+public:
+  /** The type of the atom (default value: ordinary atom) */
+  AtomType _type = AtomType::ordinary;
+  /** The limits type of the atom (default value: nolimits) */
+  LimitsType _limitsType = LimitsType::noLimits;
+  /** The alignment type of the atom (default value: none) */
+  Alignment _alignment = Alignment::none;
+
+  Atom() = default;
+
+  /**
+   * Get the type of the leftmost child atom. Most atoms have no child
+   * atoms, so the "left type" and the "right type" are the same: the atom's
+   * type. This also is the default implementation. But Some atoms are
+   * composed of child atoms put one after another in a horizontal row. These
+   * atoms must override this method.
+   *
+   * @return the type of the leftmost child atom
+   */
+  virtual AtomType leftType() const { return _type; }
+
+  /**
+   * Get the type of the rightmost child atom. Most atoms have no child
+   * atoms, so the "left type" and the "right type" are the same: the atom's
+   * type. This also is the default implementation. But Some atoms are
+   * composed of child atoms put one after another in a horizontal row. These
+   * atoms must override this method.
+   *
+   * @return the type of the rightmost child atom
+   */
+  virtual AtomType rightType() const { return _type; }
+
+  /**
+   * Convert this atom into a Box, using properties set by "parent"
+   * atoms, like the TeX style, the last used font, color settings, ...
+   *
+   * @param env the current environment settings
+   *
+   * @return the resulting box.
+   */
+  virtual sptr<Box> createBox(Env& env) = 0;
+
+  /** Test if this atom is a single character */
+  virtual bool isChar() const { return false; }
+
+  virtual ~Atom() = default;
+};
+
+/** Atom decor contains another atom */
+class WrapAtom : public Atom {
+protected:
+  sptr<Atom> _base;
+
+public:
+  explicit WrapAtom(const sptr<Atom>& base);
+
+  inline sptr<Atom> base() const { return _base; }
+
+  AtomType leftType() const override {
+    return _base == nullptr ? Atom::leftType() : _base->leftType();
+  }
+
+  AtomType rightType() const override {
+    return _base == nullptr ? Atom::rightType() : _base->rightType();
+  }
+};
+
+}  // namespace microtex
+
+#endif  // ATOM_H_INCLUDED

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

@@ -0,0 +1,115 @@
+#include "atom/atom_accent.h"
+
+#include "box/box_group.h"
+#include "box/box_single.h"
+#include "env/env.h"
+#include "env/units.h"
+#include "utils/exceptions.h"
+
+using namespace microtex;
+using namespace std;
+
+void AccentedAtom::setupBase(const sptr<Atom>& base) {
+  auto a = dynamic_cast<AccentedAtom*>(base.get());
+  _base = a != nullptr ? a->_base : base;
+}
+
+AccentedAtom::AccentedAtom(const sptr<Atom>& base, const string& name, bool fitSize, bool fake) {
+  _accenter = SymbolAtom::get(name);
+  if (_accenter == nullptr) {
+    throw ex_parse("'" + name + "' is not defined as a symbol");
+  }
+  _fitSize = fitSize;
+  _fakeAccent = fake;
+  if (_accenter->_type == AtomType::accent) {
+    _accentee = base;
+    setupBase(base);
+    // the symbol is a real accent but specified as fake accent
+    _fakeAccent = false;
+  } else if (fake) {
+    _accentee = base;
+    setupBase(base);
+  } else {
+    throw ex_parse(
+      "The symbol with the name '" + name + "' is not defined as an accent (type='acc')!"
+    );
+  }
+}
+
+sptr<Box> AccentedAtom::createBox(Env& env) {
+  // create accentee box in cramped style
+  // clang-format off
+  auto accentee = (
+    _accentee == nullptr
+    ? StrutBox::empty()
+    : env.withStyle(env.crampStyle(), [&](Env& cramp) { return _accentee->createBox(cramp); })
+  );
+  // clang-format on
+
+  float topAccent = Otf::undefinedMathValue;
+  if (auto sym = dynamic_cast<CharSymbol*>(_base.get()); sym != nullptr) {
+    topAccent = sym->getChar(env).topAccentAttachment();
+  }
+  topAccent = topAccent == Otf::undefinedMathValue ? accentee->_width / 2.f : topAccent;
+
+  // function to retrieve best char from the accent symbol to match the accentee box's width
+  const auto& getChar = [&]() {
+    const auto& chr = ((SymbolAtom*)_accenter.get())->getChar(env);
+    if (!_fitSize) return chr;
+    int i = 1;
+    for (; i < chr.hLargerCount(); i++) {
+      const auto& larger = chr.hLarger(i);
+      if (larger.width() > accentee->_width) break;
+    }
+    return chr.hLarger(i - 1);
+  };
+
+  // accenter
+  sptr<Box> accenter;
+  if (_fakeAccent) {
+    accenter = env.withStyle(env.subStyle(), [&](Env& sub) { return _accenter->createBox(sub); });
+    accenter->_shift = topAccent - accenter->_width / 2.f;
+  } else {
+    const auto& chr = getChar();
+    accenter = sptrOf<CharBox>(chr);
+    const auto pos = chr.topAccentAttachment();
+    const auto shift = pos == Otf::undefinedMathValue ? accenter->_width / 2.f : pos;
+    accenter->_shift = topAccent - shift;
+  }
+
+  // add to vertical box
+  auto vbox = new VBox();
+  // kerning
+  auto delta = 0.f;
+  auto sigma = 0.f;
+  if (_fakeAccent) {
+    delta = Units::fsize(UnitType::mu, 1, env);
+  } else if (accenter->_depth <= 0) {
+    delta = -min(accentee->_height, (float)env.mathConsts().accentBaseHeight());
+  } else {
+    // if accent has depth (e.g. \not), we need to align the accentee and accenter
+    // by its baseline
+    if (accentee->_height > accenter->_height) {
+      auto t = accenter;
+      accenter = accentee;
+      accentee = t;
+    }
+    delta = -(accentee->_height + accenter->_depth);
+    sigma = max(accenter->_depth - accentee->_depth, 0.f);
+  }
+
+  vbox->add(accenter);
+  vbox->add(sptrOf<StrutBox>(0.f, delta, 0.f, 0.f));
+  vbox->add(accentee);
+
+  // set height and depth of the vertical box
+  vbox->_height = vbox->vlen() - accentee->_depth;
+  vbox->_depth = accentee->_depth;
+
+  // add extra space to make sure the box is tall enough to wrap all children
+  if (sigma > PREC) {
+    vbox->add(sptrOf<StrutBox>(0.f, sigma, 0.f, 0.f));
+  }
+
+  return sptr<Box>(vbox);
+}

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

@@ -0,0 +1,53 @@
+#ifndef MICROTEX_ATOM_ACCENT_H
+#define MICROTEX_ATOM_ACCENT_H
+
+#include "atom/atom.h"
+#include "atom/atom_char.h"
+
+namespace microtex {
+
+/** An atom representing another atom with an accent symbol above it */
+class AccentedAtom : public Atom {
+public:
+  sptr<SymbolAtom> _accenter;
+  sptr<Atom> _accentee;
+  sptr<Atom> _base;
+
+  bool _fakeAccent = false;
+  bool _fitSize = false;
+
+  void setupBase(const sptr<Atom>& base);
+
+public:
+  AccentedAtom() = delete;
+
+  /**
+   * Create an AccentedAtom from a base atom and an accent symbol defined by
+   * its name
+   *
+   * @param base base atom
+   * @param name name of the accent symbol to be put over the base atom
+   * @param fitSize if accent fit the base atom's width
+   * @param fake if is a fake accent
+   */
+  AccentedAtom(
+    const sptr<Atom>& base,
+    const std::string& name,
+    bool fitSize = false,
+    bool fake = false
+  );
+
+  AtomType leftType() const override {
+    return _accentee == nullptr ? AtomType::ordinary : _accentee->leftType();
+  }
+
+  AtomType rightType() const override {
+    return _accentee == nullptr ? AtomType::ordinary : _accentee->rightType();
+  }
+
+  sptr<Box> createBox(Env& env) override;
+};
+
+}  // namespace microtex
+
+#endif  // MICROTEX_ATOM_ACCENT_H

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

@@ -0,0 +1,146 @@
+#include "atom/atom_basic.h"
+
+#include "atom/atom_scripts.h"
+#include "box/box_factory.h"
+#include "box/box_group.h"
+#include "env/env.h"
+
+using namespace std;
+using namespace microtex;
+
+sptr<Box> StyleAtom::createBox(Env& env) {
+  return env.withStyle(_style, [&](Env& e) { return _base->createBox(e); });
+}
+
+sptr<Box> AStyleAtom::createBox(Env& env) {
+  TexStyle style = TexStyle::display;
+  if (_name == "dnomstyle") {
+    style = env.dnomStyle();
+  } else if (_name == "numstyle") {
+    style = env.numStyle();
+  } else if (_name == "substyle") {
+    style = env.subStyle();
+  } else if (_name == "supstyle") {
+    style = env.supStyle();
+  }
+  return env.withStyle(style, [&](Env& e) { return _base->createBox(e); });
+}
+
+sptr<Box> SmashedAtom::createBox(Env& env) {
+  auto b = sptrOf<HBox>(_base->createBox(env));
+  if (_h) b->_height = 0;
+  if (_d) b->_depth = 0;
+  return b;
+}
+
+sptr<Box> ScaleAtom::createBox(Env& env) {
+  return sptrOf<ScaleBox>(_base->createBox(env), _sx, _sy);
+}
+
+sptr<Box> MathAtom::createBox(Env& env) {
+  const auto style = env.style();
+  // if parent style greater than "this style", that means the parent uses smaller font size,
+  // then uses parent style instead
+  if (_style > style) {
+    env.setStyle(_style);
+  }
+  _base = _base == nullptr ? sptrOf<EmptyAtom>() : _base;
+  auto box = _base->createBox(env);
+  env.setStyle(style);
+  return box;
+}
+
+sptr<Box> HlineAtom::createBox(Env& env) {
+  const auto drt = env.ruleThickness();
+  auto b = new RuleBox(drt, _width, _shift, _color, false);
+  auto vb = new VBox();
+  vb->add(sptr<Box>(b));
+  vb->_type = AtomType::hline;
+  return sptr<Box>(vb);
+}
+
+CumulativeScriptsAtom::CumulativeScriptsAtom(
+  const sptr<Atom>& base,
+  const sptr<Atom>& sub,
+  const sptr<Atom>& sup
+) {
+  if (auto ca = dynamic_cast<CumulativeScriptsAtom*>(base.get()); ca != nullptr) {
+    _base = ca->_base;
+    ca->_sup->add(sup);
+    ca->_sub->add(sub);
+    _sup = ca->_sup;
+    _sub = ca->_sub;
+  } else if (auto sa = dynamic_cast<ScriptsAtom*>(base.get()); sa != nullptr) {
+    _base = sa->_base;
+    _sup = sptrOf<RowAtom>(sa->_sup);
+    _sub = sptrOf<RowAtom>(sa->_sub);
+    _sup->add(sup);
+    _sub->add(sub);
+  } else {
+    _base = base;
+    _sup = sptrOf<RowAtom>(sup);
+    _sub = sptrOf<RowAtom>(sub);
+  }
+}
+
+void CumulativeScriptsAtom::addSuperscript(const sptr<Atom>& sup) {
+  _sup->add(sup);
+}
+
+void CumulativeScriptsAtom::addSubscript(const sptr<Atom>& sub) {
+  _sub->add(sub);
+}
+
+sptr<Atom> CumulativeScriptsAtom::getScriptsAtom() const {
+  return sptrOf<ScriptsAtom>(_base, _sub, _sup);
+}
+
+sptr<Box> CumulativeScriptsAtom::createBox(Env& env) {
+  return ScriptsAtom(_base, _sub, _sup).createBox(env);
+}
+
+const color ColorAtom::_default = black;
+
+ColorAtom::ColorAtom(const sptr<Atom>& atom, color bg, color c) : _background(bg), _color(c) {
+  _elements = sptrOf<RowAtom>(atom);
+}
+
+void ColorAtom::defineColor(const string& name, color c) {
+  _colors[name] = c;
+}
+
+sptr<Box> ColorAtom::createBox(Env& env) {
+  const auto box = _elements->createBox(env);
+  return sptrOf<ColorBox>(box, _color, _background);
+}
+
+PhantomAtom::PhantomAtom(const sptr<Atom>& el) {
+  if (el == nullptr)
+    _elements = sptrOf<RowAtom>();
+  else
+    _elements = sptrOf<RowAtom>(el);
+  _w = _h = _d = true;
+}
+
+PhantomAtom::PhantomAtom(const sptr<Atom>& el, bool w, bool h, bool d) {
+  if (el == nullptr)
+    _elements = sptrOf<RowAtom>();
+  else
+    _elements = sptrOf<RowAtom>(el);
+  _w = w, _h = h, _d = d;
+}
+
+sptr<Box> PhantomAtom::createBox(Env& env) {
+  auto res = _elements->createBox(env);
+  float w = (_w ? res->_width : 0);
+  float h = (_h ? res->_height : 0);
+  float d = (_d ? res->_depth : 0);
+  float s = res->_shift;
+  return sptrOf<StrutBox>(w, h, d, s);
+}
+
+sptr<Box> ExtensibleAtom::createBox(Env& env) {
+  const auto len = _getLen(env);
+  return _vertical ? microtex::createVDelim(_sym, env, len)
+                   : microtex::createHDelim(_sym, env, len);
+}