@simonklee/opentui-tex-native-source 0.2.0

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

@@ -0,0 +1,96 @@
+#include "atom/atom_vrow.h"
+
+#include "box/box_group.h"
+#include "box/box_single.h"
+#include "env/env.h"
+
+using namespace microtex;
+using namespace std;
+
+VRowAtom::VRowAtom() {
+  _addInterline = false;
+  _valign = Alignment::center;
+  _halign = Alignment::none;
+  _raise = sptrOf<SpaceAtom>(UnitType::ex, 0.f, 0.f, 0.f);
+}
+
+VRowAtom::VRowAtom(const sptr<Atom>& base) {
+  _addInterline = false;
+  _valign = Alignment::center;
+  _halign = Alignment::none;
+  _raise = sptrOf<SpaceAtom>(UnitType::ex, 0.f, 0.f, 0.f);
+  if (base != nullptr) {
+    auto* a = dynamic_cast<VRowAtom*>(base.get());
+    if (a != nullptr) {
+      _elements.insert(_elements.end(), a->_elements.begin(), a->_elements.end());
+    } else {
+      _elements.push_back(base);
+    }
+  }
+}
+
+void VRowAtom::setRaise(UnitType unit, float r) {
+  _raise = sptrOf<SpaceAtom>(unit, r, 0.f, 0.f);
+}
+
+sptr<Atom> VRowAtom::popLastAtom() {
+  auto x = _elements.back();
+  _elements.pop_back();
+  return x;
+}
+
+void VRowAtom::prepend(const sptr<Atom>& el) {
+  if (el != nullptr) _elements.insert(_elements.begin(), el);
+}
+
+void VRowAtom::append(const sptr<Atom>& el) {
+  if (el != nullptr) _elements.push_back(el);
+}
+
+sptr<Box> VRowAtom::createBox(Env& env) {
+  auto vb = new VBox();
+  auto lineSpace = sptrOf<StrutBox>(0.f, env.lineSpace(), 0.f, 0.f);
+
+  if (_halign != Alignment::none) {
+    float maxWidth = F_MIN;
+    vector<sptr<Box>> boxes;
+    const size_t size = _elements.size();
+    // find the width of the widest box
+    for (auto& atom : _elements) {
+      auto box = atom->createBox(env);
+      boxes.push_back(box);
+      maxWidth = std::max(maxWidth, box->_width);
+    }
+    // align the boxes and add it to the vertical box
+    for (int i = 0; i < size; i++) {
+      auto box = boxes[i];
+      auto hb = sptrOf<HBox>(box, maxWidth, _halign);
+      vb->add(hb);
+      if (_addInterline && i < size - 1) vb->add(lineSpace);
+    }
+  } else {
+    // convert atoms to boxes and add to the vertical box
+    const size_t size = _elements.size();
+    for (int i = 0; i < size; i++) {
+      vb->add(_elements[i]->createBox(env));
+      if (_addInterline && i < size - 1) vb->add(lineSpace);
+    }
+  }
+
+  vb->_shift = -_raise->createBox(env)->_width;
+  if (_valign == Alignment::top) {
+    float t = vb->size() == 0 ? 0 : vb->_children.front()->_height;
+    vb->_height = t;
+    vb->_depth = vb->_depth + vb->_height - t;
+  } else if (_valign == Alignment::center) {
+    const float axis = env.axisHeight();
+    const float h = vb->_height + vb->_depth;
+    vb->_height = h / 2 + axis;
+    vb->_depth = h / 2 - axis;
+  } else {
+    float t = vb->size() == 0 ? 0 : vb->_children.back()->_depth;
+    vb->_height = vb->_depth + vb->_height - t;
+    vb->_depth = t;
+  }
+  return sptr<Box>(vb);
+}

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

