@simonklee/opentui-tex-native-source 0.2.0

package/native/vendor/microtex/example/memcheck/mem_check_main.cpp

@@ -0,0 +1,154 @@
+#include "graphic/graphic.h"
+#include "microtex.h"
+#include "utils/utils.h"
+
+namespace microtex {
+
+class Font_none : public Font {
+public:
+  Font_none() = default;
+
+  bool operator==(const Font& f) const override { return false; }
+};
+
+class TextLayout_none : public TextLayout {
+public:
+  TextLayout_none() = default;
+
+  void getBounds(Rect& bounds) override {}
+
+  void draw(Graphics2D& g2, float x, float y) override {}
+};
+
+class PlatformFactory_none : public PlatformFactory {
+public:
+  sptr<Font> createFont(const std::string& file) override { return sptrOf<Font_none>(); }
+
+  sptr<TextLayout> createTextLayout(const std::string& src, FontStyle style, float size) override {
+    return sptrOf<TextLayout_none>();
+  }
+};
+
+class Graphics2D_none : public Graphics2D {
+private:
+  Stroke _stroke;
+  float _fontSize = 100;
+
+public:
+  void setColor(color c) override {}
+
+  color getColor() const override { return 0; }
+
+  void setStroke(const Stroke& s) override { _stroke = s; }
+
+  const Stroke& getStroke() const override { return _stroke; }
+
+  void setStrokeWidth(float w) override {}
+
+  void setDash(const std::vector<float>& dash) override {}
+
+  std::vector<float> getDash() override { return std::vector<float>(); }
+
+  sptr<Font> getFont() const override { return microtex::sptr<Font_none>(); }
+
+  void setFont(const sptr<Font>& font) override {}
+
+  float getFontSize() const override { return _fontSize; }
+
+  void setFontSize(float size) override { _fontSize = size; }
+
+  void translate(float dx, float dy) override {}
+
+  void scale(float sx, float sy) override {}
+
+  void rotate(float angle) override {}
+
+  void rotate(float angle, float px, float py) override {}
+
+  void reset() override {}
+
+  float sx() const override { return 1; }
+
+  float sy() const override { return 1; }
+
+  void drawGlyph(u16 glyph, float x, float y) override {}
+
+  bool beginPath(i32 id) override { return false; }
+
+  void moveTo(float x, float y) override {}
+
+  void lineTo(float x, float y) override {}
+
+  void cubicTo(float x1, float y1, float x2, float y2, float x3, float y3) override {}
+
+  void quadTo(float x1, float y1, float x2, float y2) override {}
+
+  void closePath() override {}
+
+  void fillPath(i32 id) override {}
+
+  void drawLine(float x1, float y1, float x2, float y2) override {}
+
+  void drawRect(float x, float y, float w, float h) override {}
+
+  void fillRect(float x, float y, float w, float h) override {}
+
+  void drawRoundRect(float x, float y, float w, float h, float rx, float ry) override {}
+
+  void fillRoundRect(float x, float y, float w, float h, float rx, float ry) override {}
+};
+
+}  // namespace microtex
+
+#include <chrono>
+
+#include "samples.h"
+
+template <typename F>
+auto countDuration(const F& f) {
+  auto start = std::chrono::high_resolution_clock::now();
+  auto res = f();
+  auto stop = std::chrono::high_resolution_clock::now();
+  return std::make_pair(
+    std::chrono::duration_cast<std::chrono::microseconds>(stop - start).count(),
+    res
+  );
+}
+
+int main(int argc, char* argv[]) {
+  if (argc < 4) {
+    fprintf(
+      stderr,
+      "Required options:\n"
+      "  <clm data file>\n"
+      "  <math font file>\n"
+      "  <samples file>\n"
+    );
+    return 1;
+  }
+  const microtex::FontSrcFile math{argv[1], argv[2]};
+  microtex::MicroTeX::init(math);
+
+  microtex::PlatformFactory::registerFactory(
+    "none",
+    std::make_unique<microtex::PlatformFactory_none>()
+  );
+  microtex::PlatformFactory::activate("none");
+
+  long total = 0;
+  microtex::Samples samples(argv[3]);
+  for (int i = 0; i < samples.count(); i++) {
+    auto [d, r] = countDuration([&]() {
+      return microtex::MicroTeX::parse(samples.next(), 720, 20, 20 / 3.f, microtex::black);
+    });
+    total += d;
+    printf("time: %ld(us)\n", d);
+    microtex::Graphics2D_none g2;
+    r->draw(g2, 0, 0);
+    delete r;
+  }
+  printf("total time: %ld(us)\n", total);
+
+  microtex::MicroTeX::release();
+  return 0;
+}

