@simonklee/opentui-tex-native-source 0.2.0

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

@@ -0,0 +1,285 @@
+#ifndef MICROTEX_BOX_GROUP_H
+#define MICROTEX_BOX_GROUP_H
+
+#include "atom/atom.h"
+#include "graphic/graphic_basic.h"
+#include "utils/nums.h"
+
+namespace microtex {
+
+/***************************************************************************************************
+ *                                        rule boxes                                               *
+ ***************************************************************************************************/
+
+/** A box composed of a horizontal row of child boxes */
+class HBox : public BoxGroup {
+private:
+  void recalculate(const Box& box);
+
+  std::pair<sptr<HBox>, sptr<HBox>> split(int pos, int shift);
+
+public:
+  std::vector<int> _breakPositions;
+
+  HBox() = default;
+
+  /** Create a horizontal box with alignment */
+  HBox(const sptr<Box>& box, float width, Alignment alignment);
+
+  /** Create a horizontal box that child box aligned at center with bias */
+  HBox(const sptr<Box>& box, float width, float bias);
+
+  explicit HBox(const sptr<Box>& box);
+
+  sptr<HBox> cloneBox();
+
+  void add(const sptr<Box>& box) override;
+
+  void add(int pos, const sptr<Box>& box) override;
+
+  void replaceFirst(const sptr<Box>& from, const sptr<Box>& to) override;
+
+  inline void addBreakPosition(int pos) { _breakPositions.push_back(pos); }
+
+  std::pair<sptr<HBox>, sptr<HBox>> split(int pos) { return split(pos, 1); }
+
+  std::pair<sptr<HBox>, sptr<HBox>> splitRemove(int pos) { return split(pos, 2); }
+
+  void draw(Graphics2D& g2, float x, float y) override;
+
+  boxname(HBox);
+};
+
+/** A box composed of other boxes, put one above the other */
+class VBox : public BoxGroup {
+private:
+  float _leftMostPos, _rightMostPos;
+
+  void recalculateWidth(const Box& box);
+
+public:
+  VBox() : _leftMostPos(F_MAX), _rightMostPos(F_MIN) {}
+
+  VBox(const sptr<Box>& box, float rest, Alignment alignment);
+
+  inline float leftMostPos() const { return _leftMostPos; }
+
+  void add(const sptr<Box>& box) override;
+
+  void add(const sptr<Box>& box, float interline);
+
+  void add(int pos, const sptr<Box>& box) override;
+
+  void draw(Graphics2D& g2, float x, float y) override;
+
+  boxname(VBox);
+};
+
+/***************************************************************************************************
+ *                                   operation boxes                                               *
+ ***************************************************************************************************/
+
+class ColorBox : public DecorBox {
+private:
+  color _foreground = transparent;
+  color _background = transparent;
+
+public:
+  ColorBox() = delete;
+
+  explicit ColorBox(const sptr<Box>& box, color fg = transparent, color bg = transparent);
+
+  void draw(Graphics2D& g2, float x, float y) override;
+
+  boxname(ColorBox);
+};
+
+/** A box representing a scale operation */
+class ScaleBox : public DecorBox {
+private:
+  float _sx = 1, _sy = 1;
+
+  void init(const sptr<Box>& b, float sx, float sy);
+
+public:
+  ScaleBox() = delete;
+
+  ScaleBox(const sptr<Box>& b, float sx, float sy) : DecorBox(b) { init(b, sx, sy); }
+
+  ScaleBox(const sptr<Box>& b, float factor) : DecorBox(b) { init(b, factor, factor); }
+
+  void draw(Graphics2D& g2, float x, float y) override;
+
+  boxname(ScaleBox);
+};
+
+/** A box representing a reflected box */
+class ReflectBox : public DecorBox {
+public:
+  ReflectBox() = delete;
+
+  explicit ReflectBox(const sptr<Box>& b);
+
+  void draw(Graphics2D& g2, float x, float y) override;
+
+  boxname(ReflectBox);
+};
+
+/** Enumeration representing rotation origin */
+enum class Rotation {
+  bl,  // Bottom Left
+  bc,  // Bottom Center
+  br,  // Bottom Right
+  tl,  // Top Left
+  tc,  // Top Center
+  tr,  // Top Right
+  Bl,  // Baseline Left
+  Br,  // Baseline Right
+  Bc,  // Baseline Center
+  cl,  // Center Left
+  cc,  // Center Center
+  cr,  // Center Right
+  none = -1
+};
+
+/** A box representing a rotate operation */
+class RotateBox : public DecorBox {
+private:
+  float _angle = 0;
+  float _xmax = 0, _xmin = 0, _ymax = 0, _ymin = 0;
+  float _shiftX = 0, _shiftY = 0;
+
+  void init(const sptr<Box>& b, float angle, float x, float y);
+
+  static Point calculateShift(const Box& b, Rotation option);
+
+public:
+  RotateBox() = delete;
+
+  RotateBox(const sptr<Box>& b, float angle, float x, float y) : DecorBox(b) {
+    init(b, angle, x, y);
+  }
+
+  RotateBox(const sptr<Box>& b, float angle, const Point& origin) : DecorBox(b) {
+    init(b, angle, origin.x, origin.y);
+  }
+
+  RotateBox(const sptr<Box>& b, float angle, Rotation option) : DecorBox(b) {
+    const Point& p = calculateShift(*b, option);
+    init(b, angle, p.x, p.y);
+  }
+
+  void draw(Graphics2D& g2, float x, float y) override;
+
+  boxname(RotateBox);
+
+  static Rotation getOrigin(std::string option);
+};
+
+/***************************************************************************************************
+ *                                  wrapped boxes                                                  *
+ ***************************************************************************************************/
+
+/** A box representing a wrapped box by square frame */
+class FramedBox : public DecorBox {
+public:
+  float _thickness = 1;
+  float _space = 0;
+  color _line = transparent;
+  color _bg = transparent;
+
+  void init(const sptr<Box>& box, float thickness, float space);
+
+public:
+  FramedBox() = delete;
+
+  FramedBox(const sptr<Box>& box, float thickness, float space) : DecorBox(box) {
+    init(box, thickness, space);
+  }
+
+  FramedBox(const sptr<Box>& box, float thickness, float space, color line, color bg)
+      : DecorBox(box) {
+    init(box, thickness, space);
+    _line = line;
+    _bg = bg;
+  }
+
+  void draw(Graphics2D& g2, float x, float y) override;
+
+  boxname(FramedBox);
+};
+
+/** A box representing a wrapped box by oval frame */
+class OvalBox : public FramedBox {
+private:
+  float _multiplier, _diameter;
+
+public:
+  OvalBox() = delete;
+
+  explicit OvalBox(const sptr<FramedBox>& fbox, float multiplier = 0.5f, float diameter = 0.f)
+      : FramedBox(fbox->_base, fbox->_thickness, fbox->_space),
+        _multiplier(multiplier),
+        _diameter(diameter) {}
+
+  void draw(Graphics2D& g2, float x, float y) override;
+
+  boxname(OvalBox);
+};
+
+/** A box representing a wrapped box by shadowed frame */
+class ShadowBox : public FramedBox {
+private:
+  float _shadowRule;
+
+public:
+  ShadowBox() = delete;
+
+  ShadowBox(const sptr<FramedBox>& fbox, float shadowRule)
+      : FramedBox(fbox->_base, fbox->_thickness, fbox->_space) {
+    _shadowRule = shadowRule;
+    _depth += shadowRule;
+    _width += shadowRule;
+  }
+
+  void draw(Graphics2D& g2, float x, float y) override;
+
+  boxname(ShadowBox);
+};
+
+/** A box representing 'wrapper' that with insets in left, top, right and bottom */
+class WrapperBox : public DecorBox {
+private:
+  float _l;
+  color _fg = 0, _bg = 0;
+
+public:
+  WrapperBox() = delete;
+
+  WrapperBox(const sptr<Box>& base, float width, float rowheight, float rowdepth, Alignment align)
+      : DecorBox(base), _l(0) {
+    _height = rowheight;
+    _depth = rowdepth;
+    _width = width;
+    if (base->_width < 0) _width += base->_width;
+    if (align == Alignment::right) {
+      _l = width - _base->_width;
+    } else if (align == Alignment::center) {
+      _l = (width - _base->_width) / 2.f;
+    }
+  }
+
+  inline void setForeground(color fg) { _fg = fg; }
+
+  inline void setBackground(color bg) { _bg = bg; }
+
+  void addInsets(float l, float t, float r, float b);
+
+  void draw(Graphics2D& g2, float x, float y) override;
+
+  boxname(WrapperBox);
+};
+
+}  // namespace microtex
+
+#endif  // MICROTEX_BOX_GROUP_H

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