@@ -0,0 +1,47 @@
+#ifndef MICROTEX_ATOM_VROW_H
+#define MICROTEX_ATOM_VROW_H
+
+#include "atom/atom.h"
+#include "atom/atom_space.h"
+
+namespace microtex {
+
+/** An atom representing a vertical row of other atoms. */
+class VRowAtom : public Atom {
+private:
+  std::vector<sptr<Atom>> _elements;
+  sptr<SpaceAtom> _raise;
+  bool _addInterline;
+
+public:
+  Alignment _valign = Alignment::none;
+  Alignment _halign = Alignment::none;
+
+  VRowAtom();
+
+  explicit VRowAtom(const sptr<Atom>& base);
+
+  inline void setAddInterline(bool addInterline) { _addInterline = addInterline; }
+
+  inline bool isAddInterline() const { return _addInterline; }
+
+  inline void setAlignTop(bool vtop) { _valign = vtop ? Alignment::top : Alignment::center; }
+
+  inline bool isAlignTop() const { return _valign == Alignment::top; }
+
+  void setRaise(UnitType unit, float r);
+
+  sptr<Atom> popLastAtom();
+
+  /** Add an atom at the front */
+  void prepend(const sptr<Atom>& el);
+
+  /** Add an atom at the tail */
+  void append(const sptr<Atom>& el);
+
+  sptr<Box> createBox(Env& env) override;
+};
+
+}  // namespace microtex
+
+#endif  // MICROTEX_ATOM_VROW_H

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

@@ -0,0 +1,66 @@
+#include "atom/atom_zstack.h"
+
+#include "atom/atom_basic.h"
+#include "box/box_group.h"
+#include "box/box_single.h"
+#include "env/env.h"
+#include "env/units.h"
+
+using namespace microtex;
+
+ZStackAtom::ZStackAtom(
+    const ZStackArgs& hargs,
+    const ZStackArgs& vargs,
+    const sptr<Atom>& atom,
+    const sptr<Atom>& anchor
+  ) : _hargs(hargs), _vargs(vargs) {
+      _atom = atom == nullptr ? sptrOf<EmptyAtom>() : atom;
+      _anchor = anchor == nullptr ? sptrOf<EmptyAtom>() : anchor;
+}
+
+sptr<Box> ZStackAtom::createBox(Env& env) {
+  const auto anchor = _anchor->createBox(env);
+  const auto box = _atom->createBox(env);
+
+  // calculate horizontal position
+  auto offset = Units::fsize(_hargs.offset, env);
+  auto l = 0.f;
+  if (_hargs.align == Alignment::left) {
+    l = offset;
+  } else if (_hargs.align == Alignment::center) {
+    l = (anchor->_width - box->_width) / 2 + offset;
+  } else if (_hargs.align == Alignment::right) {
+    l = anchor->_width - box->_width + offset;
+  }
+
+  const auto hbox = sptrOf<HBox>();
+  if (l < 0) hbox->add(StrutBox::create(-l));
+  hbox->add(anchor);
+  const auto minWidth = hbox->_width;
+
+  // add a kern box to shift the left position to the left position of the box
+  // to be stacked relative to the anchor box
+  const auto kern = l < 0 ? -hbox->_width : l - anchor->_width;
+  if (kern != 0.f) hbox->add(StrutBox::create(kern));
+
+  // calculate vertical shift (default align at baseline)
+  auto shift = Units::fsize(_vargs.offset, env);
+  if (_vargs.align == Alignment::top) {
+    shift += box->_height - anchor->_height;
+  } else if (_vargs.align == Alignment::bottom) {
+    shift = anchor->_depth - box->_depth - shift;
+  } else if (_vargs.align == Alignment::center) {
+    auto x = anchor->_depth - box->_depth;
+    auto y = (anchor->vlen() - box->vlen()) / 2;
+    shift = x - y - shift;
+  }
+  box->_shift = shift;
+
+  hbox->add(box);
+
+  if (hbox->_width < minWidth) {
+    hbox->add(StrutBox::create(minWidth - hbox->_width));
+  }
+
+  return hbox;
+}

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

@@ -0,0 +1,37 @@
+#ifndef MICROTEX_ATOM_ZSTACK_H
+#define MICROTEX_ATOM_ZSTACK_H
+
+#include "atom/atom.h"
+#include "env/units.h"
+#include "utils/utils.h"
+
+namespace microtex {
+
+struct ZStackArgs {
+  Alignment align;
+  Dimen offset;
+};
+
+class ZStackAtom : public Atom {
+private:
+  ZStackArgs _hargs, _vargs;
+  sptr<Atom> _atom, _anchor;
+
+public:
+  ZStackAtom(
+    const ZStackArgs& hargs,
+    const ZStackArgs& vargs,
+    const sptr<Atom>& atom,
+    const sptr<Atom>& anchor
+  );
+
+  AtomType leftType() const override { return _anchor->leftType(); }
+
+  AtomType rightType() const override { return _anchor->rightType(); }
+
+  sptr<Box> createBox(Env& env) override;
+};
+
+}  // namespace microtex
+
+#endif  // MICROTEX_ATOM_ZSTACK_H

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

