@simonklee/opentui-tex-native-source 0.2.0

package/native/vendor/microtex/meson.build

@@ -0,0 +1,75 @@
+project('microtex', 'cpp', 'c',
+	version : '1.0.0',
+	default_options : ['buildtype=release', 'warning_level=0', 'cpp_std=c++17']
+)
+
+cpp = meson.get_compiler('cpp')
+
+# the API (and ABI) is compatiable if API version is the same
+microtex_api_version = 1
+
+if get_option('TARGET_DEVEL')
+  pkgconfig = import('pkgconfig')
+endif
+
+subdir('lib')
+
+if get_option('CAIRO')
+  subdir('platform/cairo')
+  if get_option('EXAMPLE_GTKMM')
+    subdir('example/gtkmm')
+  endif
+else
+  if get_option('EXAMPLE_GTKMM')
+    error('EXAMPLE_GTKMM was enabled, but it requires CAIRO platform')
+  endif
+endif
+
+if get_option('GTK')
+  if not get_option('CAIRO')
+    error('GTK was enabled, but it requires CAIRO platform')
+  endif
+  subdir('platform/gtk')
+  if get_option('EXAMPLE_GTK')
+    subdir('example/gtk')
+  endif
+else
+  if get_option('EXAMPLE_GTK')
+    error('EXAMPLE_GTK was enabled, but it requires GTK platform')
+  endif
+endif
+
+if get_option('QT')
+  subdir('platform/qt')
+  if get_option('EXAMPLE_QT')
+    subdir('example/qt')
+  endif
+else
+  if get_option('EXAMPLE_QT')
+    error('EXAMPLE_QT was enabled, but it requires QT platform')
+  endif
+endif
+
+gdi_dep = cpp.find_library('gdiplus', required: get_option('GDI'))
+if gdi_dep.found() and cpp.has_header('windows.h')
+  subdir('platform/gdi_win')
+  if get_option('EXAMPLE_WIN32')
+    subdir('example/win32')
+  endif
+else
+  if get_option('EXAMPLE_WIN32')
+    error('EXAMPLE_WIN32 was enabled, but it requires GDI platform')
+  endif
+endif
+
+if cpp.get_id() == 'emscripten'
+  subdir('platform/wasm')
+endif
+
+if get_option('TEST')
+    subdir('test')
+endif
+
+if get_option('TARGET_DOCUMENTATION')
+    subdir('doc')
+endif

package/native/vendor/microtex/meson_options.txt

@@ -0,0 +1,29 @@
+option('HAVE_AUTO_FONT_FIND', type: 'boolean', value: true)
+
+# generate pkgconfig files & install headers
+option('TARGET_DEVEL', type : 'boolean', value : true)
+# generate documentation for gtk (requires TAGET_DEVEL)
+option('TARGET_DOCUMENTATION', type: 'boolean', value: false)
+
+# if build tests
+option('TEST', type: 'boolean', value: true)
+
+# if build cairo
+option('CAIRO', type: 'boolean', value: true)
+# if build gtkmm example
+option('EXAMPLE_GTKMM', type : 'boolean', value: true)
+
+# if build gtk (note: requires cairo)
+option('GTK', type: 'boolean', value: true)
+# if build gtk example
+option('EXAMPLE_GTK', type : 'boolean', value: true)
+
+# if build qt
+option('QT', type: 'boolean', value: true)
+# if build qt example
+option('EXAMPLE_QT', type: 'boolean', value: true)
+
+# if build gdi
+option('GDI', type: 'feature')
+# if build win32 example
+option('EXAMPLE_WIN32', type: 'boolean', value: false)

package/native/vendor/microtex/platform/cairo/CMakeLists.txt

