@simonklee/opentui-tex-native-source 0.2.0

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

@@ -0,0 +1,268 @@
+#ifndef MICROTEX_ATOM_MATRIX_H
+#define MICROTEX_ATOM_MATRIX_H
+
+#include "atom/atom.h"
+#include "atom/atom_char.h"
+#include "atom/atom_space.h"
+#include "box/box_group.h"
+#include "box/box_single.h"
+
+namespace microtex {
+
+class ArrayFormula;
+
+/** Atom to justify cells in array */
+class CellSpecifier : public Atom {
+public:
+  virtual void apply(WrapperBox& box) = 0;
+
+  sptr<Box> createBox(Env& env) override { return sptrOf<StrutBox>(0.f, 0.f, 0.f, 0.f); }
+};
+
+/** Atom representing column color in array */
+class CellColorAtom : public CellSpecifier {
+private:
+  color _color;
+
+public:
+  CellColorAtom() = delete;
+
+  explicit CellColorAtom(color c) : _color(c) {}
+
+  void apply(WrapperBox& box) override { box.setBackground(_color); }
+};
+
+/** Atom representing column foreground in array */
+class CellForegroundAtom : public CellSpecifier {
+private:
+  color _color;
+
+public:
+  CellForegroundAtom() = delete;
+
+  explicit CellForegroundAtom(color c) : _color(c) {}
+
+  void apply(WrapperBox& box) override { box.setForeground(_color); }
+};
+
+class VlineAtom;
+
+enum class MatrixType : i8 {
+  array,
+  matrix,
+  align,
+  alignAt,
+  flAlign,
+  smallMatrix,
+  aligned,
+  alignedAt
+};
+
+/** Atom represents matrix */
+class MatrixAtom : public Atom {
+private:
+  static std::map<std::string, std::string> _colspeReplacement;
+
+  static SpaceAtom _align;
+
+  sptr<ArrayFormula> _matrix;
+  std::vector<Alignment> _position;
+  std::map<int, sptr<VlineAtom>> _vlines;
+  std::map<int, sptr<Atom>> _columnSpecifiers;
+
+  MatrixType _matType;
+  bool _isPartial;
+  bool _spaceAround;
+
+  void parsePositions(std::string opt, std::vector<Alignment>& lpos);
+
+  sptr<Box> generateMulticolumn(
+    Env& env,
+    const sptr<Box>& b,
+    const float* hsep,
+    const float* colWidth,
+    int i,
+    int j
+  );
+
+  static void recalculateLine(
+    int rows,
+    sptr<Box>** boxarr,
+    std::vector<sptr<Atom>>& multiRows,
+    float* height,
+    float* depth,
+    float drt,
+    float vspace
+  );
+
+  float* getColumnSep(Env& env, float width);
+
+  void applyCell(WrapperBox& box, int i, int j);
+
+  sptr<Box> createBoxInner(Env& env);
+
+public:
+  // The color to draw the rule of the matrix
+  static color LINE_COLOR;
+
+  static SpaceAtom _hsep, _semihsep, _vsep_in, _vsep_ext_top, _vsep_ext_bot;
+
+  static sptr<Box> _nullbox;
+
+  MatrixAtom() = delete;
+
+  MatrixAtom(
+    bool isPartial,
+    const sptr<ArrayFormula>& arr,
+    const std::string& options,
+    bool spaceAround
+  );
+
+  MatrixAtom(bool isPartial, const sptr<ArrayFormula>& arr, const std::string& options);
+
+  MatrixAtom(bool isPartial, const sptr<ArrayFormula>& arr, MatrixType type);
+
+  sptr<Box> createBox(Env& env) override;
+
+  static void defineColumnSpecifier(const std::string& rep, const std::string& spe);
+};
+
+/** An atom representing vertical-line in matrix Env */
+class VlineAtom : public Atom {
+private:
+  // Number of lines to draw
+  int _n;
+
+public:
+  float _height, _shift;
+
+  VlineAtom() = delete;
+
+  explicit VlineAtom(int n) : _n(n), _height(0), _shift(0) {}
+
+  float getWidth(Env& env) const;
+
+  sptr<Box> createBox(Env& env) override;
+};
+
+/** An atom used in array mode that across several columns */
+class MulticolumnAtom : public Atom {
+protected:
+  // Number of columns across
+  int _n;
+  Alignment _align;
+  float _width;
+  int _beforeVlines, _afterVlines;
+  int _row, _col;
+  sptr<Atom> _cols;
+
+  Alignment parseAlign(const std::string& str);
+
+public:
+  MulticolumnAtom() = delete;
+
+  MulticolumnAtom(int n, const std::string& align, const sptr<Atom>& cols)
+      : _width(0), _beforeVlines(0), _afterVlines(0), _row(0), _col(0) {
+    _n = n >= 1 ? n : 1;
+    _cols = cols;
+    _align = parseAlign(align);
+  }
+
+  virtual bool isNeedWidth() const { return false; }
+
+  inline void setColWidth(float w) { _width = w; }
+
+  inline float colWidth() const { return _width; }
+
+  inline int skipped() const { return _n; }
+
+  inline bool hasRightVline() const { return _afterVlines != 0; }
+
+  inline void setRowColumn(int i, int j) {
+    _row = i;
+    _col = j;
+  }
+
+  inline Alignment align() { return _align; }
+
+  inline int row() const { return _row; }
+
+  inline int col() const { return _col; }
+
+  sptr<Box> createBox(Env& env) override;
+};
+
+/** An atom used in array mode representing "dots" */
+class HdotsforAtom : public MulticolumnAtom {
+private:
+  float _coeff;
+
+  static sptr<Box> createBox(float space, const sptr<Box>& b, Env& env);
+
+public:
+  HdotsforAtom() = delete;
+
+  HdotsforAtom(int n, float coeff)
+      : MulticolumnAtom(n, "c", sptrOf<CharAtom>('.', true)), _coeff(coeff) {}
+
+  bool isNeedWidth() const override { return true; }
+
+  sptr<Box> createBox(Env& env) override;
+};
+
+/** Atom representing multi-row */
+class MultiRowAtom : public Atom {
+private:
+  sptr<Atom> _rows;
+
+public:
+  int _i, _j, _n;
+
+  MultiRowAtom() = delete;
+
+  MultiRowAtom(int n, const std::string& option, const sptr<Atom>& rows)
+      : _i(0), _j(0), _rows(rows), _n(n == 0 ? 1 : n) {}
+
+  inline void setRowColumn(int r, int c) {
+    _i = r;
+    _j = c;
+  }
+
+  sptr<Box> createBox(Env& env) override {
+    auto b = _rows->createBox(env);
+    b->_type = AtomType::multiRow;
+    return b;
+  }
+};
+
+enum class MultiLineType { multiline, gather, gathered };
+
+/** An atom representing a vertical row of other atoms */
+class MultlineAtom : public Atom {
+private:
+  static SpaceAtom _vsep_in;
+  sptr<ArrayFormula> _column;
+  MultiLineType _lineType;
+  bool _isPartial;
+
+public:
+  MultlineAtom() = delete;
+
+  MultlineAtom(bool isPartial, const sptr<ArrayFormula>& col, MultiLineType type) {
+    _isPartial = isPartial;
+    _lineType = type;
+    _column = col;
+  }
+
+  MultlineAtom(const sptr<ArrayFormula>& col, MultiLineType type) {
+    _isPartial = false;
+    _lineType = type;
+    _column = col;
+  }
+
+  sptr<Box> createBox(Env& env) override;
+};
+
+}  // namespace microtex
+
+#endif  // MICROTEX_ATOM_MATRIX_H

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

