@shqld/canvas 3.2.2-rc.1

package/src/Canvas.h

@@ -0,0 +1,128 @@
+// Copyright (c) 2010 LearnBoost <tj@learnboost.com>
+
+#pragma once
+
+struct Closure;
+struct PdfSvgClosure;
+
+#include "closure.h"
+#include <cairo.h>
+#include "dll_visibility.h"
+#include <napi.h>
+#include <pango/pangocairo.h>
+#include <vector>
+#include <cstddef>
+
+/*
+ * Canvas types.
+ */
+
+typedef enum {
+  CANVAS_TYPE_IMAGE,
+  CANVAS_TYPE_PDF,
+  CANVAS_TYPE_SVG
+} canvas_type_t;
+
+
+/*
+ * FontFace describes a font file in terms of one PangoFontDescription that
+ * will resolve to it and one that the user describes it as (like @font-face)
+ */
+class FontFace {
+  public:
+    PangoFontDescription *sys_desc = nullptr;
+    PangoFontDescription *user_desc = nullptr;
+    unsigned char file_path[1024];
+};
+
+enum text_baseline_t : uint8_t {
+  TEXT_BASELINE_ALPHABETIC = 0,
+  TEXT_BASELINE_TOP = 1,
+  TEXT_BASELINE_BOTTOM = 2,
+  TEXT_BASELINE_MIDDLE = 3,
+  TEXT_BASELINE_IDEOGRAPHIC = 4,
+  TEXT_BASELINE_HANGING = 5
+};
+
+enum text_align_t : int8_t {
+  TEXT_ALIGNMENT_LEFT = -1,
+  TEXT_ALIGNMENT_CENTER = 0,
+  TEXT_ALIGNMENT_RIGHT = 1,
+  TEXT_ALIGNMENT_START = -2,
+  TEXT_ALIGNMENT_END = 2
+};
+
+enum canvas_draw_mode_t : uint8_t {
+  TEXT_DRAW_PATHS,
+  TEXT_DRAW_GLYPHS
+};
+
+/*
+ * Canvas.
+ */
+
+class Canvas : public Napi::ObjectWrap<Canvas> {
+  public:
+    Canvas(const Napi::CallbackInfo& info);
+    ~Canvas();
+    static void Initialize(Napi::Env& env, Napi::Object& target);
+
+    Napi::Value ToBuffer(const Napi::CallbackInfo& info);
+    Napi::Value GetType(const Napi::CallbackInfo& info);
+    Napi::Value GetStride(const Napi::CallbackInfo& info);
+    Napi::Value GetWidth(const Napi::CallbackInfo& info);
+    Napi::Value GetHeight(const Napi::CallbackInfo& info);
+    void SetWidth(const Napi::CallbackInfo& info, const Napi::Value& value);
+    void SetHeight(const Napi::CallbackInfo& info, const Napi::Value& value);
+    void StreamPNGSync(const Napi::CallbackInfo& info);
+    void StreamPDFSync(const Napi::CallbackInfo& info);
+    void StreamJPEGSync(const Napi::CallbackInfo& info);
+    static void RegisterFont(const Napi::CallbackInfo& info);
+    static void DeregisterAllFonts(const Napi::CallbackInfo& info);
+    static Napi::Value ParseFont(const Napi::CallbackInfo& info);
+    Napi::Error CairoError(cairo_status_t status);
+    static void ToPngBufferAsync(Closure* closure);
+    static void ToJpegBufferAsync(Closure* closure);
+    static PangoWeight GetWeightFromCSSString(const char *weight);
+    static PangoStyle GetStyleFromCSSString(const char *style);
+    static PangoFontDescription *ResolveFontDescription(const PangoFontDescription *desc);
+
+    inline bool isPDF() { return type == CANVAS_TYPE_PDF; }
+    inline bool isSVG() { return type == CANVAS_TYPE_SVG; }
+    inline bool isImage() { return type == CANVAS_TYPE_IMAGE; }
+    inline void *closure() { return _closure; }
+
+    cairo_t* createCairoContext();
+
+    DLL_PUBLIC inline uint8_t *data() { return cairo_image_surface_get_data(ensureSurface()); }
+    DLL_PUBLIC inline int stride() { return cairo_image_surface_get_stride(ensureSurface()); }
+    DLL_PUBLIC inline std::size_t nBytes() {
+      return static_cast<std::size_t>(height) * stride();
+    }
+
+    DLL_PUBLIC inline uint16_t getWidth() { return width; }
+    DLL_PUBLIC inline uint16_t getHeight() { return height; }
+
+    uint8_t approxBytesPerPixel();
+    void setFormat(cairo_format_t format);
+    cairo_format_t getFormat();
+    void resurface(Napi::Object This, uint16_t width, uint16_t height);
+    cairo_surface_t *ensureSurface();
+    void destroySurface();
+
+    Napi::Env env;
+    static int fontSerial;
+
+  private:
+
+    cairo_surface_t *_surface;
+    PdfSvgClosure *_closure;
+
+    Napi::FunctionReference ctor;
+    static std::vector<FontFace> font_face_list;
+
+    uint16_t width;
+    uint16_t height;
+    canvas_type_t type;
+    cairo_format_t format;
+};

