@simonklee/opentui-tex-native-source 0.2.0

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

@@ -0,0 +1,180 @@
+#include "core/formula.h"
+
+#include "atom/atom_basic.h"
+#include "atom/atom_char.h"
+#include "atom/atom_fence.h"
+#include "atom/atom_vrow.h"
+#include "utils/string_utils.h"
+#include "utils/utf.h"
+
+using namespace std;
+using namespace microtex;
+
+map<string, sptr<Formula>> Formula::_predefFormulas;
+
+Formula::Formula() : _parser("", this, false) {}
+
+Formula::Formula(const Parser& tp, const string& latex, bool preprocess, bool isMathMode)
+    : _parser(tp.isPartial(), latex, this, preprocess, isMathMode) {
+  if (tp.isPartial()) {
+    try {
+      _parser.parse();
+    } catch (exception& e) {
+      if (_root == nullptr) _root = sptrOf<EmptyAtom>();
+    }
+  } else {
+    _parser.parse();
+  }
+}
+
+Formula::Formula(const string& latex, bool preprocess) : _parser(latex, this, preprocess) {
+  _parser.parse();
+}
+
+void Formula::setLaTeX(const string& latex) {
+  _parser.reset(latex);
+  if (!latex.empty()) _parser.parse();
+}
+
+const std::vector<sptr<MiddleAtom>>& Formula::middle() {
+  return _middle;
+}
+
+Formula* Formula::add(const sptr<Atom>& a) {
+  if (a == nullptr) return this;
+  auto atom = dynamic_pointer_cast<MiddleAtom>(a);
+  if (atom != nullptr) _middle.push_back(atom);
+  if (_root == nullptr) {
+    _root = a;
+    return this;
+  }
+  auto* rm = dynamic_cast<RowAtom*>(_root.get());
+  if (rm == nullptr) _root = sptrOf<RowAtom>(_root);
+  rm = static_cast<RowAtom*>(_root.get());
+  rm->add(a);
+  auto* ta = dynamic_cast<TypedAtom*>(a.get());
+  if (ta != nullptr) {
+    AtomType rt = ta->rightType();
+    if (rt == AtomType::binaryOperator || rt == AtomType::relation) {
+      rm->add(sptrOf<BreakMarkAtom>());
+    }
+  }
+  return this;
+}
+
+sptr<Box> Formula::createBox(Env& env) {
+  if (_root == nullptr) return StrutBox::empty();
+  return _root->createBox(env);
+}
+
+sptr<Formula> Formula::get(const string& name) {
+  auto it = _predefFormulas.find(name);
+  if (it != _predefFormulas.end()) return it->second;
+
+  auto i = _predefFormulaStrs.find(name);
+  if (i == _predefFormulaStrs.end()) return nullptr;
+
+  auto tf = sptrOf<Formula>(i->second);
+  auto* ra = dynamic_cast<RowAtom*>(tf->_root.get());
+  if (ra == nullptr) {
+    _predefFormulas[name] = tf;
+  }
+  return tf;
+}
+
+/*************************************** ArrayFormula implementation ******************************/
+
+ArrayFormula::ArrayFormula() : _row(0), _col(0) {
+  _array.emplace_back();
+}
+
+void ArrayFormula::addCol() {
+  _array[_row].push_back(_root);
+  _root = nullptr;
+  _col++;
+}
+
+void ArrayFormula::addCol(int n) {
+  _array[_row].push_back(_root);
+  for (int i = 1; i < n - 1; i++) {
+    _array[_row].push_back(nullptr);
+  }
+  _root = nullptr;
+  _col += n;
+}
+
+void ArrayFormula::insertAtomIntoCol(int col, const sptr<Atom>& atom) {
+  _col++;
+  for (size_t j = 0; j < _row; j++) {
+    size_t n_row_columns = _array[j].size();
+    if (n_row_columns < col) {
+      for (unsigned int i = 0; i < col - n_row_columns; i++)
+        _array[j].push_back(sptrOf<EmptyAtom>());
+    }
+    auto it = _array[j].begin();
+    _array[j].insert(it + col, atom);
+  }
+}
+
+void ArrayFormula::addRow() {
+  addCol();
+  _array.emplace_back();
+  _row++;
+  _col = 0;
+}
+
+void ArrayFormula::addRowSpecifier(const sptr<CellSpecifier>& spe) {
+  auto it = _rowSpecifiers.find(_row);
+  if (it == _rowSpecifiers.end()) {
+    _rowSpecifiers[_row] = vector<sptr<CellSpecifier>>();
+  }
+  _rowSpecifiers[_row].push_back(spe);
+}
+
+void ArrayFormula::addCellSpecifier(const sptr<CellSpecifier>& spe) {
+  string str = toString(_row) + toString(_col);
+  auto it = _cellSpecifiers.find(str);
+  if (it == _cellSpecifiers.end()) {
+    _cellSpecifiers[str] = vector<sptr<CellSpecifier>>();
+  }
+  _cellSpecifiers[str].push_back(spe);
+}
+
+int ArrayFormula::rows() const {
+  return _row;
+}
+
+int ArrayFormula::cols() const {
+  return _col;
+}
+
+sptr<VRowAtom> ArrayFormula::getAsVRow() {
+  auto vr = sptrOf<VRowAtom>();
+  vr->setAddInterline(true);
+  for (auto& c : _array) {
+    for (auto& j : c) vr->append(j);
+  }
+  return vr;
+}
+
+void ArrayFormula::checkDimensions() {
+  if (!_array.back().empty() || _root != nullptr) addRow();
+
+  _row = _array.size() - 1;
+  _col = _array[0].size();
+
+  // Find the column count of the widest row
+  for (size_t i = 1; i < _row; i++) {
+    if (_array[i].size() > _col) _col = _array[i].size();
+  }
+
+  for (size_t i = 0; i < _row; i++) {
+    size_t j = _array[i].size();
+    if (j != _col && _array[i][0] != nullptr && _array[i][0]->_type != AtomType::interText) {
+      // Fill the row with null atom
+      vector<sptr<Atom>>& r = _array[i];
+      for (; j < _col; j++) r.push_back(nullptr);
+    }
+  }
+}
+

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

