@simonklee/opentui-tex-native-source 0.2.0

package/native/vendor/microtex/lib/wrapper/cwrapper.h

@@ -0,0 +1,305 @@
+/** A C-wrapper for microtex. */
+
+#ifndef MICROTEX_CWRAPPER_H
+#define MICROTEX_CWRAPPER_H
+
+#ifdef HAVE_CWRAPPER
+
+#include "microtexexport.h"
+#include "wrapper/callback.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef void* FontMetaPtr;
+typedef void* RenderPtr;
+typedef void* DrawingData;
+
+/** Get the library version. */
+MICROTEX_CAPI const char* microtex_version();
+
+/**
+ * Register callbacks to the engine.
+ *
+ * @param createTextLayout callback to create text-layout
+ * @param getTextLayoutBounds callback to retrieve the bounds of text-layout created
+ * by [createTextLayout]
+ * @param releaseTextLayout callback to release a text-layout created by [createTextLayout]
+ * @param isPathExists callback to check if a graphical-path is exists
+ */
+MICROTEX_CAPI void microtex_registerCallbacks(
+  CBCreateTextLayout createTextLayout,
+  CBGetTextLayoutBounds getTextLayoutBounds,
+  CBReleaseTextLayout releaseTextLayout,
+  CBIsPathExists isPathExists
+);
+
+/** Set text-layout bounds by given width, height, and ascent. For FFI bindings. */
+MICROTEX_CAPI void
+microtex_setTextLayoutBounds(TextLayoutBounds* b, float width, float height, float ascent);
+
+/** Test if a font is bold. For FFI bindings. */
+MICROTEX_CAPI bool microtex_isBold(FontDesc* desc);
+
+/** Test if a font is italic. For FFI bindings. */
+MICROTEX_CAPI bool microtex_isItalic(FontDesc* desc);
+
+/** Test if a font is sans-serif. For FFI bindings. */
+MICROTEX_CAPI bool microtex_isSansSerif(FontDesc* desc);
+
+/** Test if a font is monospace. For FFI bindings. */
+MICROTEX_CAPI bool microtex_isMonospace(FontDesc* desc);
+
+/** Retrieve the font size. For FFI bindings. */
+MICROTEX_CAPI float microtex_fontSize(FontDesc* desc);
+
+/**
+ * Initialize the engine by given `clm` data. The data must represents a math font.
+ *
+ * @param len the number of bytes of the `clm` data
+ * @param data the `clm` data
+ * @return the meta info of the font, you can retrieve the font family via
+ * [microtex_getFontFamily], the font name via [microtex_getFontName], and to test if
+ * the font is a math font by [microtex_isMathFont]. You must call [microtex_releaseFontMeta]
+ * after this object has no usages.
+ */
+MICROTEX_CAPI FontMetaPtr microtex_init(unsigned long len, const unsigned char* data);
+
+/** Release the engine. */
+MICROTEX_CAPI void microtex_release();
+
+/** Test if the engine is initialized. */
+MICROTEX_CAPI bool microtex_isInited();
+
+/**
+ * Add a font to the engine context.
+ *
+ * @param len the number of bytes of the `clm` data
+ * @param data the `clm` data
+ * @return the font meta info. You must call [microtex_releaseFontMeta] after this object has
+ * no usages.
+ */
+MICROTEX_CAPI FontMetaPtr microtex_addFont(unsigned long len, const unsigned char* data);
+
+/** Get the font family name from the given FontMetaPtr. */
+MICROTEX_CAPI const char* microtex_getFontFamily(FontMetaPtr ptr);
+
+/** Get the font name from the given FontMetaPtr. */
+MICROTEX_CAPI const char* microtex_getFontName(FontMetaPtr ptr);
+
+/** Test if the given font is a math font. */
+MICROTEX_CAPI bool microtex_isMathFont(FontMetaPtr ptr);
+
+/** Release the font meta info. */
+MICROTEX_CAPI void microtex_releaseFontMeta(FontMetaPtr ptr);
+
+/**
+ * Set the default math font by name.
+ * See [lib/microtex.h: MicroTex::setDefaultMathFont] for details.
+ */
+MICROTEX_CAPI void microtex_setDefaultMathFont(const char* name);
+
+/**
+ * Set the default main font family by name.
+ * See [lib/microtex.h: MicroTex::setDefaultMainFont] for details.
+ */
+MICROTEX_CAPI void microtex_setDefaultMainFont(const char* name);
+
+/** Test if has the ability to use path to render glyphs. */
+MICROTEX_CAPI bool microtex_hasGlyphPathRender();
+
+/**
+ * Set if use path to render glyphs, only works when compile option
+ * GLYPH_RENDER_TYPE is GLYPH_RENDER_TYPE_BOTH (equals to 0, that means render
+ * glyphs use font and path both), otherwise this function takes no effect.
+ */
+MICROTEX_CAPI void microtex_setRenderGlyphUsePath(bool use);
+
+/**
+ * Test if currently use path to render glyphs.
+ *
+ * See [lib/microtex.h: MicroTeX::isRenderGlyphUsePath] for details.
+ */
+MICROTEX_CAPI bool microtex_isRenderGlyphUsePath();
+
+/**
+ * Parse a (La)TeX string (in UTF-8 encoding) to Render. You must
+ * call [microtex_deleteRender] after it has no usages.
+ *
+ * See [lib/microtex.h: MicroTeX::parse] for details.
+ */
+MICROTEX_CAPI RenderPtr microtex_parseRender(
+  const char* tex,
+  int width,
+  float textSize,
+  float lineSpace,
+  unsigned int color,
+  bool fillWidth,
+  bool enableOverrideTeXStyle,
+  unsigned int texStyle
+);
+
+/** Delete the render created by [microtex_parseRender] before. */
+MICROTEX_CAPI void microtex_deleteRender(RenderPtr render);
+
+/**
+ * Get the drawing data from the render created by [microtex_parseRender] before.
+ * It generates the drawing commands from the render. You must call
+ * [microtex_freeDrawingData] after it has no usages.
+ *
+ * The drawing data are arranged by following format:
+ *
+ * @code
+ * bytes    desc
+ * -----------------------------------------------------
+ *     4    number of bytes of the drawing data
+ *     1    drawing command (e.g. drawLine, setColor...)
+ * @endcode
+ *
+ * And for each drawing command, followed by its arguments, the tables below
+ * shows the drawing commands and its arguments.
+ *
+ * Short for data types:
+ *
+ * @code
+ *      data type bytes  short
+ * ---------------------------
+ *            int     4  i32
+ *   unsigned int     4  u32
+ * unsigned short     2  u16
+ *          float     4  f32
+ *           bool     1  u8
+ * @endcode
+ *
+ * And arguments for each drawing command:
+ *
+ * @code
+ * cmd  args                desc
+ * -----------------------------------------------------------------------------
+ *   0          color: u32  Set color.
+ *
+ *   1    line width : f32  Set line stroke. The possible line-caps are
+ *        miter limit: f32  {0: butt, 1: round, 2: square}, and the possible
+ *           line cap: u32  line-joins are {0: bevel, 1: miter, 2: round}.
+ *          line join: u32
+ *
+ *   2        has dash: u8  Set the dash pattern to draw lines, users are free
+ *                          to use various dash patterns.
+ *
+ *   3 font family: string  Set font by font family name, the name is 0
+ *                          terminated.
+ *
+ *   4      font size: f32  Set the font size.
+ *
+ *   5        delta-x: f32  Translate the context by delta-x and delta-y.
+ *            delta-y: f32
+ *
+ *   6        scale-x: f32  Scale the context by scale-x and scale-y.
+ *            scale-y: f32
+ *
+ *   7         radian: f32  Rotate the context by the given radian and pivot.
+ *            pivot-x: f32
+ *            pivot-y: f32
+ *
+ *   8                 N/A  Reset the transformation of the context.
+ *
+ *   9          glyph: u16  Draw a single glyph at given point (x, y), the glyph
+ *                  x: f32  drawing should be baseline aligned.
+ *                  y: f32
+ *
+ *  10        path-id: i32  Begin a path with id. The id will be >= 0 if the
+ *                          path is cacheable, otherwise it will be < 0. The
+ *                          engine will use [CBIsPathExists] to determine if the
+ *                          path is in cache.
+ *
+ *  11              x: f32  Move to point (x, y).
+ *                  y: f32
+ *
+ *  12              x: f32  Add a line with its end point (x, y) to path.
+ *                  y: f32
+ *
+ *  13             x1: f32  Add a cubic Bezier spline to path, with control
+ *                 y1: f32  points (x1, y1), (x2, y2) and the final point
+ *                 x2: f32  (x3, y3).
+ *                 y2: f32
+ *                 x3: f32
+ *                 y3: f32
+ *
+ *  14             x1: f32  Add a quadratic Bezier spline to path, with control
+ *                 y1: f32  point (x1, y1) and the final point (x2, y2).
+ *                 x2: f32
+ *                 y2: f32
+ *
+ *  15                 N/A  Close the path.
+ *
+ *  16             id: i32  Fill the path with the given id. If the path is not
+ *                          cacheable, it always is -1.
+ *
+ *  17             x1: f32  Draw a line from (x1, y1) to (x2, y2).
+ *                 y1: f32
+ *                 x2: f32
+ *                 y2: f32
+ *
+ *  18              x: f32  Draw an outlined rectangle at point (x, y) with its
+ *                  y: f32  width (w) and height (h).
+ *                  w: f32
+ *                  h: f32
+ *
+ *  19              x: f32  Draw a rectangle at point (x, y) with its width (w)
+ *                  y: f32  and height (h).
+ *                  w: f32
+ *                  h: f32
+ *
+ *  20              x: f32  Draw an outlined round rectangle at point (x, y)
+ *                  y: f32  with its width (w), height (h), radius in
+ *                  w: f32  x-direction (rx) and radius in y-direction (ry).
+ *                  h: f32
+ *                 rx: f32
+ *                 ry: f32
+ *
+ *  21              x: f32  Draw a round rectangle at point (x, y) with its
+ *                  y: f32  width(w), height(h), radius in x-direction (rx) and
+ *                  w: f32  radius in y-direction (ry).
+ *                  h: f32
+ *                 rx: f32
+ *                 ry: f32
+ *
+ *  22             id: u32  Draw a text-layout by given id at point (x, y). The
+ *                  x: f32  id was generated by [CBCreateTextLayout].
+ *                  y: f32
+ * @endcode
+ */
+MICROTEX_CAPI DrawingData microtex_getDrawingData(RenderPtr render, int x, int y);
+
+/** Release the drawing data generated by [microtex_getDrawingData] before. */
+MICROTEX_CAPI void microtex_freeDrawingData(DrawingData data);
+
+/** Test if the host machine is little-endian. */
+MICROTEX_CAPI bool microtex_isLittleEndian();
+
+/** Get the render width. */
+MICROTEX_CAPI int microtex_getRenderWidth(RenderPtr render);
+
+/** Get the render height. */
+MICROTEX_CAPI int microtex_getRenderHeight(RenderPtr render);
+
+/** Get the render depth. */
+MICROTEX_CAPI int microtex_getRenderDepth(RenderPtr render);
+
+/** Test if the render is split (has new line). */
+MICROTEX_CAPI bool microtex_isRenderSplit(RenderPtr render);
+
+/** Set the text size to draw the render. */
+MICROTEX_CAPI void microtex_setRenderTextSize(RenderPtr render, float size);
+
+/** Set the foreground color to draw the render. */
+MICROTEX_CAPI void microtex_setRenderForeground(RenderPtr render, unsigned int c);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // HAVE_CWRAPPER
+
+#endif  // MICROTEX_CWRAPPER_H