@@ -0,0 +1,157 @@
+#include "atom_basic.h"
+#include "utils/string_utils.h"
+
+#define c(name, c, m, y, k) \
+  { name, cmyk(c, m, y, k) }
+
+using namespace std;
+using namespace microtex;
+
+map<string, microtex::color> microtex::ColorAtom::_colors{
+  {"black",   black  },
+  {"white",   white  },
+  {"red",     red    },
+  {"green",   green  },
+  {"blue",    blue   },
+  {"cyan",    cyan   },
+  {"magenta", magenta},
+  {"yellow",  yellow },
+  c("greenyellow", 0.15f, 0.f, 0.69f, 0.f),
+  c("goldenrod", 0.f, 0.10f, 0.84f, 0.f),
+  c("dandelion", 0.f, 0.29f, 0.84f, 0.f),
+  c("apricot", 0.f, 0.32f, 0.52f, 0.f),
+  c("peach", 0.f, 0.50f, 0.70f, 0.f),
+  c("melon", 0.f, 0.46f, 0.50f, 0.f),
+  c("yelloworange", 0.f, 0.42f, 1.f, 0.f),
+  c("orange", 0.f, 0.61f, 0.87f, 0.f),
+  c("burntorange", 0.f, 0.51f, 1.f, 0.f),
+  c("bittersweet", 0.f, 0.75f, 1.f, 0.24f),
+  c("redorange", 0.f, 0.77f, 0.87f, 0.f),
+  c("mahogany", 0.f, 0.85f, 0.87f, 0.35f),
+  c("maroon", 0.f, 0.87f, 0.68f, 0.32f),
+  c("brickred", 0.f, 0.89f, 0.94f, 0.28f),
+  c("orangered", 0.f, 1.f, 0.50f, 0.f),
+  c("rubinered", 0.f, 1.f, 0.13f, 0.f),
+  c("wildstrawberry", 0.f, 0.96f, 0.39f, 0.f),
+  c("salmon", 0.f, 0.53f, 0.38f, 0.f),
+  c("carnationpink", 0.f, 0.63f, 0.f, 0.f),
+  c("magenta", 0.f, 1.f, 0.f, 0.f),
+  c("violetred", 0.f, 0.81f, 0.f, 0.f),
+  c("rhodamine", 0.f, 0.82f, 0.f, 0.f),
+  c("mulberry", 0.34f, 0.90f, 0.f, 0.02f),
+  c("redviolet", 0.07f, 0.90f, 0.f, 0.34f),
+  c("fuchsia", 0.47f, 0.91f, 0.f, 0.08f),
+  c("lavender", 0.f, 0.48f, 0.f, 0.f),
+  c("thistle", 0.12f, 0.59f, 0.f, 0.f),
+  c("orchid", 0.32f, 0.64f, 0.f, 0.f),
+  c("darkorchid", 0.40f, 0.80f, 0.20f, 0.f),
+  c("purple", 0.45f, 0.86f, 0.f, 0.f),
+  c("plum", 0.50f, 1.f, 0.f, 0.f),
+  c("violet", 0.79f, 0.88f, 0.f, 0.f),
+  c("royalpurple", 0.75f, 0.90f, 0.f, 0.f),
+  c("blueviolet", 0.86f, 0.91f, 0.f, 0.04f),
+  c("periwinkle", 0.57f, 0.55f, 0.f, 0.f),
+  c("cadetblue", 0.62f, 0.57f, 0.23f, 0.f),
+  c("cornflowerblue", 0.65f, 0.13f, 0.f, 0.f),
+  c("midnightblue", 0.98f, 0.13f, 0.f, 0.43f),
+  c("navyblue", 0.94f, 0.54f, 0.f, 0.f),
+  c("royalblue", 1.f, 0.50f, 0.f, 0.f),
+  c("cerulean", 0.94f, 0.11f, 0.f, 0.f),
+  c("processblue", 0.96f, 0.f, 0.f, 0.f),
+  c("skyblue", 0.62f, 0.f, 0.12f, 0.f),
+  c("turquoise", 0.85f, 0.f, 0.20f, 0.f),
+  c("tealblue", 0.86f, 0.f, 0.34f, 0.02f),
+  c("aquamarine", 0.82f, 0.f, 0.30f, 0.f),
+  c("bluegreen", 0.85f, 0.f, 0.33f, 0.f),
+  c("emerald", 1.f, 0.f, 0.50f, 0.f),
+  c("junglegreen", 0.99f, 0.f, 0.52f, 0.f),
+  c("seagreen", 0.69f, 0.f, 0.50f, 0.f),
+  c("forestgreen", 0.91f, 0.f, 0.88f, 0.12f),
+  c("pinegreen", 0.92f, 0.f, 0.59f, 0.25f),
+  c("limegreen", 0.50f, 0.f, 1.f, 0.f),
+  c("yellowgreen", 0.44f, 0.f, 0.74f, 0.f),
+  c("springgreen", 0.26f, 0.f, 0.76f, 0.f),
+  c("olivegreen", 0.64f, 0.f, 0.95f, 0.40f),
+  c("rawsienna", 0.f, 0.72f, 1.f, 0.45f),
+  c("sepia", 0.f, 0.83f, 1.f, 0.70f),
+  c("brown", 0.f, 0.81f, 1.f, 0.60f),
+  c("tan", 0.14f, 0.42f, 0.56f, 0.f),
+  c("gray", 0.f, 0.f, 0.f, 0.50f),
+};
+
+color ColorAtom::getColor(std::string name) {
+  if (name.empty()) return _default;
+  trim(name);
+
+  // #AARRGGBB formatted color
+  if (name[0] == '#') return decodeColor(name);
+  if (name.find(',') == string::npos) {
+    // find from predefined colors
+    auto it = _colors.find(toLower(name));
+    if (it != _colors.end()) return it->second;
+    // AARRGGBB formatted color
+    if (name.find('.') == string::npos) return decodeColor("#" + name);
+    // gray color
+    float x = 0.f;
+    valueOf(name, x);
+    if (x != 0.f) {
+      float g = min(1.f, max(x, 0.f));
+      return rgb(g, g, g);
+    }
+    return _default;
+  }
+
+  auto en = string::npos;
+  StrTokenizer toks(name, ";,");
+  int n = toks.count();
+  if (n == 3) {
+    // RGB model
+    string R = toks.next();
+    string G = toks.next();
+    string B = toks.next();
+
+    float r = 0.f, g = 0.f, b = 0.f;
+    valueOf(trim(R), r);
+    valueOf(trim(G), g);
+    valueOf(trim(B), b);
+
+    if (r == 0.f && g == 0.f && b == 0.f) return _default;
+
+    // clang-format off
+    if (r == (int) r && g == (int) g && b == (int) b &&
+        R.find('.') == en && G.find('.') == en && B.find('.') == en
+    ) {
+      // clang-format on
+      int ir = (int)min(255.f, max(0.f, r));
+      int ig = (int)min(255.f, max(0.f, g));
+      int ib = (int)min(255.f, max(0.f, b));
+      return rgb(ir, ig, ib);
+    }
+    r = min(1.f, max(0.f, r));
+    g = min(1.f, max(0.f, g));
+    b = min(1.f, max(0.f, b));
+    return rgb(r, g, b);
+  } else if (n == 4) {
+    // CMYK model
+    float c = 0.f, m = 0.f, y = 0.f, k = 0.f;
+    string C = toks.next();
+    string M = toks.next();
+    string Y = toks.next();
+    string K = toks.next();
+    valueOf(trim(C), c);
+    valueOf(trim(M), m);
+    valueOf(trim(Y), y);
+    valueOf(trim(K), k);
+
+    if (c == 0.f && m == 0.f && y == 0.f && k == 0.f) return _default;
+
+    c = min(1.f, max(0.f, c));
+    m = min(1.f, max(0.f, m));
+    y = min(1.f, max(0.f, y));
+    k = min(1.f, max(0.f, k));
+
+    return cmyk(c, m, y, k);
+  }
+
+  return _default;
+}

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

