@simonklee/opentui-tex-native-source 0.2.0

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

@@ -0,0 +1,221 @@
+#ifndef MICROTEX_ENV_H
+#define MICROTEX_ENV_H
+
+#include "unimath/uni_font.h"
+#include "unimath/uni_symbol.h"
+#include "utils/nums.h"
+
+namespace microtex {
+
+struct Dimen;
+
+class Env {
+private:
+  static constexpr float FIXED_TEXT_SIZE = 1000;
+  // point-to-pixel conversion
+  static float PIXELS_PER_POINT;
+
+  TexStyle _style = TexStyle::display;
+
+  i32 _lastFontId = FontContext::NO_FONT;
+  sptr<FontContext> _fctx;
+
+  float _textWidth = POS_INF;
+  float _lineSpace = 1.f;
+  float _fixedScale = 1.f;
+
+  FontStyle _textFontStyle = FontStyle::none;
+  FontStyle _mathFontStyle = FontStyle::none;
+
+  void addFontStyle(FontStyle style, FontStyle& target);
+
+  void removeFontStyle(FontStyle style, FontStyle& target);
+
+public:
+  no_copy_assign(Env);
+
+  Env(TexStyle style, const sptr<FontContext>& fctx, float pointSize)
+      : _style(style), _fctx(fctx), _fixedScale(FIXED_TEXT_SIZE / pointSize) {}
+
+  // region statics
+  /** Set the dot per inch target */
+  static inline void setDpi(float dpi) { PIXELS_PER_POINT = dpi / 72.f; }
+
+  static inline float pixelsPerPoint() { return PIXELS_PER_POINT; }
+
+  static inline float fixedTextSize() { return FIXED_TEXT_SIZE; }
+  // endregion
+
+  // region getters and setters
+  /** Get the scale factor of the current environment */
+  float scale() const;
+
+  /** Get the scale factor of the given style */
+  float scale(TexStyle style) const;
+
+  /** Set environment width with given dimension. */
+  Env& setTextWidth(const Dimen& dimen);
+
+  /** Set line space with given dimension. */
+  Env& setLineSpace(const Dimen& dimen);
+
+  /** Set current style to display formulas */
+  inline Env& setStyle(TexStyle style) {
+    _style = style;
+    return *this;
+  }
+
+  /** Set the last font id will be used later when box is to be painted */
+  inline Env& setLastFontId(i32 lastFontId) {
+    _lastFontId = lastFontId == FontContext::NO_FONT ? _fctx->mathFontId() : _lastFontId;
+    return *this;
+  }
+
+  /** The environment width */
+  inline float textWidth() const { return _textWidth; }
+
+  /** The style to display formulas */
+  inline TexStyle style() const { return _style; }
+
+  /** The text size, in point */
+  inline float textSize() const { return FIXED_TEXT_SIZE; }
+
+  /** The fixed scale */
+  inline float fixedScale() const { return _fixedScale; }
+
+  /** The line space to layout boxes vertically */
+  inline float lineSpace() const { return _lineSpace; }
+
+  /** The font style to display formulas */
+  inline FontStyle mathFontStyle() const { return _mathFontStyle; }
+
+  /** The font style to display text */
+  inline FontStyle textFontStyle() const { return _textFontStyle; }
+
+  /** The last used font's id, or the math font's id if no font was used */
+  inline i32 lastFontId() const {
+    return _lastFontId == FontContext::NO_FONT ? _fctx->mathFontId() : _lastFontId;
+  }
+
+  /** The math font id */
+  inline i32 mathFontId() const { return _fctx->mathFontId(); }
+  // endregion
+
+  // region Font related
+  /** Helper function to get math constants */
+  const MathConsts& mathConsts() const;
+
+  /** units per em, environment independent */
+  float upem() const;
+
+  /** The em size of the current environment */
+  float em() const;
+
+  /** pixels per em */
+  float ppem() const;
+
+  /** The x-height of the current environment */
+  float xHeight() const;
+
+  /** The space size of the current environment */
+  float space(bool isMathMode) const;
+
+  /** The rule thickness, equals to the fraction rule thickness */
+  float ruleThickness() const;
+
+  /** The axis height */
+  float axisHeight() const;
+
+  /** Add a math font style to this environment */
+  void addMathFontStyle(FontStyle style);
+
+  /** Remove a math font style from this environment */
+  void removeMathFontStyle(FontStyle style);
+
+  /** Add a text font style to this environment */
+  void addTextFontStyle(FontStyle style);
+
+  /** Remove a text font style from this environment */
+  void removeTextFontStyle(FontStyle style);
+
+  /** Select math font to paint formulas from given name and style */
+  void selectMathFont(const std::string& name, MathStyle style);
+  // endregion
+
+  // region Styles
+  /** Test if current style is cramped */
+  inline bool isCrampedStyle() const { return crampStyle() == _style; }
+
+  /** Style to display formulas in smaller size */
+  TexStyle crampStyle() const;
+
+  /** Style to display denominator */
+  TexStyle dnomStyle() const;
+
+  /** Style to display numerator */
+  TexStyle numStyle() const;
+
+  /** Style to display radical roots */
+  TexStyle rootStyle() const;
+
+  /** Style to display subscripts */
+  TexStyle subStyle() const;
+
+  /** Style to display superscripts */
+  TexStyle supStyle() const;
+  // endregion
+
+  /**
+   * Get a Char describe the given character with scale information depending
+   * on the current environment.
+   *
+   * @param code the alphanumeric character code-point
+   * @param isMathMode if is in math-mode
+   * @param style the font style, will use the environment font style instead if
+   *        it is FontStyle::invalid, default is FontStyle::invalid
+   *
+   * @return the Char, Char#isValid() will return false if not found
+   */
+  Char getChar(c32 code, bool isMathMode, FontStyle style = FontStyle::invalid) const;
+
+  /**
+   * Get a Char describe the given symbol with scale information depending
+   * on the current environment.
+   *
+   * @param sym the symbol
+   *
+   * @return the Char, the method Char#isValid() will return false if not found
+   */
+  Char getChar(const Symbol& sym) const;
+
+  /**
+   * Do something with given TexStyle. This will reset the style after function #f
+   * return.
+   */
+  template <typename F>
+  auto withStyle(const TexStyle style, F&& f) -> decltype(f(*this)) {
+    auto oldStyle = _style;
+    setStyle(style);
+    auto result = f(*this);
+    setStyle(oldStyle);
+    return result;
+  }
+
+  /**
+   * Do something with given FontStyle. This will reset the FontStyle after function #f
+   * return.
+   */
+  template <typename F>
+  auto withFontStyle(const FontStyle style, bool isMathMode, F&& f) -> decltype(f(*this)) {
+    auto oldStyle = isMathMode ? _mathFontStyle : _textFontStyle;
+    auto& target = isMathMode ? _mathFontStyle : _textFontStyle;
+    target = style;
+    auto result = f(*this);
+    target = oldStyle;
+    return result;
+  }
+};
+
+}  // namespace microtex
+
+#endif  // MICROTEX_ENV_H

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