package/native/vendor/microtex/lib/wrapper/graphic_wrapper.cpp

@@ -0,0 +1,211 @@
+#ifdef HAVE_CWRAPPER
+
+#include "wrapper/graphic_wrapper.h"
+
+#include "wrapper/callback.h"
+
+using namespace microtex;
+
+Font_wrapper::Font_wrapper(std::string name) : _name(std::move(name)) {}
+
+const std::string& Font_wrapper::name() const {
+  return _name;
+}
+
+bool Font_wrapper::operator==(const Font& f) const {
+  return _name == static_cast<const Font_wrapper&>(f)._name;
+}
+
+/**************************************************************************************************/
+
+TextLayout_wrapper::TextLayout_wrapper(u32 id) : _id(id) {}
+
+TextLayout_wrapper::~TextLayout_wrapper() noexcept {
+  microtex_releaseTextLayout(_id);
+}
+
+void TextLayout_wrapper::getBounds(Rect& bounds) {
+  TextLayoutBounds b{0, 0, 0};
+  microtex_getTextLayoutBounds(_id, &b);
+  bounds.x = 0;
+  bounds.w = b.width;
+  bounds.h = b.height;
+  bounds.y = b.ascent;
+}
+
+void TextLayout_wrapper::draw(Graphics2D& g2, float x, float y) {
+  auto& g = static_cast<Graphics2D_wrapper&>(g2);
+  g.drawTextLayout(_id, x, y);
+}
+
+/**************************************************************************************************/
+
+sptr<TextLayout>
+PlatformFactory_wrapper::createTextLayout(const std::string& src, FontStyle style, float size) {
+  FontDesc f{
+    microtex::isBold(style),
+    microtex::isItalic(style),
+    microtex::isSansSerif(style),
+    microtex::isMono(style),
+    size,
+  };
+  const auto id = microtex_createTextLayout(src.c_str(), &f);
+  return sptrOf<TextLayout_wrapper>(id);
+}
+
+sptr<Font> PlatformFactory_wrapper::createFont(const std::string& file) {
+  return sptrOf<Font_wrapper>(file);
+}
+
+/**************************************************************************************************/
+
+Graphics2D_wrapper::Graphics2D_wrapper() : _color(black), _sx(1), _sy(1) {}
+
+void* Graphics2D_wrapper::getDrawingData() {
+  return _cmds.finish();
+}
+
+void Graphics2D_wrapper::setColor(color c) {
+  if (_color == c) return;
+  _color = c;
+  _cmds.put((u8)0, c);
+}
+
+color Graphics2D_wrapper::getColor() const {
+  return _color;
+}
+
+void Graphics2D_wrapper::setStroke(const Stroke& s) {
+  if (_stroke == s) return;
+  _stroke = s;
+  _cmds.put((u8)1, s.lineWidth, s.miterLimit, (u32)s.cap, (u32)s.join);
+}
+
+void Graphics2D_wrapper::setStrokeWidth(float w) {
+  if (_stroke.lineWidth == w) return;
+  _stroke.lineWidth = w;
+  _cmds.put((u8)1, _stroke.lineWidth, _stroke.miterLimit, (u32)_stroke.cap, (u32)_stroke.join);
+}
+
+const Stroke& Graphics2D_wrapper::getStroke() const {
+  return _stroke;
+}
+
+void Graphics2D_wrapper::setDash(const std::vector<float>& dash) {
+  // TODO only support command, no pattern was given
+  const auto hasDash = !dash.empty();
+  _cmds.put((u8)2, hasDash ? (u8)1 : (u8)0);
+}
+
+std::vector<float> Graphics2D_wrapper::getDash() {
+  return {};
+}
+
+sptr<Font> Graphics2D_wrapper::getFont() const {
+  return _font;
+}
+
+void Graphics2D_wrapper::setFont(const sptr<Font>& font) {
+  if (_font != nullptr && *_font == *font) return;
+  _font = font;
+  _cmds.put((u8)3, std::static_pointer_cast<Font_wrapper>(_font)->name().c_str());
+}
+
+float Graphics2D_wrapper::getFontSize() const {
+  return _fontSize;
+}
+
+void Graphics2D_wrapper::setFontSize(float size) {
+  if (_fontSize == size) return;
+  _cmds.put((u8)4, size);
+}
+
+void Graphics2D_wrapper::translate(float dx, float dy) {
+  _cmds.put((u8)5, dx, dy);
+}
+
+void Graphics2D_wrapper::scale(float sx, float sy) {
+  _sx *= sx;
+  _sy *= sy;
+  _cmds.put((u8)6, sx, sy);
+}
+
+void Graphics2D_wrapper::rotate(float angle) {
+  _cmds.put((u8)7, angle, 0.f, 0.f);
+}
+
+void Graphics2D_wrapper::rotate(float angle, float px, float py) {
+  _cmds.put((u8)7, angle, px, py);
+}
+
+void Graphics2D_wrapper::reset() {
+  _sx = _sy = 1.f;
+  _cmds.put((u8)8);
+}
+
+float Graphics2D_wrapper::sx() const {
+  return _sx;
+}
+
+float Graphics2D_wrapper::sy() const {
+  return _sy;
+}
+
+void Graphics2D_wrapper::drawGlyph(u16 glyph, float x, float y) {
+  _cmds.put((u8)9, glyph, x, y);
+}
+
+bool Graphics2D_wrapper::beginPath(i32 id) {
+  _cmds.put((u8)10, id);
+  return microtex_isPathExists(id);
+}
+
+void Graphics2D_wrapper::moveTo(float x, float y) {
+  _cmds.put((u8)11, x, y);
+}
+
+void Graphics2D_wrapper::lineTo(float x, float y) {
+  _cmds.put((u8)12, x, y);
+}
+
+void Graphics2D_wrapper::cubicTo(float x1, float y1, float x2, float y2, float x3, float y3) {
+  _cmds.put((u8)13, x1, y1, x2, y2, x3, y3);
+}
+
+void Graphics2D_wrapper::quadTo(float x1, float y1, float x2, float y2) {
+  _cmds.put((u8)14, x1, y1, x2, y2);
+}
+
+void Graphics2D_wrapper::closePath() {
+  _cmds.put((u8)15);
+}
+
+void Graphics2D_wrapper::fillPath(i32 id) {
+  _cmds.put((u8)16, id);
+}
+
+void Graphics2D_wrapper::drawLine(float x1, float y1, float x2, float y2) {
+  _cmds.put((u8)17, x1, y1, x2, y2);
+}
+
+void Graphics2D_wrapper::drawRect(float x, float y, float w, float h) {
+  _cmds.put((u8)18, x, y, w, h);
+}
+
+void Graphics2D_wrapper::fillRect(float x, float y, float w, float h) {
+  _cmds.put((u8)19, x, y, w, h);
+}
+
+void Graphics2D_wrapper::drawRoundRect(float x, float y, float w, float h, float rx, float ry) {
+  _cmds.put((u8)20, x, y, w, h, rx, ry);
+}
+
+void Graphics2D_wrapper::fillRoundRect(float x, float y, float w, float h, float rx, float ry) {
+  _cmds.put((u8)21, x, y, w, h, rx, ry);
+}
+
+void Graphics2D_wrapper::drawTextLayout(u32 id, float x, float y) {
+  _cmds.put((u8)22, id, x, y);
+}
+
+#endif  // HAVE_CWRAPPER