@@ -0,0 +1,179 @@
+#include "box_single.h"
+
+#include "core/debug_config.h"
+#include "env/env.h"
+#include "microtex.h"
+#include "utils/exceptions.h"
+#include "utils/log.h"
+#include "utils/utf.h"
+
+using namespace std;
+using namespace microtex;
+
+CharBox::CharBox(const Char& chr) : _chr(chr) {
+  _width = chr.width();
+  _height = chr.height();
+  _depth = chr.depth();
+}
+
+namespace microtex {
+
+#ifdef HAVE_GLYPH_RENDER_TYPEFACE
+
+void _drawWithFont(const Char& chr, Graphics2D& g2, float x, float y) {
+  auto factory = PlatformFactory::get();
+  const auto font = factory->createFont(chr.otfFont()->fontFile);
+  g2.setFont(font);
+  g2.setFontSize(Env::fixedTextSize() * chr.scale);
+  if (chr.isValid()) {
+    g2.drawGlyph(chr.glyphId, x, y);
+    return;
+  }
+  const auto old = g2.getColor();
+  g2.setColor(red);
+  g2.drawGlyph(chr.fallbackGlyphId(), x, y);
+  g2.setColor(old);
+}
+
+#endif
+
+#ifdef HAVE_GLYPH_RENDER_PATH
+
+void _drawWithPath(const Char& chr, Graphics2D& g2, float x, float y) {
+  const auto old = g2.getColor();
+  if (!chr.isValid()) g2.setColor(red);
+  const auto scale = chr.scale;
+  g2.translate(x, y);
+  if (scale != 1.f) g2.scale(scale, scale);
+  chr.glyph()->path().draw(g2);
+  if (scale != 1.f) g2.scale(1 / scale, 1 / scale);
+  g2.translate(-x, -y);
+  if (!chr.isValid()) g2.setColor(old);
+}
+
+#endif
+}  // namespace microtex
+
+void CharBox::draw(Graphics2D& g2, float x, float y) {
+#if GLYPH_RENDER_TYPE == GLYPH_RENDER_TYPE_PATH
+  _drawWithPath(_chr, g2, x, y);
+#elif GLYPH_RENDER_TYPE == GLYPH_RENDER_TYPE_TYPEFACE
+  _drawWithFont(_chr, g2, x, y);
+#elif GLYPH_RENDER_TYPE == GLYPH_RENDER_TYPE_BOTH
+  auto font = _chr.otfFont();
+  const bool hasGlyphPath = font != nullptr && font->otf().hasGlyphPath();
+#ifdef HAVE_LOG
+  if (MicroTeX::isRenderGlyphUsePath() && !hasGlyphPath) {
+    logv(
+      "Render use glyph path, but the font '%s' does not have glyph paths, "
+      "fallback to use font instead.\n",
+      font->otf().name().c_str()
+    );
+  }
+#endif
+  if (MicroTeX::isRenderGlyphUsePath() && hasGlyphPath) {
+    _drawWithPath(_chr, g2, x, y);
+  } else {
+    _drawWithFont(_chr, g2, x, y);
+  }
+#endif
+}
+
+int CharBox::lastFontId() {
+  return _chr.fontId;
+}
+
+std::string CharBox::toString() const {
+  std::string str;
+  appendToUtf8(str, _chr.mappedCode);
+  return str + " scale: " + std::to_string(_chr.scale);
+}
+
+TextBox::TextBox(const std::string& str, FontStyle style, float size) {
+  auto factory = PlatformFactory::get();
+  _layout = factory->createTextLayout(str, style, size);
+  Rect rect;
+  _layout->getBounds(rect);
+  _height = -rect.y;
+  _depth = rect.h - _height;
+  _width = rect.w + rect.x;
+}
+
+void TextBox::draw(Graphics2D& g2, float x, float y) {
+  g2.translate(x, y);
+  _layout->draw(g2, 0, 0);
+  g2.translate(-x, -y);
+}
+
+LineBox::LineBox(const vector<float>& lines, float thickness) {
+  _thickness = thickness;
+  if (lines.size() % 4 != 0) throw ex_invalid_param("The vector not represent lines.");
+  _lines = lines;
+}
+
+void LineBox::draw(Graphics2D& g2, float x, float y) {
+  const auto oldStroke = g2.getStroke();
+  auto stroke = Stroke(_thickness, CAP_ROUND, JOIN_ROUND);
+  g2.setStroke(stroke);
+  g2.translate(0, -_height);
+  int count = _lines.size() / 4;
+  for (int i = 0; i < count; i++) {
+    int j = i * 4;
+    float x1 = _lines[j] + x, y1 = _lines[j + 1] + y;
+    float x2 = _lines[j + 2] + x, y2 = _lines[j + 3] + y;
+    g2.drawLine(x1, y1, x2, y2);
+  }
+  g2.translate(0, _height);
+  g2.setStroke(oldStroke);
+}
+
+RuleBox::RuleBox(float thickness, float width, float shift, color c, bool trueshift)
+    : _color(c), _speShift(0) {
+  _height = thickness;
+  _width = width;
+  if (trueshift) {
+    _shift = shift;
+  } else {
+    _shift = 0;
+    _speShift = shift;
+  }
+}
+
+void RuleBox::draw(Graphics2D& g2, float x, float y) {
+  const color oldColor = g2.getColor();
+  if (!isTransparent(_color)) g2.setColor(_color);
+  const Stroke oldStroke = g2.getStroke();
+  g2.setStroke(Stroke(_height, CAP_BUTT, JOIN_BEVEL));
+  y = y - _height / 2.f - _speShift;
+  g2.drawLine(x, y, x + _width, y);
+  g2.setStroke(oldStroke);
+  g2.setColor(oldColor);
+}
+
+DebugBox::DebugBox(const sptr<Box>& base) {
+  copyMetrics(base);
+}
+
+void DebugBox::draw(Graphics2D& g2, float x, float y) {
+  const auto& config = DebugConfig::INSTANCE;
+
+  const color prevColor = g2.getColor();
+  const auto& prevStroke = g2.getStroke();
+
+  g2.setColor(config.boundColor);
+  g2.setStrokeWidth(std::abs(1.f / g2.sx()));
+
+  // draw box
+  g2.drawRect(x, y - _height, _width, _height + _depth);
+  // draw baseline
+  if (_depth > PREC) {
+    const auto& prevDash = g2.getDash();
+    g2.setColor(config.baselineColor);
+    g2.setDash({std::abs(5 / g2.sx()), std::abs(5 / g2.sx())});
+    g2.drawLine(x, y, x + _width, y);
+    g2.setDash(prevDash);
+  }
+
+  g2.setColor(prevColor);
+  g2.setStroke(prevStroke);
+}

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