package/src/CanvasError.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <string>
+#include <napi.h>
+
+class CanvasError {
+  public:
+    std::string message;
+    std::string syscall;
+    std::string path;
+    int cerrno = 0;
+    void set(const char* iMessage = NULL, const char* iSyscall = NULL, int iErrno = 0, const char* iPath = NULL) {
+      if (iMessage) message.assign(iMessage);
+      if (iSyscall) syscall.assign(iSyscall);
+      cerrno = iErrno;
+      if (iPath) path.assign(iPath);
+    }
+    void reset() {
+      message.clear();
+      syscall.clear();
+      path.clear();
+      cerrno = 0;
+    }
+    bool empty() {
+      return cerrno == 0 && message.empty();
+    }
+    Napi::Error toError(Napi::Env env) {
+      if (cerrno) {
+        Napi::Error err = Napi::Error::New(env, strerror(cerrno));
+        if (!syscall.empty()) err.Value().Set("syscall", syscall);
+        if (!path.empty()) err.Value().Set("path", path);
+        return err;
+      } else {
+        return Napi::Error::New(env, message);
+      }
+    }
+};

package/src/CanvasGradient.cc

@@ -0,0 +1,113 @@
+// Copyright (c) 2010 LearnBoost <tj@learnboost.com>
+
+#include "CanvasGradient.h"
+#include "InstanceData.h"
+
+#include "Canvas.h"
+#include "color.h"
+
+using namespace Napi;
+
+/*
+ * Initialize CanvasGradient.
+ */
+
+void
+Gradient::Initialize(Napi::Env& env, Napi::Object& exports) {
+  Napi::HandleScope scope(env);
+  InstanceData* data = env.GetInstanceData<InstanceData>();
+
+  Napi::Function ctor = DefineClass(env, "CanvasGradient", {
+    InstanceMethod<&Gradient::AddColorStop>("addColorStop", napi_default_method)
+  });
+
+  exports.Set("CanvasGradient", ctor);
+  data->CanvasGradientCtor = Napi::Persistent(ctor);
+}
+
+/*
+ * Initialize a new CanvasGradient.
+ */
+
+Gradient::Gradient(const Napi::CallbackInfo& info) : Napi::ObjectWrap<Gradient>(info), env(info.Env()) {
+  // Linear
+  if (
+    4 == info.Length() &&
+    info[0].IsNumber() &&
+    info[1].IsNumber() &&
+    info[2].IsNumber() &&
+    info[3].IsNumber()
+  ) {
+    double x0 = info[0].As<Napi::Number>().DoubleValue();
+    double y0 = info[1].As<Napi::Number>().DoubleValue();
+    double x1 = info[2].As<Napi::Number>().DoubleValue();
+    double y1 = info[3].As<Napi::Number>().DoubleValue();
+    _pattern = cairo_pattern_create_linear(x0, y0, x1, y1);
+    return;
+  }
+
+  // Radial
+  if (
+    6 == info.Length() &&
+    info[0].IsNumber() &&
+    info[1].IsNumber() &&
+    info[2].IsNumber() &&
+    info[3].IsNumber() &&
+    info[4].IsNumber() &&
+    info[5].IsNumber()
+  ) {
+    double x0 = info[0].As<Napi::Number>().DoubleValue();
+    double y0 = info[1].As<Napi::Number>().DoubleValue();
+    double r0 = info[2].As<Napi::Number>().DoubleValue();
+    double x1 = info[3].As<Napi::Number>().DoubleValue();
+    double y1 = info[4].As<Napi::Number>().DoubleValue();
+    double r1 = info[5].As<Napi::Number>().DoubleValue();
+    _pattern = cairo_pattern_create_radial(x0, y0, r0, x1, y1, r1);
+    return;
+  }
+
+  Napi::TypeError::New(env, "invalid arguments").ThrowAsJavaScriptException();
+}
+
+/*
+ * Add color stop.
+ */
+
+void
+Gradient::AddColorStop(const Napi::CallbackInfo& info) {
+  if (!info[0].IsNumber()) {
+    Napi::TypeError::New(env, "offset required").ThrowAsJavaScriptException();
+    return;
+  }
+
+  if (!info[1].IsString()) {
+    Napi::TypeError::New(env, "color string required").ThrowAsJavaScriptException();
+    return;
+  }
+
+  short ok;
+  std::string str = info[1].As<Napi::String>();
+  uint32_t rgba = rgba_from_string(str.c_str(), &ok);
+
+  if (ok) {
+    rgba_t color = rgba_create(rgba);
+    cairo_pattern_add_color_stop_rgba(
+        _pattern
+      , info[0].As<Napi::Number>().DoubleValue()
+      , color.r
+      , color.g
+      , color.b
+      , color.a);
+  } else {
+    Napi::TypeError::New(env, "parse color failed").ThrowAsJavaScriptException();
+  }
+}
+
+
+/*
+ * Destroy the pattern.
+ */
+
+Gradient::~Gradient() {
+  if (_pattern) cairo_pattern_destroy(_pattern);
+}