package/native/vendor/microtex/example/qt/CMakeLists.txt

@@ -0,0 +1,37 @@
+add_executable(
+    microtex-qt-example
+    qt_texwidget.cpp
+    qt_mainwindow.cpp
+    qt_main.cpp
+    ../samples/samples.cpp
+)
+
+target_include_directories(microtex-qt-example PUBLIC ../samples)
+
+find_package(QT NAMES Qt6 Qt5 COMPONENTS Gui Widgets REQUIRED)
+find_package(Qt${QT_VERSION_MAJOR} COMPONENTS Gui Widgets REQUIRED)
+
+target_link_libraries(
+    microtex-qt-example PRIVATE
+    microtex
+    microtex-qt
+    Qt${QT_VERSION_MAJOR}::Widgets
+)
+
+if (SKIA)
+    target_compile_definitions(microtex-qt-example PUBLIC BUILD_SKIA)
+    if (QT_VERSION_MAJOR GREATER_EQUAL 6)
+        find_package(Qt6 COMPONENTS OpenGLWidgets REQUIRED)
+        target_link_libraries(
+            microtex-qt-example PRIVATE
+            Qt${QT_VERSION_MAJOR}::OpenGLWidgets
+        )
+    endif ()
+    target_sources(microtex-qt-example PRIVATE qt_skiatexwidget.cpp)
+    target_link_libraries(
+        microtex-qt-example PRIVATE
+        microtex-skia
+    )
+endif ()
+
+set_target_properties(microtex-qt-example PROPERTIES AUTOMOC ON)

package/native/vendor/microtex/example/qt/meson.build

@@ -0,0 +1,25 @@
+example_qt_dep = [
+  dependency('qt5', modules: ['Core', 'Gui', 'Widgets']),
+  microtex_qt_dep
+]
+
+example_qt_inc = ['../samples', inc]
+example_qt_src = [
+  qt5.preprocess(moc_headers: [
+      'qt_mainwindow.h',
+    ],
+    include_directories: example_qt_inc,
+    dependencies: example_qt_dep
+  ),
+  'qt_main.cpp',
+  'qt_mainwindow.cpp',
+  'qt_texwidget.cpp',
+  '../samples/samples.cpp'
+]
+
+executable(
+    'microtex-qt-example', example_qt_src,
+    include_directories: example_qt_inc,
+    dependencies: example_qt_dep,
+    install: true
+)

package/native/vendor/microtex/example/qt/qt_main.cpp

