nuklear 0.1.0

data/examples/lib/sdl2_input.rb

@@ -0,0 +1,81 @@
+require 'sdl2'
+
+module Examples
+  module SDL2Input
+    def process_sdl2_events(nuklear_ctx, escape_keys: [SDL2::Key::ESCAPE])
+      while event = ::SDL2::Event.poll
+        case event
+        # TODO touch events
+        # when SDL2::Event::FingerMotion
+        # when SDL2::Event::FingerDown
+        # when SDL2::Event::FingerUp
+        when ::SDL2::Event::TextInput   then nuklear_ctx.trigger(:glyph,  event.text)
+        when ::SDL2::Event::MouseMotion then nuklear_ctx.trigger(:motion, event.x, event.y, event.xrel, event.yrel)
+        when ::SDL2::Event::MouseWheel  then nuklear_ctx.trigger(:scroll, event.x, event.y)
+        when ::SDL2::Event::MouseButtonDown, ::SDL2::Event::MouseButtonUp
+          is_down = event.kind_of?(::SDL2::Event::MouseButtonDown)
+          if event.button == 1 and event.clicks > 1
+            nuklear_ctx.trigger(:button, :double, event.x, event.y, is_down)
+          else
+            case event.button
+            # SDL_BUTTON_LEFT seems to be not defined
+            when 1 then nuklear_ctx.trigger(:button, :left,   event.x, event.y, is_down)
+            when 2 then nuklear_ctx.trigger(:button, :middle, event.x, event.y, is_down)
+            when 3 then nuklear_ctx.trigger(:button, :right,  event.x, event.y, is_down)
+            else yield event if block_given?
+            end
+          end
+        when ::SDL2::Event::Window
+          case event.event
+          when ::SDL2::Event::Window::FOCUS_GAINED then @focused = true
+          when ::SDL2::Event::Window::FOCUS_LOST   then @focused = false
+          end
+        when ::SDL2::Event::KeyDown, ::SDL2::Event::KeyUp
+          is_down = event.kind_of?(::SDL2::Event::KeyDown)
+          case event.sym
+          when ::SDL2::Key::LSHIFT, ::SDL2::Key::RSHIFT then nuklear_ctx.trigger(:key, :shift,           is_down)
+          when ::SDL2::Key::DELETE                      then nuklear_ctx.trigger(:key, :del,             is_down)
+          when ::SDL2::Key::RETURN                      then nuklear_ctx.trigger(:key, :enter,           is_down)
+          when ::SDL2::Key::TAB                         then nuklear_ctx.trigger(:key, :tab,             is_down)
+          when ::SDL2::Key::BACKSPACE                   then nuklear_ctx.trigger(:key, :backspace,       is_down)
+          when ::SDL2::Key::HOME                        then nuklear_ctx.trigger(:key, :text_start,      is_down)
+                                                             nuklear_ctx.trigger(:key, :scroll_start,    is_down)
+          when ::SDL2::Key::END                         then nuklear_ctx.trigger(:key, :text_end,        is_down)
+                                                             nuklear_ctx.trigger(:key, :scroll_end,      is_down)
+          when ::SDL2::Key::PAGEDOWN                    then nuklear_ctx.trigger(:key, :scroll_down,     is_down)
+          when ::SDL2::Key::PAGEUP                      then nuklear_ctx.trigger(:key, :scroll_up,       is_down)
+          when ::SDL2::Key::Z                           then nuklear_ctx.trigger(:key, :text_undo,       is_down && (event.mod & ::SDL2::Key::Mod::CTRL > 0))
+          when ::SDL2::Key::R                           then nuklear_ctx.trigger(:key, :text_redo,       is_down && (event.mod & ::SDL2::Key::Mod::CTRL > 0))
+          when ::SDL2::Key::C                           then nuklear_ctx.trigger(:key, :copy,            is_down && (event.mod & ::SDL2::Key::Mod::CTRL > 0))
+          when ::SDL2::Key::V                           then nuklear_ctx.trigger(:key, :paste,           is_down && (event.mod & ::SDL2::Key::Mod::CTRL > 0))
+          when ::SDL2::Key::X                           then nuklear_ctx.trigger(:key, :cut,             is_down && (event.mod & ::SDL2::Key::Mod::CTRL > 0))
+          when ::SDL2::Key::B                           then nuklear_ctx.trigger(:key, :text_line_start, is_down && (event.mod & ::SDL2::Key::Mod::CTRL > 0))
+          when ::SDL2::Key::E                           then nuklear_ctx.trigger(:key, :text_line_end,   is_down && (event.mod & ::SDL2::Key::Mod::CTRL > 0))
+          when ::SDL2::Key::UP                          then nuklear_ctx.trigger(:key, :up,              is_down)
+          when ::SDL2::Key::DOWN                        then nuklear_ctx.trigger(:key, :down,            is_down)
+          when ::SDL2::Key::LEFT
+            if event.mod & ::SDL2::Key::Mod::CTRL > 0   then nuklear_ctx.trigger(:key, :text_word_left,  is_down)
+            else nuklear_ctx.trigger(:key, :left, is_down)
+            end
+          when ::SDL2::Key::RIGHT
+            if event.mod & ::SDL2::Key::Mod::CTRL > 0   then nuklear_ctx.trigger(:key, :text_word_right, is_down)
+            else nuklear_ctx.trigger(:key, :right, is_down)
+            end
+          end
+
+          yield event if block_given? && escape_keys.include?(event.sym)
+        when SDL2::Event::Quit then exit
+        when SDL2::Event::KeyDown
+          case event.sym
+          when SDL2::Key::C
+            if (event.mod & SDL2::Key::Mod::CTRL) > 0
+              exit
+            end
+          end
+        else
+          yield event if block_given?
+        end
+      end
+    end
+  end
+end

