@simonklee/opentui-tex-native-source 0.2.0

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

@@ -0,0 +1,314 @@
+#ifndef GRAPHIC_H_INCLUDED
+#define GRAPHIC_H_INCLUDED
+
+#include <map>
+#include <vector>
+
+#include "graphic/font_style.h"
+#include "graphic/graphic_basic.h"
+
+namespace microtex {
+
+class Graphics2D;
+
+/** Interface to represents a font. */
+class Font {
+public:
+  /** Check if current font is equals to another */
+  virtual bool operator==(const Font& f) const = 0;
+
+  /** Check if current font is not equals to another */
+  inline bool operator!=(const Font& f) const { return !(*this == f); }
+
+  virtual ~Font() = default;
+};
+
+/** To layout the text that the program cannot recognize. */
+class TextLayout {
+public:
+  /**
+   * Get the layout bounds with current text and font
+   *
+   * @param bounds rectangle to retrieve the bounds. The metrics of the text layout
+   * is arranged by following ways:
+   *
+   * - [bounds.w] takes the width of the layout
+   * - [bounds.h] takes the height of the layout (ascent + descent)
+   * - [bounds.y] takes the ascent (distance above the baseline, in negative) of the
+   *   layout
+   */
+  virtual void getBounds(Rect& bounds) = 0;
+
+  /**
+   * Draw the layout
+   *
+   * @param g2 the graphics (2D) context
+   * @param x the x coordinate
+   * @param y the y coordinate, is baseline aligned
+   */
+  virtual void draw(Graphics2D& g2, float x, float y) = 0;
+
+  virtual ~TextLayout() = default;
+};
+
+struct PlatformFactoryData;
+
+/** Simple factory to create platform specific Font and TextLayout. */
+class MICROTEX_EXPORT PlatformFactory {
+private:
+  static PlatformFactoryData* _data;
+
+public:
+  virtual ~PlatformFactory() = default;
+
+  /**
+   * Create font from file. You may cache the loaded platform specific font
+   * to avoid repetitive loading.
+   *
+   * @param file the 'font file' doesn't have to be a real font file, it depends
+   * on the font source you given before. See [lib/unimath/font_src.h: FontSrc]
+   * for details.
+   */
+  virtual sptr<Font> createFont(const std::string& file) = 0;
+
+  /**
+   * Create a TextLayout with given text and font
+   *
+   * @param src the source text to layout and draw
+   * @param style the font style. Unlike the fonts the engine using internally,
+   * you are free to create the font you want based on the given style, the style
+   * is for reference, not a constraint.
+   * @param size the font size
+   */
+  virtual sptr<TextLayout>
+  createTextLayout(const std::string& src, FontStyle style, float size) = 0;
+
+  /** Register a factory */
+  static void registerFactory(const std::string& name, std::unique_ptr<PlatformFactory> factory);
+
+  /** Activate a factory */
+  static void activate(const std::string& name);
+
+  /** Get the current platform factory */
+  static PlatformFactory* get();
+};
+
+/**
+ * Abstract class to represents a graphics (2D) context, all the TeX drawing operations will on it.
+ * It must have scale, translation, and rotation support.
+ */
+class Graphics2D {
+public:
+  virtual ~Graphics2D() = default;
+
+  /**
+   * Set the color of the context
+   *
+   * @param c required color
+   */
+  virtual void setColor(color c) = 0;
+
+  /** Get the color of the context */
+  virtual color getColor() const = 0;
+
+  /** Set the stroke of the context */
+  virtual void setStroke(const Stroke& s) = 0;
+
+  /** Get the stroke of the context */
+  virtual const Stroke& getStroke() const = 0;
+
+  /** Set the stroke width of the context */
+  virtual void setStrokeWidth(float w) = 0;
+
+  /**
+   * Set the dash style to draw the lines.
+   * Each line can be drawn with a different pen dash. It defines the style of the line.
+   * The pattern is set by the dash array, which is an array of positive floating point values.
+   * They set the on and off parts of the dash pattern. We also specify the length of the array
+   * and the offset value. If the length is 0, the dashing is disabled. If it is 1, a symmetric
+   * pattern is assumed with alternating on and off portions of the size specified by the single
+   * value in dashes.
+   *
+   * @param dash the dash pattern
+   */
+  virtual void setDash(const std::vector<float>& dash) = 0;
+
+  /** Get the dash pattern to draw lines. */
+  virtual std::vector<float> getDash() = 0;
+
+  /** Get the current font */
+  virtual sptr<Font> getFont() const = 0;
+
+  /** Set the font of the context */
+  virtual void setFont(const sptr<Font>& font) = 0;
+
+  /** Get the font size */
+  virtual float getFontSize() const = 0;
+
+  /** Set font size */
+  virtual void setFontSize(float size) = 0;
+
+  /**
+   * Translate the context by dx, dy
+   *
+   * @param dx distance in x-direction to translate
+   * @param dy distance in y-direction to translate
+   */
+  virtual void translate(float dx, float dy) = 0;
+
+  /**
+   * Scale the context by sx, sy
+   *
+   * @param sx scale ratio in x-direction
+   * @param sy scale ratio in y-direction
+   */
+  virtual void scale(float sx, float sy) = 0;
+
+  /**
+   * Rotate the context with the given angle (in radian) and pivot (0, 0).
+   *
+   * @param angle angle (in radian) amount to rotate
+   */
+  virtual void rotate(float angle) = 0;
+
+  /**
+   * Rotate the context with the given angle (in radian) and pivot (px, py).
+   *
+   * @param angle angle (in radian) amount to rotate
+   * @param px pivot in x-direction
+   * @param py pivot in y-direction
+   */
+  virtual void rotate(float angle, float px, float py) = 0;
+
+  /** Reset transformations */
+  virtual void reset() = 0;
+
+  /**
+   * Get the scale ratio of the context in x-direction
+   *
+   * @return the scale in x-direction
+   */
+  virtual float sx() const = 0;
+
+  /**
+   * Get the scale ratio of the context in y-direction
+   *
+   * @return the scale in y-direction
+   */
+  virtual float sy() const = 0;
+
+  /**
+   * Draw glyph, is baseline aligned
+   *
+   * @param glyph glyph index in the current font
+   * @param x x-coordinate
+   * @param y y-coordinate, is baseline aligned
+   */
+  virtual void drawGlyph(u16 glyph, float x, float y) = 0;
+
+  // region path commands
+
+  /**
+   * Begin a new path. We promise every path begin with function [beginPath] and
+   * end with [fillPath]. You may cache the path via its id.
+   *
+   * @param id the path id, if id < 0 that means the path is not cacheable.
+   * @returns true if the path about to draw given by the id is exists, false otherwise.
+   * The id is for optimizing purpose, if the engine find the path is already exists, the
+   * following path drawing command will be ignored. If path caching is not supported,
+   * just return false.
+   */
+  virtual bool beginPath(i32 id) = 0;
+
+  /** Move to point (x, y). */
+  virtual void moveTo(float x, float y) = 0;
+
+  /** Add a line to path. */
+  virtual void lineTo(float x, float y) = 0;
+
+  /**
+   * Add a cubic Bezier spline to path, with control points (x1, y1), (x2, y2)
+   * and the final point (x3, y3).
+   */
+  virtual void cubicTo(float x1, float y1, float x2, float y2, float x3, float y3) = 0;
+
+  /**
+   * Add a quadratic Bezier spline to path, with control point (x1, y1) and the
+   * final point (x2, y2).
+   */
+  virtual void quadTo(float x1, float y1, float x2, float y2) = 0;
+
+  /** Close the path. */
+  virtual void closePath() = 0;
+
+  /**
+   * Fill the path with the given id.
+   *
+   * @param id the path id. If the path is not cacheable, it always is -1.
+   */
+  virtual void fillPath(i32 id) = 0;
+
+  // endregion
+
+  // region shape commands
+
+  /**
+   * Draw line
+   *
+   * @param x1 start point in x-direction
+   * @param y1 start point in y-direction
+   * @param x2 end point in x-direction
+   * @param y2 end point in y-direction
+   */
+  virtual void drawLine(float x1, float y1, float x2, float y2) = 0;
+
+  /**
+   * Draw rectangle
+   *
+   * @param x left position
+   * @param y top position
+   * @param w width
+   * @param h height
+   */
+  virtual void drawRect(float x, float y, float w, float h) = 0;
+
+  /**
+   * Fill rectangle
+   *
+   * @param x left position
+   * @param y top position
+   * @param w width
+   * @param h height
+   */
+  virtual void fillRect(float x, float y, float w, float h) = 0;
+
+  /**
+   * Draw round rectangle
+   *
+   * @param x left position
+   * @param y top position
+   * @param w width
+   * @param h height
+   * @param rx radius in x-direction
+   * @param ry radius in y-direction
+   */
+  virtual void drawRoundRect(float x, float y, float w, float h, float rx, float ry) = 0;
+
+  /**
+   * Fill round rectangle
+   *
+   * @param x left position
+   * @param y top position
+   * @param w width
+   * @param h height
+   * @param rx radius in x-direction
+   * @param ry radius in y-direction
+   */
+  virtual void fillRoundRect(float x, float y, float w, float h, float rx, float ry) = 0;
+
+  // endregion
+};
+
+}  // namespace microtex
+
+#endif  // GRAPHIC_H_INCLUDED

