@simonklee/opentui-tex-native-source 0.2.0

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

@@ -0,0 +1,273 @@
+#ifndef MICROTEX_ATOM_BASIC_H
+#define MICROTEX_ATOM_BASIC_H
+
+#include "atom/atom.h"
+#include "atom/atom_row.h"
+#include "box/box_single.h"
+#include "unimath/math_type.h"
+
+namespace microtex {
+
+class Formula;
+
+/** Atom to mark do not add kern between */
+class NokernAtom : public Atom {
+public:
+  NokernAtom() { _type = AtomType::none; }
+
+  sptr<Box> createBox(Env& env) override { return StrutBox::empty(); }
+};
+
+/**
+ * An atom representing a modification of style in a formula
+ * (e.g. text-style or display-style)
+ */
+class StyleAtom : public WrapAtom {
+private:
+  TexStyle _style;
+
+public:
+  StyleAtom() = delete;
+
+  StyleAtom(TexStyle style, const sptr<Atom>& a) : _style(style), WrapAtom(a) {}
+
+  sptr<Box> createBox(Env& env) override;
+};
+
+/**
+ * An atom representing a modification of style in a formula
+ * relative to current style
+ */
+class AStyleAtom : public WrapAtom {
+private:
+  std::string _name;
+
+public:
+  AStyleAtom() = delete;
+
+  AStyleAtom(std::string name, const sptr<Atom>& a) : _name(std::move(name)), WrapAtom(a) {}
+
+  sptr<Box> createBox(Env& env) override;
+};
+
+/** An empty atom */
+class EmptyAtom : public Atom {
+public:
+  sptr<Box> createBox(Env& env) override { return StrutBox::empty(); }
+
+  static sptr<EmptyAtom> create() { return sptrOf<EmptyAtom>(); }
+};
+
+/** A placeholder atom */
+class PlaceholderAtom : public Atom {
+private:
+  sptr<Box> _box;
+  float _italic;
+
+public:
+  PlaceholderAtom(float width, float height, float depth, float italic = 0.f) : _italic(italic) {
+    _box = sptrOf<StrutBox>(width, height, depth, 0.f);
+  }
+
+  PlaceholderAtom(const sptr<Box>& box, float italic = 0.f) : _box(box), _italic(italic) {}
+
+  sptr<Box> createBox(Env& env) override { return _box; }
+
+  inline float italic() const { return _italic; }
+};
+
+/** An atom representing a smashed atom (i.e. with no height and no depth) */
+class SmashedAtom : public WrapAtom {
+private:
+  bool _h, _d;
+
+public:
+  SmashedAtom() = delete;
+
+  SmashedAtom(const sptr<Atom>& a, const std::string& opt) : _h(true), _d(true), WrapAtom(a) {
+    if (opt == "opt")
+      _d = false;
+    else if (opt == "b")
+      _h = false;
+  }
+
+  explicit SmashedAtom(const sptr<Atom>& a) : _h(true), _d(true), WrapAtom(a) {}
+
+  sptr<Box> createBox(Env& env) override;
+};
+
+/** An atom representing a scaled atom */
+class ScaleAtom : public WrapAtom {
+private:
+  float _sx, _sy;
+
+public:
+  ScaleAtom() = delete;
+
+  ScaleAtom(const sptr<Atom>& base, float sx, float sy) noexcept
+      : WrapAtom(base), _sx(sx), _sy(sy) {}
+
+  ScaleAtom(const sptr<Atom>& base, float scale) : ScaleAtom(base, scale, scale) {}
+
+  sptr<Box> createBox(Env& env) override;
+};
+
+/** An atom representing a math atom */
+class MathAtom : public WrapAtom {
+private:
+  TexStyle _style;
+
+public:
+  MathAtom() = delete;
+
+  MathAtom(const sptr<Atom>& base, TexStyle style) noexcept : _style(style), WrapAtom(base) {}
+
+  sptr<Box> createBox(Env& env) override;
+};
+
+/** An atom representing a horizontal-line in array environment */
+class HlineAtom : public Atom {
+private:
+  float _width, _shift;
+  color _color;
+
+public:
+  HlineAtom() noexcept : _color(transparent), _width(0), _shift(0) { _type = AtomType::hline; }
+
+  inline void setWidth(float w) { _width = w; }
+
+  inline void setShift(float s) { _shift = s; }
+
+  inline void setColor(color c) { _color = c; }
+
+  sptr<Box> createBox(Env& env) override;
+};
+
+/** An atom representing a cumulative scripts atom */
+class CumulativeScriptsAtom : public Atom {
+private:
+  sptr<Atom> _base;
+  sptr<RowAtom> _sup, _sub;
+
+public:
+  CumulativeScriptsAtom() = delete;
+
+  CumulativeScriptsAtom(const sptr<Atom>& base, const sptr<Atom>& sub, const sptr<Atom>& sup);
+
+  void addSuperscript(const sptr<Atom>& sup);
+
+  void addSubscript(const sptr<Atom>& sub);
+
+  sptr<Atom> getScriptsAtom() const;
+
+  sptr<Box> createBox(Env& env) override;
+};
+
+/** An atom representing the foreground and background color of an other atom */
+class ColorAtom : public Atom, public Row {
+private:
+  static std::map<std::string, color> _colors;
+  static const color _default;
+
+  color _background, _color;
+  // RowAtom for which the color settings apply
+  sptr<RowAtom> _elements;
+
+public:
+  ColorAtom() = delete;
+
+  ColorAtom(const sptr<Atom>& atom, color bg, color c);
+
+  sptr<Box> createBox(Env& env) override;
+
+  AtomType leftType() const override { return _elements->leftType(); }
+
+  AtomType rightType() const override { return _elements->rightType(); }
+
+  void setPreviousAtom(const sptr<AtomDecor>& prev) override { _elements->setPreviousAtom(prev); }
+
+  /**
+   * Parse color from given name. The name can be one of the following format:
+   * [#AARRGGBB] or [AARRGGBB], [gray color], [c,m,y,k], [c;m;y;k], [r,g,b], [r;g;b]
+   * or a predefined color name. Return black if not found.
+   */
+  static color getColor(std::string name);
+
+  /** Define a color with given name */
+  static void defineColor(const std::string& name, color c);
+};
+
+/** An atom representing another atom that should be drawn invisibly */
+class PhantomAtom : public Atom, public Row {
+private:
+  sptr<RowAtom> _elements;
+  // if show with width, height or depth
+  bool _w, _h, _d;
+
+public:
+  PhantomAtom() = delete;
+
+  explicit PhantomAtom(const sptr<Atom>& el);
+
+  PhantomAtom(const sptr<Atom>& el, bool w, bool h, bool d);
+
+  AtomType leftType() const override { return _elements->leftType(); }
+
+  AtomType rightType() const override { return _elements->rightType(); }
+
+  void setPreviousAtom(const sptr<AtomDecor>& prev) override { _elements->setPreviousAtom(prev); }
+
+  sptr<Box> createBox(Env& env) override;
+};
+
+/**
+ * An atom representing another atom with an override left-type and right-type
+ * this affects the glue inserted before and after this atom.
+ */
+class TypedAtom : public Atom {
+private:
+  // override left-type and right-type
+  AtomType _leftType, _rightType;
+  // atom for which new types are set
+  sptr<Atom> _atom;
+
+public:
+  TypedAtom() = delete;
+
+  TypedAtom(AtomType lt, AtomType rt, const sptr<Atom>& atom)
+      : _leftType(lt), _rightType(rt), _atom(atom) {
+    _limitsType = atom->_limitsType;
+  }
+
+  sptr<Atom> base() {
+    _atom->_limitsType = _limitsType;
+    return _atom;
+  }
+
+  sptr<Box> createBox(Env& env) override { return _atom->createBox(env); }
+
+  AtomType leftType() const override { return _leftType; }
+
+  AtomType rightType() const override { return _rightType; }
+};
+
+class ExtensibleAtom : public Atom {
+private:
+  std::string _sym;
+  bool _vertical;
+  std::function<float(const Env&)> _getLen;
+
+public:
+  explicit ExtensibleAtom(
+    std::string sym,
+    std::function<float(const Env&)>&& getLen,
+    bool isVertical = false
+  )
+      : _sym(std::move(sym)), _getLen(getLen), _vertical(isVertical) {}
+
+  sptr<Box> createBox(Env& env) override;
+};
+
+}  // namespace microtex
+
+#endif  // MICROTEX_ATOM_BASIC_H

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

