@simonklee/opentui-tex-native-source 0.2.0

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

@@ -0,0 +1,31 @@
+#ifndef QT_TEXQMLITEM_H
+#define QT_TEXQMLITEM_H
+
+#include <QtQuick/QQuickPaintedItem>
+
+#include "graphic_qt.h"
+#include "microtex.h"
+
+class TexQmlItem : public QQuickPaintedItem {
+  Q_OBJECT
+  Q_PROPERTY(QString latexString READ latexString WRITE setLatexString);
+
+public:
+  explicit TexQmlItem(QQuickItem* parent = nullptr, float text_size = 20.f);
+
+  virtual ~TexQmlItem();
+
+  void paint(QPainter* painter) override;
+
+  void setLatexString(const QString& latex);
+
+  QString latexString() const;
+
+private:
+  microtex::Render* _render;
+  float _text_size;
+  int _padding;
+  QString m_latexString;
+};
+
+#endif  // QT_TEXQMLITEM_H

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

@@ -0,0 +1,62 @@
+#include "qt_texwidget.h"
+
+using namespace microtex;
+
+TeXWidget::TeXWidget(QWidget* parent, float text_size)
+    : QWidget(parent), _render(nullptr), _text_size(text_size), _padding(20) {
+  QPalette pal = palette();
+  pal.setColor(QPalette::Window, Qt::white);
+  setPalette(pal);
+}
+
+TeXWidget::~TeXWidget() {
+  delete _render;
+}
+
+float TeXWidget::getTextSize() {
+  return _text_size;
+}
+
+void TeXWidget::setTextSize(float size) {
+  if (size == _text_size) return;
+  _text_size = size;
+  if (_render != nullptr) {
+    _render->setTextSize(_text_size);
+    resize(getRenderWidth(), getRenderHeight());
+    update();
+  }
+}
+
+void TeXWidget::setLaTeX(const std::string& latex) {
+  delete _render;
+  auto parent = parentWidget();
+  int w = parent == nullptr ? width() : parent->width();
+  _render = MicroTeX::parse(latex, w - _padding * 2, _text_size, _text_size / 3.f, 0xff424242);
+  resize(getRenderWidth(), getRenderHeight());
+  update();
+}
+
+bool TeXWidget::isRenderDisplayed() {
+  return _render != nullptr;
+}
+
+int TeXWidget::getRenderWidth() {
+  return _render == nullptr ? 0 : _render->getWidth() + _padding * 2;
+}
+
+int TeXWidget::getRenderHeight() {
+  return _render == nullptr ? 0 : _render->getHeight() + _padding * 2;
+}
+
+void TeXWidget::saveSVG(const char* path) {
+  // TODO
+}
+
+void TeXWidget::paintEvent(QPaintEvent* event) {
+  if (_render != nullptr) {
+    QPainter painter(this);
+    painter.setRenderHint(QPainter::Antialiasing, true);
+    Graphics2D_qt g2(&painter);
+    _render->draw(g2, _padding, _padding);
+  }
+}

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

@@ -0,0 +1,31 @@
+#ifndef QT_TEXWIDGET_H
+#define QT_TEXWIDGET_H
+
+#include <QWidget>
+
+#include "graphic_qt.h"
+#include "microtex.h"
+#include "qt_tex_render.h"
+
+class TeXWidget : public QWidget, public TeXRender {
+public:
+  explicit TeXWidget(QWidget* parent = nullptr, float text_size = 20.f);
+
+  ~TeXWidget() 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 paintEvent(QPaintEvent* event) override;
+  void saveSVG(const char* path) override;
+
+private:
+  microtex::Render* _render;
+  float _text_size;
+  int _padding;
+};
+
+#endif

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