@@ -0,0 +1,36 @@
+message(STATUS "Cross-building using GTK")
+
+add_library(microtex-cairo SHARED graphic_cairo.cpp)
+
+set_target_properties(
+    microtex-cairo PROPERTIES
+    VERSION ${PROJECT_VERSION}
+    SOVERSION ${MICROTEX_API_VERSION}
+    CXX_VISIBILITY_PRESET hidden
+)
+
+find_package(Fontconfig REQUIRED)
+find_package(PkgConfig REQUIRED)
+pkg_check_modules(Cairo REQUIRED IMPORTED_TARGET cairo)
+pkg_check_modules(Pango REQUIRED IMPORTED_TARGET pango)
+pkg_check_modules(Pangocairo REQUIRED IMPORTED_TARGET pangocairo)
+
+target_include_directories(
+    microtex-cairo PUBLIC
+    $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}>
+    $<INSTALL_INTERFACE:include/microtex-cairo>
+)
+
+# we need to export the library on Windows
+target_compile_definitions(microtex-cairo PRIVATE -DMICROTEX_LIBRARY)
+target_link_libraries(
+    microtex-cairo PRIVATE
+    microtex
+    Fontconfig::Fontconfig
+    PkgConfig::Cairo
+    PkgConfig::Pango
+    PkgConfig::Pangocairo
+)
+
+microtex_install_target(microtex-cairo)
+microtex_install_headers(microtex-cairo HEADERS graphic_cairo.h)

package/native/vendor/microtex/platform/cairo/graphic_cairo.cpp