@@ -0,0 +1,41 @@
+#include "atom/atom_box.h"
+
+#include "box/box_group.h"
+#include "box/box_single.h"
+#include "env/env.h"
+#include "env/units.h"
+
+using namespace microtex;
+
+float OvalAtom::_multiplier = 0.5f;
+float OvalAtom::_diameter = 0.f;
+
+sptr<Box> FBoxAtom::createBox(Env& env) {
+  auto base = _base->createBox(env);
+  auto t = env.mathConsts().fractionRuleThickness() * env.scale();
+  auto space = Units::fsize(0.5_em, env);
+  if (isTransparent(_bg)) return sptrOf<FramedBox>(base, t, space);
+  return sptrOf<FramedBox>(base, t, space, _line, _bg);
+}
+
+sptr<Box> DoubleFramedAtom::createBox(Env& env) {
+  auto base = _base->createBox(env);
+  auto t = env.mathConsts().fractionRuleThickness() * env.scale();
+  auto space = Units::fsize(0.5_em, env);
+  auto sspace = 1.5f * t + Units::fsize(1._pt, env);
+  auto inner = sptrOf<FramedBox>(base, 0.75f * t, space);
+  return sptrOf<FramedBox>(inner, 1.5f * t, sspace);
+}
+
+sptr<Box> ShadowAtom::createBox(Env& env) {
+  auto x = FBoxAtom::createBox(env);
+  auto b = std::static_pointer_cast<FramedBox>(x);
+  float t = env.mathConsts().fractionRuleThickness() * env.scale() * 3;
+  return sptrOf<ShadowBox>(b, t);
+}
+
+sptr<Box> OvalAtom::createBox(Env& env) {
+  auto x = FBoxAtom::createBox(env);
+  auto b = std::static_pointer_cast<FramedBox>(x);
+  return sptrOf<OvalBox>(b, _multiplier, _diameter);
+}

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