package/native/vendor/microtex/lib/wrapper/graphic_wrapper.h

@@ -0,0 +1,159 @@
+#ifndef MICROTEX_GRAPHIC_WRAPPER_H
+#define MICROTEX_GRAPHIC_WRAPPER_H
+
+#ifdef HAVE_CWRAPPER
+
+#include "graphic/graphic.h"
+#include "wrapper/byte_seq.h"
+
+namespace microtex {
+
+class Font_wrapper : public Font {
+private:
+  std::string _name;
+
+public:
+  explicit Font_wrapper(std::string name);
+
+  const std::string& name() const;
+
+  bool operator==(const Font& f) const override;
+};
+
+/**************************************************************************************************/
+
+class TextLayout_wrapper : public TextLayout {
+private:
+  const u32 _id;
+
+public:
+  explicit TextLayout_wrapper(u32 id);
+
+  ~TextLayout_wrapper() noexcept override;
+
+  void getBounds(Rect& bounds) override;
+
+  void draw(Graphics2D& g2, float x, float y) override;
+};
+
+/**************************************************************************************************/
+
+class PlatformFactory_wrapper : public PlatformFactory {
+public:
+  sptr<Font> createFont(const std::string& file) override;
+
+  sptr<TextLayout> createTextLayout(const std::string& src, FontStyle style, float size) override;
+};
+
+/**************************************************************************************************/
+
+class Graphics2D_wrapper : public Graphics2D {
+private:
+  color _color;
+  Stroke _stroke;
+  ByteSeq _cmds;
+  float _sx, _sy;
+
+  sptr<Font> _font;
+  float _fontSize;
+
+public:
+  Graphics2D_wrapper();
+
+  void* getDrawingData();
+
+  // cmd: 0
+  void setColor(color c) override;
+
+  color getColor() const override;
+
+  // cmd: 1
+  void setStroke(const Stroke& s) override;
+
+  const Stroke& getStroke() const override;
+
+  // cmd: 1
+  void setStrokeWidth(float w) override;
+
+  // cmd: 2
+  void setDash(const std::vector<float>& dash) override;
+
+  std::vector<float> getDash() override;
+
+  sptr<Font> getFont() const override;
+
+  // cmd: 3
+  void setFont(const sptr<Font>& font) override;
+
+  float getFontSize() const override;
+
+  // cmd: 4
+  void setFontSize(float size) override;
+
+  // cmd: 5
+  void translate(float dx, float dy) override;
+
+  // cmd: 6
+  void scale(float sx, float sy) override;
+
+  // cmd: 7
+  void rotate(float angle) override;
+
+  // cmd: 7
+  void rotate(float angle, float px, float py) override;
+
+  // cmd: 8
+  void reset() override;
+
+  float sx() const override;
+
+  float sy() const override;
+
+  // cmd: 9
+  void drawGlyph(u16 glyph, float x, float y) override;
+
+  // cmd: 10
+  bool beginPath(i32 id) override;
+
+  // cmd: 11
+  void moveTo(float x, float y) override;
+
+  // cmd: 12
+  void lineTo(float x, float y) override;
+
+  // cmd: 13
+  void cubicTo(float x1, float y1, float x2, float y2, float x3, float y3) override;
+
+  // cmd: 14
+  void quadTo(float x1, float y1, float x2, float y2) override;
+
+  // cmd: 15
+  void closePath() override;
+
+  // cmd: 16
+  void fillPath(i32 id) override;
+
+  // cmd: 17
+  void drawLine(float x1, float y1, float x2, float y2) override;
+
+  // cmd: 18
+  void drawRect(float x, float y, float w, float h) override;
+
+  // cmd: 19
+  void fillRect(float x, float y, float w, float h) override;
+
+  // cmd: 20
+  void drawRoundRect(float x, float y, float w, float h, float rx, float ry) override;
+
+  // cmd: 21
+  void fillRoundRect(float x, float y, float w, float h, float rx, float ry) override;
+
+  // cmd: 22
+  void drawTextLayout(u32 id, float x, float y);
+};
+
+}  // namespace microtex
+
+#endif  // HAVE_CWRAPPER
+
+#endif  // MICROTEX_GRAPHIC_WRAPPER_H

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

@@ -0,0 +1,22 @@
+cwrapper_src = [
+	'byte_seq.cpp',
+	'callback.cpp',
+	'cwrapper.cpp',
+	'graphic_wrapper.cpp'
+]
+
+microtex_cwrapper_lib = library('microtex-cwrapper', cwrapper_src,
+	link_with: microtex_lib,
+	include_directories: inc,
+	cpp_args: ['-DHAVE_CWRAPPER'],
+	version: meson.project_version(),
+	soversion: microtex_api_version,
+	install: false
+)
+
+microtex_cwrapper_dep = declare_dependency(
+	link_with: [microtex_lib, microtex_cwrapper_lib],
+	include_directories: ['.', inc],
+	compile_args: ['-DHAVE_CWRAPPER'],
+	version: meson.project_version()
+)