@@ -0,0 +1,70 @@
+#include <QApplication>
+
+#include "graphic_qt.h"
+#include "microtex.h"
+#include "qt_mainwindow.h"
+
+#ifdef BUILD_SKIA
+#include "graphic_skia.h"
+#include "qt_skiatexwidget.h"
+#endif
+
+void initSkia() {
+#ifdef BUILD_SKIA
+  microtex::PlatformFactory::registerFactory(
+    "skia",
+    std::make_unique<microtex::PlatformFactory_skia>()
+  );
+  microtex::PlatformFactory::activate("skia");
+  initGL();
+#endif
+}
+
+void initQt() {
+  microtex::PlatformFactory::registerFactory(
+    "qt",
+    std::make_unique<microtex::PlatformFactory_qt>()
+  );
+  microtex::PlatformFactory::activate("qt");
+}
+
+int main(int argc, char** argv) {
+  QApplication app(argc, argv);
+
+  if (argc < 4) {
+    fprintf(
+      stderr,
+      "Required arguments:\n"
+      "  <clm data file>\n"
+      "  <math font file>\n"
+      "  <samples file>\n"
+      "Optional arguments:\n"
+      "  <if render glyph use path: true|false>\n"
+      "  <if render use skia: true|false>\n"
+    );
+    return 1;
+  }
+  const microtex::FontSrcFile math{argv[1], argv[2]};
+  microtex::MicroTeX::init(math);
+  const std::string samples(argv[3]);
+  microtex::MicroTeX::setRenderGlyphUsePath(
+    argc > 4 && std::string("true") == std::string(argv[4])
+  );
+
+  bool useSkia = argc > 5 && std::string("true") == std::string(argv[5]);
+#ifdef BUILD_SKIA
+  if (useSkia) {
+    initSkia();
+  } else {
+    initQt();
+  }
+#else
+  initQt();
+#endif
+  MainWindow win(nullptr, useSkia, samples);
+  win.show();
+  int ret = QApplication::exec();
+
+  microtex::MicroTeX::release();
+  return ret;
+}

package/native/vendor/microtex/example/qt/qt_mainwindow.cpp

@@ -0,0 +1,107 @@
+#include "qt_mainwindow.h"
+
+#include <QHBoxLayout>
+#include <QLabel>
+#include <QPushButton>
+#include <QScrollArea>
+#include <QSplitter>
+#include <QString>
+#include <string>
+// #include "moc_qt_mainwindow.cpp"
+
+#include "qt_texwidget.h"
+
+#ifdef BUILD_SKIA
+#include "qt_skiatexwidget.h"
+#endif
+
+using namespace std;
+
+MainWindow::MainWindow(QWidget* parent, bool useSkia, const std::string& samplesFile)
+    : QWidget(parent), _samples(samplesFile) {
+  int text_size = 20;
+
+  // main layout for window
+  QHBoxLayout* layout = new QHBoxLayout;
+
+  // splitter separates left from right
+  QSplitter* splitter = new QSplitter;
+  layout->addWidget(splitter);
+
+  // the TeX widget is on the left
+#ifdef BUILD_SKIA
+  if (useSkia) {
+    _texwidget = new SkiaTeXWidget(nullptr, text_size);
+  } else {
+    _texwidget = new TeXWidget(nullptr, text_size);
+  }
+#else
+  _texwidget = new TeXWidget(nullptr, text_size);
+#endif
+  _render = dynamic_cast<TeXRender*>(_texwidget);
+  _texwidget->setMinimumWidth(400);
+
+  QScrollArea* scrollArea = new QScrollArea;
+  scrollArea->setBackgroundRole(QPalette::Light);
+  scrollArea->setWidget(_texwidget);
+
+  // these are the widgets on the right side
+  // want an editor at the top and controls at bottom
+  QWidget* right = new QWidget;
+  QVBoxLayout* rlayout = new QVBoxLayout;
+  rlayout->setContentsMargins(0, 0, 0, 0);
+  right->setLayout(rlayout);
+  _textedit = new QTextEdit;
+  _textedit->setFontFamily("Monaco");
+  rlayout->addWidget(_textedit);
+
+  // these are the controls which go at the bottom right
+  QWidget* controls = new QWidget;
+  QHBoxLayout* clayout = new QHBoxLayout;
+  clayout->setContentsMargins(0, 0, 0, 0);
+  controls->setLayout(clayout);
+
+  QLabel* label1 = new QLabel("Change text size:");
+  _sizespin = new QSpinBox;
+  _sizespin->setValue(text_size);
+  _sizespin->setMinimum(1);
+  QPushButton* next = new QPushButton("Next example");
+  QPushButton* render = new QPushButton("Rendering");
+  QPushButton* save = new QPushButton("Save as SVG");
+  clayout->addWidget(label1);
+  clayout->addWidget(_sizespin);
+  clayout->addWidget(next);
+  clayout->addWidget(render);
+  clayout->addWidget(save);
+
+  rlayout->addWidget(controls);
+
+  splitter->addWidget(scrollArea);
+  splitter->addWidget(right);
+
+  setLayout(layout);
+
+  QObject::connect(next, &QPushButton::clicked, this, &MainWindow::nextClicked);
+  QObject::connect(render, &QPushButton::clicked, this, &MainWindow::renderClicked);
+  QObject::connect(save, &QPushButton::clicked, this, &MainWindow::saveClicked);
+  QObject::connect(_sizespin, SIGNAL(valueChanged(int)), this, SLOT(fontSizeChanged(int)));
+}
+
+void MainWindow::fontSizeChanged(int size) {
+  _render->setTextSize(size);
+}
+
+void MainWindow::nextClicked() {
+  auto sample = _samples.next();
+  _textedit->setText(QString::fromStdString(sample));
+  _render->setLaTeX(sample);
+}
+
+void MainWindow::renderClicked() {
+  QString text = _textedit->toPlainText();
+  _render->setLaTeX(text.toStdString());
+}
+
+void MainWindow::saveClicked() {
+  _render->saveSVG("out.svg");
+}

