gyruby 0.0.1 → 0.0.2

data/ext/gyruby_ext.c

@@ -28,20 +28,19 @@
 #define BUFFER_UNIT 1024
 
 typedef struct {
-  usb_dev_handle *handle;
-  GHashTable *subscriptions;
-  VALUE rb_remote;
-  Display *display;
-  VALUE display_name;
-  Window root;
-  ID grab_callback;
+  usb_dev_handle *usb_handle; // is NULL if we didnt find the device. will be automatically looked up. will not be looked up again after having been set once
+  GHashTable *subscriptions; // is initialized as a GHashTable, and destroyed on c_remote_free
+  VALUE rb_remote; // the ruby VALUE for this struct
+  Display *display; // is NULL if we havent connected to a display yet. will be looked up on grab and reset to NULL on release
+  VALUE display_name; // is Qnil if we havent connected to a display yet. will be set on grab and reset to Qnil on release
+  ID grab_callback; // is whatever until connect to a display, can be anything, except when display is set - in which case it is set to the ID of the callback for pointer movements
 } c_remote;
 
-typedef gpointer
+typedef VALUE
 (*gyration_data_handler)(gint result, gchar *data, gpointer user_data);
 
-typedef gpointer
-(*grab_data_handler)(gint x, gint y, gpointer user_data);
+typedef VALUE
+(*grab_data_handler)(gint x, gint y, gint maxx, gint maxy, gpointer user_data);
 
 static VALUE rb_remote;
 