@@ -0,0 +1,384 @@
+#include <fontconfig/fontconfig.h>
+// #include <cairo/cairo-ft.h>
+#include <cairo-ft.h>
+#include <pango/pangocairo.h>
+
+#include <utility>
+
+#include "graphic_cairo.h"
+#include "utils/log.h"
+#include "utils/utf.h"
+
+using namespace microtex;
+using namespace std;
+
+namespace cairopp {
+
+struct cairo_font_face_deleter {
+  void operator()(cairo_font_face_t* ptr) { cairo_font_face_destroy(ptr); }
+};
+
+struct cairo_ctx_deleter {
+  void operator()(cairo_t* ptr) { cairo_destroy(ptr); }
+};
+
+inline CairoFontFacePtr cairo_font_face_make_cairopp_ptr(cairo_font_face_t* ptr) {
+  return CairoFontFacePtr(ptr, cairo_font_face_deleter());
+}
+
+inline CairoCtxPtr cairo_ctx_make_cairopp_ptr(cairo_t* ptr) {
+  return CairoCtxPtr(ptr, cairo_ctx_deleter());
+}
+
+}  // namespace cairopp
+
+map<string, cairopp::CairoFontFacePtr> Font_cairo::_cairoFtFaces;
+
+Font_cairo::Font_cairo(const string& file) {
+  loadFont(file);
+}
+
+Font_cairo::~Font_cairo() {}
+
+void Font_cairo::loadFont(const string& file) {
+  auto ffaceEntry = _cairoFtFaces.find(file);
+  if (ffaceEntry != _cairoFtFaces.end()) {
+    // already loaded
+    _fface = ffaceEntry->second.get();
+    return;
+  }
+
+  // query font via fontconfig
+  const auto f = (const FcChar8*)file.c_str();
+
+  // get font family from file first
+  int count;
+  FcChar8* family = nullptr;
+  FcBlanks* blanks = FcConfigGetBlanks(nullptr);
+  FcPattern* p = FcFreeTypeQuery(f, 0, blanks, &count);
+  FcPatternGetString(p, FC_FAMILY, 0, &family);
+#ifdef HAVE_LOG
+  dbg("Load font: %s, count: %d\n", file.c_str(), count);
+  FcPatternPrint(p);
+#endif
+
+  // load font to fontconfig
+  FcBool status = FcConfigAppFontAddFile(nullptr, f);
+#ifdef HAVE_LOG
+  if (!status) dbg(ANSI_COLOR_RED "Load %s failed\n" ANSI_RESET, file.c_str());
+#endif
+
+  _fface = cairo_ft_font_face_create_for_pattern(p);
+  _cairoFtFaces.insert(std::pair<string, cairopp::CairoFontFacePtr>(
+    file,
+    cairopp::cairo_font_face_make_cairopp_ptr(_fface)
+  ));
+
+  // release
+  FcPatternDestroy(p);
+}
+
+cairo_font_face_t* Font_cairo::getCairoFontFace() const {
+  return _fface;
+}
+
+bool Font_cairo::operator==(const Font& ft) const {
+  const auto& f = static_cast<const Font_cairo&>(ft);
+  return _fface == f._fface;
+}
+
+/**************************************************************************************************/
+
+cairopp::CairoCtxPtr TextLayout_cairo::_img_context;
+
+TextLayout_cairo::TextLayout_cairo(const string& src, FontStyle style, float size) {
+  if (!_img_context) {
+    auto surface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 1, 1);
+    _img_context = cairopp::cairo_ctx_make_cairopp_ptr(cairo_create(surface));
+  }
+
+  _layout = pango_cairo_create_layout(_img_context.get());
+
+  PangoFontDescription* fd = pango_font_description_new();
+  pango_font_description_set_absolute_size(fd, size * PANGO_SCALE);
+  pango_font_description_set_style(fd, PANGO_STYLE_NORMAL);
+  pango_font_description_set_weight(fd, PANGO_WEIGHT_NORMAL);
+  pango_font_description_set_family_static(fd, "Serif");
+
+  if (microtex::isSansSerif(style)) {
+    pango_font_description_set_family_static(fd, "Sans-Serif");
+  }
+  if (microtex::isMono(style)) {
+    pango_font_description_set_family_static(fd, "Monospace");
+  }
+  if (microtex::isBold(style)) {
+    pango_font_description_set_weight(fd, PANGO_WEIGHT_BOLD);
+  }
+  if (microtex::isItalic(style)) {
+    pango_font_description_set_style(fd, PANGO_STYLE_ITALIC);
+  }
+
+  pango_layout_set_text(_layout, src.c_str(), src.length());
+  pango_layout_set_font_description(_layout, fd);
+  pango_font_description_free(fd);
+
+  _ascent = (float)(pango_layout_get_baseline(_layout) / PANGO_SCALE);
+}
+
+TextLayout_cairo::~TextLayout_cairo() {
+  g_object_unref(_layout);
+}
+
+void TextLayout_cairo::getBounds(Rect& r) {
+  int w, h;
+  pango_layout_get_pixel_size(_layout, &w, &h);
+  r.x = 0;
+  r.w = (float)w;
+  PangoRectangle rect;
+  pango_layout_get_pixel_extents(_layout, &rect, NULL);
+  r.y = -_ascent + rect.y;
+  r.h = rect.height;
+}
+
+void TextLayout_cairo::draw(Graphics2D& g2, float x, float y) {
+  // FIXME
+  // draw line, I don't know why the layout is shown in wrong position
+  // when line was not drawn
+  color old = g2.getColor();
+  g2.setColor(0x00000000);
+  g2.drawLine(x, y, x + 1, y);
+  // draw layout
+  g2.setColor(old);
+  g2.translate(x, y - _ascent);
+  auto& g = static_cast<Graphics2D_cairo&>(g2);
+  pango_cairo_show_layout(g.getCairoContext(), _layout);
+  g2.translate(-x, -y + _ascent);
+}
+
+/**************************************************************************************************/
+
+sptr<Font> PlatformFactory_cairo::createFont(const std::string& file) {
+  return sptrOf<Font_cairo>(file);
+}
+
+sptr<TextLayout>
+PlatformFactory_cairo::createTextLayout(const std::string& src, FontStyle style, float size) {
+  return sptrOf<TextLayout_cairo>(src, style, size);
+}
+
+/**************************************************************************************************/
+
+Graphics2D_cairo::Graphics2D_cairo(cairo_t* context) : _context(cairo_reference(context)), _font() {
+  _sx = _sy = 1.f;
+  setColor(BLACK);
+  setStroke(Stroke());
+}
+
+Graphics2D_cairo::~Graphics2D_cairo() {
+  unsigned int rc = cairo_get_reference_count(_context);
+  cairo_destroy(_context);
+}
+
+cairo_t* Graphics2D_cairo::getCairoContext() const {
+  return _context;
+}
+
+void Graphics2D_cairo::setColor(color c) {
+  _color = c;
+  const double a = color_a(c) / 255.;
+  const double r = color_r(c) / 255.;
+  const double g = color_g(c) / 255.;
+  const double b = color_b(c) / 255.;
+  cairo_set_source_rgba(_context, r, g, b, a);
+}
+
+color Graphics2D_cairo::getColor() const {
+  return _color;
+}
+
+void Graphics2D_cairo::setStroke(const Stroke& s) {
+  _stroke = s;
+  cairo_set_line_width(_context, (double)s.lineWidth);
+
+  // convert abstract line cap to platform line cap
+  cairo_line_cap_t c;
+  switch (s.cap) {
+    case CAP_BUTT: c = CAIRO_LINE_CAP_BUTT; break;
+    case CAP_ROUND: c = CAIRO_LINE_CAP_ROUND; break;
+    case CAP_SQUARE: c = CAIRO_LINE_CAP_SQUARE; break;
+  }
+  cairo_set_line_cap(_context, c);
+
+  // convert abstract line join to platform line join
+  cairo_line_join_t j;
+  switch (s.join) {
+    case JOIN_BEVEL: j = CAIRO_LINE_JOIN_BEVEL; break;
+    case JOIN_ROUND: j = CAIRO_LINE_JOIN_ROUND; break;
+    case JOIN_MITER: j = CAIRO_LINE_JOIN_MITER; break;
+  }
+  cairo_set_line_join(_context, j);
+
+  cairo_set_miter_limit(_context, (double)s.miterLimit);
+}
+
+const Stroke& Graphics2D_cairo::getStroke() const {
+  return _stroke;
+}
+
+void Graphics2D_cairo::setStrokeWidth(float w) {
+  _stroke.lineWidth = w;
+  cairo_set_line_width(_context, (double)w);
+}
+
+void Graphics2D_cairo::setDash(const std::vector<float>& dash) {
+  if (dash.empty()) {
+    cairo_set_dash(_context, nullptr, 0, 0.);
+  } else {
+    const vector<double> ddash(dash.begin(), dash.end());
+    cairo_set_dash(_context, ddash.data(), ddash.size(), 0.);
+  }
+}
+
+std::vector<float> Graphics2D_cairo::getDash() {
+  vector<double> dash(cairo_get_dash_count(_context));
+  double offset;
+  cairo_get_dash(_context, dash.data(), &offset);
+  return vector<float>(dash.begin(), dash.end());
+}
+
+sptr<Font> Graphics2D_cairo::getFont() const {
+  return _font;
+}
+
+void Graphics2D_cairo::setFont(const sptr<Font>& font) {
+  _font = static_pointer_cast<Font_cairo>(font);
+}
+
+float Graphics2D_cairo::getFontSize() const {
+  return _fontSize;
+}
+
+void Graphics2D_cairo::setFontSize(float size) {
+  _fontSize = size;
+}
+
+void Graphics2D_cairo::translate(float dx, float dy) {
+  cairo_translate(_context, (double)dx, (double)dy);
+}
+
+void Graphics2D_cairo::scale(float sx, float sy) {
+  _sx *= sx;
+  _sy *= sy;
+  cairo_scale(_context, (double)sx, (double)sy);
+}
+
+void Graphics2D_cairo::rotate(float angle) {
+  cairo_rotate(_context, (double)angle);
+}
+
+void Graphics2D_cairo::rotate(float angle, float px, float py) {
+  cairo_translate(_context, (double)px, (double)py);
+  cairo_rotate(_context, (double)angle);
+  cairo_translate(_context, (double)-px, (double)-py);
+}
+
+void Graphics2D_cairo::reset() {
+  cairo_identity_matrix(_context);
+  _sx = _sy = 1.f;
+}
+
+float Graphics2D_cairo::sx() const {
+  return _sx;
+}
+
+float Graphics2D_cairo::sy() const {
+  return _sy;
+}
+
+void Graphics2D_cairo::drawGlyph(u16 glyph, float x, float y) {
+  cairo_set_font_face(_context, _font->getCairoFontFace());
+  cairo_set_font_size(_context, _fontSize);
+  cairo_glyph_t g[1]{
+    {glyph, (double)x, (double)y}
+  };
+  cairo_show_glyphs(_context, g, 1);
+}
+
+bool Graphics2D_cairo::beginPath(i32 id) {
+  cairo_new_path(_context);
+  return false;
+}
+
+void Graphics2D_cairo::moveTo(float x, float y) {
+  cairo_move_to(_context, (double)x, (double)y);
+}
+
+void Graphics2D_cairo::lineTo(float x, float y) {
+  cairo_line_to(_context, x, y);
+}
+
+void Graphics2D_cairo::cubicTo(float x1, float y1, float x2, float y2, float x3, float y3) {
+  cairo_curve_to(_context, x1, y1, x2, y2, x3, y3);
+}
+
+void Graphics2D_cairo::quadTo(float x1, float y1, float x2, float y2) {
+  // See https://en.wikipedia.org/wiki/B%C3%A9zier_curve#Degree_elevation
+  // and https://lists.cairographics.org/archives/cairo/2010-April/019691.html
+  // for details
+  double x0, y0;
+  cairo_get_current_point(_context, &x0, &y0);
+  cairo_curve_to(
+    _context,
+    2.0 / 3.0 * x1 + 1.0 / 3.0 * x0,
+    2.0 / 3.0 * y1 + 1.0 / 3.0 * y0,
+    2.0 / 3.0 * x1 + 1.0 / 3.0 * x2,
+    2.0 / 3.0 * y1 + 1.0 / 3.0 * y2,
+    y1,
+    y2
+  );
+}
+
+void Graphics2D_cairo::closePath() {
+  cairo_close_path(_context);
+}
+
+void Graphics2D_cairo::fillPath(i32 id) {
+  cairo_fill(_context);
+}
+
+void Graphics2D_cairo::drawLine(float x1, float y1, float x2, float y2) {
+  cairo_move_to(_context, x1, y1);
+  cairo_line_to(_context, x2, y2);
+  cairo_stroke(_context);
+}
+
+void Graphics2D_cairo::drawRect(float x, float y, float w, float h) {
+  cairo_rectangle(_context, x, y, w, h);
+  cairo_stroke(_context);
+}
+
+void Graphics2D_cairo::fillRect(float x, float y, float w, float h) {
+  cairo_rectangle(_context, x, y, w, h);
+  cairo_fill(_context);
+}
+
+void Graphics2D_cairo::roundRect(float x, float y, float w, float h, float rx, float ry) {
+  double r = max(rx, ry);
+  double d = G_PI / 180.;
+  cairo_new_sub_path(_context);
+  cairo_arc(_context, x + r, y + r, r, 180 * d, 270 * d);
+  cairo_arc(_context, x + w - r, y + r, r, -90 * d, 0);
+  cairo_arc(_context, x + w - r, y + h - r, r, 0, 90 * d);
+  cairo_arc(_context, x + r, y + h - r, r, 90 * d, 180 * d);
+  cairo_close_path(_context);
+}
+
+void Graphics2D_cairo::drawRoundRect(float x, float y, float w, float h, float rx, float ry) {
+  roundRect(x, y, w, h, rx, ry);
+  cairo_stroke(_context);
+}
+
+void Graphics2D_cairo::fillRoundRect(float x, float y, float w, float h, float rx, float ry) {
+  roundRect(x, y, w, h, rx, ry);
+  cairo_fill(_context);
+}

