@simonklee/opentui-tex-native-source 0.2.0

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

@@ -0,0 +1,177 @@
+#ifndef MICROTEX_OTF_H
+#define MICROTEX_OTF_H
+
+#include "otf/glyph.h"
+#include "otf/math_consts.h"
+#include "utils/utils.h"
+
+namespace microtex {
+
+class CLMReader;
+
+/** Table represents standard ligatures. */
+using LigaTable = SortedDictTree<u16, i32>;
+
+/** Represents classified kerning */
+struct ClassKerning final {
+private:
+  u16 _leftCount = 0;
+  /** left glyphs, in pair format (glyph, class_index) */
+  u16* _lefts = nullptr;
+
+  u16 _rightCount = 0;
+  /** right glyphs, in pair format (glyph, class_index) */
+  u16* _rights = nullptr;
+
+  u16 _rowLength = 0, _columnLength = 0;
+  /** kerning value table, size = (_rowLength * _columnLength) */
+  i16* _table = nullptr;
+
+  ClassKerning() = default;
+
+public:
+  no_copy_assign(ClassKerning);
+
+  /**
+   * Get the kerning value for the given left and right glyph.
+   * Return [false, 0] if not found.
+   */
+  std::pair<bool, i16> operator()(u16 left, u16 right) const;
+
+  ~ClassKerning();
+
+  friend CLMReader;
+};
+
+/** Class to represent an otf font */
+class Otf final {
+private:
+  std::string _name;
+  std::string _family;
+
+  u16 _style;
+
+  u16 _unicodeCount = 0;
+  u32* _unicodes = nullptr;
+  u16* _unicodeGlyphs = nullptr;
+
+  u16 _em = 0;
+  u16 _xHeight = 0;
+  u16 _ascent = 0;
+  u16 _descent = 0;
+
+  bool _isMathFont = false;
+  MathConsts* _mathConsts = nullptr;
+  bool _hasGlyphPath = false;
+
+  LigaTable* _ligatures = nullptr;
+  u16 _classKerningCount = 0;
+  ClassKerning** _classKernings = nullptr;
+
+  u16 _glyphCount = 0;
+  Glyph** _glyphs = nullptr;
+
+  Otf() = default;
+
+public:
+  no_copy_assign(Otf);
+
+  /** Undefined value */
+  static constexpr auto undefinedMathValue = 0x7FFF;
+
+  /** Read otf font from file */
+  static Otf* fromFile(const char* filePath);
+
+  /** Read otf font from data */
+  static Otf* fromData(size_t len, const u8* data);
+
+  /** Get the full postscript name of this font */
+  inline std::string name() const { return _name; }
+
+  /** Get the postscript family name of this font */
+  inline std::string family() const { return _family; }
+
+  /** Test if this font is a math font */
+  inline bool isMathFont() const { return _isMathFont; }
+
+  /**
+   * Test if this font has glyph's path.
+   * Always is false if GLYPH_RENDER_TYPE equals to GLYPH_RENDER_TYPE_TYPEFACE.
+   */
+  inline bool hasGlyphPath() const { return _hasGlyphPath; }
+
+  /** Get the font style in clm (short enum see [lib/graphics/font_style.h: FontStyle]) format **/
+  inline u16 style() const { return _style; }
+
+  /** Get the char count covered by this font */
+  inline u16 unicodesCount() const { return _unicodeCount; }
+
+  /** Get the glyphs count covered by this font */
+  inline u16 glyphsCount() const { return _glyphCount; }
+
+  /** Get the em size of this font. */
+  inline u16 em() const { return _em; }
+
+  /** Get the quad of this font. */
+  inline u16 quad() const { return _em; }
+
+  /** Get the x-height of this font. */
+  inline u16 xHeight() const { return _xHeight; }
+
+  /** Get the ascent of this font. */
+  inline u16 ascent() const { return _ascent; }
+
+  /** Get the descent of this font. */
+  inline u16 descent() const { return _descent; }
+
+  /** Get the math-consts table, return null if absent. */
+  inline const MathConsts* mathConsts() const { return _mathConsts; }
+
+  /** Get the space size of this font. */
+  u16 space() const;
+
+  /**
+   * Get the glyph id from the given Unicode code-point, return -1 if not found.
+   *
+   * <p>
+   * The glyph id actually represents the index of the glyph in font file.
+   * <strong>Does not support CID-keyed fonts (either in PS or in CFF format).</strong>
+   *
+   * <p>
+   * See
+   * <a href="https://docs.microsoft.com/en-us/typography/opentype/spec/cff">
+   * CFF - Compact Font Format Table</a> for details.
+   *
+   * And
+   * <a
+   * href="https://freetype-py.readthedocs.io/en/latest/ft_face_flags.html#FT_FACE_FLAG_CID_KEYED">
+   * FT_FACE_FLAG_CID_KEYED</a> explains why.
+   */
+  i32 glyphId(c32 codepoint) const;
+
+  /** Get the glyph from the given Unicode code-point, return null if not found. */
+  const Glyph* glyphOfUnicode(c32 codepoint) const;
+
+  /** Get the glyph from the given glyph id, return null if absent. */
+  const Glyph* glyph(i32 id) const;
+
+  /** Get the ligatures of this font, return null if absent. */
+  const LigaTable* ligatures() const { return _ligatures; }
+
+  /**
+   * Get the classified-kerning value between left and right glyph.
+   *
+   * @param left the glyph id of the left character
+   * @param right the glyph id of the right character
+   * @return the kerning value or 0 if absent
+   */
+  i16 classKerning(u16 left, u16 right) const;
+
+  ~Otf();
+
+  friend CLMReader;
+};
+
+}  // namespace microtex
+
+#endif

