@simonklee/opentui-tex-native-source 0.2.0

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

@@ -0,0 +1,105 @@
+#ifndef MICROTEX_MATH_TYPE_H
+#define MICROTEX_MATH_TYPE_H
+
+#include <map>
+
+#include "graphic/font_style.h"
+#include "utils/utils.h"
+
+namespace microtex {
+
+/*
+ * The math styles. The math glyphs are painted in following styles:
+ *
+ * style    latin  Latin  greek  Greek
+ * -----------------------------------
+ * TeX      it     it     it     up
+ * ISO      it     it     it     it
+ * French   it     up     up     up
+ * upright  up     up     up     up
+ */
+enum class MathStyle : u8 {
+  TeX,
+  ISO,
+  French,
+  upright,
+};
+
+enum class LetterType : u8 {
+  none,
+  digit,
+  latinSmall,
+  latinCapital,
+  greekSmall,
+  greekCapital,
+};
+
+/**
+ * Represents math-version for digit, Latin and Greek alphabets.
+ *
+ * <p>
+ * This for maps a given Unicode character to the mathematical alphanumeric in various
+ * math versions.
+ *
+ * Mathematical Alphanumeric Symbols is a Unicode block comprising styled forms of
+ * Latin and Greek letters and decimal digits that enable mathematicians to denote
+ * different notions with different letter styles.
+ *
+ * <p>
+ * Unicode includes many such symbols (in the range U+1D400–U+1D7FF). But notice that
+ * there are several code-point come up as <Reserved> at Unicode, this handler will
+ * replace these <Reserved> code-points with the code-point that has the same "glyph"
+ * representation.
+ *
+ * <p>
+ * For example, the math-italic version of the character 'h' has the code-point
+ * "U+1D455" that is reserved in Unicode, and it will be replaced by "U+210E" that has
+ * the meaning of "PLANCK CONSTANT".
+ *
+ * <p>
+ * See
+ * <a href="https://en.wikipedia.org/wiki/Mathematical_Alphanumeric_Symbols">
+ * Mathematical Alphanumeric Symbols
+ * </a>
+ * for details.
+ */
+class MathVersion {
+private:
+  c32 _codepoints[6];
+  FontStyle _fontStyle;
+
+public:
+  no_copy_assign(MathVersion);
+
+  MathVersion(
+    c32 digit,
+    c32 latinSmall,
+    c32 latinCapital,
+    c32 greekSmall,
+    c32 greekCapital,
+    FontStyle fontStyle = FontStyle::none
+  ) noexcept;
+
+  /** Map an Unicode char to version-specific Unicode char. */
+  c32 map(c32 codepoint) const;
+
+  /**
+   * Set math style to display formulas.
+   *
+   * @param style one of the TeX, ISO, French, and upright
+   */
+  static void setMathStyle(MathStyle style);
+
+  /**
+   * Map an Unicode char to version-specific Unicode char.
+   *
+   * @param style the font style
+   * @param code the given code
+   * @return the mapped version-specific Unicode code-point
+   */
+  static c32 map(FontStyle style, c32 code);
+};
+
+}  // namespace microtex
+
+#endif  // MICROTEX_MATH_TYPE_H

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

@@ -0,0 +1,18 @@
+unimath_src = [
+    'unimath/font_src.cpp',
+    'unimath/math_type.cpp',
+    'unimath/uni_char.cpp',
+	'unimath/uni_font.cpp',
+	'unimath/uni_symbol.cpp'
+]
+
+if install_headerfiles
+	install_headers([
+	    'font_src.h',
+	    'font_meta.h',
+	    'math_type.h',
+	    'uni_char.h',
+		'uni_font.h',
+		'uni_symbol.h'
+	], subdir: 'microtex/unimath')
+endif

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