@@ -0,0 +1,50 @@
+atom_src = [
+	'atom/atom.cpp',
+	'atom/atom_accent.cpp',
+    'atom/atom_basic.cpp',
+    'atom/atom_box.cpp',
+    'atom/atom_char.cpp',
+    'atom/atom_delim.cpp',
+    'atom/atom_fence.cpp',
+    'atom/atom_font.cpp',
+    'atom/atom_frac.cpp',
+    'atom/atom_matrix.cpp',
+    'atom/atom_misc.cpp',
+    'atom/atom_operator.cpp',
+    'atom/atom_root.cpp',
+    'atom/atom_row.cpp',
+    'atom/atom_scripts.cpp',
+    'atom/atom_sideset.cpp',
+    'atom/atom_space.cpp',
+    'atom/atom_stack.cpp',
+    'atom/atom_text.cpp',
+    'atom/atom_vrow.cpp',
+    'atom/atom_zstack.cpp',
+    'atom/colors_def.cpp'
+]
+
+if install_headerfiles
+	install_headers([
+		'atom_accent.h',
+        'atom_basic.h',
+        'atom_box.h',
+        'atom_char.h',
+        'atom_delim.h',
+        'atom_fence.h',
+        'atom_font.h',
+        'atom_frac.h',
+        'atom.h',
+        'atom_matrix.h',
+        'atom_misc.h',
+        'atom_operator.h',
+        'atom_root.h',
+        'atom_row.h',
+        'atom_scripts.h',
+        'atom_sideset.h',
+        'atom_space.h',
+        'atom_stack.h',
+        'atom_text.h',
+        'atom_vrow.h',
+        'atom_zstack.h'
+	], subdir: 'microtex/atom')
+endif

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