package/native/vendor/microtex/lib/otf/otfconfig.h

@@ -0,0 +1,32 @@
+#ifndef MICROTEX_OTFCONFIG_H
+#define MICROTEX_OTFCONFIG_H
+
+#define GLYPH_RENDER_TYPE_BOTH 0
+#define GLYPH_RENDER_TYPE_PATH 1
+#define GLYPH_RENDER_TYPE_TYPEFACE 2
+
+// clang-format off
+// if have glyph render path
+#if GLYPH_RENDER_TYPE == GLYPH_RENDER_TYPE_BOTH || GLYPH_RENDER_TYPE == GLYPH_RENDER_TYPE_PATH
+#   define HAVE_GLYPH_RENDER_PATH
+#endif
+
+#if GLYPH_RENDER_TYPE == GLYPH_RENDER_TYPE_BOTH || GLYPH_RENDER_TYPE == GLYPH_RENDER_TYPE_TYPEFACE
+#   define HAVE_GLYPH_RENDER_TYPEFACE
+#endif
+
+// The clm data major version
+#define CLM_VER_MAJOR 5
+
+// The clm data minor version, must be 1 or 2
+#ifdef HAVE_GLYPH_RENDER_PATH
+#   define CLM_VER_MINOR 2
+#else
+#   define CLM_VER_MINOR 1
+#endif
+
+// If clm supports glyph path
+#define CLM_SUPPORT_GLYPH_PATH(minorVersion) ((minorVersion) == 2)
+// clang-format on
+
+#endif  // MICROTEX_OTFCONFIG_H

package/native/vendor/microtex/lib/otf/path.cpp