@@ -0,0 +1,121 @@
+#include "unimath/uni_char.h"
+
+#include "unimath/uni_font.h"
+#include "utils/log.h"
+
+using namespace microtex;
+
+Char::Char(c32 c, c32 mc, i32 fid, i32 gid, float s)
+    : code(c), mappedCode(mc), fontId(fid), glyphId(gid), scale(s) {}
+
+Char::Char(const Char& c)
+    : code(c.code),
+      mappedCode(c.mappedCode),
+      fontId(c.fontId),
+      glyphId(c.glyphId),
+      scale(c.scale) {}
+
+sptr<const OtfFont> Char::otfFont() const {
+  return FontContext::getFont(fontId);
+}
+
+const Glyph* Char::glyph() const {
+  auto font = FontContext::getFont(fontId);
+  if (font == nullptr) {
+#ifdef HAVE_LOG
+    logv("There's no font was found with id = %d, use '?' instead.\n", fontId);
+#endif
+    return FontContext::getFont(0)->otf().glyphOfUnicode('?');
+  }
+  auto g = font->otf().glyph(glyphId);
+  if (g == nullptr) {
+#ifdef HAVE_LOG
+    logv(
+      "There's no glyph was found with (unicode = %u, id = %d), use '?' instead.\n",
+      static_cast<std::uint32_t>(mappedCode),
+      glyphId
+    );
+#endif
+    return font->otf().glyphOfUnicode('?');
+  }
+  return g;
+}
+
+i32 Char::fallbackGlyphId() const {
+  if (isValid()) return glyphId;
+  auto font = FontContext::getFont(fontId);
+  if (font == nullptr) {
+    return FontContext::getFont(0)->otf().glyphId('?');
+  }
+  return font->otf().glyphId('?');
+}
+
+float Char::width() const {
+  return glyph()->metrics().width() * scale;
+}
+
+float Char::height() const {
+  return glyph()->metrics().height() * scale;
+}
+
+float Char::depth() const {
+  return glyph()->metrics().depth() * scale;
+}
+
+float Char::italic() const {
+  auto italic = glyph()->math().italicsCorrection();
+  return italic == Otf::undefinedMathValue ? 0.f : italic * scale;
+}
+
+float Char::topAccentAttachment() const {
+  auto t = glyph()->math().topAccentAttachment();
+  return t == Otf::undefinedMathValue ? width() / 2.f : t * scale;
+}
+
+static Char
+variant(const Char& chr, u32 index, const std::function<const Variants&(const Glyph*)>& f) {
+  auto g = chr.glyph();
+  const auto& v = f(g);
+  if (v.isEmpty()) return chr;
+  index = std::min<int>(index, v.count() - 1);
+  // only changes the glyph version, other fields remain unchanged
+  return {chr.code, chr.mappedCode, chr.fontId, v[index], chr.scale};
+}
+
+u16 Char::vLargerCount() const {
+  return glyph()->math().verticalVariants().count();
+}
+
+Char Char::vLarger(u32 index) const {
+  return variant(*this, index, [](const Glyph* g) -> const Variants& {
+    return g->math().verticalVariants();
+  });
+}
+
+u16 Char::hLargerCount() const {
+  return glyph()->math().horizontalVariants().count();
+}
+
+Char Char::hLarger(u32 index) const {
+  return variant(*this, index, [](const Glyph* g) -> const Variants& {
+    return g->math().horizontalVariants();
+  });
+}
+
+Char Char::script(u32 index) const {
+  return variant(*this, index, [](const Glyph* g) -> const Variants& {
+    return g->math().scriptsVariants();
+  });
+}
+
+const GlyphAssembly& Char::vAssembly() const {
+  return glyph()->math().verticalAssembly();
+}
+
+const GlyphAssembly& Char::hAssembly() const {
+  return glyph()->math().horizontalAssembly();
+}
+
+const Char Char::assemblyPart(i32 id) const {
+  return onlyGlyph(fontId, id, scale);
+}

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

