glfw 0.1.0 → 0.9.8

data/ext/glfw/vulkan.h

@@ -0,0 +1,16 @@
+
+#ifndef GLFW_RB_VULKAN_H
+#define GLFW_RB_VULKAN_H 1
+
+#include "common.h"
+
+void Init_glfw_vulkan(VALUE module);
+
+VALUE rb_glfw_vulkan_supported(VALUE klass);
+VALUE rb_glfw_vulkan_required_ext(VALUE klass);
+
+VALUE rb_glfw_vulkan_create_surface(VALUE self, VALUE window, VALUE allocator);
+VALUE rb_glfw_vulkan_proc_address(VALUE self, VALUE name);
+VALUE rb_glfw_vulkan_device_support(VALUE self, VALUE device, VALUE family);
+
+#endif /* GLFW_RB_VULKAN_H */

data/ext/glfw/window.c

@@ -0,0 +1,708 @@
+
+#include "window.h"
+
+VALUE rb_cGLFWwindow;
+
+ID id_moved;
+ID id_resized;
+ID id_framebuffer_resized;
+ID id_closing;
+ID id_refreshed;
+ID id_focus_changed;
+ID id_minimize_changed;
+ID id_mouse_move;
+ID id_mouse_scroll;
+ID id_mouse_button;
+ID id_mouse_enter;
+ID id_key;
+ID id_char;
+ID id_char_mods;
+ID id_file_drop;
+
+#define RB_CALLBACK(id, name) \
+    id = rb_intern(name);     \
+    rb_define_method_id(rb_cGLFWwindow, id, rb_glfw_window_empty_method, -1)
+
+void Init_glfw_window(VALUE mmodule) {
+    rb_cGLFWwindow = rb_define_class_under(rb_mGLFW, "Window", rb_cObject);
+
+    rb_define_alloc_func(rb_cGLFWwindow, rb_glfw_window_alloc);
+    rb_define_method(rb_cGLFWwindow, "initialize", rb_glfw_window_initialize, -1);
+    rb_define_method(rb_cGLFWwindow, "destroy", rb_glfw_window_destroy, 0);
+    rb_define_method(rb_cGLFWwindow, "show", rb_glfw_window_show, 0);
+    rb_define_method(rb_cGLFWwindow, "hide", rb_glfw_window_hide, 0);
+    rb_define_method(rb_cGLFWwindow, "minimize", rb_glfw_window_minimize, 0);
+    rb_define_method(rb_cGLFWwindow, "maximize", rb_glfw_window_maximize, 0);
+    rb_define_method(rb_cGLFWwindow, "restore", rb_glfw_window_restore, 0);
+    rb_define_method(rb_cGLFWwindow, "focus", rb_glfw_window_focus, 0);
+    rb_define_method(rb_cGLFWwindow, "closing?", rb_glfw_window_closing_p, 0);
+    rb_define_method(rb_cGLFWwindow, "close", rb_glfw_window_close, -1);
+
+    rb_define_method(rb_cGLFWwindow, "swap_buffers", rb_glfw_window_swap_buffers, 0);
+    rb_define_method(rb_cGLFWwindow, "make_current", rb_glfw_window_make_current, 0);
+    rb_define_method(rb_cGLFWwindow, "monitor", rb_glfw_window_get_monitor, 0);
+    rb_define_method(rb_cGLFWwindow, "set_monitor", rb_glfw_window_set_monitor, -1);
+
+    rb_define_method(rb_cGLFWwindow, "dimensions", rb_glfw_window_dimensions, 0);
+    rb_define_method(rb_cGLFWwindow, "position", rb_glfw_window_get_pos, 0);
+    rb_define_method(rb_cGLFWwindow, "move", rb_glfw_window_set_pos, 2);
+    rb_define_method(rb_cGLFWwindow, "size", rb_glfw_window_get_size, 0);
+    rb_define_method(rb_cGLFWwindow, "resize", rb_glfw_window_set_size, 2);
+    rb_define_method(rb_cGLFWwindow, "framebuffer_size", rb_glfw_window_get_framebuffer_size, 0);
+    rb_define_method(rb_cGLFWwindow, "x", rb_glfw_window_get_x, 0);
+    rb_define_method(rb_cGLFWwindow, "y", rb_glfw_window_get_y, 0);
+    rb_define_method(rb_cGLFWwindow, "width", rb_glfw_window_get_width, 0);
+    rb_define_method(rb_cGLFWwindow, "height", rb_glfw_window_get_height, 0);
+    rb_define_method(rb_cGLFWwindow, "x=", rb_glfw_window_set_x, 1);
+    rb_define_method(rb_cGLFWwindow, "y=", rb_glfw_window_set_y, 1);
+    rb_define_method(rb_cGLFWwindow, "width=", rb_glfw_window_set_width, 1);
+    rb_define_method(rb_cGLFWwindow, "height=", rb_glfw_window_set_height, 1);
+
+    rb_define_method(rb_cGLFWwindow, "focused?", rb_glfw_window_focused_p, 0);
+    rb_define_method(rb_cGLFWwindow, "minimized?", rb_glfw_window_minimized_p, 0);
+    rb_define_method(rb_cGLFWwindow, "maximized?", rb_glfw_window_maximized_p, 0);
+    rb_define_method(rb_cGLFWwindow, "visible?", rb_glfw_window_visible_p, 0);
+    rb_define_method(rb_cGLFWwindow, "resizable?", rb_glfw_window_resizable_p, 0);
+    rb_define_method(rb_cGLFWwindow, "decorated?", rb_glfw_window_decorated_p, 0);
+    rb_define_method(rb_cGLFWwindow, "topmost?", rb_glfw_window_floating_p, 0);
+    rb_define_method(rb_cGLFWwindow, "set_icon", rb_glfw_window_set_icon, -2);
+    rb_define_method(rb_cGLFWwindow, "enable_callback", rb_glfw_window_enable_callback, 2);
+
+    rb_define_method(rb_cGLFWwindow, "aspect_ratio", rb_glfw_window_aspect_ratio, 2);
+    rb_define_method(rb_cGLFWwindow, "size_limits", rb_glfw_window_limits, 4);
+    rb_define_method(rb_cGLFWwindow, "frame_size", rb_glfw_window_frame_size, 0);
+
+    rb_define_method(rb_cGLFWwindow, "set_cursor", rb_glfw_window_set_cursor, 1);
+    rb_define_method(rb_cGLFWwindow, "cursor_pos", rb_glfw_window_cursor_pos, 0);
+    rb_define_method(rb_cGLFWwindow, "set_cursor_pos", rb_glfw_window_set_cursor_pos, 2);
+    rb_define_method(rb_cGLFWwindow, "cursor", rb_glfw_window_get_input_cursor, 0);
+    rb_define_method(rb_cGLFWwindow, "cursor=", rb_glfw_window_set_input_cursor, 1);
+    rb_define_method(rb_cGLFWwindow, "sticky_keys", rb_glfw_window_get_input_sticky_keys, 0);
+    rb_define_method(rb_cGLFWwindow, "sticky_keys=", rb_glfw_window_set_input_sticky_keys, 1);
+    rb_define_method(rb_cGLFWwindow, "sticky_mouse", rb_glfw_window_get_input_sticky_mouse, 0);
+    rb_define_method(rb_cGLFWwindow, "sticky_mouse=", rb_glfw_window_set_input_sticky_mouse, 1);
+
+    rb_define_method(rb_cGLFWwindow, "key_down?", rb_glfw_window_get_key, 1);
+    rb_define_method(rb_cGLFWwindow, "mouse_down?", rb_glfw_window_get_mouse_button, 1);
+
+    // Callbacks
+    RB_CALLBACK(id_moved, "moved");
+    RB_CALLBACK(id_refreshed, "resized");
+    RB_CALLBACK(id_framebuffer_resized, "framebuffer_resized");
+    RB_CALLBACK(id_closing, "closing");
+    RB_CALLBACK(id_refreshed, "refreshed");
+    RB_CALLBACK(id_focus_changed, "focus_changed");
+    RB_CALLBACK(id_minimize_changed, "minimize_changed");
+    RB_CALLBACK(id_mouse_move, "mouse_move");
+    RB_CALLBACK(id_mouse_scroll, "mouse_scroll");
+    RB_CALLBACK(id_mouse_button, "mouse_button");
+    RB_CALLBACK(id_mouse_enter, "mouse_enter");
+    RB_CALLBACK(id_key, "key");
+    RB_CALLBACK(id_char, "char");
+    RB_CALLBACK(id_char_mods, "char_mods");
+    RB_CALLBACK(id_file_drop, "file_drop");
+
+    // Alias
+    rb_define_alias(rb_cGLFWwindow, "dispose", "destroy");
+    rb_define_alias(rb_cGLFWwindow, "iconify", "minimize");
+    rb_define_alias(rb_cGLFWwindow, "floating?", "topmost?");
+    rb_define_alias(rb_cGLFWwindow, "iconified?", "minimized?");
+    rb_define_alias(rb_cGLFWwindow, "iconify_changed", "minimize_changed");
+}
+
+static VALUE rb_glfw_window_alloc(VALUE klass) {
+    GLFWwindow *w = ruby_xmalloc(SIZEOF_INTPTR_T);
+    memset(w, 0, SIZEOF_INTPTR_T);
+    return Data_Wrap_Struct(klass, NULL, RUBY_DEFAULT_FREE, w);
+}
+
+// initialize(width, height, title = '', **options)
+VALUE rb_glfw_window_initialize(int argc, VALUE *argv, VALUE self) {
+    // Initialize GLFW (does nothing and returns immediately if already called)
+    glfwInit();
+
+    GLFWmonitor *mon = NULL;
+    GLFWwindow *window, *other = NULL;
+
+    VALUE width, height, title, options, monitor, share;
+
+    rb_scan_args(argc, argv, "21:", &width, &height, &title, &options);
+    const char *str = NIL_P(title) ? "" : StringValueCStr(title);
+
+    if (!NIL_P(options)) {
+        // Monitor
+        if (RTEST(rb_hash_aref(options, STR2SYM("fullscreen")))) {
+            mon = glfwGetPrimaryMonitor();
+        } else {
+            monitor = rb_hash_aref(options, STR2SYM("monitor"));
+            if (!NIL_P(monitor))
+                Data_Get_Struct(monitor, GLFWmonitor, mon);
+        }
+
+        // Share
+        share = rb_hash_aref(options, STR2SYM("share"));
+        if (!NIL_P(share))
+            Data_Get_Struct(share, GLFWwindow, other);
+    }
+
+    window = glfwCreateWindow(NUM2INT(width), NUM2INT(height), str, mon, other);
+    RDATA(self)->data = window;
+
+    // Store the Ruby VALUE as a "user pointer" to get the Ruby instance from the C struct
+    glfwSetWindowUserPointer(window, (void *)self);
+
+    if (rb_block_given_p()) {
+        rb_yield(self);
+        glfwDestroyWindow(window);
+    }
+
+    return Qnil;
+}
+
+VALUE rb_glfw_window_destroy(VALUE self) {
+    WINDOW();
+    glfwDestroyWindow(w);
+    return self;
+}
+
+VALUE rb_glfw_window_show(VALUE self) {
+    WINDOW();
+    glfwShowWindow(w);
+    return self;
+}
+
+VALUE rb_glfw_window_hide(VALUE self) {
+    WINDOW();
+    glfwHideWindow(w);
+    return self;
+}
+
+VALUE rb_glfw_window_minimize(VALUE self) {
+    WINDOW();
+    glfwIconifyWindow(w);
+    return self;
+}
+
+VALUE rb_glfw_window_maximize(VALUE self) {
+    WINDOW();
+    glfwMaximizeWindow(w);
+    return self;
+}
+
+VALUE rb_glfw_window_restore(VALUE self) {
+    WINDOW();
+    glfwRestoreWindow(w);
+    return self;
+}
+
+VALUE rb_glfw_window_focus(VALUE self) {
+    WINDOW();
+    glfwFocusWindow(w);
+    return self;
+}
+
+VALUE rb_glfw_window_swap_buffers(VALUE self) {
+    WINDOW();
+    glfwSwapBuffers(w);
+    return Qnil;
+}
+
+VALUE rb_glfw_window_make_current(VALUE self) {
+    WINDOW();
+    glfwMakeContextCurrent(w);
+    return Qnil;
+}
+
+VALUE rb_glfw_window_dimensions(VALUE self) {
+    WINDOW();
+    int x, y, width, height;
+    glfwGetWindowPos(w, &x, &y);
+    glfwGetWindowSize(w, &width, &height);
+    VALUE ary = rb_ary_new_capa(4);
+    rb_ary_store(ary, 0, INT2NUM(x));
+    rb_ary_store(ary, 1, INT2NUM(y));
+    rb_ary_store(ary, 2, INT2NUM(width));
+    rb_ary_store(ary, 3, INT2NUM(height));
+    return ary;
+}
+
+VALUE rb_glfw_window_get_pos(VALUE self) {
+    WINDOW();
+    int x, y;
+    glfwGetWindowPos(*&w, &x, &y);
+    VALUE ary = rb_ary_new_capa(2);
+    rb_ary_store(ary, 0, INT2NUM(x));
+    rb_ary_store(ary, 1, INT2NUM(y));
+    return ary;
+}
+
+VALUE rb_glfw_window_set_pos(VALUE self, VALUE x, VALUE y) {
+    WINDOW();
+    glfwSetWindowPos(w, NUM2INT(x), NUM2INT(y));
+    return self;
+}
+
+VALUE rb_glfw_window_get_size(VALUE self) {
+    WINDOW();
+    int width, height;
+    glfwGetWindowSize(w, &width, &height);
+    VALUE ary = rb_ary_new_capa(2);
+    rb_ary_store(ary, 0, INT2NUM(width));
+    rb_ary_store(ary, 1, INT2NUM(height));
+    return ary;
+}
+
+VALUE rb_glfw_window_set_size(VALUE self, VALUE width, VALUE height) {
+    WINDOW();
+    glfwSetWindowSize(w, NUM2INT(width), NUM2INT(height));
+    return self;
+}
+
+VALUE rb_glfw_window_get_framebuffer_size(VALUE self) {
+    WINDOW();
+    int width, height;
+    glfwGetFramebufferSize(w, &width, &height);
+    VALUE ary = rb_ary_new_capa(2);
+    rb_ary_store(ary, 0, INT2NUM(width));
+    rb_ary_store(ary, 1, INT2NUM(height));
+    return ary;
+}
+
+VALUE rb_glfw_window_get_x(VALUE self) {
+    WINDOW();
+    int x;
+    glfwGetWindowPos(w, &x, NULL);
+    return INT2NUM(x);
+}
+
+VALUE rb_glfw_window_get_y(VALUE self) {
+    WINDOW();
+    int y;
+    glfwGetWindowPos(w, NULL, &y);
+    return INT2NUM(y);
+}
+
+VALUE rb_glfw_window_set_x(VALUE self, VALUE x) {
+    WINDOW();
+    int y;
+    glfwGetWindowSize(w, NULL, &y);
+    glfwSetWindowSize(w, NUM2INT(x), y);
+    return x;
+}
+
+VALUE rb_glfw_window_set_y(VALUE self, VALUE y) {
+    WINDOW();
+    int x;
+    glfwGetWindowSize(w, &x, NULL);
+    glfwSetWindowSize(w, x, NUM2INT(y));
+    return y;
+}
+
+VALUE rb_glfw_window_get_width(VALUE self) {
+    WINDOW();
+    int width;
+    glfwGetWindowSize(w, &width, NULL);
+    return INT2NUM(width);
+}
+
+VALUE rb_glfw_window_get_height(VALUE self) {
+    WINDOW();
+    int height;
+    glfwGetWindowSize(w, NULL, &height);
+    return INT2NUM(height);
+}
+
+VALUE rb_glfw_window_set_width(VALUE self, VALUE width) {
+    WINDOW();
+    int height;
+    glfwGetWindowSize(w, NULL, &height);
+    glfwSetWindowSize(w, NUM2INT(width), height);
+    return width;
+}
+
+VALUE rb_glfw_window_set_height(VALUE self, VALUE height) {
+    WINDOW();
+    int width;
+    glfwGetWindowSize(w, &width, NULL);
+    glfwSetWindowSize(w, width, NUM2INT(height));
+    return height;
+}
+
+VALUE rb_glfw_window_closing_p(VALUE self) {
+    WINDOW();
+    return glfwWindowShouldClose(w) ? Qtrue : Qfalse;
+}
+
+VALUE rb_glfw_window_close(int argc, VALUE *argv, VALUE self) {
+    WINDOW();
+    switch (argc) {
+        case 0:
+            glfwSetWindowShouldClose(w, 1);
+            break;
+        case 1:
+            glfwSetWindowShouldClose(w, RTEST(argv[0]));
+            break;
+        default:
+            rb_raise(rb_eArgError, "wrong number of arguments (given %d, expected 0, 1)", argc);
+            break;
+    }
+    return self;
+}
+
+VALUE rb_glfw_window_get_monitor(VALUE self) {
+    WINDOW();
+    GLFWmonitor *monitor = glfwGetWindowMonitor(w);
+    return Data_Wrap_Struct(rb_cGLFWmonitor, NULL, RUBY_DEFAULT_FREE, monitor);
+}
+
+VALUE rb_glfw_window_set_monitor(int argc, VALUE *argv, VALUE self) {
+    WINDOW();
+    switch (argc) {
+        case 2:  // monitor, refresh_rate (fullscreen)
+        {
+            GLFWmonitor *m = NULL;
+            Data_Get_Struct(argv[0], GLFWmonitor, m);
+            glfwSetWindowMonitor(w, m, 0, 0, 0, 0, NUM2INT(argv[1]));
+            break;
+        }
+        case 4:  // x, y, width, height (windowed)
+        {
+            int mx = NUM2INT(argv[0]), my = NUM2INT(argv[1]), mw = NUM2INT(argv[2]), mh = NUM2INT(argv[3]);
+            glfwSetWindowMonitor(w, NULL, mx, my, mw, mh, 0);
+            break;
+        }
+        default:
+            rb_raise(rb_eArgError, "wrong number of arguments (given %d, expected 2, 4)", argc);
+            break;
+    }
+    return self;
+}
+
+VALUE rb_glfw_window_set_title(VALUE self, volatile VALUE title) {
+    WINDOW();
+    const char *str = rb_string_value_cstr(&title);
+    glfwSetWindowTitle(w, str);
+    return title;
+}
+
+VALUE rb_glfw_window_focused_p(VALUE self) {
+    WINDOW();
+    return glfwGetWindowAttrib(w, GLFW_FOCUSED) ? Qtrue : Qfalse;
+}
+
+VALUE rb_glfw_window_minimized_p(VALUE self) {
+    WINDOW();
+    return glfwGetWindowAttrib(w, GLFW_ICONIFIED) ? Qtrue : Qfalse;
+}
+
+VALUE rb_glfw_window_maximized_p(VALUE self) {
+    WINDOW();
+    return glfwGetWindowAttrib(w, GLFW_MAXIMIZED) ? Qtrue : Qfalse;
+}
+
+VALUE rb_glfw_window_visible_p(VALUE self) {
+    WINDOW();
+    return glfwGetWindowAttrib(w, GLFW_VISIBLE) ? Qtrue : Qfalse;
+}
+
+VALUE rb_glfw_window_resizable_p(VALUE self) {
+    WINDOW();
+    return glfwGetWindowAttrib(w, GLFW_RESIZABLE) ? Qtrue : Qfalse;
+}
+
+VALUE rb_glfw_window_decorated_p(VALUE self) {
+    WINDOW();
+    return glfwGetWindowAttrib(w, GLFW_DECORATED) ? Qtrue : Qfalse;
+}
+
+VALUE rb_glfw_window_floating_p(VALUE self) {
+    WINDOW();
+    return glfwGetWindowAttrib(w, GLFW_FLOATING) ? Qtrue : Qfalse;
+}
+
+VALUE rb_glfw_window_aspect_ratio(VALUE self, VALUE numerator, VALUE denominator) {
+    WINDOW();
+    glfwSetWindowAspectRatio(w, NUM2INT(numerator), NUM2INT(denominator));
+    return Qnil;
+}
+
+VALUE rb_glfw_window_limits(VALUE self, VALUE minWidth, VALUE minHeight, VALUE maxWidth, VALUE maxHeight) {
+    WINDOW();
+    glfwSetWindowSizeLimits(w, NUM2INT(minWidth), NUM2INT(minHeight), NUM2INT(maxWidth), NUM2INT(maxHeight));
+    return Qnil;
+}
+
+VALUE rb_glfw_window_frame_size(VALUE self) {
+    WINDOW();
+    int left, top, right, bottom;
+    glfwGetWindowFrameSize(w, &left, &top, &right, &bottom);
+    VALUE ary = rb_ary_new_capa(4);
+    rb_ary_store(ary, 0, INT2NUM(left));
+    rb_ary_store(ary, 1, INT2NUM(top));
+    rb_ary_store(ary, 2, INT2NUM(right));
+    rb_ary_store(ary, 3, INT2NUM(bottom));
+    return ary;
+}
+
+VALUE rb_glfw_window_get_clipboard(VALUE self) {
+    WINDOW();
+    const char *str = glfwGetClipboardString(w);
+    return rb_utf8_str_new_cstr(str);
+}
+
+VALUE rb_glfw_window_set_clipboard(VALUE self, VALUE str) {
+    WINDOW();
+    volatile VALUE utf8 = rb_funcall(str, rb_intern("encode"), 1, rb_str_new_cstr("utf-8"));
+    glfwSetClipboardString(w, StringValueCStr(utf8));
+    return str;
+}
+
+VALUE rb_glfw_window_set_icon(VALUE self, VALUE args) {
+    WINDOW();
+    int argc = rb_array_len(args);
+    GLFWimage *images = malloc(sizeof(GLFWimage) * argc);
+
+    for (int i = 0; i < argc; i++) {
+        VALUE img = rb_ary_entry(args, i);
+        images[i] = *(GLFWimage *)RDATA(img)->data;
+    }
+
+    glfwSetWindowIcon(w, argc, images);
+
+    free(images);
+    return self;
+}
+
+VALUE rb_glfw_window_get_input_cursor(VALUE self) {
+    WINDOW();
+    return INT2BOOL(glfwGetInputMode(w, GLFW_CURSOR));
+}
+
+VALUE rb_glfw_window_set_input_cursor(VALUE self, VALUE value) {
+    WINDOW();
+    glfwSetInputMode(w, GLFW_CURSOR, RTEST(value));
+    return value;
+}
+
+VALUE rb_glfw_window_get_input_sticky_keys(VALUE self) {
+    WINDOW();
+    return INT2BOOL(glfwGetInputMode(w, GLFW_STICKY_KEYS));
+}
+
+VALUE rb_glfw_window_set_input_sticky_keys(VALUE self, VALUE value) {
+    WINDOW();
+    glfwSetInputMode(w, GLFW_STICKY_KEYS, RTEST(value));
+    return value;
+}
+
+VALUE rb_glfw_window_get_input_sticky_mouse(VALUE self) {
+    WINDOW();
+    return INT2BOOL(glfwGetInputMode(w, GLFW_STICKY_MOUSE_BUTTONS));
+}
+
+VALUE rb_glfw_window_set_input_sticky_mouse(VALUE self, VALUE value) {
+    WINDOW();
+    glfwSetInputMode(w, GLFW_STICKY_MOUSE_BUTTONS, RTEST(value));
+    return value;
+}
+
+VALUE rb_glfw_window_cursor_pos(VALUE self) {
+    WINDOW();
+    double x, y;
+    glfwGetCursorPos(w, &x, &y);
+    VALUE ary = rb_ary_new_capa(2);
+    rb_ary_store(ary, 0, DBL2NUM(x));
+    rb_ary_store(ary, 1, DBL2NUM(y));
+    return ary;
+}
+
+VALUE rb_glfw_window_set_cursor_pos(VALUE self, VALUE x, VALUE y) {
+    WINDOW();
+    glfwSetCursorPos(w, NUM2DBL(x), NUM2DBL(y));
+    return self;
+}
+
+VALUE rb_glfw_window_set_cursor(VALUE self, VALUE cursor) {
+    WINDOW();
+    GLFWcursor *c;
+    Data_Get_Struct(cursor, GLFWcursor, c);
+    glfwSetCursor(w, c);
+    return self;
+}
+
+VALUE rb_glfw_window_get_key(VALUE self, VALUE key) {
+    WINDOW();
+    return RTEST(glfwGetKey(w, NUM2INT(key)));
+}
+
+VALUE rb_glfw_window_get_mouse_button(VALUE self, VALUE mbtn) {
+    WINDOW();
+    return RTEST(glfwGetMouseButton(w, NUM2INT(mbtn)));
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Callbacks
+/////////////////////////////////////////////////////////////////////////////
+
+VALUE rb_glfw_window_empty_method(int argc, VALUE *argv, VALUE self) {
+    // Empty method stub, as NULL causes segfaults
+    return Qnil;
+}
+
+VALUE rb_glfw_window_enable_callback(VALUE self, VALUE cbtype, VALUE enable) {
+    WINDOW();
+    enum GLFW_RB_CALLBACK_TYPE type = NUM2INT(cbtype);
+    int state = RTEST(enable);
+    switch (type) {
+        case GLFW_RB_MOVED:
+            glfwSetWindowPosCallback(w, state ? rb_glfw_window_moved : NULL);
+            break;
+        case GLFW_RB_RESIZED:
+            glfwSetWindowSizeCallback(w, state ? rb_glfw_window_resized : NULL);
+            break;
+        case GLFW_RB_FRAMEBUFFER_RESIZED:
+            glfwSetFramebufferSizeCallback(w, state ? rb_glfw_window_frame_buffer_resized : NULL);
+            break;
+        case GLFW_RB_CLOSING:
+            glfwSetWindowCloseCallback(w, state ? rb_glfw_window_closing : NULL);
+            break;
+        case GLFW_RB_REFRESHED:
+            glfwSetWindowRefreshCallback(w, state ? rb_glfw_window_refreshed : NULL);
+            break;
+        case GLFW_RB_FOCUS_CHANGED:
+            glfwSetWindowFocusCallback(w, state ? rb_glfw_window_focus_changed : NULL);
+            break;
+        case GLFW_RB_MINIMIZE_CHANGED:
+            glfwSetWindowIconifyCallback(w, state ? rb_glfw_window_minimize_changed : NULL);
+            break;
+        case GLFW_RB_MOUSE_MOVE:
+            glfwSetCursorPosCallback(w, state ? rb_glfw_window_cursor_mouse_move : NULL);
+            break;
+        case GLFW_RB_MOUSE_SCROLL:
+            glfwSetScrollCallback(w, state ? rb_glfw_window_cursor_mouse_scroll : NULL);
+            break;
+        case GLFW_RB_MOUSE_BUTTON:
+            glfwSetMouseButtonCallback(w, state ? rb_glfw_window_cursor_mouse_button : NULL);
+            break;
+        case GLFW_RB_MOUSE_ENTER:
+            glfwSetCursorEnterCallback(w, state ? rb_glfw_window_mouse_enter : NULL);
+            break;
+        case GLFW_RB_KEY:
+            glfwSetKeyCallback(w, state ? rb_glfw_window_key : NULL);
+            break;
+        case GLFW_RB_CHAR:
+            glfwSetCharCallback(w, state ? rb_glfw_window_char : NULL);
+            break;
+        case GLFW_RB_CHAR_MODS:
+            glfwSetCharModsCallback(w, state ? rb_glfw_window_char_mods : NULL);
+            break;
+        case GLFW_RB_FILE_DROP:
+            glfwSetDropCallback(w, state ? rb_glfw_window_file_drop : NULL);
+            break;
+        default:
+            rb_raise(rb_eArgError, "invalid callback identifier - %d", type);
+            break;
+    }
+
+    return Qnil;
+}
+
+static void rb_glfw_window_closing(GLFWwindow *window) {
+    VALUE w = (VALUE)glfwGetWindowUserPointer(window);
+    if (RTEST(w))
+        rb_funcall(w, id_closing, 0);
+}
+
+static void rb_glfw_window_moved(GLFWwindow *window, int x, int y) {
+    VALUE w = (VALUE)glfwGetWindowUserPointer(window);
+    if (RTEST(w))
+        rb_funcall(w, id_moved, 2, INT2NUM(x), INT2NUM(y));
+}
+
+static void rb_glfw_window_resized(GLFWwindow *window, int width, int height) {
+    VALUE w = (VALUE)glfwGetWindowUserPointer(window);
+    if (RTEST(w))
+        rb_funcall(w, id_resized, 2, INT2NUM(width), INT2NUM(height));
+}
+
+static void rb_glfw_window_refreshed(GLFWwindow *window) {
+    VALUE w = (VALUE)glfwGetWindowUserPointer(window);
+    if (RTEST(w))
+        rb_funcall(w, id_refreshed, 0);
+}
+
+static void rb_glfw_window_focus_changed(GLFWwindow *window, int focused) {
+    VALUE w = (VALUE)glfwGetWindowUserPointer(window);
+    if (RTEST(w))
+        rb_funcall(w, id_focus_changed, 1, INT2BOOL(focused));
+}
+
+static void rb_glfw_window_minimize_changed(GLFWwindow *window, int minimized) {
+    VALUE w = (VALUE)glfwGetWindowUserPointer(window);
+    if (RTEST(w))
+        rb_funcall(w, id_minimize_changed, 1, INT2BOOL(minimized));
+}
+
+static void rb_glfw_window_frame_buffer_resized(GLFWwindow *window, int width, int height) {
+    VALUE w = (VALUE)glfwGetWindowUserPointer(window);
+    if (RTEST(w))
+        rb_funcall(w, id_framebuffer_resized, 2, INT2NUM(width), INT2NUM(height));
+}
+
+static void rb_glfw_window_cursor_mouse_move(GLFWwindow *window, double x, double y) {
+    VALUE w = (VALUE)glfwGetWindowUserPointer(window);
+    if (RTEST(w))
+        rb_funcall(w, id_mouse_move, 2, DBL2NUM(x), DBL2NUM(y));
+}
+
+static void rb_glfw_window_cursor_mouse_button(GLFWwindow *window, int button, int action, int mods) {
+    VALUE w = (VALUE)glfwGetWindowUserPointer(window);
+    if (RTEST(w))
+        rb_funcall(w, id_mouse_button, 3, INT2NUM(button), INT2NUM(action), INT2NUM(mods));
+}
+
+static void rb_glfw_window_cursor_mouse_scroll(GLFWwindow *window, double xoffset, double yoffset) {
+    VALUE w = (VALUE)glfwGetWindowUserPointer(window);
+    if (RTEST(w))
+        rb_funcall(w, id_mouse_scroll, 2, DBL2NUM(xoffset), DBL2NUM(yoffset));
+}
+
+static void rb_glfw_window_mouse_enter(GLFWwindow *window, int entered) {
+    VALUE w = (VALUE)glfwGetWindowUserPointer(window);
+    if (RTEST(w))
+        rb_funcall(w, id_mouse_enter, 1, INT2BOOL(entered));
+}
+
+static void rb_glfw_window_key(GLFWwindow *window, int key, int scancode, int action, int mods) {
+    VALUE w = (VALUE)glfwGetWindowUserPointer(window);
+    if (RTEST(w))
+        rb_funcall(w, id_key, 4, INT2NUM(key), INT2NUM(scancode), INT2NUM(action), INT2NUM(mods));
+}
+
+static void rb_glfw_window_char(GLFWwindow *window, unsigned int codepoint) {
+    VALUE w = (VALUE)glfwGetWindowUserPointer(window);
+    if (RTEST(w))
+        rb_funcall(w, id_char, 1, UINT2NUM(codepoint));
+}
+
+static void rb_glfw_window_char_mods(GLFWwindow *window, unsigned int codepoint, int mods) {
+    VALUE w = (VALUE)glfwGetWindowUserPointer(window);
+    if (RTEST(w))
+        rb_funcall(w, id_char_mods, 2, UINT2NUM(codepoint), INT2NUM(mods));
+}
+
+static void rb_glfw_window_file_drop(GLFWwindow *window, int count, const char **files) {
+    VALUE w = (VALUE)glfwGetWindowUserPointer(window);
+    if (RTEST(w)) {
+        VALUE ary = rb_ary_new_capa(count);
+        for (int i = 0; i < count; i++) {
+            char *pos = strchr(files[i], '\\');
+            while (pos) {
+                *pos = '/';
+                pos = strchr(pos, '\\');
+            }
+            rb_ary_store(ary, i, rb_utf8_str_new_cstr(files[i]));
+        }
+        rb_funcall(w, id_file_drop, 1, ary);
+    }
+}