@@ -0,0 +1,187 @@
+#include "otf/path.h"
+
+microtex::u16 microtex::pathCmdArgsCount(char cmd) {
+  switch (cmd) {
+    case 'M':
+    case 'm':
+    case 'L':
+    case 'l':
+    case 'T':
+    case 't': return 2;
+
+    case 'H':
+    case 'h':
+    case 'V':
+    case 'v': return 1;
+
+    case 'Z':
+    case 'z': return 0;
+
+    case 'C':
+    case 'c': return 6;
+
+    case 'S':
+    case 's':
+    case 'Q':
+    case 'q': return 4;
+
+    default: return 0;
+  }
+}
+
+#ifdef HAVE_GLYPH_RENDER_PATH
+
+#include "graphic/graphic.h"
+#include "utils/string_utils.h"
+
+namespace microtex {
+
+PathCmd::PathCmd(char cmd, const i16* args) noexcept : cmd(cmd), args(args) {}
+
+std::string PathCmd::toString() const {
+  std::string str;
+  str.append(1, cmd).append(1, ' ');
+  for (int i = 0; i < pathCmdArgsCount(cmd); i++) {
+    str.append(microtex::toString(args[i])).append(1, ' ');
+  }
+  str.append(1, '\n');
+  return str;
+}
+
+PathCmd::~PathCmd() {
+  delete[] args;
+}
+
+Path Path::empty(-1, 0, nullptr);
+
+Path::Path(i32 id, u16 cmdCnt, PathCmd** cmds) noexcept : _id(id), _cmdCnt(cmdCnt), _cmds(cmds) {}
+
+void Path::draw(Graphics2D& g2) const {
+  if (isEmpty()) return;
+  const auto cached = g2.beginPath(_id);
+  if (cached) {
+    g2.fillPath(_id);
+    return;
+  }
+  int mx = 0, my = 0;  // the first point to move to
+  int px = 0, py = 0;  // the current point
+  int cx = 0, cy = 0;  // the last control point
+  for (u16 i = 0; i < _cmdCnt; i++) {
+    const auto& cmd = *_cmds[i];
+    if (!cmd.isValid()) continue;
+    switch (cmd.cmd) {
+      case 'M':
+        mx = px = cmd[0];
+        my = py = cmd[1];
+        g2.moveTo(px, py);
+        break;
+      case 'm':
+        mx = px = cmd[0] + px;
+        my = py = cmd[1] + py;
+        g2.moveTo(px, py);
+        break;
+      case 'L':
+        px = cmd[0];
+        py = cmd[1];
+        g2.lineTo(px, py);
+        break;
+      case 'l':
+        px += cmd[0];
+        py += cmd[1];
+        g2.lineTo(px, py);
+        break;
+      case 'H':
+        px = cmd[0];
+        g2.lineTo(px, py);
+        break;
+      case 'h':
+        px += cmd[0];
+        g2.lineTo(px, py);
+        break;
+      case 'V':
+        py = cmd[0];
+        g2.lineTo(px, py);
+        break;
+      case 'v':
+        py += cmd[0];
+        g2.lineTo(px, py);
+        break;
+      case 'C':
+        cx = cmd[2];
+        cy = cmd[3];
+        px = cmd[4];
+        py = cmd[5];
+        g2.cubicTo(cmd[0], cmd[1], cx, cy, px, py);
+        break;
+      case 'c':
+        g2.cubicTo(px + cmd[0], py + cmd[1], px + cmd[2], py + cmd[3], px + cmd[4], py + cmd[5]);
+        cx = px + cmd[2];
+        cy = py + cmd[3];
+        px += cmd[4];
+        py += cmd[5];
+        break;
+      case 'S':
+        g2.cubicTo(px + px - cx, py + py - cy, cmd[0], cmd[1], cmd[2], cmd[3]);
+        cx = cmd[0];
+        cy = cmd[1];
+        px = cmd[2];
+        py = cmd[3];
+        break;
+      case 's':
+        g2.cubicTo(px + px - cx, py + py - cy, px + cmd[0], py + cmd[1], px + cmd[2], py + cmd[3]);
+        cx = cmd[0] + px;
+        cy = cmd[1] + py;
+        px += cmd[2];
+        py += cmd[3];
+        break;
+      case 'Q':
+        cx = cmd[0];
+        cy = cmd[1];
+        px = cmd[2];
+        py = cmd[3];
+        g2.quadTo(cx, cy, px, py);
+        break;
+      case 'q':
+        cx = cmd[0] + px;
+        cy = cmd[1] + py;
+        px += cmd[2];
+        py += cmd[3];
+        g2.quadTo(cx, cy, px, py);
+        break;
+      case 'T':
+        cx = px + px - cx;
+        cy = py + py - cy;
+        px = cmd[0];
+        py = cmd[1];
+        g2.quadTo(cx, cy, px, py);
+        break;
+      case 't':
+        cx = px + px - cx;
+        cy = py + py - cy;
+        px += cmd[0];
+        py += cmd[1];
+        g2.quadTo(cx, cy, px, py);
+        break;
+      case 'Z':
+      case 'z': g2.closePath(); break;
+    }
+  }
+  g2.fillPath(_id);
+}
+
+std::string Path::toString() const {
+  std::string str;
+  for (int i = 0; i < _cmdCnt; i++) {
+    str.append(_cmds[i]->toString());
+  }
+  return str;
+}
+
+Path::~Path() {
+  for (u16 i = 0; i < _cmdCnt; i++) delete _cmds[i];
+  delete[] _cmds;
+}
+
+}  // namespace microtex
+
+#endif  // HAVE_GLYPH_RENDER_PATH

package/native/vendor/microtex/lib/otf/path.h