@@ -0,0 +1,137 @@
+#ifndef MICROTEX_FORMULA_H
+#define MICROTEX_FORMULA_H
+
+#include <string>
+#include <utility>
+
+#include "core/parser.h"
+
+namespace microtex {
+
+class MiddleAtom;
+class VRowAtom;
+class CellSpecifier;
+class Parser;
+
+/**
+ * Represents a logical mathematical formula that will be displayed (by creating
+ * a Render from it and painting it) using algorithms that are based
+ * on the TeX algorithms.
+ */
+class Formula {
+private:
+  // predefined TeX formulas
+  static std::map<std::string, sptr<Formula>> _predefFormulas;
+  static std::map<std::string, std::string> _predefFormulaStrs;
+
+  Parser _parser;
+  std::vector<sptr<MiddleAtom>> _middle;
+
+public:
+  // character-to-symbol mappings
+  static const std::map<c32, std::string> _charToSymbol;
+
+  // the root atom of the "atom tree" that represents the formula
+  sptr<Atom> _root;
+
+  /** Create an empty Formula */
+  Formula();
+
+  /**
+   * Creates a new Formula by parsing the given string (using a primitive
+   * TeX parser).
+   *
+   * @param tp the given TeXParser
+   * @param latex the string to be parsed
+   * @param preprocess if do preprocessing
+   * @param isMathMode if parse in math mode
+   *
+   * @throw ex_parse if the string could not be parsed correctly
+   */
+  Formula(
+    const Parser& tp,
+    const std::string& latex,
+    bool preprocess = true,
+    bool isMathMode = true
+  );
+
+  /**
+   * Creates a new Formula by parsing the given string (using a primitive
+   * TeX parser).
+   *
+   * @param latex the string to be parsed
+   * @param preprocess if do preprocessing
+   *
+   * @throw ex_parse if the string could not be parsed correctly
+   */
+  explicit Formula(const std::string& latex, bool preprocess = true);
+
+  /**
+   * Change the text of the Formula and regenerate the root atom.
+   *
+   * @param latex the latex formula
+   */
+  void setLaTeX(const std::string& latex);
+
+  const std::vector<sptr<MiddleAtom>>& middle();
+
+  /** Inserts an atom at the end of the current formula. */
+  Formula* add(const sptr<Atom>& a);
+
+  /** Convert this Formula into a box, with the given environment. */
+  sptr<Box> createBox(Env& env);
+
+  /** Test if this formula is in array mode. */
+  virtual bool isArrayMode() const { return false; }
+
+  /**
+   * Get a predefined Formula.
+   *
+   * @param name the name of the predefined Formula
+   * @return the predefined Formula or nullptr if not found
+   */
+  static sptr<Formula> get(const std::string& name);
+
+  virtual ~Formula() = default;
+};
+
+/** Represents a formula in array mode. */
+class ArrayFormula : public Formula {
+private:
+  size_t _row, _col;
+
+public:
+  std::vector<std::vector<sptr<Atom>>> _array;
+  std::map<int, std::vector<sptr<CellSpecifier>>> _rowSpecifiers;
+  std::map<std::string, std::vector<sptr<CellSpecifier>>> _cellSpecifiers;
+
+  ArrayFormula();
+
+  void addCol();
+
+  void addCol(int n);
+
+  void insertAtomIntoCol(int col, const sptr<Atom>& atom);
+
+  void addRow();
+
+  void addRowSpecifier(const sptr<CellSpecifier>& spe);
+
+  void addCellSpecifier(const sptr<CellSpecifier>& spe);
+
+  int rows() const;
+
+  int cols() const;
+
+  sptr<VRowAtom> getAsVRow();
+
+  void checkDimensions();
+
+  bool isArrayMode() const override { return true; }
+
+  ~ArrayFormula() override = default;
+};
+
+}  // namespace microtex
+
+#endif  // MICROTEX_FORMULA_H

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