@@ -0,0 +1,49 @@
+#include "box/box.h"
+
+#include "unimath/uni_font.h"
+
+using namespace microtex;
+using namespace std;
+
+void Box::copyMetrics(const sptr<Box>& box) {
+  _width = box->_width;
+  _height = box->_height;
+  _depth = box->_depth;
+  _shift = box->_shift;
+}
+
+int Box::lastFontId() {
+  return FontContext::NO_FONT;
+}
+
+void Box::replaceFirst(const sptr<Box>& from, const sptr<Box>& to) {
+  // nothing to do
+}
+
+std::string Box::name() const {
+  return "Box";
+}
+
+std::string Box::toString() const {
+  return "";
+}
+
+void BoxGroup::add(const sptr<Box>& box) {
+  _children.push_back(box);
+}
+
+void BoxGroup::add(int pos, const sptr<Box>& box) {
+  _children.insert(_children.begin() + pos, box);
+}
+
+int BoxGroup::lastFontId() {
+  int id = FontContext::NO_FONT;
+  for (int i = _children.size() - 1; i >= 0 && id == FontContext::NO_FONT; i--) {
+    id = _children[i]->lastFontId();
+  }
+  return id;
+}
+
+int DecorBox::lastFontId() {
+  return _base->lastFontId();
+}

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

