glfw3 0.4.5 → 0.4.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: df407facc1820d92c316b35de01040569b79e376
-  data.tar.gz: 12b236e4b4c291898eca5166f116133f27091ceb
+  metadata.gz: 3587273712306283209d889f6d43ba43161cad94
+  data.tar.gz: f9eea41ba36fa06658d0e2f568f789b46a594863
 SHA512:
-  metadata.gz: dcdc263c8718b4aa259020d25d023b46f15482e31e3d4a5b3065dff299aa9e46d36c5ca6e5b2ea15d93861af6437e77f7fb90eb3db5532c8356e770375cd4c09
-  data.tar.gz: 8f0fe94522d88a65979f6039733b341280cde3fca756c6796531bc8fe62452d1065088a368abc48599c7dd17b18acd416deead6cccd5bec877c6a9bc0329f3a1
+  metadata.gz: 697392601c4b0cea552420068b5c950dc94f784e500e931a45e9a658359d3fd9e4100e6abd8f3b2ffb3c259ab75a8da01506b8ef66affd15108319743d246793
+  data.tar.gz: 9e07041cf488e8455c9f11ff0ad9272ba449f9a2ca82ba1ba3c2c150b89d065073f037e7695cbf62b49fd3abcdb2cf4e5b40143ff690872373cfd75d6750b448

data/ext/glfw3/glfw3.c

@@ -1,6 +1,7 @@
 #include "ruby.h"
 #include <GLFW/glfw3.h>
 
+void Init_glfw3(void);
 
 static const char *kRB_IVAR_WINDOW_INTERNAL_NAME                   = "@__internal_window";
 static const char *kRB_IVAR_WINDOW_KEY_CALLBACK_NAME               = "@__key_callback";
@@ -59,6 +60,9 @@ static void rb_glfw_error_callback(int error_code, const char *description);
 static void rb_glfw_monitor_callback(GLFWmonitor *monitor, int message);
 
 