@@ -0,0 +1,167 @@
+#include "core/formula.h"
+
+using namespace std;
+using namespace microtex;
+
+// clang-format off
+const map<c32, string> Formula::_charToSymbol{
+  {'+', "plus"},
+  {'-', "minus"},
+  {'*', "ast"},
+  {'/', "slash"},
+  {'|', "vert"},
+  {'(', "lparen"},
+  {')', "rparen"},
+  {'[', "lbrack"},
+  {']', "rbrack"},
+  {'{', "lbrace"},
+  {'}', "rbrace"},
+  {',', "comma"},
+  {';', "semicolon"},
+  {'!', "exclam"},
+  {'?', "question"},
+  {'|', "vert"},
+  {':', "colon"},
+  {'=', "equal"},
+  {'>', "greater"},
+  {'<', "less"},
+};
+
+map<string, string> Formula::_predefFormulaStrs{
+  {"qquad",            "\\quad\\quad"},
+  {" ",                "\\nbsp"},
+  // region dots
+  {"dotsc",            "\\ldots"},
+  {"dots",             "\\ldots"},
+  {"dotsb",            "\\cdots"},
+  {"dotso",            "\\ldots"},
+  {"dotsi",            "\\!\\cdots"},
+  {"hdots",            "\\ldots"},
+  // endregion
+  // region math symbols
+  {"relbar",           "\\mathrel{\\smash-}"},
+  {"log",              "\\mathop{\\mathrm{log}}\\nolimits"},
+  {"lg",               "\\mathop{\\mathrm{lg}}\\nolimits"},
+  {"ln",               "\\mathop{\\mathrm{ln}}\\nolimits"},
+  {"ln",               "\\mathop{\\mathrm{ln}}\\nolimits"},
+  {"lim",              "\\mathop{\\mathrm{lim}}"},
+  {"limsup",           "\\mathop{\\mathrm{lim\\,sup}}"},
+  {"liminf",           "\\mathop{\\mathrm{lim\\,inf}}"},
+  {"injlim",           "\\mathop{\\mathrm{inj\\,lim}}"},
+  {"projlim",          "\\mathop{\\mathrm{proj\\,lim}}"},
+  {"varinjlim",        "\\mathop{\\underrightarrow{\\mathrm{lim}}}"},
+  {"varprojlim",       "\\mathop{\\underleftarrow{\\mathrm{lim}}}"},
+  {"varliminf",        "\\mathop{\\underline{\\mathrm{lim}}}"},
+  {"varlimsup",        "\\mathop{\\overline{\\mathrm{lim}}}"},
+  {"sin",              "\\mathop{\\mathrm{sin}}\\nolimits"},
+  {"arcsin",           "\\mathop{\\mathrm{arcsin}}\\nolimits"},
+  {"sinh",             "\\mathop{\\mathrm{sinh}}\\nolimits"},
+  {"cos",              "\\mathop{\\mathrm{cos}}\\nolimits"},
+  {"arccos",           "\\mathop{\\mathrm{arccos}}\\nolimits"},
+  {"cot",              "\\mathop{\\mathrm{cot}}\\nolimits"},
+  {"arccot",           "\\mathop{\\mathrm{arccot}}\\nolimits"},
+  {"cosh",             "\\mathop{\\mathrm{cosh}}\\nolimits"},
+  {"tan",              "\\mathop{\\mathrm{tan}}\\nolimits"},
+  {"arctan",           "\\mathop{\\mathrm{arctan}}\\nolimits"},
+  {"tanh",             "\\mathop{\\mathrm{tanh}}\\nolimits"},
+  {"coth",             "\\mathop{\\mathrm{coth}}\\nolimits"},
+  {"sec",              "\\mathop{\\mathrm{sec}}\\nolimits"},
+  {"arcsec",           "\\mathop{\\mathrm{arcsec}}\\nolimits"},
+  {"arccsc",           "\\mathop{\\mathrm{arccsc}}\\nolimits"},
+  {"sech",             "\\mathop{\\mathrm{sech}}\\nolimits"},
+  {"csc",              "\\mathop{\\mathrm{csc}}\\nolimits"},
+  {"csch",             "\\mathop{\\mathrm{csch}}\\nolimits"},
+  {"max",              "\\mathop{\\mathrm{max}}"},
+  {"min",              "\\mathop{\\mathrm{min}}"},
+  {"sup",              "\\mathop{\\mathrm{sup}}"},
+  {"inf",              "\\mathop{\\mathrm{inf}}"},
+  {"arg",              "\\mathop{\\mathrm{arg}}\\nolimits"},
+  {"ker",              "\\mathop{\\mathrm{ker}}\\nolimits"},
+  {"dim",              "\\mathop{\\mathrm{dim}}\\nolimits"},
+  {"hom",              "\\mathop{\\mathrm{hom}}\\nolimits"},
+  {"det",              "\\mathop{\\mathrm{det}}"},
+  {"exp",              "\\mathop{\\mathrm{exp}}\\nolimits"},
+  {"Pr",               "\\mathop{\\mathrm{Pr}}"},
+  {"gcd",              "\\mathop{\\mathrm{gcd}}"},
+  {"deg",              "\\mathop{\\mathrm{deg}}\\nolimits"},
+  {"bmod",             "\\:\\mathbin{\\mathrm{mod}}\\:"},
+  // endregion
+  // region symbol alias
+  {"arrowvert",        "\\vert"},
+  {"Arrowvert",        "\\Vert"},
+  {"aa",               "\\mathring{a}"},
+  {"AA",               "\\mathring{A}"},
+  {"ddag",             "\\ddagger"},
+  {"dag",              "\\dagger"},
+  {"Doteq",            "\\doteqdot"},
+  {"doublecup",        "\\Cup"},
+  {"doublecap",        "\\Cap"},
+  {"llless",           "\\lll"},
+  {"gggtr",            "\\ggg"},
+  {"copyright",        "\\circledR"},
+  {"micro",            "\\mu"},
+  {"rVert",            "\\Vert"},
+  {"lVert",            "\\Vert"},
+  {"lvert",            "\\vert"},
+  {"rvert",            "\\vert"},
+  // endregion
+  // region Greek
+  {"Alpha",            "Α"},
+  {"Beta",             "Β"},
+  {"Epsilon",          "Ε"},
+  {"Zeta",             "Ζ"},
+  {"Eta",              "Η"},
+  {"Iota",             "Ι"},
+  {"Kappa",            "Κ"},
+  {"Mu",               "Μ"},
+  {"Nu",               "Ν"},
+  {"Omicron",          "Ο"},
+  {"Rho",              "Ρ"},
+  {"Tau",              "Τ"},
+  {"Chi",              "Χ"},
+#if defined(WIN32)
+    {"Nabla", u8"\u2207"},  // win32 compat, ugly
+#else
+    {"Nabla", "\u2207"},
+#endif
+  {"omicron",          "ο"},
+  // endregion
+  // region colons
+  {"ratio",            "\\mathrel{\\colon}"},
+  {"minuscolon",       "\\dashcolon"},
+  {"minuscoloncolon",  "\\mathrel{\\minus\\nokern\\colon\\nokern\\colon}"},
+  {"simcolon",         "\\mathrel{\\sim\\nokern\\colon}"},
+  {"simcoloncolon",    "\\mathrel{\\sim\\nokern\\colon\\nokern\\colon}"},
+  {"approxcolon",      "\\mathrel{\\approx\\nokern\\colon}"},
+  {"approxcoloncolon", "\\mathrel{\\approx\\nokern\\colon\\nokern\\colon}"},
+  {"coloncolon",       "\\Colon"},
+  {"equalscolon",      "\\eqcolon"},
+  {"equalscoloncolon", "\\mathrel{\\equal\\nokern\\colon\\nokern\\colon}"},
+  {"colonminus",       "\\mathrel{\\reflectbox{\\dashcolon}}"},
+  {"coloncolonminus",  "\\mathrel{\\colon\\nokern\\colon\\nokern\\minus}"},
+  {"colonequals",      "\\mathrel{\\reflectbox{\\eqcolon}}"},
+  {"coloncolonequals", "\\mathrel{\\colon\\nokern\\colon\\nokern\\equal}"},
+  {"colonsim",         "\\mathrel{\\colon\\nokern\\sim}"},
+  {"coloncolonsim",    "\\mathrel{\\colon\\nokern\\colon\\nokern\\sim}"},
+  {"colonapprox",      "\\mathrel{\\colon\\nokern\\approx}"},
+  {"coloncolonapprox", "\\mathrel{\\colon\\nokern\\colon\\nokern\\approx}"},
+  // endregion
+  {"celsius",          "\\mathord{{}^\\circ\\mathrm{C}}"},
+  {"marker",           "\\kern{0.25ex}\\rule{0.5ex}{1.2ex}\\kern{0.25ex}"},
+  {"hybull",           "\\rule[0.6ex]{1ex}{0.2ex}"},
+  {"block",            "\\rule{1ex}{1.2ex}"},
+  {"uhblk",            "\\rule[0.6ex]{1ex}{0.6ex}"},
+  {"lhblk",            "\\rule{1ex}{0.6ex}"},
+  {"Android",          "\\large{🤖️}"},
+  {"AndroidTeX",       "\\Android\\TeX"},
+  {"TeX",              "\\mathrm{T\\kern-.15em\\raisebox{-.4ex}{E}\\kern-.15em X}"},
+  {"LaTeX",            "\\mathrm{L\\kern-0.3em"
+                       "\\raisebox{.45ex}{\\scalebox{0.7}{A}}"
+                       "\\kern-.15em T\\kern-.15em"
+                       "\\raisebox{-.4ex}{E}\\kern-.15em X}"},
+  {"IJ",               "{I\\kern-0.065em J}"},
+  {"ij",               "{i\\kern-0.065em j}"},
+  {"idotsint",         "\\int\\cdots\\int"},
+  {"MicroTeX",         "\\mathrm{\\mathit{\\mu}\\kern-.1em\\TeX}"},
+};
+// clang-format on

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