data/examples/lib/window.rb

@@ -0,0 +1,47 @@
+require_relative 'sdl2_input'
+require 'nuklear/nuklear_renderer_opengl2'
+
+module Examples
+  class Window
+    include Examples::SDL2Input
+    attr_reader :nuklear_context
+
+    def initialize(title = "Example", left: 0, top: 0, width: 640, height: 480, hidden: false)
+      flags = SDL2::Window::Flags::OPENGL |
+              SDL2::Window::Flags::ALLOW_HIGHDPI |
+              SDL2::Window::Flags::RESIZABLE
+      flags = flags | SDL2::Window::Flags::HIDDEN if hidden
+      @handle = SDL2::Window.create title, left, top, width, height, flags
+      @gl = SDL2::GL::Context.create(@handle)
+      @focused = false
+      glViewport(0, 0, *renderable_size)
+      glClearColor(0, 0, 0, 0)
+    end
+
+    def close
+      @handle.destroy
+    end
+
+    def frame
+      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+      process_sdl2_events(@nuklear_context)
+      yield # do app specific stuff
+      @handle.gl_swap
+    end
+
+    def focused?
+      @focused
+    end
+
+    def nuklear_context=(ctx)
+      @nuklear_context = ctx
+      @nuklear_context.renderer = Nuklear::Renderer::OpenGL2.new(@nuklear_context)
+      @nuklear_context.renderer.window_size = @handle.size
+      @nuklear_context.renderer.drawable_size = renderable_size
+    end
+
+    def renderable_size
+      @handle.gl_drawable_size
+    end
+  end
+end

data/ext/freetype/extconf.rb

@@ -0,0 +1,26 @@
+require 'fileutils'
+require 'mini_portile2'
+include FileUtils
+
+root = File.expand_path('../..')
+$freetype = MiniPortile.new('freetype', '2.7.0')
+$freetype.target = File.expand_path('ports', root)
+$freetype.files = ['http://download.savannah.gnu.org/releases/freetype/freetype-2.7.tar.gz']
+$freetype.configure_options << 'CFLAGS=-fPIC'
+checkpoint = File.expand_path("ports/.#{$freetype.name}-#{$freetype.version}.installed", root)
+
+unless File.exist?(checkpoint)
+  $freetype.cook
+  touch checkpoint
+end
+
+if $CFLAGS
+  $CFLAGS << ' ' << `sh #{$freetype.path}/bin/freetype-config --cflags --static`.chomp
+  `sh #{$freetype.path}/bin/freetype-config --libs --static`.chomp.shellsplit.each do |arg|
+    case arg
+    when /\A-L(.+)\z/ then $LIBPATH << $1
+    when /\A-l./      then $libs    << ' ' << arg.shellescape
+    else                   $LDFLAGS << ' ' << arg.shellescape
+    end
+  end
+end

data/ext/nuklear/extconf.rb

@@ -0,0 +1,14 @@
+require 'mkmf'
+# require_relative '../freetype/extconf'
+
+$CFLAGS << ' -DNK_INCLUDE_VERTEX_BUFFER_OUTPUT=1'
+$CFLAGS << ' -DNK_INCLUDE_FONT_BAKING=1'
+$CFLAGS << ' -DNK_INCLUDE_DEFAULT_FONT=1'
+$CFLAGS << ' -DNK_INCLUDE_COMMAND_USERDATA=1'
+$CFLAGS << ' -DNK_BUTTON_TRIGGER_ON_RELEASE=1'
+$CFLAGS << ' -DNK_ZERO_COMMAND_MEMORY=1'
+$CFLAGS << ' -DNK_INCLUDE_FIXED_TYPES=1'
+$CFLAGS << ' -DNK_INCLUDE_DEFAULT_ALLOCATOR=1'
+$CFLAGS << ' -DNK_INCLUDE_STANDARD_IO=1'
+
+create_makefile('nuklear/nuklear')

data/ext/nuklear/nkrb.c