package/native/vendor/microtex/platform/cairo/graphic_cairo.h

@@ -0,0 +1,119 @@
+#ifndef GRAPHIC_CAIRO_H_INCLUDED
+#define GRAPHIC_CAIRO_H_INCLUDED
+
+#include <cairo.h>
+#include <pango/pango.h>
+
+#include "graphic/graphic.h"
+#include "microtexexport.h"
+
+namespace cairopp {
+
+typedef std::shared_ptr<cairo_font_face_t> CairoFontFacePtr;
+typedef std::shared_ptr<cairo_t> CairoCtxPtr;
+
+}  // namespace cairopp
+
+namespace microtex {
+
+class MICROTEX_EXPORT Font_cairo : public Font {
+private:
+  static std::map<std::string, cairopp::CairoFontFacePtr> _cairoFtFaces;
+
+  cairo_font_face_t* _fface;
+
+  void loadFont(const std::string& file);
+
+public:
+  explicit Font_cairo(const std::string& file);
+
+  ~Font_cairo() override;
+
+  cairo_font_face_t* getCairoFontFace() const;
+
+  bool operator==(const Font& f) const override;
+};
+
+/**************************************************************************************************/
+
+class MICROTEX_EXPORT TextLayout_cairo : public TextLayout {
+private:
+  static cairopp::CairoCtxPtr _img_context;
+  PangoLayout* _layout;
+  float _ascent;
+
+public:
+  TextLayout_cairo(const std::string& src, FontStyle style, float size);
+
+  ~TextLayout_cairo() override;
+
+  void getBounds(Rect& r) override;
+
+  void draw(Graphics2D& g2, float x, float y) override;
+};
+
+/**************************************************************************************************/
+
+class MICROTEX_EXPORT PlatformFactory_cairo : public PlatformFactory {
+public:
+  sptr<Font> createFont(const std::string& file) override;
+
+  sptr<TextLayout> createTextLayout(const std::string& src, FontStyle style, float size) override;
+};
+
+/**************************************************************************************************/
+
+class MICROTEX_EXPORT Graphics2D_cairo : public Graphics2D {
+private:
+  cairo_t* _context;
+  color _color;
+  Stroke _stroke;
+  sptr<Font_cairo> _font;
+  float _fontSize;
+  float _sx, _sy;
+
+  void roundRect(float x, float y, float w, float h, float rx, float ry);
+
+public:
+  explicit Graphics2D_cairo(cairo_t* context);
+
+  ~Graphics2D_cairo() override;
+
+  cairo_t* getCairoContext() const;
+
+  void setColor(color c) override;
+  color getColor() const override;
+  void setStroke(const Stroke& s) override;
+  const Stroke& getStroke() const override;
+  void setStrokeWidth(float w) override;
+  void setDash(const std::vector<float>& dash) override;
+  std::vector<float> getDash() override;
+  sptr<Font> getFont() const override;
+  void setFont(const sptr<Font>& font) override;
+  float getFontSize() const override;
+  void setFontSize(float size) override;
+  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;
+  float sy() const override;
+  void drawGlyph(u16 glyph, float x, float y) override;
+  bool beginPath(i32 id) override;
+  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 x, 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
+
+#endif  // GRAPHIC_CAIRO_H_INCLUDED

package/native/vendor/microtex/platform/cairo/meson.build

@@ -0,0 +1,47 @@
+cairo_src = [
+    'graphic_cairo.cpp'
+]
+
+cairo_deps = [
+    dependency('fontconfig'),
+    dependency('cairo'),
+    dependency('cairo-ft'),
+    dependency('pango'),
+    dependency('pangocairo')
+]
+
+microtex_cairo_lib = library('microtex-cairo', cairo_src,
+    link_with: microtex_lib,
+    include_directories: inc,
+    dependencies: cairo_deps,
+    version: meson.project_version(),
+    soversion: microtex_api_version,
+    install: true
+)
+
+microtex_cairo_dep = declare_dependency(
+	link_with: [microtex_lib, microtex_cairo_lib],
+	include_directories: ['.', inc],
+	dependencies: [
+		dependency('cairo'),
+		dependency('pango'),
+	],
+	version: meson.project_version()
+)
+
+if get_option('TARGET_DEVEL')
+    pkgconfig.generate(microtex_cairo_lib,
+        libraries: microtex_lib,
+        version: meson.project_version(),
+        name: 'microtex-cairo',
+        filebase: 'microtex-cairo',
+        subdirs: ['microtex/platform/cairo'],
+        description: 'cairomm backend to microtex'
+    )
+endif
+
+if install_headerfiles
+    install_headers([
+        'graphic_cairo.h'
+    ], subdir: 'microtex/platform/cairo')
+endif

package/native/vendor/microtex/platform/cairo/microtex-cairoConfig.cmake.in

@@ -0,0 +1,11 @@
+include(CMakeFindDependencyMacro)
+
+find_dependency(microtex REQUIRED)
+# FIXME is these really needed?
+find_dependency(Fontconfig REQUIRED)
+find_dependency(PkgConfig REQUIRED)
+pkg_check_modules(Cairo REQUIRED IMPORTED_TARGET cairo)
+pkg_check_modules(Pango REQUIRED IMPORTED_TARGET pango)
+pkg_check_modules(Pangocairo REQUIRED IMPORTED_TARGET pangocairo)
+
+include("${CMAKE_CURRENT_LIST_DIR}/microtex-cairoTargets.cmake")