@@ -0,0 +1,108 @@
+#include "core/glue.h"
+
+#include "box/box_single.h"
+#include "env/env.h"
+#include "env/units.h"
+
+using namespace std;
+using namespace microtex;
+
+namespace {
+constexpr int TYPE_COUNT = 8;
+constexpr int STYLE_COUNT = 5;
+
+// contains the different glue types
+const Glue _glueTypes[4]{
+  {0, 0, 0},
+  {3, 0, 0},
+  {4, 4, 2},
+  {5, 0, 5},
+};
+
+/*
+ GLUE TABLE
+ Page 181 in [The TeXBook]
+ -------------------------------------------------------
+       ORD   OP    BIN   REL   OPEN  CLOSE  PUNCT  INNER
+ ORD    0     1    (2)   (3)    0     0      0     (1)
+ OP     1     1     *    (3)    0     0      0     (1)
+ BIN   (2)   (2)    *     *    (2)    *      *     (2)
+ REL   (3)   (3)    *     0    (3)    0      0     (3)
+ OPEN  (0)    0     *     0     0     0      0      0
+ CLOSE (0)    1    (2)   (3)    0     0      0     (1)
+ PUNCT (1)   (1)    *    (1)   (1)   (1)    (1)    (1)
+ INNER (1)    1    (2)   (3)   (1)    0     (1)    (1)
+
+ 0: no space
+ 1: thin space
+ 2: medium space
+ 3: thick space
+
+ The table entry is parenthesized if the space is to be inserted only in
+ display and text styles, not in script and scriptscript styles.
+
+ Some of the entries in the table are ‘*’; such cases never arise, because
+ Bin atoms must be preceded and followed by atoms compatible with the
+ nature of binary operations.
+*/
+const char _table[TYPE_COUNT][TYPE_COUNT][STYLE_COUNT]{
+  {"0000", "1111", "2200", "3300", "0000", "0000", "0000", "1100"},
+  {"1111", "1111", "0000", "3300", "0000", "0000", "0000", "1100"},
+  {"2200", "2200", "0000", "0000", "2200", "0000", "0000", "2200"},
+  {"3300", "3300", "0000", "0000", "3300", "0000", "0000", "3300"},
+  {"0000", "0000", "0000", "0000", "0000", "0000", "0000", "0000"},
+  {"0000", "1111", "2200", "3300", "0000", "0000", "0000", "1100"},
+  {"1100", "1100", "0000", "1100", "1100", "1100", "1100", "1100"},
+  {"1100", "1111", "2200", "3300", "1100", "0000", "1100", "1100"},
+};
+
+float getFactor(const Env& env) {
+  return Units::fsize(UnitType::mu, 1.f, env);
+}
+
+const Glue& getGlue(SpaceType skipType) {
+  const i8 i = static_cast<i8>(skipType);
+  return _glueTypes[i < 0 ? -i : i];
+}
+
+int indexOf(AtomType ltype, AtomType rtype, const Env& env) {
+  // types > INNER are considered of type ORD for glue calculations
+  AtomType l = (ltype > AtomType::inner ? AtomType::ordinary : ltype);
+  AtomType r = (rtype > AtomType::inner ? AtomType::ordinary : rtype);
+  const i8 k = static_cast<i8>(env.style()) / 2;
+  return _table[static_cast<u8>(l)][static_cast<u8>(r)][k] - '0';
+}
+
+}  // namespace
+
+sptr<GlueBox> Glue::createBox(const Env& env) const {
+  float factor = getFactor(env);
+  return sptrOf<GlueBox>(_space * factor, _stretch * factor, _shrink * factor);
+}
+
+sptr<GlueBox> Glue::get(AtomType ltype, AtomType rtype, const Env& env) {
+  if (ltype == AtomType::none || rtype == AtomType::none) {
+    return sptrOf<GlueBox>(0.f, 0.f, 0.f);
+  }
+  int i = indexOf(ltype, rtype, env);
+  return _glueTypes[i].createBox(env);
+}
+
+sptr<GlueBox> Glue::get(SpaceType skipType, const Env& env) {
+  const Glue& glue = getGlue(skipType);
+  auto b = glue.createBox(env);
+  if (static_cast<i8>(skipType) < 0) b->negWidth();
+  return b;
+}
+
+float Glue::getSpace(AtomType ltype, AtomType rtype, const Env& env) {
+  int i = indexOf(ltype, rtype, env);
+  const Glue& glueType = _glueTypes[i];
+  return glueType._space * getFactor(env);
+}
+
+float Glue::getSpace(SpaceType skipType, const Env& env) {
+  const Glue& glue = getGlue(skipType);
+  const auto v = glue._space * getFactor(env);
+  return static_cast<i8>(skipType) < 0 ? -v : v;
+}

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