@@ -0,0 +1,79 @@
+#define NK_IMPLEMENTATION
+#include "nkrb.h"
+
+VALUE mNuklear = Qnil;
+
+void Init_nuklear(void) {
+  mNuklear = rb_define_module("Nuklear");
+
+  rb_const_set(mNuklear, rb_intern("NK_WINDOW_BORDER"),             INT2FIX(NK_WINDOW_BORDER));
+  rb_const_set(mNuklear, rb_intern("NK_WINDOW_MOVABLE"),            INT2FIX(NK_WINDOW_MOVABLE));
+  rb_const_set(mNuklear, rb_intern("NK_WINDOW_SCALABLE"),           INT2FIX(NK_WINDOW_SCALABLE));
+  rb_const_set(mNuklear, rb_intern("NK_WINDOW_CLOSABLE"),           INT2FIX(NK_WINDOW_CLOSABLE));
+  rb_const_set(mNuklear, rb_intern("NK_WINDOW_MINIMIZABLE"),        INT2FIX(NK_WINDOW_MINIMIZABLE));
+  rb_const_set(mNuklear, rb_intern("NK_WINDOW_NO_SCROLLBAR"),       INT2FIX(NK_WINDOW_NO_SCROLLBAR));
+  rb_const_set(mNuklear, rb_intern("NK_WINDOW_TITLE"),              INT2FIX(NK_WINDOW_TITLE));
+  rb_const_set(mNuklear, rb_intern("NK_WINDOW_SCROLL_AUTO_HIDE"),   INT2FIX(NK_WINDOW_SCROLL_AUTO_HIDE));
+  rb_const_set(mNuklear, rb_intern("NK_WINDOW_BACKGROUND"),         INT2FIX(NK_WINDOW_BACKGROUND));
+  rb_const_set(mNuklear, rb_intern("NK_WINDOW_SCALE_LEFT"),         INT2FIX(NK_WINDOW_SCALE_LEFT));
+  rb_const_set(mNuklear, rb_intern("NK_WINDOW_NO_INPUT"),           INT2FIX(NK_WINDOW_NO_INPUT));
+
+  rb_const_set(mNuklear, rb_intern("NK_EDIT_DEFAULT"),              INT2FIX(NK_EDIT_DEFAULT));
+  rb_const_set(mNuklear, rb_intern("NK_EDIT_READ_ONLY"),            INT2FIX(NK_EDIT_READ_ONLY));
+  rb_const_set(mNuklear, rb_intern("NK_EDIT_AUTO_SELECT"),          INT2FIX(NK_EDIT_AUTO_SELECT));
+  rb_const_set(mNuklear, rb_intern("NK_EDIT_SIG_ENTER"),            INT2FIX(NK_EDIT_SIG_ENTER));
+  rb_const_set(mNuklear, rb_intern("NK_EDIT_ALLOW_TAB"),            INT2FIX(NK_EDIT_ALLOW_TAB));
+  rb_const_set(mNuklear, rb_intern("NK_EDIT_NO_CURSOR"),            INT2FIX(NK_EDIT_NO_CURSOR));
+  rb_const_set(mNuklear, rb_intern("NK_EDIT_SELECTABLE"),           INT2FIX(NK_EDIT_SELECTABLE));
+  rb_const_set(mNuklear, rb_intern("NK_EDIT_CLIPBOARD"),            INT2FIX(NK_EDIT_CLIPBOARD));
+  rb_const_set(mNuklear, rb_intern("NK_EDIT_CTRL_ENTER_NEWLINE"),   INT2FIX(NK_EDIT_CTRL_ENTER_NEWLINE));
+  rb_const_set(mNuklear, rb_intern("NK_EDIT_NO_HORIZONTAL_SCROLL"), INT2FIX(NK_EDIT_NO_HORIZONTAL_SCROLL));
+  rb_const_set(mNuklear, rb_intern("NK_EDIT_ALWAYS_INSERT_MODE"),   INT2FIX(NK_EDIT_ALWAYS_INSERT_MODE));
+  rb_const_set(mNuklear, rb_intern("NK_EDIT_MULTILINE"),            INT2FIX(NK_EDIT_MULTILINE));
+  rb_const_set(mNuklear, rb_intern("NK_EDIT_GOTO_END_ON_ACTIVATE"), INT2FIX(NK_EDIT_GOTO_END_ON_ACTIVATE));
+
+  rb_const_set(mNuklear, rb_intern("NK_EDIT_SIMPLE"),               INT2FIX(NK_EDIT_SIMPLE));
+  rb_const_set(mNuklear, rb_intern("NK_EDIT_FIELD"),                INT2FIX(NK_EDIT_FIELD));
+  rb_const_set(mNuklear, rb_intern("NK_EDIT_BOX"),                  INT2FIX(NK_EDIT_BOX));
+  rb_const_set(mNuklear, rb_intern("NK_EDIT_EDITOR"),               INT2FIX(NK_EDIT_EDITOR));
+
+  rb_const_set(mNuklear, rb_intern("NK_EDIT_ACTIVE"),               INT2FIX(NK_EDIT_ACTIVE));
+  rb_const_set(mNuklear, rb_intern("NK_EDIT_INACTIVE"),             INT2FIX(NK_EDIT_INACTIVE));
+  rb_const_set(mNuklear, rb_intern("NK_EDIT_ACTIVATED"),            INT2FIX(NK_EDIT_ACTIVATED));
+  rb_const_set(mNuklear, rb_intern("NK_EDIT_DEACTIVATED"),          INT2FIX(NK_EDIT_DEACTIVATED));
+  rb_const_set(mNuklear, rb_intern("NK_EDIT_COMMITED"),             INT2FIX(NK_EDIT_COMMITED));
+
+  rb_const_set(mNuklear, rb_intern("NK_STYLE_ITEM_COLOR"),          INT2FIX(NK_STYLE_ITEM_COLOR));
+  rb_const_set(mNuklear, rb_intern("NK_STYLE_ITEM_IMAGE"),          INT2FIX(NK_STYLE_ITEM_IMAGE));
+
+  rb_const_set(mNuklear, rb_intern("NK_MINIMIZED"),                 INT2FIX(NK_MINIMIZED));
+  rb_const_set(mNuklear, rb_intern("NK_MAXIMIZED"),                 INT2FIX(NK_MAXIMIZED));
+
+  rb_const_set(mNuklear, rb_intern("NK_TREE_NODE"),                 INT2FIX(NK_TREE_NODE));
+  rb_const_set(mNuklear, rb_intern("NK_TREE_TAB"),                  INT2FIX(NK_TREE_TAB));
+
+  rb_const_set(mNuklear, rb_intern("NK_DYNAMIC"),                   INT2FIX(NK_DYNAMIC));
+  rb_const_set(mNuklear, rb_intern("NK_STATIC"),                    INT2FIX(NK_STATIC));
+
+  rb_const_set(mNuklear, rb_intern("NK_POPUP_DYNAMIC"),             INT2FIX(NK_POPUP_DYNAMIC));
+  rb_const_set(mNuklear, rb_intern("NK_POPUP_STATIC"),              INT2FIX(NK_POPUP_STATIC));
+
+  rb_const_set(mNuklear, rb_intern("NK_TEXT_ALIGN_LEFT"),           INT2FIX(NK_TEXT_ALIGN_LEFT));
+  rb_const_set(mNuklear, rb_intern("NK_TEXT_ALIGN_CENTERED"),       INT2FIX(NK_TEXT_ALIGN_CENTERED));
+  rb_const_set(mNuklear, rb_intern("NK_TEXT_ALIGN_RIGHT"),          INT2FIX(NK_TEXT_ALIGN_RIGHT));
+  rb_const_set(mNuklear, rb_intern("NK_TEXT_ALIGN_TOP"),            INT2FIX(NK_TEXT_ALIGN_TOP));
+  rb_const_set(mNuklear, rb_intern("NK_TEXT_ALIGN_MIDDLE"),         INT2FIX(NK_TEXT_ALIGN_MIDDLE));
+  rb_const_set(mNuklear, rb_intern("NK_TEXT_ALIGN_BOTTOM"),         INT2FIX(NK_TEXT_ALIGN_BOTTOM));
+
+  rb_const_set(mNuklear, rb_intern("NK_TEXT_LEFT"),                 INT2FIX(NK_TEXT_LEFT));
+  rb_const_set(mNuklear, rb_intern("NK_TEXT_CENTERED"),             INT2FIX(NK_TEXT_CENTERED));
+  rb_const_set(mNuklear, rb_intern("NK_TEXT_RIGHT"),                INT2FIX(NK_TEXT_RIGHT));
+
+  nkrb_context_init();
+  nkrb_font_init();
+  nkrb_buffer_init();
+  nkrb_renderer_init();
+  nkrb_style_init();
+  nkrb_ui_builder_init();
+  nkrb_ui_init();
+}