package/native/vendor/microtex/lib/graphic/graphic_basic.cpp

@@ -0,0 +1,44 @@
+#include "graphic/graphic_basic.h"
+
+#include "atom/atom_basic.h"
+#include "utils/string_utils.h"
+
+microtex::color microtex::decodeColor(const std::string& s) {
+  if (s[0] == '#') {
+    const std::string x = s.substr(1);
+    color c = black;
+    auto success = str2int(s.c_str() + 1, s.length() - 1, reinterpret_cast<int&>(c), 16);
+    if (!success) {
+      return black;
+    }
+    if (s.size() == 7) {
+      // set alpha value
+      c |= 0xff000000;
+    } else if (s.size() != 9) {
+      return black;
+    }
+    return c;
+  }
+  return black;
+}
+
+microtex::color microtex::getColor(const std::string& name) {
+  return ColorAtom::getColor(name);
+}
+
+bool microtex::Point::operator==(const Point& other) const {
+  return x == other.x && y == other.y;
+}
+
+bool microtex::Rect::operator==(const Rect& other) const {
+  return x == other.x && y == other.y && w == other.w && h == other.h;
+}
+
+// clang-format off
+bool microtex::Stroke::operator==(const Stroke& other) const {
+  return lineWidth == other.lineWidth
+         && miterLimit == other.miterLimit
+         && cap == other.cap
+         && join == other.join;
+}
+// clang-format on