@@ -0,0 +1,55 @@
+#ifndef MICROTEX_GLUE_H
+#define MICROTEX_GLUE_H
+
+#include "utils/utils.h"
+
+namespace microtex {
+
+class Env;
+
+class GlueBox;
+
+/** Represents glue by its 3 components. Contains the "glue rules" */
+class Glue {
+private:
+  // the glue components, in "mu" unit
+  u16 _space, _stretch, _shrink;
+
+  sptr<GlueBox> createBox(const Env& env) const;
+
+public:
+  no_copy_assign(Glue);
+
+  Glue(u16 space, u16 stretch, u16 shrink) noexcept
+      : _space(space), _stretch(stretch), _shrink(shrink) {}
+
+  /**
+   * Creates a box representing the glue type according to the "glue rules" based
+   * on the atom types between which the glue must be inserted.
+   *
+   * @param ltype left atom type
+   * @param rtype right atom type
+   * @param env the Env
+   * @return a box containing representing the glue
+   */
+  static sptr<GlueBox> get(AtomType ltype, AtomType rtype, const Env& env);
+
+  /**
+   * Creates a box representing the glue type according to the "glue rules" based
+   * on the skip-type
+   */
+  static sptr<GlueBox> get(SpaceType skipType, const Env& env);
+
+  /**
+   * Get the space amount from the given left-type and right-type of atoms
+   * according to the "glue rules".
+   */
+  static float getSpace(AtomType ltype, AtomType rtype, const Env& env);
+
+  /** Get the space amount from the given skip-type according to the "glue rules" */
+  static float getSpace(SpaceType skipType, const Env& env);
+};
+
+}  // namespace microtex
+
+#endif  // MICROTEX_GLUE_H