@@ -0,0 +1,11 @@
+add_executable(latex2png latex2png.cpp)
+
+find_package(QT NAMES Qt6 Qt5 COMPONENTS Core Gui REQUIRED)
+find_package(Qt${QT_VERSION_MAJOR} COMPONENTS Core Gui REQUIRED)
+target_link_libraries(
+    latex2png PRIVATE
+    microtex
+    microtex-qt
+    Qt${QT_VERSION_MAJOR}::Core
+    Qt${QT_VERSION_MAJOR}::Gui
+)

package/native/vendor/microtex/example/qtpng/latex2png.cpp

@@ -0,0 +1,115 @@
+//
+// Created by pikachu on 2021/5/11.
+//
+
+#include <QCommandLineParser>
+#include <QDebug>
+#include <QFile>
+#include <QFileInfo>
+#include <QGuiApplication>
+#include <QPainter>
+#include <QPixmap>
+#include <QTimer>
+
+#include "graphic_qt.h"
+#include "microtex.h"
+
+class TexGuard {
+public:
+  TexGuard(const microtex::FontSrc& math) {
+    microtex::MicroTeX::init(math);
+    microtex::PlatformFactory::registerFactory(
+      "qt",
+      std::make_unique<microtex::PlatformFactory_qt>()
+    );
+    microtex::PlatformFactory::activate("qt");
+  }
+
+  ~TexGuard() { microtex::MicroTeX::release(); }
+};
+
+int main(int argc, char** argv) {
+  QGuiApplication app(argc, argv);
+  QGuiApplication::setApplicationName("latex2png");
+  QGuiApplication::setApplicationVersion("1.0.0");
+  QCommandLineParser parser;
+  parser.setApplicationDescription("Convert LaTex Sample to Image(.png)");
+  parser.addHelpOption();
+  parser.addVersionOption();
+  parser.addPositionalArgument("source", "path to tex file");
+  parser.addPositionalArgument("destination", "path to image file");
+  QCommandLineOption mathFontOption(
+    QStringList() << "mathfont",
+    "path to math font (must absolution path)",
+    "mathfont",
+    "../../res/XITSMath-Regular.otf"
+  );
+  parser.addOption(mathFontOption);
+  QCommandLineOption clmOption(
+    QStringList() << "clm",
+    "path to clm data file",
+    "clm",
+    "../../res/xits/XITSMath-Regular.clm"
+  );
+  parser.addOption(clmOption);
+  parser.process(app);
+
+  QStringList args = parser.positionalArguments();
+  QString mathFontPath = parser.value(mathFontOption);
+  QString clmPath = parser.value(clmOption);
+  if (!QFile(mathFontPath).exists()) {
+    qDebug() << "math font not exist:" << mathFontPath;
+    return 1;
+  }
+  if (!QFileInfo(mathFontPath).isAbsolute()) {
+    qDebug() << "math font path must absolute path.";
+    return 1;
+  }
+  if (!QFile(clmPath).exists()) {
+    qDebug() << "clm not exist:" << clmPath;
+    return 1;
+  }
+
+  microtex::FontSrcFile math{clmPath.toStdString(), mathFontPath.toStdString()};
+
+  TexGuard texGuard(math);
+#ifdef BUILD_SKIA
+  initGL();
+#endif
+  if (args.size() != 2) {
+    qDebug().nospace().noquote() << parser.helpText();
+    return 1;
+  }
+  QString texName = args[0];
+  QString pngName = args[1];
+  if (!pngName.endsWith(".png")) {
+    pngName += ".png";
+  }
+  QFile file(texName);
+  if (!file.exists()) {
+    qDebug() << "file not exist." << texName;
+    return 2;
+  }
+  auto ok = file.open(QIODevice::ReadOnly);
+  if (!ok) {
+    qDebug() << "file open fail." << texName;
+    return 3;
+  }
+  QString latex = file.readAll();
+  qDebug() << latex;
+  auto render =
+    microtex::MicroTeX::parse(latex.toStdString(), 600 - 0 * 2, 20, 20 / 3.f, 0xff424242);
+  qDebug() << render->getWidth() << render->getHeight();
+  QPixmap img(render->getWidth(), render->getHeight());
+  img.fill(Qt::white);
+  QPainter painter(&img);
+  painter.setRenderHint(QPainter::Antialiasing, true);
+  microtex::Graphics2D_qt g2(&painter);
+  render->draw(g2, 0, 0);
+  ok = img.save(pngName);
+  if (!ok) {
+    qDebug() << "save image fail." << pngName;
+    return 4;
+  }
+  return 0;
+}