+#define Q_IS_A(OBJ, KLASS) RTEST(rb_obj_is_kind_of((OBJ), (KLASS)))
+
+
 #define RB_ENABLE_CALLBACK_DEF(NAME, CALLBACK, GLFW_FUNC)                     \
 static VALUE NAME (VALUE self, VALUE enabled)                                 \
 {                                                                             \
@@ -81,7 +85,6 @@ static VALUE NAME (VALUE self, VALUE enabled)                                 \
  */
 static VALUE rb_glfw_init(VALUE self)
 {
-  (void)self;
   VALUE result = glfwInit() ? Qtrue : Qfalse;
   if (result == Qtrue) {
     glfwSetMonitorCallback(rb_glfw_monitor_callback);
@@ -128,7 +131,7 @@ static void rb_glfw_error_callback(int error_code, const char *description)
 {
   VALUE lambda = rb_cvar_get(s_glfw_module, kRB_CVAR_GLFW_ERROR_CALLBACK);
 
-  if (RTEST(lambda)) {
+  if (rb_obj_respond_to(lambda, kRB_CALL, 0)) {
     VALUE rb_description = rb_str_new2(description);
     VALUE rb_error_code = INT2FIX(error_code);
     OBJ_FREEZE(rb_description);
@@ -149,7 +152,7 @@ static void rb_glfw_error_callback(int error_code, const char *description)
  *
  * Wraps glfwGetMonitors.
  */
-VALUE rb_glfw_get_monitors(VALUE self)
+static VALUE rb_glfw_get_monitors(VALUE self)
 {
   long monitor_index = 0;
   int num_monitors = 0;
@@ -158,7 +161,7 @@ VALUE rb_glfw_get_monitors(VALUE self)
 
   if (monitors) {
     monitors_out = rb_ary_new();
-    for (; num_monitors; --num_monitors, ++monitor_index) {
+    for (; monitor_index < num_monitors; ++monitor_index) {
       VALUE monitor = Data_Wrap_Struct(s_glfw_monitor_klass, 0, 0, monitors[monitor_index]);
       rb_obj_call_init(monitor, 0, 0);
       rb_ary_push(monitors_out, monitor);
@@ -177,7 +180,7 @@ VALUE rb_glfw_get_monitors(VALUE self)
  *
  * Wraps glfwGetPrimaryMonitor.
  */
-VALUE rb_glfw_get_primary_monitor(VALUE self)
+static VALUE rb_glfw_get_primary_monitor(VALUE self)
 {
   GLFWmonitor *monitor = glfwGetPrimaryMonitor();
   VALUE rb_monitor = Qnil;
@@ -198,12 +201,12 @@ VALUE rb_glfw_get_primary_monitor(VALUE self)
  *
  * Wraps glfwGetMonitorPos.
  */
-VALUE rb_monitor_position(VALUE self)
+static VALUE rb_monitor_position(VALUE self)
 {
-  GLFWmonitor *monitor;
-  Data_Get_Struct(self, GLFWmonitor, monitor);
+  GLFWmonitor *monitor = NULL;
   int xpos = 0;
   int ypos = 0;
+  Data_Get_Struct(self, GLFWmonitor, monitor);
   glfwGetMonitorPos(monitor, &xpos, &ypos);
   return rb_ary_new3(2, INT2FIX(xpos), INT2FIX(ypos));
 }
@@ -218,12 +221,12 @@ VALUE rb_monitor_position(VALUE self)
  *
  * Wraps glfwGetMonitorPhysicalSize.
  */
-VALUE rb_monitor_physical_size(VALUE self)
+static VALUE rb_monitor_physical_size(VALUE self)
 {
-  GLFWmonitor *monitor;
-  Data_Get_Struct(self, GLFWmonitor, monitor);
+  GLFWmonitor *monitor = NULL;
   int width = 0;
   int height = 0;
+  Data_Get_Struct(self, GLFWmonitor, monitor);
   glfwGetMonitorPhysicalSize(monitor, &width, &height);
   return rb_ary_new3(2, INT2FIX(width), INT2FIX(height));
 }
@@ -238,9 +241,9 @@ VALUE rb_monitor_physical_size(VALUE self)
  *
  * Wraps glfwGetMonitorName.
  */
-VALUE rb_monitor_name(VALUE self)
+static VALUE rb_monitor_name(VALUE self)
 {
-  GLFWmonitor *monitor;
+  GLFWmonitor *monitor = NULL;
   const char *monitor_name = NULL;
   Data_Get_Struct(self, GLFWmonitor, monitor);
   monitor_name = glfwGetMonitorName(monitor);
@@ -252,7 +255,7 @@ VALUE rb_monitor_name(VALUE self)
 static void rb_glfw_monitor_callback(GLFWmonitor *monitor, int message)
 {
   VALUE lambda = rb_cvar_get(s_glfw_module, kRB_CVAR_GLFW_MONITOR_CALLBACK);
-  if (RTEST(lambda)) {
+  if (rb_obj_respond_to(lambda, kRB_CALL, 0)) {
     VALUE rb_monitor = Data_Wrap_Struct(s_glfw_monitor_klass, 0, 0, monitor);
     rb_obj_call_init(rb_monitor, 0, 0);
     rb_funcall(lambda, kRB_CALL, 2, rb_monitor, INT2FIX(message));
@@ -271,7 +274,7 @@ static void rb_glfw_monitor_callback(GLFWmonitor *monitor, int message)
  */
 static VALUE rb_videomode_width(VALUE self)
 {
-  GLFWvidmode *mode;
+  GLFWvidmode *mode = NULL;
   Data_Get_Struct(self, GLFWvidmode, mode);
   return INT2FIX(mode->width);
 }
@@ -286,7 +289,7 @@ static VALUE rb_videomode_width(VALUE self)
  */
 static VALUE rb_videomode_height(VALUE self)
 {
-  GLFWvidmode *mode;
+  GLFWvidmode *mode = NULL;
   Data_Get_Struct(self, GLFWvidmode, mode);
   return INT2FIX(mode->height);
 }
@@ -301,7 +304,7 @@ static VALUE rb_videomode_height(VALUE self)
  */
 static VALUE rb_videomode_red_bits(VALUE self)
 {
-  GLFWvidmode *mode;
+  GLFWvidmode *mode = NULL;
   Data_Get_Struct(self, GLFWvidmode, mode);
   return INT2FIX(mode->redBits);
 }
@@ -316,7 +319,7 @@ static VALUE rb_videomode_red_bits(VALUE self)
  */
 static VALUE rb_videomode_green_bits(VALUE self)
 {
-  GLFWvidmode *mode;
+  GLFWvidmode *mode = NULL;
   Data_Get_Struct(self, GLFWvidmode, mode);
   return INT2FIX(mode->greenBits);
 }
@@ -331,7 +334,7 @@ static VALUE rb_videomode_green_bits(VALUE self)
  */
 static VALUE rb_videomode_blue_bits(VALUE self)
 {
-  GLFWvidmode *mode;
+  GLFWvidmode *mode = NULL;
   Data_Get_Struct(self, GLFWvidmode, mode);
   return INT2FIX(mode->blueBits);
 }
@@ -346,7 +349,7 @@ static VALUE rb_videomode_blue_bits(VALUE self)
  */
 static VALUE rb_videomode_refresh_rate(VALUE self)
 {
-  GLFWvidmode *mode;
+  GLFWvidmode *mode = NULL;
   Data_Get_Struct(self, GLFWvidmode, mode);
   return INT2FIX(mode->refreshRate);
 }
@@ -363,16 +366,22 @@ static VALUE rb_videomode_refresh_rate(VALUE self)
  */
 static VALUE rb_monitor_video_modes(VALUE self)
 {
-  GLFWmonitor *monitor;
-  Data_Get_Struct(self, GLFWmonitor, monitor);
-  VALUE rb_modes = rb_ary_new();
+  GLFWmonitor *monitor = NULL;
+  const GLFWvidmode *modes = NULL;
+  VALUE rb_modes = Qnil;
   int num_modes = 0;
   int mode_index = 0;
-  const GLFWvidmode *modes = glfwGetVideoModes(monitor, &num_modes);
-  for (; num_modes; --num_modes, ++mode_index) {
-    GLFWvidmode *mode = ALLOC(GLFWvidmode);
+  VALUE rb_mode = Qnil;
+  GLFWvidmode *mode = NULL;
+
+  Data_Get_Struct(self, GLFWmonitor, monitor);
+  rb_modes = rb_ary_new();
+  modes = glfwGetVideoModes(monitor, &num_modes);
+
+  for (; mode_index < num_modes; ++mode_index) {
+    ALLOC(GLFWvidmode);
     *mode = modes[mode_index];
-    VALUE rb_mode = Data_Wrap_Struct(s_glfw_videomode_klass, 0, free, mode);
+    rb_mode = Data_Wrap_Struct(s_glfw_videomode_klass, 0, free, mode);
     rb_obj_call_init(rb_mode, 0, 0);
     rb_ary_push(rb_modes, rb_mode);
   }
@@ -391,11 +400,13 @@ static VALUE rb_monitor_video_modes(VALUE self)
  */
 static VALUE rb_monitor_video_mode(VALUE self)
 {
-  GLFWmonitor *monitor;
+  GLFWmonitor *monitor = NULL;
+  GLFWvidmode *mode = NULL;
+  VALUE rb_mode = Qnil;
   Data_Get_Struct(self, GLFWmonitor, monitor);
-  GLFWvidmode *mode = ALLOC(GLFWvidmode);
+  mode = ALLOC(GLFWvidmode);
   *mode = *glfwGetVideoMode(monitor);
-  VALUE rb_mode = Data_Wrap_Struct(s_glfw_videomode_klass, 0, free, mode);
+  rb_mode = Data_Wrap_Struct(s_glfw_videomode_klass, 0, free, mode);
   rb_obj_call_init(rb_mode, 0, 0);
   return rb_mode;
 }
@@ -413,7 +424,7 @@ static VALUE rb_monitor_video_mode(VALUE self)
  */
 static VALUE rb_monitor_set_gamma(VALUE self, VALUE gamma)
 {
-  GLFWmonitor *monitor;
+  GLFWmonitor *monitor = NULL;
   Data_Get_Struct(self, GLFWmonitor, monitor);
   glfwSetGamma(monitor, (float)NUM2DBL(gamma));
   return self;
@@ -435,8 +446,8 @@ static VALUE rb_monitor_set_gamma(VALUE self, VALUE gamma)
  */
 static VALUE rb_monitor_get_gamma_ramp(VALUE self)
 {
-  GLFWmonitor *monitor;
-  const GLFWgammaramp *ramp;
+  GLFWmonitor *monitor = NULL;
+  const GLFWgammaramp *ramp = NULL;
   VALUE rb_gamma_hash, rb_red, rb_green, rb_blue;
   unsigned int ramp_index;
   unsigned int ramp_len = ramp->size;
@@ -487,11 +498,16 @@ static VALUE rb_monitor_get_gamma_ramp(VALUE self)
  */
 static VALUE rb_monitor_set_gamma_ramp(VALUE self, VALUE ramp_hash)
 {
-  GLFWmonitor *monitor;
+  GLFWmonitor *monitor = NULL;
   GLFWgammaramp ramp;
   VALUE rb_red, rb_green, rb_blue;
-  unsigned int ramp_index;
+  unsigned int ramp_index = 0;
   unsigned int ramp_len = 0;
+  unsigned short *ramp_buffer = NULL;
+
+  if (!Q_IS_A(ramp_hash, rb_cHash)) {
+    rb_raise(rb_eArgError, "ramp_hash must be a Hash");
+  }
 
   Data_Get_Struct(self, GLFWmonitor, monitor);
 
@@ -499,26 +515,25 @@ static VALUE rb_monitor_set_gamma_ramp(VALUE self, VALUE ramp_hash)
   rb_green = rb_hash_aref(ramp_hash, ID2SYM(kRB_GREEN));
   rb_blue = rb_hash_aref(ramp_hash, ID2SYM(kRB_BLUE));
 
-  if (!(RTEST(rb_red) && RTEST(rb_green) && RTEST(rb_blue))) {
+  if (!(Q_IS_A(rb_red, rb_cArray) && Q_IS_A(rb_green, rb_cArray) && Q_IS_A(rb_blue, rb_cArray))) {
     rb_raise(rb_eArgError, "Ramp Hash must contain :red, :green, and :blue arrays");
   }
 
-  ramp_len = RARRAY_LEN(rb_red);
-  if ((ramp_index = (unsigned int)RARRAY_LEN(rb_green)) < ramp_len) {
-    ramp_len = ramp_index;
-  } else if ((ramp_index = (unsigned int)RARRAY_LEN(rb_blue)) < ramp_len) {
-    ramp_len = ramp_index;
+  /* NOTE: loses precision */
+  ramp_len = (unsigned int)RARRAY_LEN(rb_red);
+  if (RARRAY_LEN(rb_green) != ramp_len || RARRAY_LEN(rb_blue) != ramp_len) {
+    rb_raise(rb_eArgError, "All ramps must have the same length");
   }
 
-  unsigned short *ramp_buffer = ALLOC_N(unsigned short, 3 * ramp_len);
+  ramp_buffer = ALLOC_N(unsigned short, 3 * ramp_len);
   ramp.red = ramp_buffer;
   ramp.green = &ramp_buffer[ramp_len];
   ramp.blue = &ramp_buffer[ramp_len * 2];
 
-  for (ramp_index = 0; ramp_index < ramp_len; ++ramp_index) {
-    ramp.red[ramp_index] = rb_num2uint(rb_ary_entry(rb_red, ramp_index));
-    ramp.green[ramp_index] = rb_num2uint(rb_ary_entry(rb_green, ramp_index));
-    ramp.blue[ramp_index] = rb_num2uint(rb_ary_entry(rb_blue, ramp_index));
+  for (; ramp_index < ramp_len; ++ramp_index) {
+    ramp.red[ramp_index] = (unsigned short)rb_num2uint(rb_ary_entry(rb_red, ramp_index));
+    ramp.green[ramp_index] = (unsigned short)rb_num2uint(rb_ary_entry(rb_green, ramp_index));
+    ramp.blue[ramp_index] = (unsigned short)rb_num2uint(rb_ary_entry(rb_blue, ramp_index));
   }
 
   ramp.size = ramp_len;
@@ -567,7 +582,13 @@ static VALUE rb_window_window_hint(VALUE self, VALUE target, VALUE hint)
 /* Auxiliary function for extracting a Glfw::Window object from a GLFWwindow. */
 static VALUE rb_lookup_window(GLFWwindow *window)
 {
-  return (VALUE)glfwGetWindowUserPointer(window);
+  if (window) {
+    void *uptr = glfwGetWindowUserPointer(window);
+    if (uptr) {
+      return (VALUE)uptr;
+    }
+  }
+  return Qnil;
 }
 
 /* And the opposite of rb_lookup_window */
@@ -622,11 +643,11 @@ static VALUE rb_window_new(int argc, VALUE *argv, VALUE self)
     title = StringValueCStr(rb_title);
   }
 
-  if (RTEST(rb_monitor) && RTEST(rb_obj_is_kind_of(rb_monitor, s_glfw_monitor_klass))) {
+  if (Q_IS_A(rb_monitor, s_glfw_monitor_klass)) {
     Data_Get_Struct(rb_monitor, GLFWmonitor, monitor);
   }
 
-  if (RTEST(rb_share) && RTEST(rb_obj_is_kind_of(rb_share, s_glfw_window_klass))) {
+  if (Q_IS_A(rb_share, s_glfw_window_klass)) {
     VALUE rb_shared_window = rb_ivar_get(rb_share, ivar_window);
     Data_Get_Struct(rb_shared_window, GLFWwindow, share);
   }
@@ -678,11 +699,12 @@ static VALUE rb_window_new(int argc, VALUE *argv, VALUE self)
  */
 static VALUE rb_window_destroy(VALUE self)
 {
+  VALUE rb_windows = Qnil;
   GLFWwindow *window = rb_get_window(self);
   if (window) {
     glfwDestroyWindow(window);
     rb_ivar_set(self, kRB_IVAR_WINDOW_INTERNAL, Qnil);
-    VALUE rb_windows = rb_cvar_get(s_glfw_window_klass, kRB_CVAR_WINDOW_WINDOWS);
+    rb_windows = rb_cvar_get(s_glfw_window_klass, kRB_CVAR_WINDOW_WINDOWS);
     rb_hash_delete(rb_windows, INT2FIX((int)window));
   }
   return self;
@@ -908,8 +930,12 @@ static VALUE rb_window_get_monitor(VALUE self)
 static void rb_window_window_position_callback(GLFWwindow *window, int x, int y)
 {
   VALUE rb_window = rb_lookup_window(window);
-  VALUE rb_func = rb_ivar_get(rb_window, kRB_IVAR_WINDOW_POSITION_CALLBACK);
-  rb_funcall(rb_func, kRB_CALL, 3, rb_window, INT2FIX(x), INT2FIX(y));
+  if (RTEST(rb_window)) {
+    VALUE rb_func = rb_ivar_get(rb_window, kRB_IVAR_WINDOW_POSITION_CALLBACK);
+    if (rb_obj_respond_to(rb_func, kRB_CALL, 0)) {
+      rb_funcall(rb_func, kRB_CALL, 3, rb_window, INT2FIX(x), INT2FIX(y));
+    }
+  }
 }
 
 RB_ENABLE_CALLBACK_DEF(rb_window_set_window_position_callback, rb_window_window_position_callback, glfwSetWindowPosCallback);
@@ -919,8 +945,12 @@ RB_ENABLE_CALLBACK_DEF(rb_window_set_window_position_callback, rb_window_window_
 static void rb_window_window_size_callback(GLFWwindow *window, int width, int height)
 {
   VALUE rb_window = rb_lookup_window(window);
-  VALUE rb_func = rb_ivar_get(rb_window, kRB_IVAR_WINDOW_SIZE_CALLBACK);
-  rb_funcall(rb_func, kRB_CALL, 3, rb_window, INT2FIX(width), INT2FIX(height));
+  if (RTEST(rb_window)) {
+    VALUE rb_func = rb_ivar_get(rb_window, kRB_IVAR_WINDOW_SIZE_CALLBACK);
+    if (rb_obj_respond_to(rb_func, kRB_CALL, 0)) {
+      rb_funcall(rb_func, kRB_CALL, 3, rb_window, INT2FIX(width), INT2FIX(height));
+    }
+  }
 }
 
 RB_ENABLE_CALLBACK_DEF(rb_window_set_window_size_callback, rb_window_window_size_callback, glfwSetWindowSizeCallback);
@@ -930,8 +960,12 @@ RB_ENABLE_CALLBACK_DEF(rb_window_set_window_size_callback, rb_window_window_size
 static void rb_window_close_callback(GLFWwindow *window)
 {
   VALUE rb_window = rb_lookup_window(window);
-  VALUE rb_func = rb_ivar_get(rb_window, kRB_IVAR_WINDOW_CLOSE_CALLBACK);
-  rb_funcall(rb_func, kRB_CALL, 1, rb_window);
+  if (RTEST(rb_window)) {
+    VALUE rb_func = rb_ivar_get(rb_window, kRB_IVAR_WINDOW_CLOSE_CALLBACK);
+    if (rb_obj_respond_to(rb_func, kRB_CALL, 0)) {
+      rb_funcall(rb_func, kRB_CALL, 1, rb_window);
+    }
+  }
 }
 
 RB_ENABLE_CALLBACK_DEF(rb_window_set_close_callback, rb_window_close_callback, glfwSetWindowCloseCallback);
@@ -941,8 +975,12 @@ RB_ENABLE_CALLBACK_DEF(rb_window_set_close_callback, rb_window_close_callback, g
 static void rb_window_refresh_callback(GLFWwindow *window)
 {
   VALUE rb_window = rb_lookup_window(window);
-  VALUE rb_func = rb_ivar_get(rb_window, kRB_IVAR_WINDOW_REFRESH_CALLBACK);
-  rb_funcall(rb_func, kRB_CALL, 1, rb_window);
+  if (RTEST(rb_window)) {
+    VALUE rb_func = rb_ivar_get(rb_window, kRB_IVAR_WINDOW_REFRESH_CALLBACK);
+    if (rb_obj_respond_to(rb_func, kRB_CALL, 0)) {
+      rb_funcall(rb_func, kRB_CALL, 1, rb_window);
+    }
+  }
 }
 
 RB_ENABLE_CALLBACK_DEF(rb_window_set_refresh_callback, rb_window_refresh_callback, glfwSetWindowRefreshCallback);
@@ -952,8 +990,12 @@ RB_ENABLE_CALLBACK_DEF(rb_window_set_refresh_callback, rb_window_refresh_callbac
 static void rb_window_focus_callback(GLFWwindow *window, int focused)
 {
   VALUE rb_window = rb_lookup_window(window);
-  VALUE rb_func = rb_ivar_get(rb_window, kRB_IVAR_WINDOW_FOCUS_CALLBACK);
-  rb_funcall(rb_func, kRB_CALL, 2, rb_window, focused ? Qtrue : Qfalse);
+  if (RTEST(rb_window)) {
+    VALUE rb_func = rb_ivar_get(rb_window, kRB_IVAR_WINDOW_FOCUS_CALLBACK);
+    if (rb_obj_respond_to(rb_func, kRB_CALL, 0)) {
+      rb_funcall(rb_func, kRB_CALL, 2, rb_window, focused ? Qtrue : Qfalse);
+    }
+  }
 }
 
 RB_ENABLE_CALLBACK_DEF(rb_window_set_focus_callback, rb_window_focus_callback, glfwSetWindowFocusCallback);
@@ -963,8 +1005,12 @@ RB_ENABLE_CALLBACK_DEF(rb_window_set_focus_callback, rb_window_focus_callback, g
 static void rb_window_iconify_callback(GLFWwindow *window, int iconified)
 {
   VALUE rb_window = rb_lookup_window(window);
-  VALUE rb_func = rb_ivar_get(rb_window, kRB_IVAR_WINDOW_ICONIFY_CALLBACK);
-  rb_funcall(rb_func, kRB_CALL, 2, rb_window, iconified ? Qtrue : Qfalse);
+  if (RTEST(rb_window)) {
+    VALUE rb_func = rb_ivar_get(rb_window, kRB_IVAR_WINDOW_ICONIFY_CALLBACK);
+    if (rb_obj_respond_to(rb_func, kRB_CALL, 0)) {
+      rb_funcall(rb_func, kRB_CALL, 2, rb_window, iconified ? Qtrue : Qfalse);
+    }
+  }
 }
 
 RB_ENABLE_CALLBACK_DEF(rb_window_set_iconify_callback, rb_window_iconify_callback, glfwSetWindowIconifyCallback);
@@ -974,8 +1020,12 @@ RB_ENABLE_CALLBACK_DEF(rb_window_set_iconify_callback, rb_window_iconify_callbac
 static void rb_window_fbsize_callback(GLFWwindow *window, int width, int height)
 {
   VALUE rb_window = rb_lookup_window(window);
-  VALUE rb_func = rb_ivar_get(rb_window, kRB_IVAR_WINDOW_FRAMEBUFFER_SIZE_CALLBACK);
-  rb_funcall(rb_func, kRB_CALL, 3, rb_window, INT2FIX(width), INT2FIX(height));
+  if (RTEST(rb_window)) {
+    VALUE rb_func = rb_ivar_get(rb_window, kRB_IVAR_WINDOW_FRAMEBUFFER_SIZE_CALLBACK);
+    if (rb_obj_respond_to(rb_func, kRB_CALL, 0)) {
+      rb_funcall(rb_func, kRB_CALL, 3, rb_window, INT2FIX(width), INT2FIX(height));
+    }
+  }
 }
 
 RB_ENABLE_CALLBACK_DEF(rb_window_set_fbsize_callback, rb_window_fbsize_callback, glfwSetFramebufferSizeCallback);
@@ -1124,8 +1174,12 @@ static VALUE rb_window_set_cursor_pos(VALUE self, VALUE x, VALUE y)
 static void rb_window_key_callback(GLFWwindow *window, int key, int scancode, int action, int mods)
 {
   VALUE rb_window = rb_lookup_window(window);
-  VALUE rb_func = rb_ivar_get(rb_window, kRB_IVAR_WINDOW_KEY_CALLBACK);
-  rb_funcall(rb_func, kRB_CALL, 5, rb_window, INT2FIX(key), INT2FIX(scancode), INT2FIX(action), INT2FIX(mods));
+  if (RTEST(rb_window)) {
+    VALUE rb_func = rb_ivar_get(rb_window, kRB_IVAR_WINDOW_KEY_CALLBACK);
+    if (rb_obj_respond_to(rb_func, kRB_CALL, 0)) {
+      rb_funcall(rb_func, kRB_CALL, 5, rb_window, INT2FIX(key), INT2FIX(scancode), INT2FIX(action), INT2FIX(mods));
+    }
+  }
 }
 
 RB_ENABLE_CALLBACK_DEF(rb_window_set_key_callback, rb_window_key_callback, glfwSetKeyCallback);
@@ -1135,8 +1189,12 @@ RB_ENABLE_CALLBACK_DEF(rb_window_set_key_callback, rb_window_key_callback, glfwS
 static void rb_window_char_callback(GLFWwindow *window, unsigned int code)
 {
   VALUE rb_window = rb_lookup_window(window);
-  VALUE rb_func = rb_ivar_get(rb_window, kRB_IVAR_WINDOW_CHAR_CALLBACK);
-  rb_funcall(rb_func, kRB_CALL, 2, rb_window, UINT2NUM(code));
+  if (RTEST(rb_window)) {
+    VALUE rb_func = rb_ivar_get(rb_window, kRB_IVAR_WINDOW_CHAR_CALLBACK);
+    if (rb_obj_respond_to(rb_func, kRB_CALL, 0)) {
+      rb_funcall(rb_func, kRB_CALL, 2, rb_window, UINT2NUM(code));
+    }
+  }
 }
 
 RB_ENABLE_CALLBACK_DEF(rb_window_set_char_callback, rb_window_char_callback, glfwSetCharCallback);
@@ -1147,8 +1205,12 @@ RB_ENABLE_CALLBACK_DEF(rb_window_set_char_callback, rb_window_char_callback, glf
 static void rb_window_mouse_button_callback(GLFWwindow *window, int button, int action, int mods)
 {
   VALUE rb_window = rb_lookup_window(window);
-  VALUE rb_func = rb_ivar_get(rb_window, kRB_IVAR_WINDOW_MOUSE_BUTTON_CALLBACK);
-  rb_funcall(rb_func, kRB_CALL, 4, rb_window, INT2FIX(button), INT2FIX(action), INT2FIX(mods));
+  if (RTEST(rb_window)) {
+    VALUE rb_func = rb_ivar_get(rb_window, kRB_IVAR_WINDOW_MOUSE_BUTTON_CALLBACK);
+    if (rb_obj_respond_to(rb_func, kRB_CALL, 0)) {
+      rb_funcall(rb_func, kRB_CALL, 4, rb_window, INT2FIX(button), INT2FIX(action), INT2FIX(mods));
+    }
+  }
 }
 
 RB_ENABLE_CALLBACK_DEF(rb_window_set_mouse_button_callback, rb_window_mouse_button_callback, glfwSetMouseButtonCallback);
@@ -1158,8 +1220,12 @@ RB_ENABLE_CALLBACK_DEF(rb_window_set_mouse_button_callback, rb_window_mouse_butt
 static void rb_window_cursor_position_callback(GLFWwindow *window, double x, double y)
 {
   VALUE rb_window = rb_lookup_window(window);
-  VALUE rb_func = rb_ivar_get(rb_window, kRB_IVAR_WINDOW_CURSOR_POSITION_CALLBACK);
-  rb_funcall(rb_func, kRB_CALL, 3, rb_window, rb_float_new(x), rb_float_new(y));
+  if (RTEST(rb_window)) {
+    VALUE rb_func = rb_ivar_get(rb_window, kRB_IVAR_WINDOW_CURSOR_POSITION_CALLBACK);
+    if (rb_obj_respond_to(rb_func, kRB_CALL, 0)) {
+      rb_funcall(rb_func, kRB_CALL, 3, rb_window, rb_float_new(x), rb_float_new(y));
+    }
+  }
 }
 
 RB_ENABLE_CALLBACK_DEF(rb_window_set_cursor_position_callback, rb_window_cursor_position_callback, glfwSetCursorPosCallback);
@@ -1169,8 +1235,12 @@ RB_ENABLE_CALLBACK_DEF(rb_window_set_cursor_position_callback, rb_window_cursor_
 static void rb_window_cursor_enter_callback(GLFWwindow *window, int entered)
 {
   VALUE rb_window = rb_lookup_window(window);
-  VALUE rb_func = rb_ivar_get(rb_window, kRB_IVAR_WINDOW_CURSOR_ENTER_CALLBACK);
-  rb_funcall(rb_func, kRB_CALL, 2, rb_window, entered ? Qtrue : Qfalse);
+  if (RTEST(rb_window)) {
+    VALUE rb_func = rb_ivar_get(rb_window, kRB_IVAR_WINDOW_CURSOR_ENTER_CALLBACK);
+    if (rb_obj_respond_to(rb_func, kRB_CALL, 0)) {
+      rb_funcall(rb_func, kRB_CALL, 2, rb_window, entered ? Qtrue : Qfalse);
+    }
+  }
 }
 
 RB_ENABLE_CALLBACK_DEF(rb_window_set_cursor_enter_callback, rb_window_cursor_enter_callback, glfwSetCursorEnterCallback);
@@ -1180,8 +1250,12 @@ RB_ENABLE_CALLBACK_DEF(rb_window_set_cursor_enter_callback, rb_window_cursor_ent
 static void rb_window_scroll_callback(GLFWwindow *window, double x, double y)
 {
   VALUE rb_window = rb_lookup_window(window);
-  VALUE rb_func = rb_ivar_get(rb_window, kRB_IVAR_WINDOW_SCROLL_CALLBACK);
-  rb_funcall(rb_func, kRB_CALL, 3, rb_window, rb_float_new(x), rb_float_new(y));
+  if (RTEST(rb_window)) {
+    VALUE rb_func = rb_ivar_get(rb_window, kRB_IVAR_WINDOW_SCROLL_CALLBACK);
+    if (rb_obj_respond_to(rb_func, kRB_CALL, 0)) {
+      rb_funcall(rb_func, kRB_CALL, 3, rb_window, rb_float_new(x), rb_float_new(y));
+    }
+  }
 }
 
 RB_ENABLE_CALLBACK_DEF(rb_window_set_scroll_callback, rb_window_scroll_callback, glfwSetScrollCallback);
@@ -1217,11 +1291,12 @@ static VALUE rb_glfw_get_joystick_axes(VALUE self, VALUE joystick)
 {
   VALUE rb_axes = Qnil;
   int num_axes = 0;
+  int axis_index = 0;
   const float *axes = glfwGetJoystickAxes(NUM2INT(joystick), &num_axes);
   if (num_axes > 0) {
     rb_axes = rb_ary_new();
-    for (; num_axes; --num_axes, ++axes) {
-      rb_ary_push(rb_axes, rb_float_new(*axes));
+    for (; axis_index < num_axes; ++axis_index) {
+      rb_ary_push(rb_axes, rb_float_new(axes[axis_index]));
     }
   }
   return rb_axes;
@@ -1242,11 +1317,12 @@ static VALUE rb_glfw_get_joystick_buttons(VALUE self, VALUE joystick)
 {
   VALUE rb_buttons = Qnil;
   int num_buttons = 0;
+  int button_index = 0;
   const unsigned char *buttons = glfwGetJoystickButtons(NUM2INT(joystick), &num_buttons);
   if (num_buttons > 0) {
     rb_buttons = rb_ary_new();
-    for (; num_buttons; --num_buttons, ++buttons) {
-      rb_ary_push(rb_buttons, rb_float_new(INT2FIX((int)*buttons)));
+    for (; button_index < num_buttons; ++button_index) {
+      rb_ary_push(rb_buttons, rb_float_new(INT2FIX((int)buttons[button_index])));
     }
   }
   return rb_buttons;
@@ -1391,12 +1467,7 @@ static VALUE rb_window_unset_context(VALUE self)
  */
 static VALUE rb_window_get_current_context(VALUE self)
 {
-  GLFWwindow *window = glfwGetCurrentContext();
-  if (window) {
-    return (VALUE)glfwGetWindowUserPointer(window);
-  } else {
-    return Qnil;
-  }
+  return rb_lookup_window(glfwGetCurrentContext());
 }
 
 
@@ -1487,10 +1558,10 @@ void Init_glfw3(void)
   kRB_BLUE                                  = rb_intern(kRB_BLUE_NAME);
 
   s_glfw_module = rb_define_module("Glfw");
-  s_glfw_monitor_klass = rb_define_class_under(s_glfw_module, "Monitor", rb_cObject);
+  s_glfw_monitor_klass = rb_define_class_under(s_glfw_module, "Monitor", rb_cData);
   s_glfw_window_klass = rb_define_class_under(s_glfw_module, "Window", rb_cObject);
-  s_glfw_window_internal_klass = rb_define_class_under(s_glfw_window_klass, "InternalWindow", rb_cObject);
-  s_glfw_videomode_klass = rb_define_class_under(s_glfw_module, "VideoMode", rb_cObject);
+  s_glfw_window_internal_klass = rb_define_class_under(s_glfw_window_klass, "InternalWindow", rb_cData);
+  s_glfw_videomode_klass = rb_define_class_under(s_glfw_module, "VideoMode", rb_cData);
 
   /* Glfw::Monitor */
   rb_define_singleton_method(s_glfw_monitor_klass, "monitors", rb_glfw_get_monitors, 0);

data/lib/glfw3/callbacks.rb

@@ -35,7 +35,7 @@ module Glfw
   # Sets the current error callback to a Proc generated from the provided block.
   #
   def self.set_error_callback(&block)
-    self.error_callback = lambda(&block)
+    self.error_callback = block
   end
 
   #
@@ -70,6 +70,6 @@ module Glfw
   # block.
   #
   def self.set_monitor_callback(&block)
-    self.monitor_callback = lambda(&block)
+    self.monitor_callback = block
   end
 end

data/lib/glfw3/window.rb

@@ -98,119 +98,119 @@ class Glfw::Window
 
   def key_callback=(func)
     @__key_callback = func
-    set_key_callback__(!func.nil?)
+    set_key_callback__(func.respond_to?(:call))
   end
 
   def set_key_callback(&block)
-    self.key_callback = lambda(&block)
+    self.key_callback = block
   end
 
   def char_callback=(func)
     @__char_callback = func
-    set_char_callback__(!func.nil?)
+    set_char_callback__(func.respond_to?(:call))
   end
 
   def set_char_callback(&block)
-    self.char_callback = lambda(&block)
+    self.char_callback = block
   end
 
   def mouse_button_callback=(func)
     @__mouse_button_callback = func
-    set_mouse_button_callback__(!func.nil?)
+    set_mouse_button_callback__(func.respond_to?(:call))
   end
 
   def set_mouse_button_callback(&block)
-    self.mouse_button_callback = lambda(&block)
+    self.mouse_button_callback = block
   end
 
   def cursor_position_callback=(func)
     @__cursor_position_callback = func
-    set_cursor_position_callback__(!func.nil?)
+    set_cursor_position_callback__(func.respond_to?(:call))
   end
 
   def set_cursor_position_callback(&block)
-    self.cursor_position_callback = lambda(&block)
+    self.cursor_position_callback = block
   end
 
   def cursor_enter_callback=(func)
     @__cursor_enter_callback = func
-    set_cursor_enter_callback__(!func.nil?)
+    set_cursor_enter_callback__(func.respond_to?(:call))
   end
 
   def set_cursor_enter_callback(&block)
-    self.cursor_enter_callback = lambda(&block)
+    self.cursor_enter_callback = block
   end
 
   def scroll_callback=(func)
     @__scroll_callback = func
-    set_scroll_callback__(!func.nil?)
+    set_scroll_callback__(func.respond_to?(:call))
   end
 
   def set_scroll_callback(&block)
-    self.scroll_callback = lambda(&block)
+    self.scroll_callback = block
   end
 
   def position_callback=(func)
     @__position_callback = func
-    set_window_position_callback__(!func.nil?)
+    set_window_position_callback__(func.respond_to?(:call))
   end
 
   def set_position_callback(&block)
-    self.position_callback = lambda(&block)
+    self.position_callback = block
   end
 
   def size_callback=(func)
     @__size_callback = func
-    set_window_size_callback__(!func.nil?)
+    set_window_size_callback__(func.respond_to?(:call))
   end
 
   def set_size_callback(&block)
-    self.size_callback = lambda(&block)
+    self.size_callback = block
   end
 
   def close_callback=(func)
     @__close_callback = func
-    set_close_callback__(!func.nil?)
+    set_close_callback__(func.respond_to?(:call))
   end
 
   def set_close_callback(&block)
-    self.close_callback = lambda(&block)
+    self.close_callback = block
   end
 
   def refresh_callback=(func)
     @__refresh_callback = func
-    set_refresh_callback__(!func.nil?)
+    set_refresh_callback__(func.respond_to?(:call))
   end
 
   def set_refresh_callback(&block)
-    self.refresh_callback = lambda(&block)
+    self.refresh_callback = block
   end
 
   def focus_callback=(func)
     @__focus_callback = func
-    set_focus_callback__(!func.nil?)
+    set_focus_callback__(func.respond_to?(:call))
   end
 
   def set_focus_callback(&block)
-    self.focus_callback = lambda(&block)
+    self.focus_callback = block
   end
 
   def iconify_callback=(func)
     @__iconify_callback = func
-    set_iconify_callback__(!func.nil?)
+    set_iconify_callback__(func.respond_to?(:call))
   end
 
   def set_iconify_callback(&block)
-    self.iconify_callback = lambda(&block)
+    self.iconify_callback = block
   end
 
   def framebuffer_size_callback=(func)
     @__framebuffer_size_callback = func
-    set_fbsize_callback__(!func.nil?)
+    set_fbsize_callback__(func.respond_to?(:call))
   end
 
   def set_framebuffer_size_callback(&block)
-    self.framebuffer_size_callback = lambda(&block)
+    self.framebuffer_size_callback = block
   end
 
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glfw3
 version: !ruby/object:Gem::Version
-  version: 0.4.5
+  version: 0.4.6
 platform: ruby
 authors:
 - Noel Raymond Cower
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-14 00:00:00.000000000 Z
+date: 2014-04-04 00:00:00.000000000 Z
 dependencies: []
 description: GLFW 3 bindings for Ruby 2.x
 email: ncower@gmail.com
@@ -53,9 +53,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.1
+rubygems_version: 2.2.0
 signing_key: 
 specification_version: 4
 summary: GLFW3
 test_files: []
-has_rdoc: true