@@ -0,0 +1,184 @@
+#ifndef MICROTEX_BOX_H
+#define MICROTEX_BOX_H
+
+#include <string>
+#include <vector>
+
+#include "utils/types.h"
+
+namespace microtex {
+
+class Graphics2D;
+
+/**
+ * An abstract graphical representation of a formula, that can be painted. All
+ * characters, font sizes, positions are fixed. Only special Glue boxes could
+ * possibly stretch or shrink (not supported by now). A box has 3 dimensions
+ * (width, height and depth), will be used for further layout calculations.
+ * <p>
+ * Subclasses must implement the abstract
+ * Box#draw(Graphics2D, float, float) method (that paints the box).
+ * <p>
+ * They must also implement the abstract Box#lastFontId() method (the last font
+ * that will be used later when this box will be painted).
+ */
+class Box {
+protected:
+  /** Initialize box with default options */
+  void init() {
+    _width = _height = _depth = _shift = 0;
+    _type = AtomType::none;
+  }
+
+public:
+  /**
+   * The width of this box, i.e. the value that will be used for further
+   * calculations.
+   */
+  float _width = 0;
+
+  /**
+   * The height of this box, i.e. the value that will be used for further
+   * calculations.
+   */
+  float _height = 0;
+
+  /**
+   * The depth of this box, i.e. the value that will be used for further
+   * calculations.
+   */
+  float _depth = 0;
+
+  /**
+   * The shift amount: the meaning depends on the particular kind of box (up,
+   * down, left, right)
+   */
+  float _shift = 0;
+
+  /** The box type (default = none, no type) */
+  AtomType _type = AtomType::none;
+
+  /** Create a new box with default options */
+  Box() { init(); }
+
+  /** Copy the metrics from another box */
+  void copyMetrics(const sptr<Box>& box);
+
+  /** Transform the width of box to negative */
+  inline void negWidth() { _width = -_width; }
+
+  /** The length in vertical direction, basically equals to #_height + #_depth */
+  inline float vlen() const { return _height + _depth; }
+
+  /**
+   * Paints this box at the given coordinates using the given 2D graphics
+   * context.
+   *
+   * @param g2 the graphics (2D) context to use for painting
+   * @param x the x-coordinate
+   * @param y the y-coordinate
+   */
+  virtual void draw(Graphics2D& g2, float x, float y) = 0;
+
+  /**
+   * Get the id of the last font that will be used later when this box is to be
+   * painted.
+   *
+   * @return the id of the last font that will be used later.
+   */
+  virtual int lastFontId();
+
+  /** Get child boxes of this box. */
+  virtual std::vector<sptr<Box>> descendants() const { return {}; }
+
+  /** Replace child box */
+  virtual void replaceFirst(const sptr<Box>& from, const sptr<Box>& to);
+
+  /** Test if this box represents a space that only has metrics and has no visual effect. */
+  virtual bool isSpace() const { return false; }
+
+  /** Test if this box is a single box */
+  virtual bool isSingle() const { return true; }
+
+  /** The box name */
+  virtual std::string name() const;
+
+  /** String to print this box */
+  virtual std::string toString() const;
+
+  virtual ~Box() = default;
+
+#ifndef boxname
+#define boxname(x) \
+  virtual std::string name() const override { return #x; }
+#endif
+};
+
+/**
+ * A box composed of other child boxes that can possibly be shifted (up, down,
+ * left of right). Child boxes can also be positioned outside their parent's box
+ * (defined by it's dimensions).
+ */
+class BoxGroup : public Box {
+public:
+  /** Children of this box */
+  std::vector<sptr<Box>> _children{};
+
+  /**
+   * Append the given box to the end of the list of the child boxes.
+   *
+   * @param box the box to be append
+   */
+  virtual void add(const sptr<Box>& box);
+
+  /**
+   * Inserts the given box at the given position in the list of child boxes.
+   *
+   * @param pos the position at which to insert the given box
+   * @param box the box to be inserted
+   */
+  virtual void add(int pos, const sptr<Box>& box);
+
+  /**
+   * Append the given box to the end of the list of the child boxes,
+   * and the given box will not participate in the metrics calculation
+   * of this composed box.
+   * <p>
+   * You shall not use this method to compose child boxes, it is for
+   * special uses (for add debug information).
+   *
+   * @param box the box to be append
+   */
+  void addOnly(const sptr<Box>& box) { _children.push_back(box); }
+
+  /** Child count of this box */
+  inline int size() const { return _children.size(); }
+
+  bool isSingle() const override { return false; }
+
+  std::vector<sptr<Box>> descendants() const override { return _children; }
+
+  int lastFontId() override;
+};
+
+/**
+ * A box contains another box that will add some decorations when to draw
+ * <p>
+ * e.g. rotation, scale and so on
+ */
+class DecorBox : public Box {
+public:
+  sptr<Box> _base;
+
+  explicit DecorBox(const sptr<Box>& base) : _base(base) {}
+
+  bool isSingle() const override { return false; }
+
+  int lastFontId() override;
+
+  std::vector<sptr<Box>> descendants() const override { return {_base}; }
+};
+
+}  // namespace microtex
+
+#endif  // MICROTEX_BOX_H