package/native/vendor/microtex/example/samples/samples.cpp

@@ -0,0 +1,52 @@
+#include "samples.h"
+
+#include <algorithm>
+#include <fstream>
+
+using namespace std;
+using namespace microtex;
+
+void Samples::readSamples(const string& path) {
+  string line;
+  string sample;
+  std::ifstream f(path);
+  if (f.is_open()) {
+    while (getline(f, line)) {
+      // clang-format off
+      if (!line.empty() &&
+          !isSpace(line) &&
+          std::all_of(line.begin(), line.end(), [](char c) { return c == '%'; })
+        ) {
+        // clang-format on
+        add(sample);
+        sample = "";
+      } else {
+        if (!line.empty() && !isSpace(line)) sample += line + "\n";
+      }
+    }
+    f.close();
+  }
+  add(sample);
+}
+
+void Samples::add(const string& str) {
+  if (str.empty()) return;
+  if (isSpace(str)) return;
+  _samples.push_back(str);
+}
+
+bool Samples::isSpace(const string& str) {
+  return std::all_of(str.begin(), str.end(), [](char c) {
+    // FIXME
+    // avoid the disgusting Windows assertion `c > -1 && c < 255`
+    // return isspace(c);
+    return c == ' ' || c == '\r' || c == '\n';
+  });
+}
+
+const std::string& Samples::next() {
+  if (_index >= _samples.size()) _index = 0;
+  const std::string& x = _samples[_index];
+  _index++;
+  return x;
+}

package/native/vendor/microtex/example/samples/samples.h

@@ -0,0 +1,32 @@
+#ifndef MICROTEX_SAMPLES_H
+#define MICROTEX_SAMPLES_H
+
+#include <string>
+#include <vector>
+
+namespace microtex {
+
+class Samples {
+private:
+  int _index;
+  std::vector<std::string> _samples;
+
+  void readSamples(const std::string& path);
+
+  void add(const std::string& str);
+
+  bool isSpace(const std::string& str);
+
+public:
+  explicit Samples(const std::string& file) : _index(0) { readSamples(file); }
+
+  const std::string& next();
+
+  inline bool isEmpty() const { return _samples.empty(); }
+
+  inline int count() const { return _samples.size(); }
+};
+
+}  // namespace microtex
+
+#endif  // MICROTEX_SAMPLES_H

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

@@ -0,0 +1,15 @@
+add_executable(
+    microtex-win32-example
+    ../samples/samples.cpp
+    win32_main.cpp
+)
+
+target_include_directories(microtex-win32-example PUBLIC ../samples)
+
+set_target_properties(microtex-win32-example PROPERTIES WIN32_EXECUTABLE ON)
+
+target_link_libraries(
+    microtex-win32-example PRIVATE
+    microtex
+    microtex-gdi
+)

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

@@ -0,0 +1,18 @@
+example_gdi_src = [
+    'win32_main.cpp',
+    '../samples/samples.cpp'
+]
+example_gdi_inc = '../samples'
+
+example_gdi_deps = [
+    gdi_dep,
+    microtex_gdi_dep
+]
+
+executable(
+    'microtex-win32-example', example_gdi_src,
+    include_directories: example_gdi_inc,
+    link_with: [microtex_gdi_lib, microtex_lib],
+    dependencies: example_gdi_deps,
+    install: true
+)