@@ -0,0 +1,120 @@
+#ifndef MICROTEX_PATH_H
+#define MICROTEX_PATH_H
+
+#include "otf/otfconfig.h"
+#include "utils/utils.h"
+
+namespace microtex {
+
+/** Get the arguments count of the given path command. */
+u16 pathCmdArgsCount(char cmd);
+
+}  // namespace microtex
+
+#ifdef HAVE_GLYPH_RENDER_PATH
+
+#include <string>
+
+namespace microtex {
+
+class Graphics2D;
+
+/** Abstract graphical path command, with its drawing command and points. */
+struct PathCmd {
+  /**
+   * Path drawing command, one of the following:
+   * @code
+   * cmd  args       desc
+   * M    x, y       Move to point (x, y).
+   *
+   * m    dx, dy     Given a current point (x0, y0), move to (x0 + dx, y0 + dy).
+   *
+   * L    x, y       Line to (x, y).
+   *
+   * l    dx, dy     Given a current point (x0, y0), line to (x0 + dx, y0 + dy).
+   *
+   * H    x          Given a current point (x0, y0), line to (x, y0).
+   *
+   * h    dx         Given a current point (x0, y0), line to (x0 + dx, y0).
+   *
+   * V    y          Given a current point (x0, y0), line to (x0, y).
+   *
+   * v    dy         Given a current point (x0, y0), line to (x0, y0 + dy).
+   *
+   * C    cx1, cy1,  Adds a cubic Bezier spline to path from current point to position
+   *      cx2, cy2,  (x, y), using (cx1, cy1) and (cx2, cy2) as the control points, the
+   *      x, y       current point will be (x, y).
+   *
+   * c    dx1, dy1,  Given a current point (x0, y0), c(dx1, dy1, dx2, dy2, dx, dy) is
+   *      dx2, dy2,  logically equivalent to
+   *      dx, dy     C(x0 + dx1, y0 + dy1, x0 + dx2, y0 + dy2, x0 + dx, y0 + dy).
+   *
+   * S    cx, cy,    Produces the same type of curve as 'C', but if it follows another
+   *      x, y       'S' command or a 'C' command, the first control point is assumed to
+   *                 be a reflection of the one used previously.
+   *
+   * s    cx, cy,    Given a current point (x0, y0), s(cx, cy, dx, dy) is logically
+   *      dx, dy     equivalent to S(x0 + cx, y0 + cy, x0 + dx, y0 + dy).
+   *
+   * Q    cx, cy     Simpler curve than the cubic one. With its control point (cx, cy)
+   *      x, y       and final point (x, y).
+   *
+   * q    cx, cy     Given a current point (x0, y0), q(cx, cy, dx, dy) is logically
+   *      dx, dy     equivalent to Q(x0 + cx, y0 + cy, x0 + dx, y0 + dy).
+   *
+   * T    x, y       Like the command 'S', if 'T' follows another curve command, the first
+   *                 control point is assumed to be a reflection of the one used previously.
+   *
+   * t    dx, dy     Same as 'T', but the params are given by the offset of the final point.
+   *
+   * Z    N/A        Close the path.
+   *
+   * z    N/A        Close the path.
+   * @endcode
+   *
+   * See <a href="https://developer.mozilla.org/en-US/docs/Web/SVG/Tutorial/Paths">this
+   * tutorial</a> for details.
+   */
+  const char cmd;
+  const i16* const args;
+
+  PathCmd(char cmd, const i16* args) noexcept;
+
+  no_copy_assign(PathCmd);
+
+  inline bool isValid() const { return cmd != ' '; }
+
+  inline i16 operator[](int i) const { return args[i]; }
+
+  std::string toString() const;
+
+  ~PathCmd();
+};
+
+/** A group of PathCmd */
+struct Path {
+private:
+  const i32 _id;
+  const u16 _cmdCnt;
+  PathCmd** _cmds;
+
+public:
+  no_copy_assign(Path);
+
+  Path(i32 id, u16 cmdCnt, PathCmd** cmds) noexcept;
+
+  inline bool isEmpty() const { return _cmdCnt <= 0; }
+
+  void draw(Graphics2D& g2) const;
+
+  std::string toString() const;
+
+  ~Path();
+
+  static Path empty;
+};
+
+}  // namespace microtex
+
+#endif  // HAVE_GLYPH_RENDER_PATH
+#endif  // MICROTEX_PATH_H

package/native/vendor/microtex/lib/render/builder.cpp