@@ -57,8 +56,8 @@ c_remote_inspect(c_remote *remote) {
 static void
 c_remote_free(c_remote *remote) {
   g_hash_table_destroy(remote->subscriptions);
-  if (remote->handle != NULL) {
-    if (usb_close(remote->handle) < 0) {
+  if (remote->usb_handle != NULL) {
+    if (usb_close(remote->usb_handle) < 0) {
       gchar *buffer = c_remote_inspect(remote);
       fprintf(stderr, "Unable to close usb handle! Freeing %s anyway.", buffer);
       free(buffer);
@@ -111,7 +110,7 @@ subscription_equal(gconstpointer a, gconstpointer b) {
 static VALUE 
 rb_remote_alloc(VALUE class) {
   c_remote *remote = ALLOC(c_remote);
-  remote->handle = NULL;
+  remote->usb_handle = NULL;
   remote->subscriptions = g_hash_table_new_full(subscription_hash, subscription_equal, free, free);
   remote->display = NULL;
   remote->display_name = Qnil;
@@ -127,13 +126,13 @@ rb_gyruby_set_debug(VALUE self, VALUE arg) {
 
 static void
 c_remote_fetch_handle(c_remote *remote) {
-  if (remote->handle == NULL) {
+  if (remote->usb_handle == NULL) {
     struct usb_bus *busses = usb_get_busses();
     for (struct usb_bus *bus = busses; bus; bus = bus->next) {
       for (struct usb_device *dev = bus->devices; dev; dev = dev->next) {
 	if (dev->descriptor.idVendor == 0x0c16 && 
 	    dev->descriptor.idProduct == 0x0006) {
-	  remote->handle = usb_open(dev);
+	  remote->usb_handle = usb_open(dev);
 	}
       }
     }
@@ -143,14 +142,14 @@ c_remote_fetch_handle(c_remote *remote) {
 static void
 c_remote_claim_device(c_remote *remote) {
   c_remote_fetch_handle(remote);
-  if (remote->handle) {
-    if (usb_claim_interface(remote->handle, 1) < 0) {
+  if (remote->usb_handle) {
+    if (usb_claim_interface(remote->usb_handle, 1) < 0) {
       char dname[32];
-      if (usb_get_driver_np(remote->handle, 1, dname, 31) == 0) {
-	if (usb_detach_kernel_driver_np(remote->handle, 1) < 0) {
+      if (usb_get_driver_np(remote->usb_handle, 1, dname, 31) == 0) {
+	if (usb_detach_kernel_driver_np(remote->usb_handle, 1) < 0) {
 	  rb_raise(rb_eRuntimeError, "Failed claiming device. Also failed detaching kernel driver for device.");
 	} else {
-	  if (usb_claim_interface(remote->handle, 1) < 0) {
+	  if (usb_claim_interface(remote->usb_handle, 1) < 0) {
 	    rb_raise(rb_eRuntimeError, "Failed claiming device. Succeded in detaching kernel driver for device. But still failed claiming device.");
 	  }
 	}
@@ -161,12 +160,12 @@ c_remote_claim_device(c_remote *remote) {
   }
 }
 
-static gpointer
+static VALUE
 c_remote_handle_usb_data(c_remote *remote, gyration_data_handler handler, gpointer user_data) {
   char inpacket[PACKET_SIZE];
   for (gint i = 0; i < PACKET_SIZE; i++)
     inpacket[i] = 0;
-  gint result = usb_interrupt_read(remote->handle, 
+  gint result = usb_interrupt_read(remote->usb_handle, 
 				   0x82, 
 				   inpacket, 
 				   PACKET_SIZE, 
@@ -182,34 +181,81 @@ true_predicate(Display *display, XEvent *event, XPointer arg) {
   return True;
 }
 
-static gpointer
+static VALUE
 c_remote_handle_grab_data(c_remote *remote, grab_data_handler handler, gpointer user_data) {
   XEvent event;
-  if (XCheckIfEvent(remote->display, &event, true_predicate, NULL) == True)
-    return handler(event.xmotion.x_root, event.xmotion.y_root, user_data);
-  else
-    return NULL;
+  if (XCheckIfEvent(remote->display, &event, true_predicate, NULL) == True &&
+      event.xmotion.same_screen == True) {
+    Screen *screen = XDefaultScreenOfDisplay(remote->display);
+    return handler(event.xmotion.x_root, event.xmotion.y_root, WidthOfScreen(screen), HeightOfScreen(screen), user_data);
+  } else {
+    return Qnil;
+  }
 }
 
-static gpointer
-c_remote_handle_data_until(c_remote *remote, gyration_data_handler gyration_handler, grab_data_handler grab_handler, gpointer user_data) {
-  gpointer rval = NULL;
+static void
+c_remote_grab_pointer(c_remote *remote) {
+  if (remote->display_name != Qnil) {
+    remote->display = XOpenDisplay(RSTRING(remote->display_name)->ptr);
+    if (XGrabPointer(remote->display, 
+		     XDefaultRootWindow(remote->display),
+		     False, 
+		     PointerMotionMask, 
+		     GrabModeAsync, 
+		     GrabModeAsync, 
+		     None, 
+		     None, 
+		     CurrentTime) != GrabSuccess) {
+      remote->display = NULL;
+      rb_raise(rb_eRuntimeError, "Failed grabbing the pointer for the root window at %s.", RSTRING(remote->display_name)->ptr);
+    }
+  }
+}
+
+static VALUE
+c_remote_handle_data_loop(VALUE arg) {
+  gpointer *args = (gpointer *) GINT_TO_POINTER(arg);
+  c_remote *remote = (c_remote *) args[0];
+  gyration_data_handler gyration_handler = (gyration_data_handler) args[1];
+  grab_data_handler grab_handler = (grab_data_handler) args[2];
+  gpointer user_data = args[3];
+  VALUE rval = Qnil;
   struct timeval wait_time = { 0, 1 };
-  c_remote_claim_device(remote);
   while (1) {
     if (gyration_handler != NULL &&
-	remote->handle != NULL && 
-	(rval = c_remote_handle_usb_data(remote, gyration_handler, user_data)) != NULL)
+	remote->usb_handle != NULL && 
+	(rval = c_remote_handle_usb_data(remote, gyration_handler, user_data)) != Qnil)
       return rval;
     if (grab_handler != NULL && 
-	remote->display != NULL && 
-	(rval = c_remote_handle_grab_data(remote, grab_handler, user_data)) != NULL)
+	remote->display_name != Qnil && 
+	(rval = c_remote_handle_grab_data(remote, grab_handler, user_data)) != Qnil)
       return rval;
     rb_thread_wait_for(wait_time);
   }
   return rval;
 }
 
+static VALUE
+c_remote_release_pointer(VALUE arg) {
+  c_remote *remote = (c_remote *) GINT_TO_POINTER(arg);
+  if (remote->display != NULL) {
+    XUngrabPointer(remote->display, CurrentTime);
+    XCloseDisplay(remote->display);
+    remote->display = NULL;
+  }
+  return Qnil;
+}
+
+static VALUE
+c_remote_handle_data_until(c_remote *remote, gyration_data_handler gyration_handler, grab_data_handler grab_handler, gpointer user_data) {
+  VALUE rval;
+  gpointer loop_args[4] = { remote, gyration_handler, grab_handler, user_data };
+  c_remote_claim_device(remote);
+  c_remote_grab_pointer(remote);
+  rval = rb_ensure(c_remote_handle_data_loop, GPOINTER_TO_INT(loop_args), c_remote_release_pointer, GPOINTER_TO_INT(remote));
+  return rval;
+}
+
 static gchar*
 subscription_from_result_and_packet(gint result, gchar *packet) {
   gchar *subscription = malloc(sizeof(gint) + (sizeof(gchar) * PACKET_SIZE));
@@ -222,71 +268,53 @@ subscription_from_result_and_packet(gint result, gchar *packet) {
   return subscription;
 }
 
-static gpointer
+static VALUE
 c_remote_yield_gyration_data(gint result, gchar *packet, gpointer user_data) {
   VALUE result_value = INT2NUM(result);
   VALUE result_string = rb_str_new(packet, PACKET_SIZE);
-  VALUE rval;
-  if ((rval = rb_yield_values(2, result_value, result_string)) == Qnil)
-    return NULL;
-  else
-    return GINT_TO_POINTER(rval);
+  return rb_yield_values(2, result_value, result_string);
 }
 
-static gpointer
-c_remote_call_grab_handler(gint x, gint y, gpointer user_data) {
+static VALUE
+c_remote_call_grab_handler(gint x, gint y, gint maxx, gint maxy, gpointer user_data) {
   c_remote *remote = (c_remote *) user_data;
-  VALUE rval;
-  if ((rval = rb_funcall(remote->rb_remote,
-			 remote->grab_callback,
-			 2,
-			 INT2NUM(x),
-			 INT2NUM(y))) == Qnil)
-    return NULL;
-  else
-    return GINT_TO_POINTER(rval);
+  return rb_funcall(remote->rb_remote,
+		    remote->grab_callback,
+		    4,
+		    INT2NUM(x),
+		    INT2NUM(y),
+		    INT2NUM(maxx),
+		    INT2NUM(maxy));
 }
 
-static gpointer
+static VALUE
 c_remote_call_subscription(gint result, gchar *packet, gpointer user_data) {
   gchar *subscription = subscription_from_result_and_packet(result, packet);
   c_remote *remote = (c_remote *) user_data;
   ID *callback;
   if ((callback = g_hash_table_lookup(remote->subscriptions, subscription)) != NULL) {
-    VALUE rval;
-    if ((rval = rb_funcall(remote->rb_remote, 
-			   *callback, 
-			   2, 
-			   INT2NUM(result), 
-			   rb_str_new(packet, PACKET_SIZE))) == Qnil)
-      return NULL;
-    else
-      return GINT_TO_POINTER(rval);
+    return rb_funcall(remote->rb_remote, 
+		      *callback, 
+		      2, 
+		      INT2NUM(result), 
+		      rb_str_new(packet, PACKET_SIZE));
   } else {
-    return NULL;
+    return Qnil;
   }  
 }
 
 static VALUE
 rb_remote_listen(VALUE self) {
   c_remote *this;
-  gpointer rval;
   C_REMOTE(self, this);
-  if ((rval = c_remote_handle_data_until(this, c_remote_call_subscription, c_remote_call_grab_handler, this)) == NULL)
-    return Qnil;
-  else
-    return (VALUE) GPOINTER_TO_INT(rval);
+  return c_remote_handle_data_until(this, c_remote_call_subscription, c_remote_call_grab_handler, this);
 }
 
 static VALUE
 rb_remote_record(VALUE self) {
   c_remote *this;
-  gpointer rval;
   C_REMOTE(self, this);
-  if ((rval = c_remote_handle_data_until(this, c_remote_yield_gyration_data, NULL, NULL)) == NULL)
-    return Qnil;
-  else
-    return (VALUE) GPOINTER_TO_INT(rval);
+  return c_remote_handle_data_until(this, c_remote_yield_gyration_data, NULL, NULL);
 }
 
 static VALUE
@@ -348,21 +376,8 @@ static VALUE
 rb_remote_grab(VALUE self, VALUE display_name_value, VALUE callback) {
   c_remote *this;
   Check_Type(display_name_value, T_STRING);
+  Check_Type(callback, T_SYMBOL);
   C_REMOTE(self, this);
-  this->display = XOpenDisplay(RSTRING(display_name_value)->ptr);
-  this->root = XDefaultRootWindow(this->display);
-  if (XGrabPointer(this->display, 
-		   this->root, 
-		   False, 
-		   PointerMotionMask, 
-		   GrabModeAsync, 
-		   GrabModeAsync, 
-		   None, 
-		   None, 
-		   CurrentTime) != GrabSuccess) {
-    this->display = NULL;
-    rb_raise(rb_eRuntimeError, "Failed grabbing the pointer for the root window at %s.", RSTRING(display_name_value)->ptr);
-  }
   this->grab_callback = rb_to_id(callback);
   this->display_name = display_name_value;
   return display_name_value;
@@ -372,11 +387,9 @@ static VALUE
 rb_remote_release(VALUE self) {
   c_remote *this;
   C_REMOTE(self, this);
-  if (this->display == NULL)
+  if (this->display_name == Qnil)
     rb_raise(rb_eRuntimeError, "You can't release a %s that isn't grabbed.", rb_obj_classname(self));
-  XUngrabPointer(this->display, CurrentTime);
-  XCloseDisplay(this->display);
-  this->display = NULL;
+  this->display_name = Qnil;
   return self;
 }
 

data/lib/gyruby.rb

@@ -0,0 +1,2 @@
+
+require 'gyruby_ext'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: gyruby
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Martin Kihlgren
@@ -22,6 +22,7 @@ extensions:
 extra_rdoc_files: []
 
 files: 
+- lib/gyruby.rb
 - ext/extconf.rb
 - ext/gyruby_ext.c
 has_rdoc: true