@shqld/canvas 3.2.2-rc.1

package/src/color.h

@@ -0,0 +1,30 @@
+// Copyright (c) 2010 LearnBoost <tj@learnboost.com>
+
+#pragma once
+
+#include <stdint.h> // node < 7 uses libstdc++ on macOS which lacks complete c++11
+#include <cstdlib>
+
+/*
+ * RGBA struct.
+ */
+
+typedef struct {
+  double r, g, b, a;
+} rgba_t;
+
+/*
+ * Prototypes.
+ */
+
+rgba_t
+rgba_create(uint32_t rgba);
+
+int32_t
+rgba_from_string(const char *str, short *ok);
+
+void
+rgba_to_string(rgba_t rgba, char *buf, size_t len);
+
+void
+rgba_inspect(int32_t rgba);

package/src/dll_visibility.h

@@ -0,0 +1,20 @@
+#ifndef DLL_PUBLIC
+
+#if defined _WIN32
+  #ifdef __GNUC__
+    #define DLL_PUBLIC __attribute__ ((dllexport))
+  #else
+    #define DLL_PUBLIC __declspec(dllexport)
+  #endif
+  #define DLL_LOCAL
+#else
+  #if __GNUC__ >= 4
+    #define DLL_PUBLIC __attribute__ ((visibility ("default")))
+    #define DLL_LOCAL  __attribute__ ((visibility ("hidden")))
+  #else
+    #define DLL_PUBLIC
+    #define DLL_LOCAL
+  #endif
+#endif
+
+#endif

package/src/init.cc

@@ -0,0 +1,114 @@
+// Copyright (c) 2010 LearnBoost <tj@learnboost.com>
+
+#include <cstdio>
+#include <pango/pango.h>
+
+#include <cairo.h>
+#if CAIRO_VERSION < CAIRO_VERSION_ENCODE(1, 10, 0)
+// CAIRO_FORMAT_RGB16_565: undeprecated in v1.10.0
+// CAIRO_STATUS_INVALID_SIZE: v1.10.0
+// CAIRO_FORMAT_INVALID: v1.10.0
+// Lots of the compositing operators: v1.10.0
+// JPEG MIME tracking: v1.10.0
+// Note: CAIRO_FORMAT_RGB30 is v1.12.0 and still optional
+#error("cairo v1.10.0 or later is required")
+#endif
+
+#include "Canvas.h"
+#include "CanvasGradient.h"
+#include "CanvasPattern.h"
+#include "CanvasRenderingContext2d.h"
+#include "Image.h"
+#include "ImageData.h"
+#include "InstanceData.h"
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+/*
+ * Save some external modules as private references.
+ */
+
+static void
+setDOMMatrix(const Napi::CallbackInfo& info) {
+  InstanceData* data = info.Env().GetInstanceData<InstanceData>();
+  data->DOMMatrixCtor = Napi::Persistent(info[0].As<Napi::Function>());
+}
+
+static void
+setParseFont(const Napi::CallbackInfo& info) {
+  InstanceData* data = info.Env().GetInstanceData<InstanceData>();
+  data->parseFont = Napi::Persistent(info[0].As<Napi::Function>());
+}
+
+// Compatibility with Visual Studio versions prior to VS2015
+#if defined(_MSC_VER) && _MSC_VER < 1900
+#define snprintf _snprintf
+#endif
+
+Napi::Object init(Napi::Env env, Napi::Object exports) {
+  env.SetInstanceData(new InstanceData());
+
+  Canvas::Initialize(env, exports);
+  Image::Initialize(env, exports);
+  ImageData::Initialize(env, exports);
+  Context2d::Initialize(env, exports);
+  Gradient::Initialize(env, exports);
+  Pattern::Initialize(env, exports);
+
+  exports.Set("setDOMMatrix", Napi::Function::New(env, &setDOMMatrix));
+  exports.Set("setParseFont", Napi::Function::New(env, &setParseFont));
+
+  exports.Set("cairoVersion", Napi::String::New(env, cairo_version_string()));
+#ifdef HAVE_JPEG
+
+#ifndef JPEG_LIB_VERSION_MAJOR
+#ifdef JPEG_LIB_VERSION
+#define JPEG_LIB_VERSION_MAJOR (JPEG_LIB_VERSION / 10)
+#else
+#define JPEG_LIB_VERSION_MAJOR 0
+#endif
+#endif
+
+#ifndef JPEG_LIB_VERSION_MINOR
+#ifdef JPEG_LIB_VERSION
+#define JPEG_LIB_VERSION_MINOR (JPEG_LIB_VERSION % 10)
+#else
+#define JPEG_LIB_VERSION_MINOR 0
+#endif
+#endif
+
+  char jpeg_version[10];
+  static bool minor_gt_0 = JPEG_LIB_VERSION_MINOR > 0;
+  if (minor_gt_0) {
+    snprintf(jpeg_version, 10, "%d%c", JPEG_LIB_VERSION_MAJOR, JPEG_LIB_VERSION_MINOR + 'a' - 1);
+  } else {
+    snprintf(jpeg_version, 10, "%d", JPEG_LIB_VERSION_MAJOR);
+  }
+  exports.Set("jpegVersion", Napi::String::New(env, jpeg_version));
+#endif
+
+#ifdef HAVE_GIF
+#ifndef GIF_LIB_VERSION
+  char gif_version[10];
+  snprintf(gif_version, 10, "%d.%d.%d", GIFLIB_MAJOR, GIFLIB_MINOR, GIFLIB_RELEASE);
+  exports.Set("gifVersion", Napi::String::New(env, gif_version));
+#else
+  exports.Set("gifVersion", Napi::String::New(env, GIF_LIB_VERSION));
+#endif
+#endif
+
+#ifdef HAVE_RSVG
+  exports.Set("rsvgVersion", Napi::String::New(env, LIBRSVG_VERSION));
+#endif
+
+  exports.Set("pangoVersion", Napi::String::New(env, PANGO_VERSION_STRING));
+
+  char freetype_version[10];
+  snprintf(freetype_version, 10, "%d.%d.%d", FREETYPE_MAJOR, FREETYPE_MINOR, FREETYPE_PATCH);
+  exports.Set("freetypeVersion", Napi::String::New(env, freetype_version));
+
+  return exports;
+}
+
+NODE_API_MODULE(canvas, init);