@@ -0,0 +1,109 @@
+#ifndef MICROTEX_UNI_CHAR_H
+#define MICROTEX_UNI_CHAR_H
+
+#include "otf/glyph.h"
+#include "utils/utils.h"
+
+namespace microtex {
+
+struct OtfFont;
+
+/** Represents a character-glyph to be measured and drawn with its font, glyph id and scale */
+struct Char final {
+  /** The original code point of the character */
+  const c32 code = 0;
+  /** The mapped code point (by math style) of the character */
+  const c32 mappedCode = 0;
+  /** The font id */
+  const i32 fontId = -1;
+  /** The glyph id, -1 if no corresponding glyph in the font */
+  const i32 glyphId = -1;
+
+  /** The glyph scale, can be modified during using */
+  float scale = 1.f;
+
+  Char() = default;
+
+  Char(c32 code, c32 mapped, i32 fid, i32 gid, float scale = 1.f);
+
+  Char(const Char& chr);
+
+  /**
+   * Create a char-glyph with only font and glyph, the Unicode code-point is 0.
+   * <p>
+   * Notice that the char-glyph is valid even if its Unicode is 0, because many glyph has no
+   * corresponding Unicode code-point.
+   */
+  static inline Char onlyGlyph(i32 font, i32 glyph, float scale = 1.f) {
+    return {0, 0, font, glyph, scale};
+  }
+
+  /** Test if current glyph is valid, basically the #_glyph >= 0 */
+  inline bool isValid() const { return glyphId >= 0; }
+
+  /** The otf font spec the char belongs to */
+  sptr<const OtfFont> otfFont() const;
+
+  /**
+   * The glyph of this char-glyph, NOT NULL.
+   * If the char has no corresponding glyph was found, the '?' will be
+   * returned instead. You should test the validity of this object before
+   * call this function.
+   */
+  const Glyph* glyph() const;
+
+  /** The fallback glyph id if is invalid */
+  i32 fallbackGlyphId() const;
+
+  /** The width of this char-glyph */
+  float width() const;
+
+  /** The height of this char-glyph */
+  float height() const;
+
+  /** The depth of this char-glyph, in positive */
+  float depth() const;
+
+  /** The italic correction of this char-glyph */
+  float italic() const;
+
+  /** Get the position (shift) to attach top accent */
+  float topAccentAttachment() const;
+
+  /** Get the number of vertical larger variants */
+  u16 vLargerCount() const;
+
+  /**
+   * Get the vertical larger version of this char-glyph, return the copy of
+   * this if no larger version was found. The index 0 is this itself.
+   */
+  Char vLarger(u32 index) const;
+
+  /** Get the number of horizontal larger variants */
+  u16 hLargerCount() const;
+
+  /**
+   * Get the horizontal larger version of this char-glyph, return the copy of
+   * this if no larger version was found. The index 0 is this itself.
+   */
+  Char hLarger(u32 index) const;
+
+  /**
+   * Get the script version of this char-glyph, return the copy of this if
+   * no script version was found.
+   */
+  Char script(u32 index) const;
+
+  /** Get the glyph assembly in vertical direction */
+  const GlyphAssembly& vAssembly() const;
+
+  /** Get the glyph assembly in horizontal direction */
+  const GlyphAssembly& hAssembly() const;
+
+  /** Get the char of the assembly part */
+  const Char assemblyPart(i32 id) const;
+};
+
+}  // namespace microtex
+
+#endif  // MICROTEX_UNI_CHAR_H

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