@@ -0,0 +1,68 @@
+#include "builder.h"
+
+#include "atom/atom_basic.h"
+#include "box/box_group.h"
+#include "box/box_single.h"
+#include "core/formula.h"
+#include "core/split.h"
+#include "utils/exceptions.h"
+
+using namespace microtex;
+
+RenderBuilder& RenderBuilder::setLineSpace(const Dimen& dimen) {
+  if (!dimen.isValid()) {
+    throw ex_invalid_state("Cannot set line space without having specified a width!");
+  }
+  _lineSpace = dimen;
+  return *this;
+}
+
+Render* RenderBuilder::build(Formula& f) {
+  return build(f._root);
+}
+
+Render* RenderBuilder::build(const sptr<Atom>& fc) {
+  sptr<Atom> f = fc;
+  if (f == nullptr) f = sptrOf<EmptyAtom>();
+  if (_textSize == -1) {
+    throw ex_invalid_state("A text size is required, call function setTextSize before build.");
+  }
+  if (_mathFontName.empty()) {
+    throw ex_invalid_state("A math font is required, call function setMathFontName before build.");
+  }
+
+  auto fctx = sptrOf<FontContext>();
+  fctx->selectMathFont(_mathFontName);
+  fctx->selectMainFont(_mainFontName);
+
+  const auto style = _style;
+  Env env(style, fctx, _textSize);
+  const auto isLimitedWidth = !_textWidth.isEmpty();
+  if (isLimitedWidth) {
+    env.setTextWidth(_textWidth);
+  }
+  if (_lineSpace.isValid()) {
+    env.setLineSpace(_lineSpace);
+  }
+
+  Render* render;
+  auto box = f->createBox(env);
+  if (isLimitedWidth) {
+    HBox* hb;
+    bool isBoxSplit = false;
+    if (!_lineSpace.isEmpty()) {
+      auto space = Units::fsize(_lineSpace, env);
+      auto [isSplit, split] = BoxSplitter::split(box, env.textWidth(), space);
+      isBoxSplit = isSplit;
+      hb = new HBox(split, _fillWidth ? env.textWidth() : split->_width, _align);
+    } else {
+      hb = new HBox(box, _fillWidth ? env.textWidth() : box->_width, _align);
+    }
+    render = new Render(sptr<Box>(hb), _textSize, isBoxSplit);
+  } else {
+    render = new Render(box, _textSize);
+  }
+
+  if (!isTransparent(_fg)) render->setForeground(_fg);
+  return render;
+}

package/native/vendor/microtex/lib/render/builder.h

@@ -0,0 +1,73 @@
+#ifndef MICROTEX_BUILDER_H
+#define MICROTEX_BUILDER_H
+
+#include "env/units.h"
+#include "render.h"
+
+namespace microtex {
+
+class Formula;
+
+class Atom;
+
+class RenderBuilder {
+private:
+  TexStyle _style = TexStyle::display;
+  Dimen _textWidth;
+  Dimen _lineSpace;
+  float _textSize = 0;
+  bool _fillWidth = false;
+  color _fg = black;
+  Alignment _align = Alignment::none;
+  std::string _mathFontName;
+  std::string _mainFontName;
+
+public:
+  RenderBuilder() = default;
+
+  inline RenderBuilder& setStyle(TexStyle style) {
+    _style = style;
+    return *this;
+  }
+
+  inline RenderBuilder& setTextSize(float textSize) {
+    _textSize = textSize;
+    return *this;
+  }
+
+  inline RenderBuilder& setForeground(color c) {
+    _fg = c;
+    return *this;
+  }
+
+  inline RenderBuilder& setWidth(const Dimen& dimen, Alignment align) {
+    _textWidth = dimen;
+    _align = align;
+    return *this;
+  }
+
+  inline RenderBuilder& setMathFontName(const std::string& name) {
+    _mathFontName = name;
+    return *this;
+  }
+
+  inline RenderBuilder& setMainFontName(const std::string& name) {
+    _mainFontName = name;
+    return *this;
+  }
+
+  inline RenderBuilder& setFillWidth(bool i) {
+    _fillWidth = i;
+    return *this;
+  }
+
+  RenderBuilder& setLineSpace(const Dimen& dimen);
+
+  Render* build(const sptr<Atom>& f);
+
+  Render* build(Formula& f);
+};
+
+}  // namespace microtex
+
+#endif  // MICROTEX_BUILDER_H

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

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