@@ -0,0 +1,70 @@
+#ifndef MICROTEX_ATOM_BOX_H
+#define MICROTEX_ATOM_BOX_H
+
+#include "atom/atom.h"
+#include "atom/atom_row.h"
+#include "graphic/graphic_basic.h"
+
+namespace microtex {
+
+/** An atom representing a boxed base atom */
+class FBoxAtom : public Atom {
+protected:
+  sptr<Atom> _base;
+  color _bg, _line;
+
+public:
+  FBoxAtom() = delete;
+
+  explicit FBoxAtom(const sptr<Atom>& base, color bg = TRANSPARENT, color line = TRANSPARENT) {
+    if (base == nullptr)
+      _base = sptrOf<RowAtom>();
+    else {
+      _base = base;
+      _type = base->_type;
+    }
+    _bg = bg;
+    _line = line;
+  }
+
+  sptr<Box> createBox(Env& env) override;
+};
+
+/** An atom representing a boxed base atom */
+class DoubleFramedAtom : public FBoxAtom {
+public:
+  DoubleFramedAtom() = delete;
+
+  explicit DoubleFramedAtom(const sptr<Atom>& base) : FBoxAtom(base) {}
+
+  sptr<Box> createBox(Env& env) override;
+};
+
+/** An atom representing a box-shadowed atom */
+class ShadowAtom : public FBoxAtom {
+public:
+  ShadowAtom() = delete;
+
+  explicit ShadowAtom(const sptr<Atom>& base) : FBoxAtom(base) {}
+
+  sptr<Box> createBox(Env& env) override;
+};
+
+/**
+ * An atom representing a oval-boxed base atom
+ */
+class OvalAtom : public FBoxAtom {
+public:
+  static float _multiplier;
+  static float _diameter;
+
+  OvalAtom() = delete;
+
+  explicit OvalAtom(const sptr<Atom>& base) : FBoxAtom(base) {}
+
+  sptr<Box> createBox(Env& env) override;
+};
+
+}  // namespace microtex
+
+#endif  // MICROTEX_ATOM_BOX_H

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