@@ -0,0 +1,11 @@
+env_src = [
+    'env/env.cpp',
+    'env/units.cpp'
+]
+
+if install_headerfiles
+    install_headers([
+        'env.h',
+        'units.h'
+    ], subdir: 'microtex/env')
+endif

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

@@ -0,0 +1,109 @@
+#include "env/units.h"
+
+#include <cstring>
+
+#include "utils/string_utils.h"
+#include "utils/utf.h"
+
+using namespace microtex;
+using namespace std;
+
+namespace {
+
+// IMPORTANT: sorted by the unit name, you must re-sort this array after add item
+const pair<const char*, UnitType> _units[]{
+  {"bp",    UnitType::point},
+  {"cc",    UnitType::cc   },
+  {"cm",    UnitType::cm   },
+  {"dd",    UnitType::dd   },
+  {"em",    UnitType::em   },
+  {"ex",    UnitType::ex   },
+  {"in",    UnitType::in   },
+  {"mm",    UnitType::mm   },
+  {"mu",    UnitType::mu   },
+  {"pc",    UnitType::pica },
+  {"pica",  UnitType::pica },
+  {"pix",   UnitType::pixel},
+  {"pixel", UnitType::pixel},
+  {"pt",    UnitType::pt   },
+  {"px",    UnitType::pixel},
+  {"sp",    UnitType::sp   },
+};
+
+const u32 _unitsCount = sizeof(_units) / sizeof(pair<const char*, UnitType>);
+
+/**
+ * Helper function to get the size of 1 point (big-point) corresponds to
+ * the font design unit.
+ */
+float pt(const Env& env) {
+  return Env::pixelsPerPoint() * env.upem() / env.ppem() * env.fixedScale();
+}
+
+// IMPORTANT: the order corresponds to the order of the enum UnitType
+const function<float(const Env&)> _unitConversions[]{
+  // em
+  [](const Env& env) -> float { return env.em(); },
+  // ex
+  [](const Env& env) -> float { return env.xHeight(); },
+  // pixel
+  [](const Env& env) -> float { return pt(env) / Env::pixelsPerPoint(); },
+  // point
+  [](const Env& env) -> float { return pt(env); },
+  // 1 pica = 12 point
+  [](const Env& env) -> float { return 12 * pt(env); },
+  // 1 mu = 1/18 em
+  [](const Env& env) -> float { return env.em() / 18.f; },
+  // 1 cm = 28.346456693 point
+  [](const Env& env) -> float { return 28.346456693f * pt(env); },
+  // 1 mm = 1/10 cm
+  [](const Env& env) -> float { return 2.8346456693f * pt(env); },
+  // 1 in = 72 point
+  [](const Env& env) -> float { return 72.f * pt(env); },
+  // 1 sp = 65536 point
+  [](const Env& env) -> float { return 65536.f * pt(env); },
+  // 1 pt = 0.99626401 point (in printer's)
+  [](const Env& env) -> float { return 0.99626401f * pt(env); },
+  // 1 dd = 1.0660349422 point
+  [](const Env& env) -> float { return 1.0660349422f * pt(env); },
+  // 1 cc = 12 dd
+  [](const Env& env) -> float { return 12.7924193070f * pt(env); },
+  // 1 tt = rule thickness
+  [](const Env& env) -> float { return env.ruleThickness() * env.scale(); },
+};
+
+}  // namespace
+
+float Units::fsize(UnitType unit, float size, const Env& env) {
+  if (unit == UnitType::none) return size;
+  return _unitConversions[static_cast<i8>(unit)](env) * size;
+}
+
+float Units::fsize(const Dimen& dimen, const Env& env) {
+  return Units::fsize(dimen.unit, dimen.val, env);
+}
+
+UnitType Units::getUnit(const std::string& unit) {
+  const auto i =
+    binIndexOf(_unitsCount, [&](int i) { return strcmp(unit.c_str(), _units[i].first); });
+  if (i < 0) return UnitType::pixel;
+  return _units[i].second;
+}
+
+Dimen Units::getDimen(const std::string& lgth) {
+  if (lgth.empty()) return {0.f, UnitType::none};
+
+  size_t i = 0;
+  for (; i < lgth.length() && !isAlpha(lgth[i]); i++)
+    ;
+  float f = 0;
+  valueOf(lgth.substr(0, i), f);
+
+  UnitType unit = UnitType::none;
+  string str = lgth.substr(i);
+  string x = trim(str);
+  toLower(x);
+  if (i != lgth.size()) unit = getUnit(x);
+
+  return {f, unit};
+}

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