package/native/vendor/microtex/example/qt/qt_mainwindow.h

@@ -0,0 +1,40 @@
+#ifndef QT_MAINWINDOW_H
+#define QT_MAINWINDOW_H
+
+#include <QSpinBox>
+#include <QTextEdit>
+#include <QWidget>
+
+#include "qt_tex_render.h"
+#include "samples.h"
+
+class MainWindow : public QWidget {
+  Q_OBJECT
+
+public:
+  explicit MainWindow(
+    QWidget* parent = nullptr,
+    bool useSkia = false,
+    const std::string& smaplesFile = ""
+  );
+
+protected slots:
+
+  void nextClicked();
+
+  void renderClicked();
+
+  void saveClicked();
+
+  void fontSizeChanged(int size);
+
+protected:
+  QWidget* _texwidget;
+  TeXRender* _render;
+  QTextEdit* _textedit;
+  QSpinBox* _sizespin;
+
+  microtex::Samples _samples;
+};
+
+#endif

package/native/vendor/microtex/example/qt/qt_skiatexwidget.cpp

@@ -0,0 +1,149 @@
+#include "qt_skiatexwidget.h"
+
+#include <include/core/SkCanvas.h>
+#include <include/core/SkColorSpace.h>
+#include <include/core/SkStream.h>
+#include <include/gpu/gl/GrGLAssembleInterface.h>
+#include <include/svg/SkSVGCanvas.h>
+
+#include <QApplication>
+#include <QOpenGLContext>
+#include <QOpenGLFunctions>
+
+#include "graphic_skia.h"
+
+using namespace microtex;
+
+static bool AllowEGL;
+
+void initGL() {
+  QSurfaceFormat fmt;
+  fmt.setDepthBufferSize(0);
+  fmt.setRedBufferSize(8);
+  fmt.setGreenBufferSize(8);
+  fmt.setBlueBufferSize(8);
+  fmt.setStencilBufferSize(8);
+  fmt.setSamples(0);
+
+  fmt.setSwapBehavior(QSurfaceFormat::DoubleBuffer);
+
+  if (QOpenGLContext::openGLModuleType() == QOpenGLContext::LibGL) {
+    fmt.setVersion(3, 3);
+    fmt.setProfile(QSurfaceFormat::CoreProfile);
+  } else {
+    fmt.setVersion(3, 0);
+  }
+
+  QSurfaceFormat::setDefaultFormat(fmt);
+  AllowEGL = QApplication::platformName() != "xcb";
+}
+
+static sk_sp<GrDirectContext> makeContext(QOpenGLContext *ctx) {
+  auto interface = GrGLMakeAssembledInterface(ctx, [](auto ctx, auto name) {
+    return AllowEGL || strncmp(name, "egl", 3)
+             ? static_cast<QOpenGLContext *>(ctx)->getProcAddress(name)
+             : nullptr;
+  });
+  return GrDirectContext::MakeGL(interface);
+}
+
+static sk_sp<SkSurface> createSurface(GrRecordingContext *ctx, int w, int h, GrGLuint fbo) {
+  GrGLFramebufferInfo info;
+  info.fFBOID = fbo;
+  info.fFormat = GL_RGBA8;
+  GrBackendRenderTarget target(w, h, 0, 8, info);
+  const SkSurfaceProps props(
+    0,
+    SkPixelGeometry::kUnknown_SkPixelGeometry
+  );  // Can customize subpixel layout here
+  return SkSurface::MakeFromBackendRenderTarget(
+    ctx,
+    target,
+    kBottomLeft_GrSurfaceOrigin,
+    kRGBA_8888_SkColorType,
+    nullptr,
+    &props,
+    nullptr
+  );
+}
+
+SkiaTeXWidget::SkiaTeXWidget(QWidget *parent, float text_size)
+    : QOpenGLWidget(parent), _render(nullptr), _text_size(text_size), _padding(20) {}
+
+SkiaTeXWidget::~SkiaTeXWidget() {
+  delete _render;
+}
+
+float SkiaTeXWidget::getTextSize() {
+  return _text_size;
+}
+
+void SkiaTeXWidget::setTextSize(float size) {
+  if (size == _text_size) return;
+  _text_size = size;
+  if (_render != nullptr) {
+    _render->setTextSize(_text_size * devicePixelRatio());
+    update();
+  }
+}
+
+void SkiaTeXWidget::setLaTeX(const std::string &latex) {
+  delete _render;
+  const auto size = _text_size * devicePixelRatio();
+  auto parent = parentWidget();
+  int w = parent == nullptr ? width() : parent->width();
+  _render =
+    MicroTeX::parse(latex, w * devicePixelRatio() - _padding * 2, size, size / 3.f, 0xff424242);
+  resize(getRenderWidth() / devicePixelRatio(), getRenderHeight() / devicePixelRatio());
+  update();
+}
+
+bool SkiaTeXWidget::isRenderDisplayed() {
+  return _render != nullptr;
+}
+
+int SkiaTeXWidget::getRenderWidth() {
+  return _render == nullptr ? 0 : _render->getWidth() + _padding * 2;
+}
+
+int SkiaTeXWidget::getRenderHeight() {
+  return _render == nullptr ? 0 : _render->getHeight() + _padding * 2;
+}
+
+void SkiaTeXWidget::initializeGL() {
+  _context = makeContext(context());
+  _gl = context()->functions();
+}
+
+void SkiaTeXWidget::paintGL() {
+  auto *canvas = _surface->getCanvas();
+  canvas->clear(SK_ColorWHITE);
+  SkPaint paint;
+  if (_render) {
+    Graphics2D_skia g2(canvas);
+    _render->draw(g2, _padding, _padding);
+  }
+  _context->flush();
+}
+
+void SkiaTeXWidget::resizeGL(int w, int h) {
+  _gl->glViewport(0, 0, w, h);
+  _context->resetContext();
+  auto r = devicePixelRatio();
+  _surface = createSurface(_context.get(), w * r, h * r, defaultFramebufferObject());
+  update();
+}
+
+void SkiaTeXWidget::saveSVG(const char *path) {
+  // This does not work properly for the more complex examples,
+  // which might be due to skia as the SkSVG backend is still experimental.
+  // Simples case like $\frac12$ seem to work fine, though.
+  SkFILEWStream stream(path);
+  SkRect bounds = SkRect::MakeIWH(width(), height());
+  std::unique_ptr<SkCanvas> canvas = SkSVGCanvas::Make(bounds, &stream);
+
+  if (_render) {
+    Graphics2D_skia g2(canvas.get());
+    _render->draw(g2, _padding, _padding);
+  }
+}