@@ -0,0 +1,99 @@
+#include "atom/atom_char.h"
+
+#include "box/box_single.h"
+#include "core/split.h"
+#include "env/env.h"
+#include "utils/utf.h"
+
+using namespace microtex;
+using namespace std;
+
+std::string FixedCharAtom::name() const {
+  // TODO name?
+  return "";
+}
+
+sptr<Box> FixedCharAtom::createBox(Env& env) {
+  return sptrOf<CharBox>(_chr);
+}
+
+sptr<SymbolAtom> SymbolAtom::get(const std::string& name) {
+  const auto symbol = Symbol::get(name.c_str());
+  return symbol == nullptr ? nullptr : sptrOf<SymbolAtom>(symbol);
+}
+
+SymbolAtom::SymbolAtom(const Symbol* symbol) noexcept : _symbol(symbol) {
+  if (_symbol == nullptr) {
+    _type = AtomType::none;
+  } else {
+    _type = _symbol->type();
+    _limitsType = _symbol->limitsType();
+  }
+}
+
+c32 SymbolAtom::unicode() const {
+  return _symbol == nullptr ? 0 : _symbol->unicode;
+}
+
+string SymbolAtom::name() const {
+  return _symbol == nullptr ? "" : _symbol->name;
+}
+
+bool SymbolAtom::isValid() const {
+  return _symbol != nullptr;
+}
+
+Char SymbolAtom::getChar(Env& env) const {
+  if (_symbol == nullptr) return {};
+  if (env.style() >= TexStyle::script) {
+    const auto& chr = env.getChar(*_symbol);
+    return chr.script(0);
+  }
+  if (_type == AtomType::bigOperator) {
+    const auto& chr = env.getChar(*_symbol);
+    return env.style() < TexStyle::text ? chr.vLarger(1) : chr;
+  }
+  return env.getChar(*_symbol);
+}
+
+sptr<Box> SymbolAtom::createBox(Env& env) {
+  const auto& chr = getChar(env);
+  if (_type == AtomType::bigOperator) {
+    auto box = sptrOf<CharBox>(chr);
+    const auto axis = env.axisHeight();
+    box->_shift = (box->_height - box->_depth) / 2 - axis;
+    return sptrOf<HBox>(box);
+  } else {
+    return sptrOf<CharBox>(chr);
+  }
+}
+
+Char CharAtom::getChar(Env& env) const {
+  if (_mathMode && env.style() >= TexStyle::script) {
+    const auto& chr = env.getChar(_unicode, true, _fontStyle);
+    return chr.isValid() ? chr.script(0) : chr;
+  }
+  return env.getChar(unicode(), isMathMode(), _fontStyle);
+}
+
+std::string CharAtom::name() const {
+  std::string str;
+  microtex::appendToUtf8(str, _unicode);
+  return str;
+}
+
+sptr<Box> CharAtom::createBox(Env& env) {
+  const auto& chr = getChar(env);
+  if (chr.isValid()) return sptrOf<CharBox>(chr);
+  FontStyle fontStyle;
+  if (_fontStyle != FontStyle::invalid) {
+    fontStyle = _fontStyle;
+  } else {
+    fontStyle = _mathMode ? env.mathFontStyle() : env.textFontStyle();
+  }
+  return sptrOf<TextBox>(name(), fontStyle, Env::fixedTextSize() * env.scale());
+}
+
+sptr<Box> BreakMarkAtom::createBox(Env& env) {
+  return StrutBox::empty();
+}

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