package/native/vendor/microtex/lib/graphic/graphic_basic.h

@@ -0,0 +1,131 @@
+#ifndef GRAPHIC_BASIC_H_INCLUDED
+#define GRAPHIC_BASIC_H_INCLUDED
+
+#include <string>
+
+#include "microtexexport.h"
+#include "utils/types.h"
+
+namespace microtex {
+
+using color = std::uint32_t;
+
+static constexpr color transparent = 0x00000000;
+static constexpr color black = 0xff000000;
+static constexpr color white = 0xffffffff;
+static constexpr color red = 0xffff0000;
+static constexpr color green = 0xff00ff00;
+static constexpr color blue = 0xff0000ff;
+static constexpr color yellow = 0xffffff00;
+static constexpr color cyan = 0xff00ffff;
+static constexpr color magenta = 0xffff00ff;
+
+static constexpr color TRANSPARENT = transparent;
+static constexpr color BLACK = black;
+static constexpr color WHITE = white;
+static constexpr color RED = red;
+static constexpr color GREEN = green;
+static constexpr color BLUE = blue;
+static constexpr color YELLOW = yellow;
+static constexpr color CYAN = cyan;
+static constexpr color MAGENTA = magenta;
+
+/** Construct a 32 bit true color with its alpha, red, green and blue channel*/
+inline color MICROTEX_EXPORT argb(int a, int r, int g, int b) {
+  return (a << 24) | (r << 16) | (g << 8) | b;
+}
+
+inline color MICROTEX_EXPORT rgb(int r, int g, int b) {
+  return argb(0xff, r, g, b);
+}
+
+inline color MICROTEX_EXPORT argb(float a, float r, float g, float b) {
+  return argb((int)(a * 255), (int)(r * 255), (int)(g * 255), (int)(b * 255));
+}
+
+inline color MICROTEX_EXPORT rgb(float r, float g, float b) {
+  return argb(1.f, r, g, b);
+}
+
+inline color MICROTEX_EXPORT color_a(color c) {
+  return c >> 24;
+}
+
+inline color MICROTEX_EXPORT color_r(color c) {
+  return c >> 16 & 0x00ff;
+}
+
+inline color MICROTEX_EXPORT color_g(color c) {
+  return c >> 8 & 0x0000ff;
+}
+
+inline color MICROTEX_EXPORT color_b(color c) {
+  return c & 0x000000ff;
+}
+
+inline color MICROTEX_EXPORT cmyk(float c, float m, float y, float k) {
+  float kk = 1.f - k;
+  return rgb(kk * (1 - c), kk * (1 - m), kk * (1 - y));
+}
+
+/** Test if the given color is transparent */
+inline bool MICROTEX_EXPORT isTransparent(color c) {
+  return (c >> 24 == 0);
+}
+
+/** Convert #AARRGGBB or #RRGGBB formatted string into color. */
+color MICROTEX_EXPORT decodeColor(const std::string& s);
+
+/** Get a color from given name, return black if not found. */
+color MICROTEX_EXPORT getColor(const std::string& name);
+
+/** Represents a point in 2D plane */
+struct MICROTEX_EXPORT Point {
+  float x, y;
+
+  Point() : x(0), y(0) {}
+
+  Point(float x1, float y1) : x(x1), y(y1) {}
+
+  bool operator==(const Point& other) const;
+};
+
+struct MICROTEX_EXPORT Rect {
+  float x, y, w, h;
+
+  Rect() : x(0), y(0), w(0), h(0) {}
+
+  Rect(float x1, float y1, float w1, float h1) : x(x1), y(y1), w(w1), h(h1) {}
+
+  bool operator==(const Rect& other) const;
+};
+
+/** Stroke cap type */
+enum MICROTEX_EXPORT Cap { CAP_BUTT, CAP_ROUND, CAP_SQUARE };
+
+/** Stroke join type */
+enum MICROTEX_EXPORT Join { JOIN_BEVEL, JOIN_MITER, JOIN_ROUND };
+
+struct MICROTEX_EXPORT Stroke {
+  float lineWidth;
+  Cap cap;
+  Join join;
+  float miterLimit;
+
+  Stroke() : lineWidth(1.f), cap(CAP_ROUND), join(JOIN_ROUND), miterLimit(0) {}
+
+  Stroke(float w, Cap c, Join j, float ml = 0) : lineWidth(w), cap(c), join(j), miterLimit(ml) {}
+
+  bool operator==(const Stroke& other) const;
+
+  inline void set(float w, Cap c, Join j, float ml = 0) {
+    lineWidth = w;
+    cap = c;
+    join = j;
+    miterLimit = ml;
+  }
+};
+
+}  // namespace microtex
+
+#endif  // GRAPHIC_BASIC_H_INCLUDED

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