data/ext/nuklear/nkrb.h

@@ -0,0 +1,89 @@
+#ifndef NUKLEAR_RUBY_H
+#define NUKLEAR_RUBY_H
+
+#include "nuklear.h"
+#include <ruby.h>
+
+#define ASSIGN_STYLE_AS_IMAGE(left, style) \
+  if (style->type == NK_STYLE_ITEM_IMAGE)  \
+    left = style->data.image;              \
+  else                                     \
+    rb_raise(rb_eArgError, "expected an image here");
+
+#define ASSIGN_STYLE_AS_COLOR(left, style) \
+  if (style->type == NK_STYLE_ITEM_COLOR)  \
+    left = style->data.color;              \
+  else                                     \
+    rb_raise(rb_eArgError, "expected a color here");
+
+
+#define SET_RSYMBOL(symbol, rsymbol) \
+  if (!NIL_P(rsymbol)) {                                                                        \
+    if      (SYM2ID(rsymbol) == rb_intern("x"))              symbol = NK_SYMBOL_X;              \
+    else if (SYM2ID(rsymbol) == rb_intern("underscore"))     symbol = NK_SYMBOL_UNDERSCORE;     \
+    else if (SYM2ID(rsymbol) == rb_intern("circle_solid"))   symbol = NK_SYMBOL_CIRCLE_SOLID;   \
+    else if (SYM2ID(rsymbol) == rb_intern("circle_outline")) symbol = NK_SYMBOL_CIRCLE_OUTLINE; \
+    else if (SYM2ID(rsymbol) == rb_intern("rect_solid"))     symbol = NK_SYMBOL_RECT_SOLID;     \
+    else if (SYM2ID(rsymbol) == rb_intern("rect_outline"))   symbol = NK_SYMBOL_RECT_OUTLINE;   \
+    else if (SYM2ID(rsymbol) == rb_intern("triangle_up"))    symbol = NK_SYMBOL_TRIANGLE_UP;    \
+    else if (SYM2ID(rsymbol) == rb_intern("triangle_down"))  symbol = NK_SYMBOL_TRIANGLE_DOWN;  \
+    else if (SYM2ID(rsymbol) == rb_intern("triangle_left"))  symbol = NK_SYMBOL_TRIANGLE_LEFT;  \
+    else if (SYM2ID(rsymbol) == rb_intern("triangle_right")) symbol = NK_SYMBOL_TRIANGLE_RIGHT; \
+    else if (SYM2ID(rsymbol) == rb_intern("plus"))           symbol = NK_SYMBOL_PLUS;           \
+    else if (SYM2ID(rsymbol) == rb_intern("minus"))          symbol = NK_SYMBOL_MINUS;          \
+    else if (SYM2ID(rsymbol) == rb_intern("max"))            symbol = NK_SYMBOL_MAX;            \
+    else rb_raise(rb_eArgError, "Symbol must be :x, :underscore, :circle_solid, :circle_outline"\
+                                ", :rect_solid, :rect_outline, :triangle_up, :triangle_down, "  \
+                                ":triangle_left, :triangle_right, :plus, :minus or :max.");     \
+  }
+
+
+void nkrb_context_init(void);
+void nkrb_font_init(void);
+void nkrb_buffer_init(void);
+void nkrb_renderer_init(void);
+void nkrb_ui_builder_init(void);
+void nkrb_ui_init(void);
+void nkrb_ui_button_init(void);
+void nkrb_ui_checkbox_init(void);
+void nkrb_ui_color_picker_init(void);
+void nkrb_ui_combo_init(void);
+void nkrb_ui_group_init(void);
+void nkrb_ui_label_init(void);
+void nkrb_ui_layout_init(void);
+void nkrb_ui_edit_string_init(void);
+void nkrb_ui_menu_init(void);
+void nkrb_ui_menubar_init(void);
+void nkrb_ui_menu_item_init(void);
+void nkrb_ui_popup_init(void);
+void nkrb_ui_progress_init(void);
+void nkrb_ui_property_init(void);
+void nkrb_ui_slider_init(void);
+void nkrb_ui_tree_init(void);
+void nkrb_ui_widget_init(void);
+void nkrb_ui_window_init(void);
+void nkrb_ui_container_init(void);
+void nkrb_style_init(void);
+void nkrb_style_color_init(void);
+void nkrb_style_image_init(void);
+struct nk_user_font *nkrb_font_to_nk(VALUE self);
+struct nk_context *nkrb_context_get(VALUE context);
+struct nk_style_item *nkrb_style_item(VALUE value);
+void nkrb_style_item_free(struct nk_style_item *item);
+VALUE nkrb_font_get_null(VALUE value);
+void instance_eval_block(VALUE self);
+void assign_button_style_from_ruby(struct nk_style_button *style, VALUE rstyle);
+
+extern VALUE mNuklear;
+extern VALUE cNuklearContext;
+extern VALUE cNuklearFont;
+extern VALUE cNuklearBuffer;
+extern VALUE cNuklearUIBuilder;
+extern VALUE mNuklearUIContainer;
+extern VALUE mNuklearUI;
+extern VALUE cNuklearUIWidget;
+extern VALUE mNuklearStyle;
+extern VALUE cNuklearStyleColor;
+extern VALUE cNuklearStyleImage;
+
+#endif // NUKLEAR_RUBY_H