@@ -0,0 +1,147 @@
+#ifndef MICROTEX_ATOM_CHAR_H
+#define MICROTEX_ATOM_CHAR_H
+
+#include "atom/atom.h"
+#include "box/box.h"
+#include "unimath/uni_char.h"
+#include "unimath/uni_font.h"
+#include "unimath/uni_symbol.h"
+#include "utils/utils.h"
+
+namespace microtex {
+
+/**
+ * An common superclass for atoms that represent one single character and access
+ * the font information.
+ */
+class CharSymbol : public Atom {
+private:
+  /**
+   * Row will mark certain CharSymbol atoms as a text symbol. Subsup will use
+   * this property for a certain spacing rule.
+   */
+  bool _isText;
+
+public:
+  CharSymbol() : _isText(false) {}
+
+  /** Mark as text symbol */
+  inline void markAsText() { _isText = true; }
+
+  /** Remove the mark so the atom remains unchanged (used by AtomDecor) */
+  inline void removeMark() { _isText = false; }
+
+  /**
+   * Tests if this atom is marked as a text symbol (used by subsup)
+   *
+   * @return whether this CharSymbol is marked as a text symbol
+   */
+  inline bool isText() const { return _isText; }
+
+  bool isChar() const override { return true; }
+
+  /** Test if is in math mode */
+  virtual bool isMathMode() const = 0;
+
+  /**
+   * Get the Char-object that uniquely identifies the character that is
+   * represented by this atom.
+   */
+  virtual Char getChar(Env& env) const = 0;
+
+  virtual std::string name() const = 0;
+
+  virtual c32 unicode() const = 0;
+};
+
+/** An atom representing a fixed character (not depending on a text style). */
+class FixedCharAtom : public CharSymbol {
+private:
+  const Char _chr;
+
+public:
+  FixedCharAtom() = delete;
+
+  explicit FixedCharAtom(const Char& chr) : _chr(chr) {}
+
+  Char getChar(Env& env) const override { return _chr; }
+
+  std::string name() const override;
+
+  bool isMathMode() const override { return false; }
+
+  c32 unicode() const override { return _chr.mappedCode; }
+
+  sptr<Box> createBox(Env& env) override;
+};
+
+class SymbolAtom : public CharSymbol {
+private:
+  const Symbol* const _symbol = nullptr;
+
+public:
+  SymbolAtom() = delete;
+
+  explicit SymbolAtom(const Symbol* symbol) noexcept;
+
+  c32 unicode() const override;
+
+  /** Name of this symbol */
+  std::string name() const override;
+
+  /** Test if this symbol is valid */
+  bool isValid() const;
+
+  bool isMathMode() const override {
+    // TODO math mode?
+    return true;
+  }
+
+  sptr<Box> createBox(Env& env) override;
+
+  Char getChar(Env& env) const override;
+
+  /** Get symbol from the given name, return null if not found */
+  static sptr<SymbolAtom> get(const std::string& name);
+};
+
+/**
+ * An atom representing exactly one alphanumeric character and the text style in
+ * which it should be drawn.
+ */
+class CharAtom : public CharSymbol {
+private:
+  // alphanumeric character
+  const c32 _unicode;
+  // the font style, invalid means use the environment default
+  FontStyle _fontStyle = FontStyle::invalid;
+  bool _mathMode = false;
+
+public:
+  CharAtom() = delete;
+
+  CharAtom(c32 unicode, FontStyle style, bool mathMode = false)
+      : _unicode(unicode), _fontStyle(style), _mathMode(mathMode) {}
+
+  CharAtom(c32 unicode, bool mathMode) : _unicode(unicode), _mathMode(mathMode) {}
+
+  c32 unicode() const override { return _unicode; }
+
+  bool isMathMode() const override { return _mathMode; }
+
+  Char getChar(Env& env) const override;
+
+  std::string name() const override;
+
+  sptr<Box> createBox(Env& env) override;
+};
+
+/** An empty atom just to add a line-break mark. */
+class BreakMarkAtom : public Atom {
+public:
+  sptr<Box> createBox(Env& env) override;
+};
+
+}  // namespace microtex
+
+#endif  // MICROTEX_ATOM_CHAR_H

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