package/src/CanvasGradient.h

@@ -0,0 +1,20 @@
+// Copyright (c) 2010 LearnBoost <tj@learnboost.com>
+
+#pragma once
+
+#include <napi.h>
+#include <cairo.h>
+
+class Gradient : public Napi::ObjectWrap<Gradient> {
+  public:
+    static void Initialize(Napi::Env& env, Napi::Object& target);
+    Gradient(const Napi::CallbackInfo& info);
+    void AddColorStop(const Napi::CallbackInfo& info);
+    inline cairo_pattern_t *pattern(){ return _pattern; }
+    ~Gradient();
+
+    Napi::Env env;
+
+  private:
+    cairo_pattern_t *_pattern;
+};

package/src/CanvasPattern.cc

@@ -0,0 +1,129 @@
+// Copyright (c) 2010 LearnBoost <tj@learnboost.com>
+
+#include "CanvasPattern.h"
+
+#include "Canvas.h"
+#include "Image.h"
+#include "InstanceData.h"
+
+using namespace Napi;
+
+const cairo_user_data_key_t *pattern_repeat_key;
+
+/*
+ * Initialize CanvasPattern.
+ */
+
+void
+Pattern::Initialize(Napi::Env& env, Napi::Object& exports) {
+  Napi::HandleScope scope(env);
+  InstanceData* data = env.GetInstanceData<InstanceData>();
+
+  // Constructor
+  Napi::Function ctor = DefineClass(env, "CanvasPattern", {
+    InstanceMethod<&Pattern::setTransform>("setTransform", napi_default_method)
+  });
+
+  // Prototype
+  exports.Set("CanvasPattern", ctor);
+  data->CanvasPatternCtor = Napi::Persistent(ctor);
+}
+
+/*
+ * Initialize a new CanvasPattern.
+ */
+
+Pattern::Pattern(const Napi::CallbackInfo& info) : ObjectWrap<Pattern>(info), env(info.Env()) {
+  if (!info[0].IsObject()) {
+    Napi::TypeError::New(env, "Image or Canvas expected").ThrowAsJavaScriptException();
+    return;
+  }
+
+  Napi::Object obj = info[0].As<Napi::Object>();
+  InstanceData* data = env.GetInstanceData<InstanceData>();
+  cairo_surface_t *surface;
+
+  // Image
+  if (obj.InstanceOf(data->ImageCtor.Value()).UnwrapOr(false)) {
+    Image *img = Image::Unwrap(obj);
+    if (!img->isComplete()) {
+      Napi::Error::New(env, "Image given has not completed loading").ThrowAsJavaScriptException();
+      return;
+    }
+    surface = img->surface();
+
+  // Canvas
+  } else if (obj.InstanceOf(data->CanvasCtor.Value()).UnwrapOr(false)) {
+    Canvas *canvas = Canvas::Unwrap(obj);
+    surface = canvas->ensureSurface();
+  // Invalid
+  } else {
+    if (!env.IsExceptionPending()) {
+      Napi::TypeError::New(env, "Image or Canvas expected").ThrowAsJavaScriptException();
+    }
+    return;
+  }
+  _pattern = cairo_pattern_create_for_surface(surface);
+
+  if (info[1].IsString()) {
+    if ("no-repeat" == info[1].As<Napi::String>().Utf8Value()) {
+      _repeat = NO_REPEAT;
+    } else if ("repeat-x" == info[1].As<Napi::String>().Utf8Value()) {
+      _repeat = REPEAT_X;
+    } else if ("repeat-y" == info[1].As<Napi::String>().Utf8Value()) {
+      _repeat = REPEAT_Y;
+    }
+  }
+
+  cairo_pattern_set_user_data(_pattern, pattern_repeat_key, &_repeat, NULL);
+}
+
+/*
+ * Set the pattern-space to user-space transform.
+ */
+void
+Pattern::setTransform(const Napi::CallbackInfo& info) {
+  if (!info[0].IsObject()) {
+    Napi::TypeError::New(env, "Expected DOMMatrix").ThrowAsJavaScriptException();
+    return;
+  }
+
+  Napi::Object mat = info[0].As<Napi::Object>();
+
+  InstanceData* data = env.GetInstanceData<InstanceData>();
+  if (!mat.InstanceOf(data->DOMMatrixCtor.Value()).UnwrapOr(false)) {
+    if (!env.IsExceptionPending()) {
+      Napi::TypeError::New(env, "Expected DOMMatrix").ThrowAsJavaScriptException();
+    }
+    return;
+  }
+
+  Napi::Value one = Napi::Number::New(env, 1);
+  Napi::Value zero = Napi::Number::New(env, 0);
+
+  cairo_matrix_t matrix;
+  cairo_matrix_init(&matrix,
+    mat.Get("a").UnwrapOr(one).As<Napi::Number>().DoubleValue(),
+    mat.Get("b").UnwrapOr(zero).As<Napi::Number>().DoubleValue(),
+    mat.Get("c").UnwrapOr(zero).As<Napi::Number>().DoubleValue(),
+    mat.Get("d").UnwrapOr(one).As<Napi::Number>().DoubleValue(),
+    mat.Get("e").UnwrapOr(zero).As<Napi::Number>().DoubleValue(),
+    mat.Get("f").UnwrapOr(zero).As<Napi::Number>().DoubleValue()
+  );
+
+  cairo_matrix_invert(&matrix);
+  cairo_pattern_set_matrix(_pattern, &matrix);
+}
+
+repeat_type_t Pattern::get_repeat_type_for_cairo_pattern(cairo_pattern_t *pattern) {
+  void *ud = cairo_pattern_get_user_data(pattern, pattern_repeat_key);
+  return *reinterpret_cast<repeat_type_t*>(ud);
+}
+
+/*
+ * Destroy the pattern.
+ */
+
+Pattern::~Pattern() {
+  if (_pattern) cairo_pattern_destroy(_pattern);
+}

package/src/CanvasPattern.h

@@ -0,0 +1,33 @@
+// Copyright (c) 2011 LearnBoost <tj@learnboost.com>
+
+#pragma once
+
+#include <cairo.h>
+#include <napi.h>
+
+/*
+ * Canvas types.
+ */
+
+typedef enum {
+  NO_REPEAT,  // match CAIRO_EXTEND_NONE
+  REPEAT,  // match CAIRO_EXTEND_REPEAT
+  REPEAT_X, // needs custom processing
+  REPEAT_Y // needs custom processing
+} repeat_type_t;
+
+extern const cairo_user_data_key_t *pattern_repeat_key;
+
+class Pattern : public Napi::ObjectWrap<Pattern> {
+  public:
+    Pattern(const Napi::CallbackInfo& info);
+    static void Initialize(Napi::Env& env, Napi::Object& target);
+    void setTransform(const Napi::CallbackInfo& info);
+    static repeat_type_t get_repeat_type_for_cairo_pattern(cairo_pattern_t *pattern);
+    inline cairo_pattern_t *pattern(){ return _pattern; }
+    ~Pattern();
+    Napi::Env env;
+  private:
+    cairo_pattern_t *_pattern;
+    repeat_type_t _repeat = REPEAT;
+};