@@ -0,0 +1,61 @@
+#ifndef MICROTEX_UNITS_H
+#define MICROTEX_UNITS_H
+
+#include "env/env.h"
+#include "utils/utils.h"
+
+namespace microtex {
+
+/** Represents a dimension */
+struct Dimen {
+  float val = 0.f;
+  UnitType unit = UnitType::none;
+
+  inline bool isValid() const { return unit != UnitType::none; }
+
+  inline bool isEmpty() const { return !isValid() || val == 0.f; }
+
+  inline Dimen& operator-() {
+    val = -val;
+    return *this;
+  }
+};
+
+constexpr Dimen operator""_ex(long double val) {
+  return {static_cast<float>(val), UnitType::ex};
+}
+
+constexpr Dimen operator""_em(long double val) {
+  return {static_cast<float>(val), UnitType::em};
+}
+
+constexpr Dimen operator""_pt(long double val) {
+  return {static_cast<float>(val), UnitType::pt};
+}
+
+constexpr Dimen operator""_tt(long double val) {
+  return {static_cast<float>(val), UnitType::tt};
+}
+
+class Units final {
+public:
+  /** Convert the given size with unit to the font design size (in font unit) */
+  static float fsize(UnitType unit, float size, const Env& env);
+
+  /** Convert the given dimension to the font design size (in font unit) */
+  static float fsize(const Dimen& dimen, const Env& env);
+
+  /** Get the unit type from the given unit name */
+  static UnitType getUnit(const std::string& unit);
+
+  /**
+   * Get the unit and length from given string. The string must be in the format: a number
+   * following with the unit (e.g. 10px, 1cm, 8.2em, ...), or (UnitType::none, 0) will be
+   * returned.
+   */
+  static Dimen getDimen(const std::string& lgth);
+};
+
+}  // namespace microtex
+
+#endif  // MICROTEX_UNITS_H

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