@@ -0,0 +1,65 @@
+#include "atom/atom_delim.h"
+
+#include "atom/atom_basic.h"
+
+#include "box/box_factory.h"
+#include "box/box_group.h"
+#include "box/box_single.h"
+#include "env/env.h"
+
+using namespace microtex;
+
+sptr<Box> OverUnderBar::createBox(Env& env) {
+  const auto base = (_base == nullptr ? sptrOf<EmptyAtom>() : _base)->createBox(env);
+  const auto vbox = sptrOf<VBox>();
+  if (_over) {
+    const auto asc = env.mathConsts().overbarExtraAscender() * env.scale();
+    vbox->add(sptrOf<StrutBox>(0.f, asc, 0.f, 0.f));
+    const auto t = env.mathConsts().overbarRuleThickness() * env.scale();
+    vbox->add(sptrOf<RuleBox>(t, base->_width, 0.f));
+    const auto gap = env.mathConsts().overbarVerticalGap() * env.scale();
+    vbox->add(sptrOf<StrutBox>(0.f, gap, 0.f, 0.f));
+    vbox->add(base);
+    const auto h = vbox->_height + vbox->_depth;
+    vbox->_depth = base->_depth;
+    vbox->_height = h - vbox->_depth;
+  } else {
+    vbox->add(base);
+    const auto gap = env.mathConsts().underbarVerticalGap() * env.scale();
+    vbox->add(sptrOf<StrutBox>(0.f, gap, 0.f, 0.f));
+    const auto t = env.mathConsts().underbarRuleThickness() * env.scale();
+    vbox->add(sptrOf<RuleBox>(t, base->_width, 0.f));
+    const auto dsc = env.mathConsts().underbarExtraDescender() * env.scale();
+    vbox->add(sptrOf<StrutBox>(0.f, dsc, 0.f, 0.f));
+    const auto h = vbox->_height + vbox->_depth;
+    vbox->_height = base->_height;
+    vbox->_depth = h - vbox->_height;
+  }
+
+  return vbox;
+}
+
+sptr<Box> OverUnderDelimiter::createBox(Env& env) {
+  const auto base = _base->createBox(env);
+  const auto delim = microtex::createHDelim(_delim, env, base->_width);
+  base->_shift = (delim->_width - base->_width) / 2;
+
+  const auto vbox = sptrOf<VBox>();
+  if (_over) {
+    vbox->add(delim);
+    const auto kern = SpaceAtom(UnitType::ex, 0.f, -1.f, 0.f).createBox(env);
+    vbox->add(kern);
+    vbox->add(base);
+    const auto h = vbox->_height + vbox->_depth;
+    vbox->_depth = base->_depth;
+    vbox->_height = h - vbox->_depth;
+  } else {
+    vbox->add(base);
+    vbox->add(delim);
+    const auto h = vbox->_height + vbox->_depth;
+    vbox->_height = base->_height;
+    vbox->_depth = h - vbox->_height;
+  }
+
+  return vbox;
+}