wkhtml 0.0.1

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+*.bundle
+*.so
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+bin

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,17 @@
+sudo: false
+os:
+  - linux
+#addons:
+#  apt:
+#    packages:
+#      - wkhtmltopdf
+before_install:
+  - ./.travis_setup.sh
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0
+  - 2.1
+  - 2.2
+  - 2.3.0
+  #- ruby-head

data/.travis_setup.sh

@@ -0,0 +1,9 @@
+#!/bin/sh
+
+wget -q http://download.gna.org/wkhtmltopdf/0.12/0.12.3/wkhtmltox-0.12.3_linux-generic-amd64.tar.xz -O /tmp/wkhtmltox.tar.xz
+tar -xf /tmp/wkhtmltox.tar.xz -C /tmp
+echo "wkhtmltopdf: `/tmp/wkhtmltox/bin/wkhtmltopdf -V`"
+echo "wkhtmltoimage: `/tmp/wkhtmltox/bin/wkhtmltoimage -V`"
+
+bundle install --jobs=3 --retry=3
+bundle exec rake compile -- --with-wkhtmltox-dir=/tmp/wkhtmltox --with-wkhtmltox-lib=/tmp/wkhtmltox/lib

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in wkhtml.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Carson Reinke
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,52 @@
+## WkHtml
+[![Build Status](https://travis-ci.org/carsonreinke/wkhtml.svg?branch=master)](https://travis-ci.org/carsonreinke/wkhtml)
+
+Ruby bindings for [wkhtmltox (wkhtmltopdf)](http://wkhtmltopdf.org/).  This gem should be considered experimental (see Todo).
+
+### Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'wkhtml'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install wkhtml
+
+And if it can't find wkhtmltox/wkhtmltopdf, you can supply `--with-wkhtmltox-dir`, `--with-wkhtmltox-include`, or `--with-wkhtmltox-lib` for location variations.
+
+To use a windowing system for rendering, can be enabled with option `--enable-use-graphics`.  For more information, [see `GUIEnabled` portion of Qt QApplication](http://doc.qt.io/qt-4.8/qapplication.html#QApplication-2).
+
+### Usage
+
+```ruby
+#PDF
+WkHtml::Converter.new('http://example.com/').to_pdf()
+#JPEG
+WkHtml::Converter.new('http://example.com/').to_jpg()
+#PNG
+WkHtml::Converter.new('http://example.com/').to_png()
+#SVG
+WkHtml::Converter.new('http://example.com/').to_svg()
+#File
+WkHtml::Converter.new('http://example.com/').to_file('/path', :pdf)
+```
+
+The `#new` will take either a `URI`, HTML content, or a `File`.
+
+Secondary argument takes a `Hash` of options, a list of these options can be found [here](http://wkhtmltopdf.org/libwkhtmltox/pagesettings.html).
+
+```ruby
+WkHtml::Converter.new('http://', {:useCompression => false})
+```
+
+### Todo
+
+* Memory leak with any image conversion :disappointed: ([see](https://github.com/wkhtmltopdf/wkhtmltopdf/issues/2700))
+* Due to wkhtmltopdf C api limitation, seg fault when try to use library from fork :disappointed:
+* Due to wkhtmltopdf C api limitation, must be used within main Ruby VM thread :disappointed:
+* Some [settings](http://wkhtmltopdf.org/libwkhtmltox/pagesettings.html) for image generation just do not work :sob: ([see](https://github.com/wkhtmltopdf/wkhtmltopdf/issues/2802))

data/Rakefile

@@ -0,0 +1,17 @@
+require 'bundler/gem_tasks'
+require 'rake/extensiontask'
+require 'rspec/core/rake_task'
+
+Rake::ExtensionTask.new('wkhtml_native', Gem::Specification.load('wkhtml.gemspec')) do |ext|
+  ext.ext_dir = 'ext/wkhtml'
+  ext.lib_dir = 'lib/wkhtml'
+end
+
+task :console => [:compile, :build] do
+  exec 'irb -r wkhtml -I ./lib'
+end
+
+RSpec::Core::RakeTask.new(:spec)
+task :spec => [:compile, :build]
+
+task :default => :spec

data/ext/wkhtml/extconf.rb

@@ -0,0 +1,33 @@
+require 'mkmf'
+
+#Copied from ruby-filemagic (https://github.com/blackwinter/ruby-filemagic/blob/master/ext/filemagic/extconf.rb)
+HEADER_DIRS = [
+  '/opt/local/include', # MacPorts
+  '/usr/local/include', # compiled from source and Homebrew
+  '/usr/include'        # system
+]
+LIB_DIRS = [
+  '/opt/local/lib', # MacPorts
+  '/usr/local/lib', # compiled from source and Homebrew
+  '/usr/lib'        # system
+]
+dir_config('wkhtmltox', HEADER_DIRS, LIB_DIRS)
+
+unless have_library('wkhtmltox')
+  abort('Missing wkhtmltox library')
+end
+  
+unless have_header('wkhtmltox/pdf.h')
+  abort('Missing wkhtmltox pdf.h')
+end
+
+unless have_header('wkhtmltox/image.h')
+  warn('Missing wkhtmltox image.h')
+end
+
+#--enable-use-graphics/--disable-use-graphics
+if enable_config('use-graphics')
+  $defs.push('-DUSE_GRAPHICS')
+end
+
+create_makefile('wkhtml/wkhtml_native')

data/ext/wkhtml/wkhtml.c

@@ -0,0 +1,388 @@
+#include "wkhtml.h"
+
+#define BUFFER_SIZE 10240
+
+//init functions take parameter use_graphics which can be set using --enable-use-graphics
+#ifdef USE_GRAPHICS
+  #define USE_GRAPHICS_INT 1
+#else
+  #define USE_GRAPHICS_INT 0
+#endif
+
+#define INT2BOOL(v) ((int)v) ? Qtrue : Qfalse
+#define BOOL2INT(v) ((VALUE)v) ? 1 : 0
+#define ENCODE_UTF8(v) rb_str_encode(v, rb_enc_from_encoding(rb_utf8_encoding()), 0, Qnil)
+
+void Init_wkhtml_native() {
+  //Global initialization of library and when Ruby shuts down
+  wkhtmltopdf_init(USE_GRAPHICS_INT);
+  wkhtmltoimage_init(USE_GRAPHICS_INT);
+  rb_set_end_proc(Deinit_wkhtml_native, Qnil);
+
+  idReady = rb_intern("ready");
+
+  mWkHtml = rb_define_module("WkHtml");
+  rb_define_const(mWkHtml, "LIBRARY_VERSION", rb_obj_freeze(rb_str_new_cstr(wkhtmltopdf_version())));
+  rb_define_const(mWkHtml, "USE_GRAPHICS", INT2BOOL(USE_GRAPHICS_INT));
+
+  mWkHtmlToPdf = rb_define_module_under(mWkHtml, "ToPdf");
+
+  cWkHtmlToPdfGlobalSettings = rb_define_class_under(mWkHtmlToPdf, "GlobalSettings", rb_cObject);
+  rb_define_alloc_func(cWkHtmlToPdfGlobalSettings, wkhtml_topdf_globalsettings_alloc);
+  rb_define_method(cWkHtmlToPdfGlobalSettings, "[]=", wkhtml_topdf_globalsettings_aset, 2);
+  rb_define_method(cWkHtmlToPdfGlobalSettings, "[]", wkhtml_topdf_globalsettings_aref, 1);
+
+  cWkHtmlToPdfObjectSettings = rb_define_class_under(mWkHtmlToPdf, "ObjectSettings", rb_cObject);
+  rb_define_alloc_func(cWkHtmlToPdfObjectSettings, wkhtml_topdf_objectsettings_alloc);
+  rb_define_method(cWkHtmlToPdfObjectSettings, "[]=", wkhtml_topdf_objectsettings_aset, 2);
+  rb_define_method(cWkHtmlToPdfObjectSettings, "[]", wkhtml_topdf_objectsettings_aref, 1);
+
+  cWkHtmlToPdfConverter = rb_define_class_under(mWkHtmlToPdf, "Converter", rb_cObject);
+  /*
+  TODO
+  rb_define_singleton_method(klass, "new", constructor, 1); //Uses Data_Wrap_Struct -> rb_obj_call_init(t_data, 1, argv);
+  rb_define_method(klass, "initialize", initialize, 1);
+  */
+  rb_define_singleton_method(cWkHtmlToPdfConverter, "create", wkhtml_topdf_converter_create, 1);
+  rb_define_method(cWkHtmlToPdfConverter, "add_object", wkhtml_topdf_converter_add_object, 2);
+  rb_define_method(cWkHtmlToPdfConverter, "convert", wkhtml_topdf_converter_convert, 0);
+  rb_define_method(cWkHtmlToPdfConverter, "http_error_code", wkhtml_topdf_converter_http_error_code, 0);
+  rb_define_method(cWkHtmlToPdfConverter, "get_output", wkhtml_topdf_converter_get_output, 0);
+  //Force use of factory method
+  rb_undef_alloc_func(cWkHtmlToPdfConverter);
+  rb_undef_method(rb_singleton_class(cWkHtmlToPdfConverter), "new");
+
+  mWkHtmlToImage = rb_define_module_under(mWkHtml, "ToImage");
+
+  cWkHtmlToImageGlobalSettings = rb_define_class_under(mWkHtmlToImage, "GlobalSettings", rb_cObject);
+  rb_define_alloc_func(cWkHtmlToImageGlobalSettings, wkhtml_toimage_globalsettings_alloc);
+  rb_define_method(cWkHtmlToImageGlobalSettings, "[]=", wkhtml_toimage_globalsettings_aset, 2);
+  rb_define_method(cWkHtmlToImageGlobalSettings, "[]", wkhtml_toimage_globalsettings_aref, 1);
+
+  cWkHtmlToImageConverter = rb_define_class_under(mWkHtmlToImage, "Converter", rb_cObject);
+  rb_define_singleton_method(cWkHtmlToImageConverter, "create", wkhtml_toimage_converter_create, 2);
+  rb_define_method(cWkHtmlToImageConverter, "convert", wkhtml_toimage_converter_convert, 0);
+  rb_define_method(cWkHtmlToImageConverter, "http_error_code", wkhtml_toimage_converter_http_error_code, 0);
+  rb_define_method(cWkHtmlToImageConverter, "get_output", wkhtml_toimage_converter_get_output, 0);
+  //Force use of factory method
+  rb_undef_alloc_func(cWkHtmlToImageConverter);
+  rb_undef_method(rb_singleton_class(cWkHtmlToImageConverter), "new");
+}
+
+void Deinit_wkhtml_native(VALUE data) {
+  wkhtmltopdf_deinit();
+  wkhtmltoimage_deinit();
+}
+
+
+#define _wkhtml_setting_aset(setting_type, setting_func) ({ \
+  setting_type* settings;\
+  char* key_cstr; \
+  \
+  rb_check_frozen(self); \
+  \
+  key = ENCODE_UTF8(rb_obj_as_string(key)); \
+  val = ENCODE_UTF8(rb_obj_as_string(val)); \
+  \
+  Data_Get_Struct(self, setting_type, settings); \
+  \
+  key_cstr = StringValueCStr(key); \
+  if( setting_func(settings, key_cstr, StringValueCStr(val)) ) { \
+    return val; \
+  } \
+  \
+  rb_raise(rb_eArgError, "Unable to set: %s", key_cstr); \
+})
+
+#define _wkhtml_setting_aref(setting_type, setting_func) ({ \
+  char* key_cstr; \
+  char* val_cstr; \
+  VALUE val; \
+  int result; \
+  setting_type* settings; \
+  \
+  key = ENCODE_UTF8(rb_obj_as_string(key)); \
+  \
+  Data_Get_Struct(self, setting_type, settings); \
+  \
+  key_cstr = StringValueCStr(key); \
+  val_cstr = ALLOC_N(char, BUFFER_SIZE); \
+  val = Qnil; \
+  result = setting_func(settings, key_cstr, val_cstr, BUFFER_SIZE); \
+  \
+  if(result) { \
+    val = rb_str_new_cstr(val_cstr); \
+  } \
+  xfree(val_cstr); \
+  \
+  if(val == Qnil) { \
+    rb_raise(rb_eArgError, "Unable to get: %s", key_cstr); \
+  } \
+  \
+  return val; \
+})
+
+/*
+* WkHtml::ToPdf::GlobalSettings
+*/
+VALUE wkhtml_topdf_globalsettings_alloc(VALUE self) {
+  wkhtmltopdf_global_settings* settings = wkhtmltopdf_create_global_settings();
+  return Data_Wrap_Struct(self, NULL, wkhtmltopdf_destroy_global_settings, settings);
+}
+VALUE wkhtml_topdf_globalsettings_aset(VALUE self, VALUE key, VALUE val) {
+  _wkhtml_setting_aset(wkhtmltopdf_global_settings, wkhtmltopdf_set_global_setting);
+}
+VALUE wkhtml_topdf_globalsettings_aref(VALUE self, VALUE key) {
+  _wkhtml_setting_aref(wkhtmltopdf_global_settings, wkhtmltopdf_get_global_setting);
+}
+
+/*
+* WkHtml::ToPdf::ObjectSettings
+*/
+VALUE wkhtml_topdf_objectsettings_alloc(VALUE self) {
+  wkhtmltopdf_object_settings* settings = wkhtmltopdf_create_object_settings();
+  return Data_Wrap_Struct(self, NULL, wkhtmltopdf_destroy_object_settings, settings);
+}
+VALUE wkhtml_topdf_objectsettings_aset(VALUE self, VALUE key, VALUE val) {
+  _wkhtml_setting_aset(wkhtmltopdf_object_settings, wkhtmltopdf_set_object_setting);
+}
+VALUE wkhtml_topdf_objectsettings_aref(VALUE self, VALUE key) {
+  _wkhtml_setting_aref(wkhtmltopdf_object_settings, wkhtmltopdf_get_object_setting);
+}
+
+/*
+* WkHtml::ToPdf::Converter
+*/
+void wkhtml_topdf_converter_free(wkhtmltopdf_converter* converter) {
+  wkhtmltopdf_destroy_converter(converter);
+
+  //Do this on Ruby exit
+  ////Deinitialize library after destroying (will only if last call)
+  //wkhtmltopdf_deinit();
+}
+
+VALUE wkhtml_topdf_converter_create(VALUE self, VALUE settings) {
+  wkhtmltopdf_global_settings* global_settings;
+  wkhtmltopdf_converter* converter;
+
+  if(rb_obj_is_kind_of(settings, cWkHtmlToPdfGlobalSettings) == Qfalse) {
+    rb_raise(rb_eArgError, "Wrong argument type, must be a GlobalSettings");
+  }
+
+  Data_Get_Struct(settings, wkhtmltopdf_global_settings, global_settings);
+
+  //Initialize on library load
+  ////Initialize library before creating (will only if first call)
+  //wkhtmltopdf_init(USE_GRAPHICS_INT);
+
+  converter = wkhtmltopdf_create_converter(global_settings);
+
+  OBJ_FREEZE(settings);
+
+  //return Data_Wrap_Struct(self, NULL, wkhtmltopdf_destroy_converter, converter);
+  return Data_Wrap_Struct(self, NULL, wkhtml_topdf_converter_free, converter);
+}
+
+VALUE wkhtml_topdf_converter_add_object(VALUE self, VALUE settings, VALUE data) {
+  wkhtmltopdf_converter* converter;
+  wkhtmltopdf_object_settings* object_settings;
+  char* data_cstr = NULL;
+
+  if(rb_obj_is_kind_of(settings, cWkHtmlToPdfObjectSettings) == Qfalse) {
+    rb_raise(rb_eArgError, "Wrong argument type, must be a ObjectSettings");
+  }
+
+  rb_check_frozen(self);
+
+  if(!NIL_P(data)) {
+    Check_Type(data, T_STRING);
+    data_cstr = StringValueCStr(data);
+  }
+
+  Data_Get_Struct(settings, wkhtmltopdf_object_settings, object_settings);
+  Data_Get_Struct(self, wkhtmltopdf_converter, converter);
+
+  wkhtmltopdf_add_object(converter, object_settings, data_cstr);
+
+  //From wkhtmltox:
+  //"Once the object has been added, the supplied settings may no longer be accessed, it Wit eventually be freed by wkhtmltopdf."
+  OBJ_FREEZE(settings);
+
+  rb_ivar_set(self, idReady, Qtrue);
+
+  return data;
+}
+
+VALUE wkhtml_topdf_converter_convert(VALUE self) {
+  wkhtmltopdf_converter* converter;
+
+  //TODO QApplication is initialized on whatever thread `wkhtmltopdf_init` is called, otherwise events are
+  //not sent properly
+  if(rb_thread_main() != rb_thread_current()) {
+    rb_raise(rb_eRuntimeError, "Yuck!  You must be on the main thread for wkhtmltopdf to work");
+  }
+
+  //Checks
+  if(rb_ivar_get(self, idReady) != Qtrue) rb_raise(rb_eRuntimeError, "Object must be added first");
+  rb_check_frozen(self);
+
+  Data_Get_Struct(self, wkhtmltopdf_converter, converter);
+
+  if(wkhtmltopdf_convert(converter)) {
+    OBJ_FREEZE(self);
+
+    return Qtrue;
+  }
+  else {
+    return Qfalse;
+  }
+}
+
+VALUE wkhtml_topdf_converter_http_error_code(VALUE self) {
+  wkhtmltopdf_converter* converter;
+  int http_error_code;
+
+  Data_Get_Struct(self, wkhtmltopdf_converter, converter);
+
+  http_error_code = wkhtmltopdf_http_error_code(converter);
+  return http_error_code == 0 ? Qnil : INT2NUM(http_error_code); //0 is treated as success and should be nil
+}
+
+VALUE wkhtml_topdf_converter_get_output(VALUE self) {
+  wkhtmltopdf_converter* converter;
+  const unsigned char* data_cstr;
+  long length;
+  VALUE data;
+
+  Data_Get_Struct(self, wkhtmltopdf_converter, converter);
+
+  length = wkhtmltopdf_get_output(converter, &data_cstr);
+
+  data = rb_str_new((char*)data_cstr, length);
+  rb_enc_associate(data, rb_ascii8bit_encoding());
+
+  return data;
+}
+
+//CAPI(void) wkhtmltopdf_set_warning_callback(wkhtmltopdf_converter * converter, wkhtmltopdf_str_callback cb)
+//CAPI(void) wkhtmltopdf_set_error_callback(wkhtmltopdf_converter * converter, wkhtmltopdf_str_callback cb)
+//CAPI(void) wkhtmltopdf_set_phase_changed_callback(wkhtmltopdf_converter * converter, wkhtmltopdf_void_callback cb)
+//CAPI(void) wkhtmltopdf_set_progress_changed_callback(wkhtmltopdf_converter * converter, wkhtmltopdf_int_callback cb)
+//CAPI(void) wkhtmltopdf_set_finished_callback(wkhtmltopdf_converter * converter, wkhtmltopdf_int_callback cb)
+//CAPI(int) wkhtmltopdf_current_phase(wkhtmltopdf_converter * converter)
+//CAPI(int) wkhtmltopdf_phase_count(wkhtmltopdf_converter * converter)
+
+/*
+* WkHtml::ToImage::GlobalSettings
+*/
+void wkhtml_toimage_globalsettings_free(wkhtmltoimage_global_settings* settings) {
+  //No free function as wkhtmltopdf claims to manage this
+}
+VALUE wkhtml_toimage_globalsettings_alloc(VALUE self) {
+  wkhtmltoimage_global_settings* settings = wkhtmltoimage_create_global_settings();
+  return Data_Wrap_Struct(self, NULL, wkhtml_toimage_globalsettings_free, settings); 
+}
+VALUE wkhtml_toimage_globalsettings_aset(VALUE self, VALUE key, VALUE val) {
+  _wkhtml_setting_aset(wkhtmltoimage_global_settings, wkhtmltoimage_set_global_setting);
+}
+VALUE wkhtml_toimage_globalsettings_aref(VALUE self, VALUE key) {
+  _wkhtml_setting_aref(wkhtmltoimage_global_settings, wkhtmltoimage_get_global_setting);
+}
+
+/*
+* WkHtml::ToImage::Converter
+*/
+void wkhtml_toimage_converter_free(wkhtmltoimage_converter* converter) {
+  wkhtmltoimage_destroy_converter(converter);
+
+  //Do this on Ruby exit
+  ////Deinitialize library after destroying (will only if last call)
+  //wkhtmltoimage_deinit();
+}
+
+VALUE wkhtml_toimage_converter_create(VALUE self, VALUE settings, VALUE data) {
+  wkhtmltoimage_global_settings* global_settings;
+  wkhtmltoimage_converter* converter;
+  char* data_cstr = NULL;
+
+  if(rb_obj_is_kind_of(settings, cWkHtmlToImageGlobalSettings) == Qfalse) {
+    rb_raise(rb_eArgError, "Wrong argument type, must be a GlobalSettings");
+  }
+  rb_check_frozen(self);
+
+  if(!NIL_P(data)) {
+    Check_Type(data, T_STRING);
+    data_cstr = StringValueCStr(data);
+  }
+
+  Data_Get_Struct(settings, wkhtmltoimage_global_settings, global_settings);
+
+  //Initialize on library load
+  ////Initialize library before creating (will only if first call)
+  //wkhtmltoimage_init(USE_GRAPHICS_INT);
+  converter = wkhtmltoimage_create_converter(global_settings, data_cstr);
+
+  OBJ_FREEZE(settings);
+
+  return Data_Wrap_Struct(self, NULL, wkhtml_toimage_converter_free, converter);
+}
+
+VALUE wkhtml_toimage_converter_convert(VALUE self) {
+  wkhtmltoimage_converter* converter;
+
+  //See wkhtml_topdf_converter_convert
+  if(rb_thread_main() != rb_thread_current()) {
+    rb_raise(rb_eRuntimeError, "Yuck!  You must be on the main thread for wkhtmltopdf to work");
+  }
+
+  //Checks
+  rb_check_frozen(self);
+
+  Data_Get_Struct(self, wkhtmltoimage_converter, converter);
+
+  if(wkhtmltoimage_convert(converter)) {
+    //Freeze converter if successful
+    OBJ_FREEZE(self);
+
+    return Qtrue;
+  }
+  else {
+    return Qfalse;
+  }
+}
+
+VALUE wkhtml_toimage_converter_http_error_code(VALUE self) {
+  wkhtmltoimage_converter* converter;
+  int http_error_code;
+
+  Data_Get_Struct(self, wkhtmltoimage_converter, converter);
+
+  http_error_code = wkhtmltoimage_http_error_code(converter);
+  return http_error_code == 0 ? Qnil : INT2NUM(http_error_code); //0 is treated as success and should be nil
+}
+
+VALUE wkhtml_toimage_converter_get_output(VALUE self) {
+  wkhtmltoimage_converter* converter;
+  const unsigned char* data_cstr;
+  long length;
+  VALUE data;
+
+  Data_Get_Struct(self, wkhtmltoimage_converter, converter);
+
+  length = wkhtmltoimage_get_output(converter, &data_cstr);
+
+  data = rb_str_new((char*)data_cstr, length);
+  rb_enc_associate(data, rb_ascii8bit_encoding());
+
+  return data;
+}
+
+//CAPI(void) wkhtmltoimage_set_warning_callback(wkhtmltoimage_converter * converter, wkhtmltoimage_str_callback cb);
+//CAPI(void) wkhtmltoimage_set_error_callback(wkhtmltoimage_converter * converter, wkhtmltoimage_str_callback cb);
+//CAPI(void) wkhtmltoimage_set_phase_changed_callback(wkhtmltoimage_converter * converter, wkhtmltoimage_void_callback cb);
+//CAPI(void) wkhtmltoimage_set_progress_changed_callback(wkhtmltoimage_converter * converter, wkhtmltoimage_int_callback cb);
+//CAPI(void) wkhtmltoimage_set_finished_callback(wkhtmltoimage_converter * converter, wkhtmltoimage_int_callback cb);
+//CAPI(int) wkhtmltoimage_current_phase(wkhtmltoimage_converter * converter);
+//CAPI(int) wkhtmltoimage_phase_count(wkhtmltoimage_converter * converter);
+//CAPI(const char *) wkhtmltoimage_phase_description(wkhtmltoimage_converter * converter, int phase);
+//CAPI(const char *) wkhtmltoimage_progress_string(wkhtmltoimage_converter * converter);