@@ -0,0 +1,157 @@
+#ifndef MICROTEX_BOX_SINGLE_H
+#define MICROTEX_BOX_SINGLE_H
+
+#include "atom/atom.h"
+#include "graphic/font_style.h"
+#include "graphic/graphic_basic.h"
+#include "unimath/uni_char.h"
+
+namespace microtex {
+
+class TextLayout;
+
+/** A box representing whitespace */
+class StrutBox : public Box {
+public:
+  StrutBox() = delete;
+
+  explicit StrutBox(const sptr<Box>& box) noexcept {
+    copyMetrics(box);
+    _shift = _shift;
+  }
+
+  StrutBox(float width, float height, float depth, float shift) noexcept {
+    _width = width;
+    _height = height;
+    _depth = depth;
+    _shift = shift;
+  }
+
+  void draw(Graphics2D& g2, float x, float y) override {
+    // no visual effect
+  }
+
+  bool isSpace() const override { return true; }
+
+  boxname(StrutBox);
+
+  static sptr<StrutBox> empty() noexcept { return sptrOf<StrutBox>(0.f, 0.f, 0.f, 0.f); }
+
+  static sptr<StrutBox> create(float width) noexcept {
+    return sptrOf<StrutBox>(width, 0.f, 0.f, 0.f);
+  }
+};
+
+/** A box representing glue */
+class GlueBox : public Box {
+public:
+  // Not used by now
+  float _stretch, _shrink;
+
+  GlueBox() = delete;
+
+  GlueBox(float space, float stretch, float shrink) {
+    _width = space;
+    _stretch = stretch;
+    _shrink = shrink;
+  }
+
+  void draw(Graphics2D& g2, float x, float y) override {
+    // no visual effect
+  }
+
+  bool isSpace() const override { return true; }
+
+  boxname(GlueBox);
+};
+
+/** A box representing a single character */
+class CharBox : public Box {
+private:
+  Char _chr;
+
+public:
+  CharBox() = delete;
+
+  /**
+   * Create a new CharBox that will represent the character defined by the
+   * given Char-object.
+   *
+   * @param chr a Char-object containing the character's font information.
+   */
+  explicit CharBox(const Char& chr);
+
+  inline float italic() const { return _chr.italic(); }
+
+  void draw(Graphics2D& g2, float x, float y) override;
+
+  int lastFontId() override;
+
+  std::string toString() const override;
+
+  boxname(CharBox);
+};
+
+/**
+ * Box to draw text. The metrics measurement and drawing is
+ * delegated to rendering backend.
+ */
+class TextBox : public Box {
+private:
+  sptr<TextLayout> _layout;
+
+public:
+  TextBox() = delete;
+
+  TextBox(const std::string& str, FontStyle style, float size);
+
+  void draw(Graphics2D& g2, float x, float y) override;
+
+  boxname(TextBox);
+};
+
+/** Class represents several lines */
+class LineBox : public Box {
+private:
+  // Every 4 elements represent a line, thus (x1, y1, x2, y2)
+  std::vector<float> _lines;
+  float _thickness;
+
+public:
+  LineBox() = delete;
+
+  LineBox(const std::vector<float>& lines, float thickness);
+
+  void draw(Graphics2D& g2, float x, float y) override;
+
+  boxname(LineBox);
+};
+
+/** A box representing a line. */
+class RuleBox : public Box {
+private:
+  color _color;
+  float _speShift;
+
+public:
+  RuleBox() = delete;
+
+  RuleBox(float thickness, float width, float shift, color c = transparent, bool trueshift = true);
+
+  void draw(Graphics2D& g2, float x, float y) override;
+
+  boxname(RuleBox);
+};
+
+class DebugBox : public Box {
+public:
+  explicit DebugBox(const sptr<Box>& base);
+
+  void draw(Graphics2D& g2, float x, float y) override;
+
+  boxname(DebugBox);
+};
+
+}  // namespace microtex
+
+#endif  // MICROTEX_BOX_SINGLE_H

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

@@ -0,0 +1,15 @@
+box_src = [
+	'box/box.cpp',
+    'box/box_factory.cpp',
+    'box/box_group.cpp',
+    'box/box_single.cpp'
+]
+
+if install_headerfiles
+	install_headers([
+		'box_factory.h',
+        'box_group.h',
+        'box.h',
+        'box_single.h'
+	], subdir: 'microtex/box')
+endif

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

@@ -0,0 +1,3 @@
+#include "core/debug_config.h"
+
+microtex::DebugConfig microtex::DebugConfig::INSTANCE;

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

@@ -0,0 +1,24 @@
+#ifndef MICROTEX_DEBUG_CONFIG_H
+#define MICROTEX_DEBUG_CONFIG_H
+
+#include "graphic/graphic_basic.h"
+
+namespace microtex {
+
+/** The graphic debug configs */
+struct DebugConfig {
+  /** If enable debug mode */
+  bool enable = false;
+  /** If show only the char boxes */
+  bool showOnlyChar = true;
+  /** The box's bound rectangle color */
+  color boundColor = RED;
+  /** The box's baseline color */
+  color baselineColor = BLUE;
+
+  static DebugConfig INSTANCE;
+};
+
+}  // namespace microtex
+
+#endif