@@ -0,0 +1,63 @@
+#include "graphic/font_style.h"
+
+#include "utils/utils.h"
+
+using namespace microtex;
+
+FontStyle microtex::findClosestStyle(const FontStyle src) {
+  u16 x = static_cast<u16>(src);
+  // roman or none
+  if (x == 0 || x == 1) return src;
+  // the last bit is 1, that means added a roman style, remove it
+  if ((x & 0x1) == 1) x &= 0xfffe;
+  // single bit, that means a single style
+  if ((x & (x - 1)) == 0) return static_cast<FontStyle>(x);
+  // find the max match from composed styles
+  static const FontStyle composedStyles[]{
+    FontStyle::bfit,
+    FontStyle::bfcal,
+    FontStyle::bffrak,
+    FontStyle::sfbf,
+    FontStyle::sfit,
+    FontStyle::sfbfit,
+  };
+  u32 similarity = 0;
+  FontStyle target = FontStyle::none;
+  for (FontStyle style : composedStyles) {
+    const auto n = countSetBits(x & static_cast<u16>(style));
+    if (n > similarity) {
+      target = style;
+      similarity = n;
+    }
+  }
+  return target;
+}
+
+bool microtex::isUnspecified(FontStyle style) {
+  return style == FontStyle::none;
+}
+
+bool microtex::isRoman(FontStyle style) {
+  return style != FontStyle::invalid
+         && (static_cast<u16>(style) & static_cast<u16>(FontStyle::rm)) != 0;
+}
+
+bool microtex::isBold(FontStyle style) {
+  return style != FontStyle::invalid
+         && (static_cast<u16>(style) & static_cast<u16>(FontStyle::bf)) != 0;
+}
+
+bool microtex::isItalic(FontStyle style) {
+  return style != FontStyle::invalid
+         && (static_cast<u16>(style) & static_cast<u16>(FontStyle::it)) != 0;
+}
+
+bool microtex::isSansSerif(FontStyle style) {
+  return style != FontStyle::invalid
+         && (static_cast<u16>(style) & static_cast<u16>(FontStyle::sf)) != 0;
+}
+
+bool microtex::isMono(FontStyle style) {
+  return style != FontStyle::invalid
+         && (static_cast<u16>(style) & static_cast<u16>(FontStyle::tt)) != 0;
+}

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