@@ -0,0 +1,230 @@
+#include "atom/atom_misc.h"
+
+#include "atom/atom_basic.h"
+#include "atom/atom_delim.h"
+#include "env/units.h"
+#include "utils/string_utils.h"
+#include "utils/utf.h"
+
+using namespace std;
+using namespace microtex;
+
+sptr<Box> BigSymbolAtom::createBox(Env& env) {
+  auto b = microtex::createVDelim(_delim, env, _size);
+  const auto axis = env.mathConsts().axisHeight() * env.scale();
+  b->_shift = -(b->vlen() / 2 - b->_height) - axis;
+  return sptrOf<HBox>(b);
+}
+
+LapedAtom::LapedAtom(const sptr<Atom>& a, char type) : _type(type) {
+	_at = a == nullptr ? sptrOf<EmptyAtom>() : a;
+}
+
+sptr<Box> LapedAtom::createBox(Env& env) {
+  auto b = _at->createBox(env);
+  auto* vb = new VBox();
+  vb->add(b);
+  vb->_width = 0;
+  switch (_type) {
+    case 'l': b->_shift = -b->_width; break;
+    case 'r': b->_shift = 0; break;
+    default: b->_shift = -b->_width / 2; break;
+  }
+
+  return sptr<Box>(vb);
+}
+
+sptr<Box> RaiseAtom::createBox(Env& env) {
+  auto base = _base->createBox(env);
+  if (_raise.isValid()) {
+    base->_shift = Units::fsize(_raise, env);
+  }
+  auto hb = sptrOf<HBox>(base);
+  if (_height.isValid()) {
+    hb->_height = Units::fsize(_height, env);
+  }
+  if (_depth.isValid()) {
+    hb->_depth = Units::fsize(_depth, env);
+  }
+  return hb;
+}
+
+sptr<Box> ResizeAtom::createBox(Env& env) {
+  auto box = _base->createBox(env);
+  if (!_width.isValid() && !_height.isValid()) return box;
+  auto sx = 1.f, sy = 1.f;
+  if (_width.isValid() && _height.isValid()) {
+    sx = Units::fsize(_width, env) / box->_width;
+    sy = Units::fsize(_height, env) / box->vlen();
+    if (_keepAspectRatio) {
+      sx = std::min(sx, sy);
+      sy = sx;
+    }
+  } else if (_width.isValid() && !_height.isValid()) {
+    sx = Units::fsize(_width, env) / box->_width;
+    sy = sx;
+  } else {
+    sy = Units::fsize(_height, env) / box->vlen();
+    sx = sy;
+  }
+  return sptrOf<ScaleBox>(box, sx, sy);
+}
+
+RotateAtom::RotateAtom(const sptr<Atom>& base, float angle, const string& option)
+    : _angle(0), _option(Rotation::bl) {
+  _base = base == nullptr ? sptrOf<EmptyAtom>() : base;
+  _type = _base->_type;
+  _angle = angle;
+  const auto& opt = parseOption(option);
+  auto it = opt.find("origin");
+  if (it != opt.end()) {
+    _option = RotateBox::getOrigin(it->second);
+    return;
+  }
+  it = opt.find("x");
+  if (it != opt.end()) {
+    _x = Units::getDimen(it->second);
+  } else {
+    _x = 0._em;
+  }
+  it = opt.find("y");
+  if (it != opt.end()) {
+    _y = Units::getDimen(it->second);
+  } else {
+    _y = 0._em;
+  }
+}
+
+RotateAtom::RotateAtom(const sptr<Atom>& base, const string& angle, const string& option)
+    : _angle(0), _option(Rotation::none), _x(0._em), _y(0._em) {
+  _type = base->_type;
+  _base = base;
+  valueOf(angle, _angle);
+  _option = RotateBox::getOrigin(option);
+}
+
+sptr<Box> RotateAtom::createBox(Env& env) {
+  if (_option != Rotation::none) {
+    return sptrOf<RotateBox>(_base->createBox(env), _angle, _option);
+  }
+
+  const auto x = Units::fsize(_x, env);
+  const auto y = Units::fsize(_y, env);
+  return sptrOf<RotateBox>(_base->createBox(env), _angle, x, y);
+}
+
+sptr<Box> RuleAtom::createBox(Env& env) {
+  float w = Units::fsize(_w, env);
+  float h = Units::fsize(_h, env);
+  float r = Units::fsize(_r, env);
+  return sptrOf<RuleBox>(h, w, r);
+}
+
+sptr<Box> StrikeThroughAtom::createBox(Env& env) {
+  const auto t = env.mathConsts().overbarRuleThickness() * env.scale();
+  const auto h = env.mathConsts().axisHeight() * env.scale();
+  auto b = _at->createBox(env);
+  auto r = sptrOf<RuleBox>(t, b->_width, -h + t);
+  auto hb = sptrOf<HBox>(b);
+  hb->add(StrutBox::create(-b->_width));
+  hb->add(r);
+  return hb;
+}
+
+sptr<Box> VCenterAtom::createBox(Env& env) {
+  auto b = _base->createBox(env);
+  auto a = env.mathConsts().axisHeight() * env.scale();
+  auto hb = sptrOf<HBox>(b);
+  hb->_height = b->vlen() / 2 + a;
+  hb->_depth = b->vlen() - hb->_height;
+  return hb;
+}
+
+LongDivAtom::LongDivAtom(long divisor, long dividend) : _divisor(divisor), _dividend(dividend) {
+  _halign = Alignment::right;
+  setAlignTop(true);
+  vector<string> results;
+  calculate(results);
+
+  auto rule = sptrOf<RuleAtom>(0._ex, 2.5_ex, 0.3_ex);
+
+  const int s = results.size();
+  for (int i = 0; i < s; i++) {
+    auto num = Formula(results[i])._root;
+    if (i == 1) {
+      string divisor = toString(_divisor);
+      auto rparen = SymbolAtom::get("rparen");
+      auto big = sptrOf<BigSymbolAtom>(rparen, 1);
+      auto raise = sptrOf<RaiseAtom>(big, -1._tt, 0._tt, 0._tt);
+      auto row = sptrOf<RowAtom>(raise);
+      row->add(num);
+      auto o = sptrOf<OverUnderBar>(row, true);
+      auto r = sptrOf<RowAtom>(Formula(divisor, false)._root);
+      r->add(sptrOf<SpaceAtom>(SpaceType::thinMuSkip));
+      r->add(o);
+      append(r);
+      continue;
+    }
+    if (i % 2 == 0) {
+      auto row = sptrOf<RowAtom>(num);
+      row->add(rule);
+      if (i == 0)
+        append(row);
+      else
+        append(sptrOf<OverUnderBar>(row, false));
+    } else {
+      auto row = sptrOf<RowAtom>(num);
+      row->add(rule);
+      append(row);
+    }
+  }
+}
+
+void LongDivAtom::calculate(vector<string>& results) const {
+  long quotient = _dividend / _divisor;
+  results.push_back(toString(quotient));
+  string x = toString(quotient);
+  size_t len = x.length();
+  long remaining = _dividend;
+  results.push_back(toString(remaining));
+  for (size_t i = 0; i < len; i++) {
+    long b = (x[i] - '0') * pow(10, len - i - 1);
+    long product = b * _divisor;
+    remaining = remaining - product;
+    results.push_back(toString(product));
+    results.push_back(toString(remaining));
+  }
+}
+
+sptr<Box> CancelAtom::createBox(Env& env) {
+  auto box = _base->createBox(env);
+  vector<float> lines;
+  if (_cancelType == SLASH) {
+    lines = {0, 0, box->_width, box->_height + box->_depth};
+  } else if (_cancelType == BACKSLASH) {
+    lines = {box->_width, 0, 0, box->_height + box->_depth};
+  } else if (_cancelType == CROSS) {
+    lines = {
+      0,
+      0,
+      box->_width,
+      box->_height + box->_depth,
+      box->_width,
+      0,
+      0,
+      box->_height + box->_depth,
+    };
+  } else {
+    return box;
+  }
+
+  const float rt = env.mathConsts().fractionRuleThickness() * env.scale();
+  auto overlap = sptrOf<LineBox>(lines, rt);
+  overlap->_width = box->_width;
+  overlap->_height = box->_height;
+  overlap->_depth = box->_depth;
+  auto hbox = new HBox(box);
+  hbox->add(sptr<Box>(new StrutBox(-box->_width, 0, 0, 0)));
+  hbox->add(overlap);
+  return sptr<Box>(hbox);
+}

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