package/native/vendor/microtex/example/qt/qt_skiatexwidget.h

@@ -0,0 +1,48 @@
+#ifndef QT_SKIATEXWIDGET_H
+#define QT_SKIATEXWIDGET_H
+
+#include <include/core/SkSurface.h>
+#include <include/gpu/GrDirectContext.h>
+
+#include <QOpenGLWidget>
+
+#include "microtex.h"
+#include "qt_tex_render.h"
+#include "render/render.h"
+
+class QOpenGLFunctions;
+
+void initGL();
+
+class SkiaTeXWidget : public QOpenGLWidget, public TeXRender {
+public:
+  explicit SkiaTeXWidget(QWidget *parent = nullptr, float text_size = 20.f);
+
+  ~SkiaTeXWidget() override;
+
+  float getTextSize() override;
+  void setTextSize(float size) override;
+  void setLaTeX(const std::string &latex) override;
+  bool isRenderDisplayed() override;
+  int getRenderWidth() override;
+  int getRenderHeight() override;
+  void saveSVG(const char *path) override;
+
+protected:
+  void initializeGL() override;
+
+  void paintGL() override;
+
+  void resizeGL(int w, int h) override;
+
+private:
+  microtex::Render *_render;
+  float _text_size;
+  int _padding;
+
+  sk_sp<GrDirectContext> _context{};
+  sk_sp<SkSurface> _surface{};
+  QOpenGLFunctions *_gl{};
+};
+
+#endif