@@ -0,0 +1,13 @@
+graphic_src = [
+    'graphic/font_style.cpp',
+    'graphic/graphic.cpp',
+    'graphic/graphic_basic.cpp'
+]
+
+if install_headerfiles
+	install_headers([
+		'font_style.h',
+        'graphic_basic.h',
+        'graphic.h'
+	], subdir: 'microtex/graphic')
+endif

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

@@ -0,0 +1,143 @@
+#include "macro/macro.h"
+
+#include <string>
+
+#include "macro/macro_misc.h"
+
+using namespace std;
+using namespace microtex;
+
+bool NewCommandMacro::_errIfConflict = true;
+
+bool NewCommandMacro::isMacro(const string& name) {
+  auto it = _codes.find(name);
+  return (it != _codes.end());
+}
+
+void NewCommandMacro::checkNew(const string& name) {
+  if (_errIfConflict && isMacro(name))
+    throw ex_parse("Command " + name + " already exists! Use renewcommand instead!");
+}
+
+void NewCommandMacro::checkRenew(const string& name) {
+  if (NewCommandMacro::_errIfConflict && !isMacro(name))
+    throw ex_parse("Command " + name + " is no defined! Use newcommand instead!");
+}
+
+void NewCommandMacro::addNewCommand(const string& name, const string& code, int argc) {
+  checkNew(name);
+  _codes[name] = code;
+  MacroInfo::add(name, new InflationMacroInfo(_instance, argc));
+}
+
+void NewCommandMacro::addNewCommand(
+  const string& name,
+  const string& code,
+  int argc,
+  const string& def
+) {
+  checkNew(name);
+  _codes[name] = code;
+  _replacements[name] = def;
+  MacroInfo::add(name, new InflationMacroInfo(_instance, argc, 1));
+}
+
+void NewCommandMacro::addRenewCommand(const string& name, const string& code, int argc) {
+  checkRenew(name);
+  _codes[name] = code;
+  MacroInfo::add(name, new InflationMacroInfo(_instance, argc));
+}
+
+void NewCommandMacro::addRenewCommand(
+  const string& name,
+  const string& code,
+  int argc,
+  const string& def
+) {
+  checkRenew(name);
+  _codes[name] = code;
+  _replacements[name] = def;
+  MacroInfo::add(name, new InflationMacroInfo(_instance, argc, 1));
+}
+
+void NewCommandMacro::execute(Parser& tp, vector<string>& args) {
+  string code = _codes[args[0]];
+  string rep;
+  size_t argc = args.size() - 12;
+  int dec = 0;
+
+  auto it = _replacements.find(args[0]);
+
+  // FIXME
+  // Keep slash "\" and dollar "$" signs?
+  // Example:
+  //      \newcommand{\cmd}[2][\sqrt{e^x}]{ #2 - #1 }
+  // we want the optional argument "\sqrt{e^x}" keep the slash sign
+  if (!args[argc + 1].empty()) {
+    dec = 1;
+    // quotereplace(args[argc + 1], rep);
+    replaceAll(code, "#1", args[argc + 1]);
+  } else if (it != _replacements.end()) {
+    dec = 1;
+    // quotereplace(it->second, rep);
+    replaceAll(code, "#1", it->second);
+  }
+
+  for (int i = 1; i <= argc; i++) {
+    rep = args[i];
+    replaceAll(code, "#" + toString(i + dec), rep);
+  }
+  // push back as returned value (inflated macro)
+  args.push_back(code);
+}
+
+void NewEnvironmentMacro::addNewEnvironment(
+  const string& name,
+  const string& begDef,
+  const string& endDef,
+  int argc
+) {
+  string n = name + "@env";
+  string def = begDef + " #" + toString(argc + 1) + " " + endDef;
+  addNewCommand(n, def, argc + 1);
+}
+
+void NewEnvironmentMacro::addRenewEnvironment(
+  const string& name,
+  const string& begDef,
+  const string& endDef,
+  int argc
+) {
+  if (_codes.find(name + "@env") == _codes.end()) {
+    throw ex_parse("Environment " + name + "is not defined! Use newenvironment instead!");
+  }
+  addRenewCommand(name + "@env", begDef + " #" + toString(argc + 1) + " " + endDef, argc + 1);
+}
+
+void NewCommandMacro::_free_() {
+  delete _instance;
+}
+
+void MacroInfo::add(const string& name, MacroInfo* mac) {
+  auto it = _commands.find(name);
+  if (it != _commands.end()) delete it->second;
+  _commands[name] = mac;
+}
+
+MacroInfo* MacroInfo::get(const std::string& name) {
+  auto it = _commands.find(name);
+  if (it == _commands.end()) return nullptr;
+  return it->second;
+}
+
+void MacroInfo::_free_() {
+  for (const auto& i : _commands) delete i.second;
+}
+
+sptr<Atom> PreDefMacro::invoke(Parser& tp, vector<string>& args) {
+  try {
+    return _delegate(tp, args);
+  } catch (ex_parse& e) {
+    throw ex_parse("Problem with command: " + args[0] + "\n caused by: " + e.what());
+  }
+}