data/ext/nuklear/nkrb_buffer.c

@@ -0,0 +1,80 @@
+#include "nkrb.h"
+
+VALUE cNuklearBuffer = Qnil;
+
+void nkrb_buffer_dynamic_free(struct nk_buffer *buf) {
+  // need to let nk free the buffer contents, then free the buffer itself.
+  nk_buffer_free(buf);
+  free(buf);
+}
+
+void nkrb_buffer_managed_free(struct nk_buffer *buf) {
+  // the buffer memory is managed elsewhere, and will be freed elsewhere.
+  // We only need to free the buffer itself.
+  free(buf);
+}
+
+void nkrb_buffer_fixed_free(struct nk_buffer *buf) {
+  // need to free the memory we allocated ourselves, then free the buffer
+  // itself.
+  free(nk_buffer_memory(buf));
+  free(buf);
+}
+
+VALUE nkrb_buffer_new(int argc, VALUE* argv, VALUE module) {
+  VALUE rsize = Qnil;
+  VALUE rptr = Qnil;
+  rb_scan_args(argc, argv, "02", &rsize, &rptr); // optional rsize, rptr
+  void (*freefn)(struct nk_buffer *buf) = NULL;
+
+  struct nk_buffer *buf = malloc(sizeof(struct nk_buffer));
+  nk_size size = 0; // if size is 0, the buffer will be dynamic.
+  if (!NIL_P(rsize)) size = (nk_size) NUM2INT(rsize);
+
+  if (size) {
+    void *mem = NULL;
+    if (!NIL_P(rptr)) {
+      // we were passed a pointer; we will treat it as a 64 bit unsigned in
+      // ruby, and a void * in c. We will not zero the user-provided buffer.
+      mem = (void *) NUM2ULL(rptr);
+      freefn = nkrb_buffer_managed_free;
+    } else {
+      // we were not passed a pointer; we will allocate a buffer of the
+      // requested size and use that. We will zero the uninitialized memory.
+      mem = malloc(size);
+      memset(mem, 0, size);
+      freefn = nkrb_buffer_fixed_free;
+    }
+    nk_buffer_init_fixed(buf, mem, size);
+  } else {
+    nk_buffer_init_default(buf);
+    freefn = nkrb_buffer_dynamic_free;
+  }
+  VALUE result = Data_Wrap_Struct(cNuklearBuffer, NULL, freefn, buf);
+  return result;
+}
+
+VALUE nkrb_buffer_size(VALUE self) {
+  struct nk_buffer *buf = NULL;
+  Data_Get_Struct(self, struct nk_buffer, buf);
+  return ULONG2NUM(nk_buffer_total(buf));
+}
+
+VALUE nkrb_buffer_to_ptr(VALUE self) {
+  struct nk_buffer *buf = NULL;
+  Data_Get_Struct(self, struct nk_buffer, buf);
+  VALUE cFiddle = rb_const_get(rb_cObject, rb_intern("Fiddle"));
+  VALUE cPointer = rb_const_get(cFiddle, rb_intern("Pointer"));
+  VALUE fiddleptr = rb_funcall(cPointer, rb_intern("new"), 2,
+                               ULONG2NUM((unsigned long) nk_buffer_memory(buf)),
+                               nkrb_buffer_size(self));
+  return fiddleptr;
+}
+
+void nkrb_buffer_init(void) {
+  cNuklearBuffer = rb_define_class_under(mNuklear, "Buffer", rb_cObject);
+
+  rb_define_module_function(cNuklearBuffer, "new", nkrb_buffer_new, -1);
+  rb_define_method(cNuklearBuffer, "size", nkrb_buffer_size, 0);
+  rb_define_method(cNuklearBuffer, "to_ptr", nkrb_buffer_to_ptr, 0);
+}