@@ -0,0 +1,61 @@
+#ifndef MICROTEX_FONT_STYLE_H
+#define MICROTEX_FONT_STYLE_H
+
+#include "microtexexport.h"
+#include "utils/types.h"
+
+namespace microtex {
+
+/** Enum represents all supported font style */
+enum class FontStyle : u16 {
+  none = 0,         // unspecified, choose an appropriate style depends on context
+  rm = 0b1,         // roman
+  bf = 0b10,        // bold
+  it = 0b100,       // italic
+  cal = 0b1000,     // calligraphic
+  frak = 0b10000,   // fraktur
+  bb = 0b100000,    // double-struck
+  sf = 0b1000000,   // sans-serif
+  tt = 0b10000000,  // type-writer (monospaced)
+  // composed styles
+  bfit = bf | it,
+  bfcal = bf | cal,
+  bffrak = bf | frak,
+  sfbf = bf | sf,
+  sfit = it | sf,
+  sfbfit = bf | it | sf,
+  // invalid
+  invalid = 0xffff
+};
+
+/**
+ * Get the most similar font style from the given source font style.
+ *
+ * <p>
+ * The similarity is measured by the number of set bits of the result
+ * that generated by the bitwise operation '&' between source font style
+ * and the composed font styles.
+ */
+FontStyle MICROTEX_EXPORT findClosestStyle(FontStyle src);
+
+/** Test if the given font style is unspecified*/
+bool MICROTEX_EXPORT isUnspecified(FontStyle style);
+
+/** Test if the given font style is roman */
+bool MICROTEX_EXPORT isRoman(FontStyle style);
+
+/** Test if the given font style is bold */
+bool MICROTEX_EXPORT isBold(FontStyle style);
+
+/** Test if the given font style is italic */
+bool MICROTEX_EXPORT isItalic(FontStyle style);
+
+/** Test if the given font style is sans-serif */
+bool MICROTEX_EXPORT isSansSerif(FontStyle style);
+
+/** Test if the given font style is mono-spaced */
+bool MICROTEX_EXPORT isMono(FontStyle style);
+
+}  // namespace microtex
+
+#endif  // MICROTEX_FONT_STYLE_H

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

@@ -0,0 +1,38 @@
+#include "graphic/graphic.h"
+
+#include "utils/exceptions.h"
+#include "utils/utils.h"
+
+using namespace std;
+using namespace microtex;
+
+namespace microtex {
+
+struct PlatformFactoryData {
+  map<string, unique_ptr<PlatformFactory>> factories;
+  string currentFactory;
+};
+
+static PlatformFactoryData MICROTEX_PLATFORM_FACTORY_DATA_INSTANCE;
+
+}  // namespace microtex
+
+PlatformFactoryData* PlatformFactory::_data = &MICROTEX_PLATFORM_FACTORY_DATA_INSTANCE;
+
+void microtex::PlatformFactory::registerFactory(const string& name, uptr<PlatformFactory> factory) {
+  _data->factories[name] = std::move(factory);
+}
+
+void microtex::PlatformFactory::activate(const std::string& name) {
+  _data->currentFactory = name;
+}
+
+microtex::PlatformFactory* microtex::PlatformFactory::get() {
+  auto it = _data->factories.find(_data->currentFactory);
+  if (it == _data->factories.end()) {
+    throw ex_invalid_state(
+      "No factory found with name '" + _data->currentFactory + "', please register one."
+    );
+  }
+  return it->second.get();
+}