package/native/vendor/microtex/example/qt/qt_tex_render.h

@@ -0,0 +1,15 @@
+#ifndef MICROTEX_QT_TEX_RENDER_H
+#define MICROTEX_QT_TEX_RENDER_H
+
+class TeXRender {
+public:
+  virtual float getTextSize() = 0;
+  virtual void setTextSize(float size) = 0;
+  virtual void setLaTeX(const std::string& latex) = 0;
+  virtual bool isRenderDisplayed() = 0;
+  virtual int getRenderWidth() = 0;
+  virtual int getRenderHeight() = 0;
+  virtual void saveSVG(const char* path) = 0;
+};
+
+#endif  // MICROTEX_QT_TEX_RENDER_H

package/native/vendor/microtex/example/qt/qt_texqmlitem.cpp

@@ -0,0 +1,56 @@
+#include <QPainter>
+// #include <QDebug>
+
+#include "qt_texqmlitem.h"
+
+using namespace microtex;
+
+TexQmlItem::TexQmlItem(QQuickItem* parent, float text_size)
+    : QQuickPaintedItem(parent), _render(nullptr), _text_size(text_size), _padding(0) {
+  setImplicitHeight(30);
+  setImplicitWidth(100);
+}
+
+TexQmlItem::~TexQmlItem() {
+  delete _render;
+}
+
+void TexQmlItem::paint(QPainter* painter) {
+  if (_render != nullptr) {
+    //        painter->setRenderHint(QPainter::Antialiasing, true);
+    Graphics2D_qt g2(painter);
+    _render->draw(g2, _padding, _padding);
+  }
+}
+
+void TexQmlItem::setLatexString(const QString& latex) {
+  if (m_latexString == latex) {
+    return;
+  }
+  m_latexString = latex;
+  if (_render != nullptr) {
+    delete _render;
+  }
+
+  try {
+    _render = LaTeX::parse(
+      latex.toStdString(),
+      width() - _padding * 2,
+      _text_size,
+      _text_size / 3.f,
+      0xff424242
+    );
+    if (_render) {
+      setImplicitHeight(_render->getHeight());
+      setImplicitWidth(_render->getWidth());
+    }
+  } catch (...) {
+    _render = nullptr;
+  }
+
+  update();
+}
+
+QString TexQmlItem::latexString() const {
+  return m_latexString;
+}