data/ext/nuklear/nkrb_context.c

@@ -0,0 +1,241 @@
+#include "nkrb.h"
+
+#define VALUE_TO_NK(value, varname)  \
+  struct nk_context *varname = NULL; \
+  Data_Get_Struct(value, struct nk_context, varname);
+
+VALUE cNuklearContext = Qnil;
+VALUE cNuklearContextEventSink = Qnil;
+
+void nkrb_context_free(struct nk_context *ctx) {
+  nk_free(ctx);
+  free(ctx);
+}
+
+struct nk_context *nkrb_context_get(VALUE context) {
+  VALUE_TO_NK(context, ctx);
+  return ctx;
+}
+
+VALUE nkrb_context_alloc(VALUE self) {
+  struct nk_context *ctx = malloc(sizeof(struct nk_context));
+  memset(ctx, 0, sizeof(struct nk_context));
+  return Data_Wrap_Struct(self, NULL, nkrb_context_free, ctx);
+}
+
+void set_default_style(struct nk_context *ctx) {
+  struct nk_color table[NK_COLOR_COUNT];
+  table[NK_COLOR_TEXT]                    = nk_rgba(210, 210, 210, 255);
+  table[NK_COLOR_WINDOW]                  = nk_rgba( 57,  67,  71, 215);
+  table[NK_COLOR_HEADER]                  = nk_rgba( 51,  51,  56, 220);
+  table[NK_COLOR_BORDER]                  = nk_rgba( 46,  46,  46, 255);
+  table[NK_COLOR_BUTTON]                  = nk_rgba( 48,  83, 111, 255);
+  table[NK_COLOR_BUTTON_HOVER]            = nk_rgba( 58,  93, 121, 255);
+  table[NK_COLOR_BUTTON_ACTIVE]           = nk_rgba( 63,  98, 126, 255);
+  table[NK_COLOR_TOGGLE]                  = nk_rgba( 50,  58,  61, 255);
+  table[NK_COLOR_TOGGLE_HOVER]            = nk_rgba( 45,  53,  56, 255);
+  table[NK_COLOR_TOGGLE_CURSOR]           = nk_rgba( 48,  83, 111, 255);
+  table[NK_COLOR_SELECT]                  = nk_rgba( 57,  67,  61, 255);
+  table[NK_COLOR_SELECT_ACTIVE]           = nk_rgba( 48,  83, 111, 255);
+  table[NK_COLOR_SLIDER]                  = nk_rgba( 50,  58,  61, 255);
+  table[NK_COLOR_SLIDER_CURSOR]           = nk_rgba( 48,  83, 111, 245);
+  table[NK_COLOR_SLIDER_CURSOR_HOVER]     = nk_rgba( 53,  88, 116, 255);
+  table[NK_COLOR_SLIDER_CURSOR_ACTIVE]    = nk_rgba( 58,  93, 121, 255);
+  table[NK_COLOR_PROPERTY]                = nk_rgba( 50,  58,  61, 255);
+  table[NK_COLOR_EDIT]                    = nk_rgba( 50,  58,  61, 225);
+  table[NK_COLOR_EDIT_CURSOR]             = nk_rgba(210, 210, 210, 255);
+  table[NK_COLOR_COMBO]                   = nk_rgba( 50,  58,  61, 255);
+  table[NK_COLOR_CHART]                   = nk_rgba( 50,  58,  61, 255);
+  table[NK_COLOR_CHART_COLOR]             = nk_rgba( 48,  83, 111, 255);
+  table[NK_COLOR_CHART_COLOR_HIGHLIGHT]   = nk_rgba(255,   0,   0, 255);
+  table[NK_COLOR_SCROLLBAR]               = nk_rgba( 50,  58,  61, 255);
+  table[NK_COLOR_SCROLLBAR_CURSOR]        = nk_rgba( 48,  83, 111, 255);
+  table[NK_COLOR_SCROLLBAR_CURSOR_HOVER]  = nk_rgba( 53,  88, 116, 255);
+  table[NK_COLOR_SCROLLBAR_CURSOR_ACTIVE] = nk_rgba( 58,  93, 121, 255);
+  table[NK_COLOR_TAB_HEADER]              = nk_rgba( 48,  83, 111, 255);
+  nk_style_from_table(ctx, table);
+}
+
+VALUE nkrb_context_initialize(VALUE context, VALUE font) {
+  struct nk_context *ctx = nkrb_context_get(context);
+  if (nk_init_default(ctx, nkrb_font_to_nk(font)) == 0) {
+    rb_raise(rb_eStandardError, "Failed to initialize Nuklear context");
+  }
+  set_default_style(ctx);
+  VALUE event_sink = rb_funcall(cNuklearContextEventSink, rb_intern("new"), 1, context);
+  rb_ivar_set(context, rb_intern("@event_sink"), event_sink);
+  rb_ivar_set(context, rb_intern("@font"), font);
+  rb_ivar_set(context, rb_intern("@null"), nkrb_font_get_null(font));
+  rb_ivar_set(context, rb_intern("@ui_builder"), rb_funcall(cNuklearUIBuilder, rb_intern("new"), 1, context));
+
+  return context;
+}
+
+VALUE nkrb_context_set_user_data(VALUE self, VALUE userdata) {
+  VALUE_TO_NK(self, ctx);
+  // maybe come back to this, might be able to access user data later on through context
+  // nk_set_user_data(ctx, userdata);
+  rb_ivar_set(self, rb_intern("@userdata"), userdata);
+  return userdata;
+}
+
+VALUE nkrb_context_get_user_data(VALUE self) {
+  return rb_ivar_get(self, rb_intern("@userdata"));
+}
+
+VALUE nkrb_context_tick(VALUE self) {
+  VALUE_TO_NK(self, ctx);
+  nk_input_begin(ctx);
+  rb_funcall(self, rb_intern("process_pending_events"), 0);
+  nk_input_end(ctx);
+  rb_funcall(self, rb_intern("paint"), 0);
+  nk_clear(ctx);
+  return self;
+}
+
+VALUE rb_nkrb_event_sink_initialize(VALUE self, VALUE context) {
+  rb_ivar_set(self, rb_intern("@context"), context);
+  return self;
+}
+
+VALUE nkrb_event_sink_motion(VALUE self, VALUE rx, VALUE ry, VALUE rxrel, VALUE ryrel) {
+  VALUE_TO_NK(rb_ivar_get(self, rb_intern("@context")), ctx);
+  if (ctx->input.mouse.grabbed) {
+    int x = (int) ctx->input.mouse.prev.x, y = (int) ctx->input.mouse.prev.y;
+    nk_input_motion(ctx, x + FIX2INT(rxrel), y + FIX2INT(ryrel));
+  } else {
+    nk_input_motion(ctx, FIX2INT(rx), FIX2INT(ry));
+  }
+  return self;
+}
+
+VALUE nkrb_event_sink_key(VALUE self, VALUE keys, VALUE down) {
+  VALUE_TO_NK(rb_ivar_get(self, rb_intern("@context")), ctx);
+  ID keys_id = SYM2ID(keys);
+  int is_down = RTEST(down) ? 1 : 0;
+
+  if (keys_id == rb_intern("shift"))          nk_input_key(ctx, NK_KEY_SHIFT, is_down);
+  else if (keys_id == rb_intern("ctrl"))      nk_input_key(ctx, NK_KEY_CTRL, is_down);
+  else if (keys_id == rb_intern("del"))       nk_input_key(ctx, NK_KEY_DEL, is_down);
+  else if (keys_id == rb_intern("enter"))     nk_input_key(ctx, NK_KEY_ENTER, is_down);
+  else if (keys_id == rb_intern("tab"))       nk_input_key(ctx, NK_KEY_TAB, is_down);
+  else if (keys_id == rb_intern("backspace")) nk_input_key(ctx, NK_KEY_BACKSPACE, is_down);
+  else if (keys_id == rb_intern("copy"))      nk_input_key(ctx, NK_KEY_COPY, is_down);
+  else if (keys_id == rb_intern("cut"))       nk_input_key(ctx, NK_KEY_CUT, is_down);
+  else if (keys_id == rb_intern("paste"))     nk_input_key(ctx, NK_KEY_PASTE, is_down);
+  else if (keys_id == rb_intern("up"))        nk_input_key(ctx, NK_KEY_UP, is_down);
+  else if (keys_id == rb_intern("down"))      nk_input_key(ctx, NK_KEY_DOWN, is_down);
+  else if (keys_id == rb_intern("left"))      nk_input_key(ctx, NK_KEY_LEFT, is_down);
+  else if (keys_id == rb_intern("right"))     nk_input_key(ctx, NK_KEY_RIGHT, is_down);
+
+  /* Shortcuts: text field */
+  else if (keys_id == rb_intern("text_insert_mode"))  nk_input_key(ctx, NK_KEY_TEXT_INSERT_MODE, is_down);
+  else if (keys_id == rb_intern("text_replace_mode")) nk_input_key(ctx, NK_KEY_TEXT_REPLACE_MODE, is_down);
+  else if (keys_id == rb_intern("text_reset_mode"))   nk_input_key(ctx, NK_KEY_TEXT_RESET_MODE, is_down);
+  else if (keys_id == rb_intern("text_line_start"))   nk_input_key(ctx, NK_KEY_TEXT_LINE_START, is_down);
+  else if (keys_id == rb_intern("text_line_end"))     nk_input_key(ctx, NK_KEY_TEXT_LINE_END, is_down);
+  else if (keys_id == rb_intern("text_start"))        nk_input_key(ctx, NK_KEY_TEXT_START, is_down);
+  else if (keys_id == rb_intern("text_end"))          nk_input_key(ctx, NK_KEY_TEXT_END, is_down);
+  else if (keys_id == rb_intern("text_undo"))         nk_input_key(ctx, NK_KEY_TEXT_UNDO, is_down);
+  else if (keys_id == rb_intern("text_redo"))         nk_input_key(ctx, NK_KEY_TEXT_REDO, is_down);
+  else if (keys_id == rb_intern("text_select_all"))   nk_input_key(ctx, NK_KEY_TEXT_SELECT_ALL, is_down);
+  else if (keys_id == rb_intern("text_word_left"))    nk_input_key(ctx, NK_KEY_TEXT_WORD_LEFT, is_down);
+  else if (keys_id == rb_intern("text_word_right"))   nk_input_key(ctx, NK_KEY_TEXT_WORD_RIGHT, is_down);
+
+  /* Shortcuts: scrollbar */
+  else if (keys_id == rb_intern("scroll_start")) nk_input_key(ctx, NK_KEY_SCROLL_START, is_down);
+  else if (keys_id == rb_intern("scroll_end"))   nk_input_key(ctx, NK_KEY_SCROLL_END, is_down);
+  else if (keys_id == rb_intern("scroll_down"))  nk_input_key(ctx, NK_KEY_SCROLL_DOWN, is_down);
+  else if (keys_id == rb_intern("scroll_up"))    nk_input_key(ctx, NK_KEY_SCROLL_UP, is_down);
+  else if (keys_id == rb_intern("max"))          nk_input_key(ctx, NK_KEY_MAX, is_down);
+  else {
+    VALUE s = rb_funcall(keys, rb_intern("inspect"), 0);
+    rb_raise(rb_eArgError, "Invalid key symbol: %s", StringValueCStr(s));
+  }
+
+  return self;
+}
+
+VALUE nkrb_event_sink_button(VALUE self, VALUE buttons, VALUE rx, VALUE ry, VALUE down) {
+  VALUE_TO_NK(rb_ivar_get(self, rb_intern("@context")), ctx);
+  ID buttons_id = SYM2ID(buttons);
+  int is_down = RTEST(down) ? 1 : 0;
+  int x = FIX2INT(rx), y = FIX2INT(ry);
+
+  if (buttons_id == rb_intern("left"))   nk_input_button(ctx, NK_BUTTON_LEFT,   x, y, is_down);
+  if (buttons_id == rb_intern("middle")) nk_input_button(ctx, NK_BUTTON_MIDDLE, x, y, is_down);
+  if (buttons_id == rb_intern("right"))  nk_input_button(ctx, NK_BUTTON_RIGHT,  x, y, is_down);
+  if (buttons_id == rb_intern("double")) nk_input_button(ctx, NK_BUTTON_DOUBLE, x, y, is_down);
+  if (buttons_id == rb_intern("max"))    nk_input_button(ctx, NK_BUTTON_MAX,    x, y, is_down);
+
+  return self;
+}
+
+VALUE nkrb_event_sink_scroll(VALUE self, VALUE x, VALUE y) {
+  VALUE_TO_NK(rb_ivar_get(self, rb_intern("@context")), ctx);
+  struct nk_vec2 vec;
+  vec.x = (float) NUM2DBL(x);
+  vec.y = (float) NUM2DBL(y);
+  nk_input_scroll(ctx, vec);
+  return self;
+}
+
+VALUE nkrb_event_sink_char(VALUE self, VALUE chr) {
+  VALUE_TO_NK(rb_ivar_get(self, rb_intern("@context")), ctx);
+  int ch = FIX2INT(rb_funcall(chr, rb_intern("ord"), 0));
+  nk_input_char(ctx, ch);
+  return self;
+}
+
+VALUE nkrb_event_sink_glyph(VALUE self, VALUE chr) {
+  VALUE_TO_NK(rb_ivar_get(self, rb_intern("@context")), ctx);
+  nk_glyph glyph;
+  int len = (int) RSTRING_LEN(chr);
+  if (len < NK_UTF_SIZE) {
+    if (len > 0) {
+      int i;
+      for (i = 0; i < len; i++) {
+        int ch = FIX2INT(rb_funcall(rb_funcall(chr, rb_intern("[]"), 1, INT2FIX(i)),
+                                    rb_intern("ord"), 0));
+        nk_input_char(ctx, ch);
+      }
+    } else {
+      rb_raise(rb_eArgError, "input is empty");
+    }
+  } else {
+    memcpy(glyph, StringValuePtr(chr), NK_UTF_SIZE);
+    nk_input_glyph(ctx, glyph);
+  }
+  return self;
+}
+
+// VALUE nkrb_event_sink_unicode(VALUE self, VALUE ch) {
+//   
+// }
+
+VALUE nkrb_context_ui(VALUE self) {
+  VALUE ui = rb_ivar_get(self, rb_intern("@ui_builder"));
+  rb_need_block();
+  rb_funcall_with_block(ui, rb_intern("instance_eval"), 0, NULL, rb_block_proc());
+  return ui;
+}
+
+void nkrb_context_init(void) {
+  cNuklearContext = rb_define_class_under(mNuklear, "Context", rb_cObject);
+  rb_define_alloc_func(cNuklearContext, nkrb_context_alloc);
+  rb_define_method(cNuklearContext, "user_data=", nkrb_context_set_user_data, 1);
+  rb_define_method(cNuklearContext, "user_data", nkrb_context_get_user_data, 0);
+  rb_define_method(cNuklearContext, "initialize", nkrb_context_initialize, 1);
+  rb_define_method(cNuklearContext, "tick", nkrb_context_tick, 0);
+  rb_define_method(cNuklearContext, "ui", nkrb_context_ui, 0);
+
+  cNuklearContextEventSink = rb_define_class_under(cNuklearContext, "EventSink", rb_cObject);
+  rb_define_method(cNuklearContextEventSink, "initialize", rb_nkrb_event_sink_initialize, 1);
+  rb_define_method(cNuklearContextEventSink, "motion",  nkrb_event_sink_motion,  4);
+  rb_define_method(cNuklearContextEventSink, "key",     nkrb_event_sink_key,     2);
+  rb_define_method(cNuklearContextEventSink, "button",  nkrb_event_sink_button,  4);
+  rb_define_method(cNuklearContextEventSink, "scroll",  nkrb_event_sink_scroll,  2);
+  rb_define_method(cNuklearContextEventSink, "char",    nkrb_event_sink_char,    1);
+  rb_define_method(cNuklearContextEventSink, "glyph",   nkrb_event_sink_glyph,   1);
+  // rb_define_method(cNuklearContextEventSink, "unicode", nkrb_event_sink_unicode, 1);
+}