@@ -0,0 +1,200 @@
+#ifndef MICROTEX_ATOM_MISC_H
+#define MICROTEX_ATOM_MISC_H
+
+#include "atom/atom.h"
+#include "atom/atom_basic.h"
+#include "atom/atom_char.h"
+#include "atom/atom_vrow.h"
+#include "box/box_factory.h"
+#include "box/box_group.h"
+#include "core/formula.h"
+#include "core/split.h"
+#include "env/env.h"
+#include "env/units.h"
+#include "graphic/graphic.h"
+
+namespace microtex {
+
+/** An atom representing a big symbol atom (i.e. sigma) */
+class BigSymbolAtom : public Atom {
+private:
+  int _size;
+
+public:
+  const sptr<SymbolAtom> _delim;
+
+  BigSymbolAtom() = delete;
+
+  BigSymbolAtom(const sptr<SymbolAtom>& delim, int size) : _delim(delim), _size(size) {}
+
+  AtomType leftType() const override { return _delim->leftType(); }
+
+  AtomType rightType() const override { return _delim->rightType(); }
+
+  sptr<Box> createBox(Env& env) override;
+};
+
+/** An atom representing a lapped atom (i.e. with no width) */
+class LapedAtom : public Atom {
+private:
+  sptr<Atom> _at;
+  char _type;
+
+public:
+  LapedAtom() = delete;
+
+  LapedAtom(const sptr<Atom>& a, char type);
+
+  sptr<Box> createBox(Env& env) override;
+};
+
+class RaiseAtom : public Atom {
+private:
+  sptr<Atom> _base;
+  Dimen _raise, _height, _depth;
+
+public:
+  RaiseAtom() = delete;
+
+  RaiseAtom(const sptr<Atom>& base, Dimen raise, Dimen height, Dimen depth)
+      : _base(base), _raise(raise), _height(height), _depth(depth) {}
+
+  AtomType leftType() const override { return _base->leftType(); }
+
+  AtomType rightType() const override { return _base->rightType(); }
+
+  sptr<Box> createBox(Env& env) override;
+};
+
+/** An atom representing a reflected atom */
+class ReflectAtom : public Atom {
+private:
+  sptr<Atom> _base;
+
+public:
+  ReflectAtom() = delete;
+
+  explicit ReflectAtom(const sptr<Atom>& base) : _base(base) { _type = _base->_type; }
+
+  sptr<Box> createBox(Env& env) override { return sptrOf<ReflectBox>(_base->createBox(env)); }
+};
+
+/** An atom representing a resize operation on given atom */
+class ResizeAtom : public Atom {
+private:
+  sptr<Atom> _base;
+  Dimen _width, _height;
+  bool _keepAspectRatio;
+
+public:
+  ResizeAtom() = delete;
+
+  ResizeAtom(
+    const sptr<Atom>& base,
+    const std::string& ws,
+    const std::string& hs,
+    bool keepAspectRatio
+  ) {
+    const sptr<Atom>& xbase = base == nullptr ? sptrOf<EmptyAtom>() : base;
+    _type = xbase->_type;
+    _base = xbase;
+    _keepAspectRatio = keepAspectRatio;
+    _width = Units::getDimen(ws);
+    _height = Units::getDimen(hs);
+  }
+
+  AtomType leftType() const override { return _base->leftType(); }
+
+  AtomType rightType() const override { return _base->rightType(); }
+
+  sptr<Box> createBox(Env& env) override;
+};
+
+/** An atom representing a rotated atom */
+class RotateAtom : public Atom {
+private:
+  sptr<Atom> _base;
+  float _angle;
+  Rotation _option;
+  Dimen _x, _y;
+
+public:
+  RotateAtom() = delete;
+
+  RotateAtom(const sptr<Atom>& base, const std::string& angle, const std::string& option);
+
+  RotateAtom(const sptr<Atom>& base, float angle, const std::string& option);
+
+  sptr<Box> createBox(Env& env) override;
+};
+
+class RuleAtom : public Atom {
+private:
+  Dimen _w, _h, _r;
+
+public:
+  RuleAtom() = delete;
+
+  RuleAtom(const Dimen& w, const Dimen& h, const Dimen& r) : _w(w), _h(h), _r(r) {}
+
+  sptr<Box> createBox(Env& env) override;
+};
+
+/** An atom representing a strike through atom */
+class StrikeThroughAtom : public Atom {
+private:
+  sptr<Atom> _at;
+
+public:
+  explicit StrikeThroughAtom(const sptr<Atom>& a) {
+    _at = a == nullptr ? sptrOf<EmptyAtom>() : a;
+  }
+
+  sptr<Box> createBox(Env& env) override;
+};
+
+/**
+ * An atom representing another atom vertically centered with respect to
+ * the math axis
+ */
+class VCenterAtom : public WrapAtom {
+public:
+  VCenterAtom() = delete;
+
+  explicit VCenterAtom(const sptr<Atom>& a) : WrapAtom(a) {}
+
+  sptr<Box> createBox(Env& env) override;
+};
+
+/** An atom representing long division */
+class LongDivAtom : public VRowAtom {
+private:
+  long _divisor, _dividend;
+
+  void calculate(std::vector<std::string>& results) const;
+
+public:
+  LongDivAtom() = delete;
+
+  LongDivAtom(long divisor, long dividend);
+};
+
+/** An atom representing an atom with lines covered */
+class CancelAtom : public Atom {
+private:
+  sptr<Atom> _base;
+  int _cancelType;
+
+public:
+  enum CancelType { SLASH, BACKSLASH, CROSS };
+
+  CancelAtom() = delete;
+
+  CancelAtom(const sptr<Atom>& base, int cancelType) : _base(base), _cancelType(cancelType) {}
+
+  sptr<Box> createBox(Env& env) override;
+};
+
+}  // namespace microtex
+
+#endif  // MICROTEX_ATOM_MISC_H