@@ -0,0 +1,248 @@
+#include "unimath/uni_font.h"
+
+#include <utility>
+
+#include "unimath/uni_symbol.h"
+#include "utils/exceptions.h"
+#include "utils/log.h"
+#include "utils/utils.h"
+
+using namespace std;
+
+namespace microtex {
+
+OtfFont::OtfFont(i32 id, sptr<const Otf> spec, std::string fontFile) noexcept
+    : id(id),
+      fontFile(fontFile.empty() ? spec->family() : std::move(fontFile)),
+      otfSpec(std::move(spec)) {}
+
+/**************************************************************************************************/
+
+const vector<FontStyle>& FontFamily::supportedStyles() {
+  static const vector<FontStyle> styles{
+    FontStyle::rm,
+    FontStyle::bf,
+    FontStyle::it,
+    FontStyle::sf,
+    FontStyle::tt,
+    FontStyle::cal,
+    FontStyle::frak,
+    FontStyle::bfit,
+    FontStyle::sfbfit,
+  };
+  return styles;
+}
+
+FontStyle FontFamily::fontStyleOf(const std::string& name) {
+  // TODO: more composed styles
+  static const map<string, FontStyle> nameStyle{
+    {"",     FontStyle::rm  },
+    {"rm",   FontStyle::rm  },
+    {"bf",   FontStyle::bf  },
+    {"it",   FontStyle::it  },
+    {"sf",   FontStyle::sf  },
+    {"tt",   FontStyle::tt  },
+    {"cal",  FontStyle::cal },
+    {"frak", FontStyle::frak},
+    {"bfit", FontStyle::bfit},
+  };
+  const auto it = nameStyle.find(name);
+  if (it == nameStyle.end()) return FontStyle::none;
+  return it->second;
+}
+
+void FontFamily::add(const sptr<const OtfFont>& font) {
+  const auto style = static_cast<FontStyle>(font->otfSpec->style());
+#ifdef HAVE_LOG
+  if (_styles.find(style) != _styles.end()) {
+    loge("the style '%hx' has a font already, but you can replace it anyway\n", style);
+  }
+#endif
+  _styles[style] = font;
+}
+
+sptr<const OtfFont> FontFamily::get(FontStyle style) const {
+  const auto it = _styles.find(style);
+  if (it == _styles.end()) {
+    FontStyle closest = findClosestStyle(style);
+    const auto t = _styles.find(closest);
+    if (t == _styles.end()) {
+      const auto rm = _styles.find(FontStyle::rm);
+      return rm == _styles.end() ? nullptr : rm->second;
+    }
+    return t->second;
+  }
+  return it->second;
+}
+
+/**************************************************************************************************/
+
+namespace {
+
+int _lastId = 0;
+vector<sptr<const OtfFont>> _fonts;
+
+map<string, sptr<FontFamily>> _mainFonts;
+map<string, sptr<const OtfFont>> _mathFonts;
+
+sptr<FontFamily> getOrCreateFontFamily(const std::string& family) {
+  sptr<FontFamily> f;
+  auto it = _mainFonts.find(family);
+  if (it == _mainFonts.end()) {
+    f = sptrOf<FontFamily>();
+    _mainFonts[family] = f;
+  } else {
+    f = it->second;
+  }
+  return f;
+}
+
+}  // namespace
+
+FontStyle FontContext::mathFontStyleOf(const std::string& name) {
+  static const map<string, FontStyle> nameStyle{
+    {"",           FontStyle::none  },
+    {"mathnormal", FontStyle::none  },
+    {"mathrm",     FontStyle::rm    },
+    {"mathbf",     FontStyle::bf    },
+    {"mathit",     FontStyle::it    },
+    {"mathcal",    FontStyle::cal   },
+    {"mathscr",    FontStyle::cal   },
+    {"mathfrak",   FontStyle::frak  },
+    {"mathbb",     FontStyle::bb    },
+    {"mathsf",     FontStyle::sf    },
+    {"mathtt",     FontStyle::tt    },
+    {"mathbfit",   FontStyle::bfit  },
+    {"mathbfcal",  FontStyle::bfcal },
+    {"mathbffrak", FontStyle::bffrak},
+    {"mathsfbf",   FontStyle::sfbf  },
+    {"mathbfsf",   FontStyle::sfbf  },
+    {"mathsfit",   FontStyle::sfit  },
+    {"mathsfbfit", FontStyle::sfbfit},
+    {"mathbfsfit", FontStyle::sfbfit},
+  };
+  const auto it = nameStyle.find(name);
+  if (it != nameStyle.end()) return it->second;
+  return FontStyle::none;
+}
+
+FontStyle FontContext::mainFontStyleOf(const std::string& name) {
+  return FontFamily::fontStyleOf(name);
+}
+
+FontMeta FontContext::addFont(const FontSrc& src) {
+  auto spec = src.loadOtf();
+  auto otf = sptrOf<OtfFont>(_lastId++, spec, src.fontFile);
+  _fonts.push_back(otf);
+  if (spec->isMathFont()) {
+    _mathFonts[spec->name()] = otf;
+  } else {
+    auto f = getOrCreateFontFamily(spec->family());
+    f->add(otf);
+  }
+  return {
+    spec->family(),
+    spec->name(),
+    static_cast<const FontStyle>(spec->style()),
+    spec->isMathFont(),
+  };
+}
+
+bool FontContext::hasMathFont() {
+  return !_mathFonts.empty();
+}
+
+FontMeta FontContext::mathFontMetaOf(const std::string& name) {
+  auto it = _mathFonts.find(name);
+  if (it == _mathFonts.end()) {
+    return {};
+  }
+  const auto& spec = it->second->otf();
+  return {spec.family(), spec.name(), static_cast<FontStyle>(spec.style()), spec.isMathFont()};
+}
+
+bool FontContext::isMathFontExists(const std::string& name) {
+  return _mathFonts.find(name) != _mathFonts.end();
+}
+
+bool FontContext::isMainFontExists(const std::string& familyName) {
+  return _mainFonts.find(familyName) != _mainFonts.end();
+}
+
+std::vector<std::string> FontContext::mathFontNames() {
+  return keys(_mathFonts);
+}
+
+std::vector<std::string> FontContext::mainFontFamilies() {
+  return keys(_mainFonts);
+}
+
+sptr<const OtfFont> FontContext::getFont(i32 id) {
+  if (id >= _fonts.size() || id < 0) return nullptr;
+  return _fonts[id];
+}
+
+bool FontContext::selectMathFont(const string& name) {
+  const auto it = _mathFonts.find(name);
+  if (it == _mathFonts.end()) {
+#ifdef HAVE_LOG
+    loge("Math font '%s' does not exists!", name.c_str());
+#endif
+    return false;
+  }
+  _mathFont = it->second;
+  return true;
+}
+
+bool FontContext::selectMainFont(const string& familyName) {
+  if (familyName.empty()) {
+    _mainFont = nullptr;
+    return false;
+  }
+  const auto it = _mainFonts.find(familyName);
+  if (it == _mainFonts.end()) {
+#ifdef HAVE_LOG
+    loge("Main font '%s' does not exists!", familyName.c_str());
+#endif
+    return false;
+  }
+  _mainFont = it->second;
+  return true;
+}
+
+u16 FontContext::mainSpace() {
+  if (_mainFont == nullptr) return mathFont().otf().space();
+  for (auto style : FontFamily::supportedStyles()) {
+    auto f = _mainFont->get(style);
+    if (f != nullptr) {
+      return f->otf().space();
+    }
+  }
+  return mathFont().otf().space();
+}
+
+Char FontContext::getChar(const Symbol& symbol, FontStyle style) const {
+  // TODO math mode?
+  const auto code = symbol.unicode;
+  return getChar(code, style, true);
+}
+
+Char FontContext::getChar(c32 code, const string& styleName, bool isMathMode) const {
+  const auto style = isMathMode ? mathFontStyleOf(styleName) : mainFontStyleOf(styleName);
+  return getChar(code, style, isMathMode);
+}
+
+Char FontContext::getChar(c32 code, FontStyle style, bool isMathMode) const {
+  if (isMathMode) {
+    const c32 unicode = MathVersion::map(style, code);
+    return {code, unicode, _mathFont->id, _mathFont->otf().glyphId(unicode)};
+  } else {
+    sptr<const OtfFont> font = _mainFont == nullptr ? nullptr : _mainFont->get(style);
+    if (font == nullptr && _mainFont != nullptr) font = _mainFont->get(FontStyle::none);
+    // fallback to math font, at least we have one
+    if (font == nullptr) font = _mathFont;
+    return {code, code, font->id, font->otf().glyphId(code)};
+  }
+}
+
+}  // namespace microtex