package/src/register_font.cc

@@ -0,0 +1,352 @@
+#include "register_font.h"
+
+#include <pango/pangocairo.h>
+#include <pango/pango-fontmap.h>
+#include <pango/pango.h>
+
+#ifdef __APPLE__
+#include <CoreText/CoreText.h>
+#elif defined(_WIN32)
+#include <windows.h>
+#include <memory>
+#else
+#include <fontconfig/fontconfig.h>
+#endif
+
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_TRUETYPE_TABLES_H
+#include FT_SFNT_NAMES_H
+#include FT_TRUETYPE_IDS_H
+#ifndef FT_SFNT_OS2
+#define FT_SFNT_OS2 ft_sfnt_os2
+#endif
+
+// OSX seems to read the strings in MacRoman encoding and ignore Unicode entries.
+// You can verify this by opening a TTF with both Unicode and Macroman on OSX.
+// It uses the MacRoman name, while Fontconfig and Windows use Unicode
+#ifdef __APPLE__
+#define PREFERRED_PLATFORM_ID TT_PLATFORM_MACINTOSH
+#define PREFERRED_ENCODING_ID TT_MAC_ID_ROMAN
+#else
+#define PREFERRED_PLATFORM_ID TT_PLATFORM_MICROSOFT
+#define PREFERRED_ENCODING_ID TT_MS_ID_UNICODE_CS
+#endif
+
+#define IS_PREFERRED_ENC(X) \
+  X.platform_id == PREFERRED_PLATFORM_ID && X.encoding_id == PREFERRED_ENCODING_ID
+
+#define GET_NAME_RANK(X) \
+  (IS_PREFERRED_ENC(X) ? 1 : 0) + (X.name_id == TT_NAME_ID_PREFERRED_FAMILY ? 1 : 0)
+
+/*
+ * Return a UTF-8 encoded string given a TrueType name buf+len
+ * and its platform and encoding
+ */
+
+char *
+to_utf8(FT_Byte* buf, FT_UInt len, FT_UShort pid, FT_UShort eid) {
+  size_t ret_len = len * 4; // max chars in a utf8 string
+  char *ret = (char*)malloc(ret_len + 1); // utf8 string + null
+
+  if (!ret) return NULL;
+
+  // In my testing of hundreds of fonts from the Google Font repo, the two types
+  // of fonts are TT_PLATFORM_MICROSOFT with TT_MS_ID_UNICODE_CS encoding, or
+  // TT_PLATFORM_MACINTOSH with TT_MAC_ID_ROMAN encoding. Usually both, never neither
+
+  char const *fromcode;
+
+  if (pid == TT_PLATFORM_MACINTOSH && eid == TT_MAC_ID_ROMAN) {
+    fromcode = "MAC";
+  } else if (pid == TT_PLATFORM_MICROSOFT && eid == TT_MS_ID_UNICODE_CS) {
+    fromcode = "UTF-16BE";
+  } else {
+    free(ret);
+    return NULL;
+  }
+
+  GIConv cd = g_iconv_open("UTF-8", fromcode);
+
+  if (cd == (GIConv)-1) {
+    free(ret);
+    return NULL;
+  }
+
+  size_t inbytesleft = len;
+  size_t outbytesleft = ret_len;
+
+  size_t n_converted = g_iconv(cd, (char**)&buf, &inbytesleft, &ret, &outbytesleft);
+
+  ret -= ret_len - outbytesleft; // rewind the pointers to their
+  buf -= len - inbytesleft;      // original starting positions
+
+  if (n_converted == (size_t)-1) {
+    free(ret);
+    return NULL;
+  } else {
+    ret[ret_len - outbytesleft] = '\0';
+    return ret;
+  }
+}
+
+/*
+ * Find a family name in the face's name table, preferring the one the
+ * system, fall back to the other
+ */
+
+char *
+get_family_name(FT_Face face) {
+  FT_SfntName name;
+
+  int best_rank = -1;
+  char* best_buf = NULL;
+
+  for (unsigned i = 0; i < FT_Get_Sfnt_Name_Count(face); ++i) {
+    FT_Get_Sfnt_Name(face, i, &name);
+
+    if (name.name_id == TT_NAME_ID_FONT_FAMILY || name.name_id == TT_NAME_ID_PREFERRED_FAMILY) {
+      char *buf = to_utf8(name.string, name.string_len, name.platform_id, name.encoding_id);
+
+      if (buf) {
+        int rank = GET_NAME_RANK(name);
+        if (rank > best_rank) {
+          best_rank = rank;
+          if (best_buf) free(best_buf);
+          best_buf = buf;
+        } else {
+          free(buf);
+        }
+      }
+    }
+  }
+
+  return best_buf;
+}
+
+PangoWeight
+get_pango_weight(FT_UShort weight) {
+  switch (weight) {
+    case 100: return PANGO_WEIGHT_THIN;
+    case 200: return PANGO_WEIGHT_ULTRALIGHT;
+    case 300: return PANGO_WEIGHT_LIGHT;
+    #if PANGO_VERSION >= PANGO_VERSION_ENCODE(1, 36, 7)
+    case 350: return PANGO_WEIGHT_SEMILIGHT;
+    #endif
+    case 380: return PANGO_WEIGHT_BOOK;
+    case 400: return PANGO_WEIGHT_NORMAL;
+    case 500: return PANGO_WEIGHT_MEDIUM;
+    case 600: return PANGO_WEIGHT_SEMIBOLD;
+    case 700: return PANGO_WEIGHT_BOLD;
+    case 800: return PANGO_WEIGHT_ULTRABOLD;
+    case 900: return PANGO_WEIGHT_HEAVY;
+    case 1000: return PANGO_WEIGHT_ULTRAHEAVY;
+    default: return PANGO_WEIGHT_NORMAL;
+  }
+}
+
+PangoStretch
+get_pango_stretch(FT_UShort width) {
+  switch (width) {
+    case 1: return PANGO_STRETCH_ULTRA_CONDENSED;
+    case 2: return PANGO_STRETCH_EXTRA_CONDENSED;
+    case 3: return PANGO_STRETCH_CONDENSED;
+    case 4: return PANGO_STRETCH_SEMI_CONDENSED;
+    case 5: return PANGO_STRETCH_NORMAL;
+    case 6: return PANGO_STRETCH_SEMI_EXPANDED;
+    case 7: return PANGO_STRETCH_EXPANDED;
+    case 8: return PANGO_STRETCH_EXTRA_EXPANDED;
+    case 9: return PANGO_STRETCH_ULTRA_EXPANDED;
+    default: return PANGO_STRETCH_NORMAL;
+  }
+}
+
+PangoStyle
+get_pango_style(FT_Long flags) {
+  if (flags & FT_STYLE_FLAG_ITALIC) {
+    return PANGO_STYLE_ITALIC;
+  } else {
+    return PANGO_STYLE_NORMAL;
+  }
+}
+
+#ifdef _WIN32
+std::unique_ptr<wchar_t[]>
+u8ToWide(const char* str) {
+  int iBufferSize = MultiByteToWideChar(CP_UTF8, 0, str, -1, (wchar_t*)NULL, 0);
+  if(!iBufferSize){
+    return nullptr;
+  }
+  std::unique_ptr<wchar_t[]> wpBufWString = std::unique_ptr<wchar_t[]>{ new wchar_t[static_cast<size_t>(iBufferSize)] };
+  if(!MultiByteToWideChar(CP_UTF8, 0, str, -1, wpBufWString.get(), iBufferSize)){
+    return nullptr;
+  }
+  return wpBufWString;
+}
+
+static unsigned long 
+stream_read_func(FT_Stream stream, unsigned long offset, unsigned char* buffer, unsigned long count){
+  HANDLE hFile = reinterpret_cast<HANDLE>(stream->descriptor.pointer);
+  DWORD numberOfBytesRead;
+  OVERLAPPED overlapped;
+  overlapped.Offset = offset;
+  overlapped.OffsetHigh = 0;
+  overlapped.hEvent = NULL;
+  if(!ReadFile(hFile, buffer, count, &numberOfBytesRead, &overlapped)){
+    return 0;
+  }
+  return numberOfBytesRead;
+};
+
+static void 
+stream_close_func(FT_Stream stream){
+  HANDLE hFile = reinterpret_cast<HANDLE>(stream->descriptor.pointer);
+  CloseHandle(hFile);
+}
+#endif
+
+/*
+ * Return a PangoFontDescription that will resolve to the font file
+ */
+
+PangoFontDescription *
+get_pango_font_description(unsigned char* filepath) {
+  FT_Library library;
+  FT_Face face;
+  PangoFontDescription *desc = pango_font_description_new();
+#ifdef _WIN32
+  // FT_New_Face use fopen. 
+  // Unable to find the file when supplied the multibyte string path on the Windows platform and throw error "Could not parse font file".
+  // This workaround fixes this by reading the font file uses win32 wide character API.
+  std::unique_ptr<wchar_t[]> wFilepath = u8ToWide((char*)filepath);
+  if(!wFilepath){
+    return NULL;
+  }
+  HANDLE hFile = CreateFileW(
+        wFilepath.get(),
+        GENERIC_READ,
+        FILE_SHARE_READ,
+        NULL,
+        OPEN_EXISTING,
+        FILE_ATTRIBUTE_NORMAL,
+        NULL
+  );
+  if(!hFile){
+    return NULL;
+  }
+  LARGE_INTEGER liSize;
+  if(!GetFileSizeEx(hFile, &liSize)) {
+    CloseHandle(hFile);
+    return NULL;
+  }
+  FT_Open_Args args;
+  args.flags = FT_OPEN_STREAM;
+  FT_StreamRec stream;
+  stream.base = NULL;
+  stream.size = liSize.QuadPart;
+  stream.pos = 0;
+  stream.descriptor.pointer = hFile;
+  stream.read = stream_read_func;
+  stream.close = stream_close_func;
+  args.stream = &stream;
+  if (
+    !FT_Init_FreeType(&library) && 
+    !FT_Open_Face(library, &args, 0, &face)) {
+#else
+  if (!FT_Init_FreeType(&library) && !FT_New_Face(library, (const char*)filepath, 0, &face)) {
+#endif
+    TT_OS2 *table = (TT_OS2*)FT_Get_Sfnt_Table(face, FT_SFNT_OS2);
+    if (table) {
+      char *family = get_family_name(face);
+
+      if (!family) {
+        pango_font_description_free(desc);
+        FT_Done_Face(face);
+        FT_Done_FreeType(library);
+
+        return NULL;
+      }
+
+      pango_font_description_set_family(desc, family);
+      free(family);
+      pango_font_description_set_weight(desc, get_pango_weight(table->usWeightClass));
+      pango_font_description_set_stretch(desc, get_pango_stretch(table->usWidthClass));
+      pango_font_description_set_style(desc, get_pango_style(face->style_flags));
+
+      FT_Done_Face(face);
+      FT_Done_FreeType(library);
+
+      return desc;
+    }
+  }
+  pango_font_description_free(desc);
+
+  return NULL;
+}
+
+/*
+ * Register font with the OS
+ */
+
+bool
+register_font(unsigned char *filepath) {
+  bool success;
+  
+  #ifdef __APPLE__
+  CFURLRef filepathUrl = CFURLCreateFromFileSystemRepresentation(NULL, filepath, strlen((char*)filepath), false);
+  success = CTFontManagerRegisterFontsForURL(filepathUrl, kCTFontManagerScopeProcess, NULL);
+  #elif defined(_WIN32)
+  std::unique_ptr<wchar_t[]> wFilepath = u8ToWide((char*)filepath);
+  if(wFilepath){
+    success = AddFontResourceExW(wFilepath.get(), FR_PRIVATE, 0) != 0;
+  }else{
+    success = false;
+  }
+
+  #else
+  success = FcConfigAppFontAddFile(FcConfigGetCurrent(), (FcChar8 *)(filepath));
+  #endif
+
+  if (!success) return false;
+
+  // Tell Pango to throw away the current FontMap and create a new one. This
+  // has the effect of registering the new font in Pango by re-looking up all
+  // font families.
+  pango_cairo_font_map_set_default(NULL);
+
+  return true;
+}
+
+/*
+ * Deregister font from the OS
+ * Note that Linux (FontConfig) can only dereregister ALL fonts at once.
+ */
+
+bool
+deregister_font(unsigned char *filepath) {
+  bool success;
+  
+  #ifdef __APPLE__
+  CFURLRef filepathUrl = CFURLCreateFromFileSystemRepresentation(NULL, filepath, strlen((char*)filepath), false);
+  success = CTFontManagerUnregisterFontsForURL(filepathUrl, kCTFontManagerScopeProcess, NULL);
+  #elif defined(_WIN32)
+  std::unique_ptr<wchar_t[]> wFilepath = u8ToWide((char*)filepath);
+  if(wFilepath){
+    success = RemoveFontResourceExW(wFilepath.get(), FR_PRIVATE, 0) != 0;
+  }else{
+    success = false;
+  }
+  #else
+  FcConfigAppFontClear(FcConfigGetCurrent());
+  success = true;
+  #endif
+
+  if (!success) return false;
+
+  // Tell Pango to throw away the current FontMap and create a new one. This
+  // has the effect of deregistering the font in Pango by re-looking up all
+  // font families.
+  pango_cairo_font_map_set_default(NULL);
+
+  return true;
+}

package/src/register_font.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <pango/pango.h>
+
+PangoFontDescription *get_pango_font_description(unsigned char *filepath);
+bool register_font(unsigned char *filepath);
+bool deregister_font(unsigned char *filepath);

package/util/has_lib.js

@@ -0,0 +1,119 @@
+const query = process.argv[2]
+const fs = require('fs')
+const childProcess = require('child_process')
+
+const SYSTEM_PATHS = [
+  '/lib',
+  '/usr/lib',
+  '/usr/lib64',
+  '/usr/local/lib',
+  '/opt/local/lib',
+  '/opt/homebrew/lib',
+  '/usr/lib/x86_64-linux-gnu',
+  '/usr/lib/i386-linux-gnu',
+  '/usr/lib/arm-linux-gnueabihf',
+  '/usr/lib/arm-linux-gnueabi',
+  '/usr/lib/aarch64-linux-gnu'
+]
+
+/**
+ * Checks for lib using ldconfig if present, or searching SYSTEM_PATHS
+ * otherwise.
+ * @param {string} lib - library name, e.g. 'jpeg' in 'libjpeg64.so' (see first line)
+ * @return {boolean} exists
+ */
+function hasSystemLib (lib) {
+  const libName = 'lib' + lib + '.+(so|dylib)'
+  const libNameRegex = new RegExp(libName)
+
+  // Try using ldconfig on linux systems
+  if (hasLdconfig()) {
+    try {
+      if (childProcess.execSync('ldconfig -p 2>/dev/null | grep -E "' + libName + '"').length) {
+        return true
+      }
+    } catch (err) {
+      // noop -- proceed to other search methods
+    }
+  }
+
+  // Try checking common library locations
+  return SYSTEM_PATHS.some(function (systemPath) {
+    try {
+      const dirListing = fs.readdirSync(systemPath)
+      return dirListing.some(function (file) {
+        return libNameRegex.test(file)
+      })
+    } catch (err) {
+      return false
+    }
+  })
+}
+
+/**
+ * Checks for ldconfig on the path and /sbin
+ * @return {boolean} exists
+ */
+function hasLdconfig () {
+  try {
+    // Add /sbin to path as ldconfig is located there on some systems -- e.g.
+    // Debian (and it can still be used by unprivileged users):
+    childProcess.execSync('export PATH="$PATH:/sbin"')
+    process.env.PATH = '...'
+    // execSync throws on nonzero exit
+    childProcess.execSync('hash ldconfig 2>/dev/null')
+    return true
+  } catch (err) {
+    return false
+  }
+}
+
+/**
+ * Checks for freetype2 with --cflags-only-I
+ * @return Boolean exists
+ */
+function hasFreetype () {
+  try {
+    if (childProcess.execSync('pkg-config cairo --cflags-only-I 2>/dev/null | grep freetype2').length) {
+      return true
+    }
+  } catch (err) {
+    // noop
+  }
+  return false
+}
+
+/**
+ * Checks for lib using pkg-config.
+ * @param {string} lib - library name
+ * @return {boolean} exists
+ */
+function hasPkgconfigLib (lib) {
+  try {
+    // execSync throws on nonzero exit
+    childProcess.execSync('pkg-config --exists "' + lib + '" 2>/dev/null')
+    return true
+  } catch (err) {
+    return false
+  }
+}
+
+function main (query) {
+  switch (query) {
+    case 'gif':
+    case 'cairo':
+      return hasSystemLib(query)
+    case 'pango':
+      return hasPkgconfigLib(query)
+    case 'freetype':
+      return hasFreetype()
+    case 'jpeg':
+      return hasPkgconfigLib('libjpeg')
+    case 'rsvg':
+      return hasPkgconfigLib('librsvg-2.0')
+    default:
+      throw new Error('Unknown library: ' + query)
+  }
+}
+
+process.stdout.write(main(query).toString())

package/util/win_jpeg_lookup.js

@@ -0,0 +1,21 @@
+const fs = require('fs')
+const paths = ['C:/libjpeg-turbo']
+
+if (process.arch === 'x64') {
+  paths.unshift('C:/libjpeg-turbo64')
+}
+
+paths.forEach(function (path) {
+  if (exists(path)) {
+    process.stdout.write(path)
+    process.exit()
+  }
+})
+
+function exists (path) {
+  try {
+    return fs.lstatSync(path).isDirectory()
+  } catch (e) {
+    return false
+  }
+}