gyruby 0.0.2 → 0.1.1

data/ext/extconf.rb

@@ -29,7 +29,7 @@ unless find_executable("pkg-config")
 end
 
 $CFLAGS += " -std=c99 -Wall -I. " + `pkg-config --cflags glib-2.0`.strip
-$LIBS += " " + `pkg-config --libs glib-2.0`
+$LIBS += " " + `pkg-config --libs gthread-2.0`
 
 unless have_library('glib-2.0')
   crash "libglib-2.0 needed"

data/ext/gyruby_ext.c

@@ -19,7 +19,9 @@
 #include <stdio.h>
 #include "ruby.h"
 #include <glib.h>
+#include <stdlib.h>
 #include <X11/Xlib.h>
+#include <errno.h>
 
 #define RB_REMOTE(c_remote_pointer,klass) (c_remote_pointer->rb_remote = (Data_Wrap_Struct(klass, c_remote_mark, c_remote_free, (c_remote_pointer))))
 #define C_REMOTE(rb_remote,c_remote_pointer) Data_Get_Struct((rb_remote), c_remote, (c_remote_pointer))
@@ -27,15 +29,37 @@
 #define PACKET_SIZE 6
 #define BUFFER_UNIT 1024
 
+extern gint errno;
+extern gint sys_nerr;
+extern const char *sys_errlist[];
+
 typedef struct {
-  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
+  /*
+   * The ruby representation of this object.
+   */
+  VALUE rb_remote;
+
+  /*
+   * Mouse capture runtime data.
+   */
+  Display *display;
+
+  /*
+   * USB capture runtime data.
+   */
+  usb_dev_handle *usb_handle;
+  GAsyncQueue *usb_event_queue;
+  gboolean run_usb_thread;
+  GThread *usb_thread;
 } c_remote;
 
+typedef struct {
+  gint x;
+  gint y;
+  gint xmax;
+  gint ymax;
+} mouse_event;
+
 typedef VALUE
 (*gyration_data_handler)(gint result, gchar *data, gpointer user_data);
 
@@ -44,6 +68,15 @@ typedef VALUE
 
 static VALUE rb_remote;
 
+static const gchar*
+errmsg() {
+  if (errno < sys_nerr) {
+    return sys_errlist[errno];
+  } else {
+    return "UNKNOWN ERROR";
+  }
+}
+
 static gchar*
 c_remote_inspect(c_remote *remote) {
   gchar *buffer = g_new(gchar, BUFFER_UNIT);
@@ -54,29 +87,37 @@ c_remote_inspect(c_remote *remote) {
 }
 
 static void
-c_remote_free(c_remote *remote) {
-  g_hash_table_destroy(remote->subscriptions);
-  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);
-    }
-  }
-  free(remote);
+unclaim_device_handle(usb_dev_handle *handle) {
+  if (usb_release_interface(handle, 1) < 0)
+    rb_raise(rb_eRuntimeError, "Failed releasing device: %s", errmsg());
+  if (usb_close(handle) < 0) 
+    rb_raise(rb_eRuntimeError, "Failed closing device: %s", errmsg());
 }
 
 static void
-g_hash_table_mark_value_pointers(gpointer key, gpointer value, gpointer user_data) {
-  VALUE *callback = (VALUE *) value;
-  rb_gc_mark(*callback);
+c_remote_unclaim_device(c_remote *remote) {
+  remote->run_usb_thread = FALSE;
+  if (g_thread_self() != remote->usb_thread)
+    g_thread_join(remote->usb_thread);
+  unclaim_device_handle(remote->usb_handle);
+  remote->usb_handle = NULL;
+  remote->usb_thread = NULL;
+  g_async_queue_unref(remote->usb_event_queue);
 }
 
 static void
-c_remote_mark(c_remote *remote) {
-  g_hash_table_foreach(remote->subscriptions, g_hash_table_mark_value_pointers, NULL);
-  rb_gc_mark(remote->grab_callback);
-  rb_gc_mark(remote->display_name);
+ungrab_mouse(Display *display) {
+  XUngrabPointer(display, CurrentTime);
+  XCloseDisplay(display);
+}
+
+static void
+c_remote_free(c_remote *remote) {
+  if (remote->display != NULL)
+    ungrab_mouse(remote->display);
+  if (remote->usb_handle != NULL)
+    c_remote_unclaim_device(remote);
+  free(remote);
 }
 
 static VALUE
@@ -91,29 +132,19 @@ rb_remote_inspect(VALUE self) {
   return rval;
 }
 
-static guint
-subscription_hash(gconstpointer key) {
-  gchar *subscription = (gchar *) key;
-  guint hash = 5381;
-  
-  for (int i = 0; i < (sizeof(gint) / sizeof(gchar)) + PACKET_SIZE; i++)
-    hash = ((hash << 5) + hash) + subscription[i]; /* hash * 33 + subscription[i] */
-  
-  return hash;
-}
-
-static gboolean
-subscription_equal(gconstpointer a, gconstpointer b) {
-  return memcmp(a, b, sizeof(gchar) * ((sizeof(gint) / sizeof(gchar)) + PACKET_SIZE)) == 0;
+static void
+c_remote_mark(c_remote *remote) {
 }
 
 static VALUE 
 rb_remote_alloc(VALUE class) {
   c_remote *remote = ALLOC(c_remote);
-  remote->usb_handle = NULL;
-  remote->subscriptions = g_hash_table_new_full(subscription_hash, subscription_equal, free, free);
   remote->display = NULL;
-  remote->display_name = Qnil;
+
+  remote->usb_handle = NULL;
+  remote->usb_event_queue = NULL;
+  remote->run_usb_thread = FALSE;
+  remote->usb_thread = NULL;
   return RB_REMOTE(remote, class);
 }
 
@@ -124,56 +155,96 @@ rb_gyruby_set_debug(VALUE self, VALUE arg) {
   return arg;
 }
 
-static void
-c_remote_fetch_handle(c_remote *remote) {
-  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->usb_handle = usb_open(dev);
-	}
+static VALUE
+rb_remote_unclaim_device(VALUE self) {
+  c_remote *this;
+  C_REMOTE(self, this);
+  if (this->usb_handle == NULL) {
+    return Qfalse;
+  } else {
+    c_remote_unclaim_device(this);
+    return Qtrue;
+  }
+}
+
+static usb_dev_handle*
+fetch_device_handle() {
+  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) {
+	return usb_open(dev);
       }
     }
   }
+  return NULL;
 }
 
-static void
-c_remote_claim_device(c_remote *remote) {
-  c_remote_fetch_handle(remote);
-  if (remote->usb_handle) {
-    if (usb_claim_interface(remote->usb_handle, 1) < 0) {
+static usb_dev_handle*
+claim_device_handle() {
+  usb_dev_handle *handle = fetch_device_handle();
+  if (handle == NULL) {
+    rb_raise(rb_eRuntimeError, "Failed finding device. Do you have permission to list it? Is it plugged in?");
+  } else {
+    if (usb_claim_interface(handle, 1) < 0) {
       char dname[32];
-      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.");
+      if (usb_get_driver_np(handle, 1, dname, 31) == 0) {
+	if (usb_detach_kernel_driver_np(handle, 1) < 0) {
+	  rb_raise(rb_eRuntimeError, 
+		   "Failed claiming device. Also failed detaching kernel driver for device: %s", errmsg());
 	} else {
-	  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.");
+	  if (usb_claim_interface(handle, 1) < 0) {
+	    rb_raise(rb_eRuntimeError, 
+		     "Failed claiming device. Succeded in detaching kernel driver for device. But still failed claiming device: %s", errmsg());
 	  }
 	}
       } else {
-	rb_raise(rb_eRuntimeError, "Failed claiming device. Also failed getting kernel driver for device.");
+	rb_raise(rb_eRuntimeError, 
+		 "Failed claiming device. Also failed getting kernel driver for device: %s", errmsg());
       }
     }
   }
+  return handle;
+}
+
+static gpointer
+read_usb(gpointer arg) {
+  c_remote *remote = (c_remote *) arg;
+  gchar inpacket[PACKET_SIZE];
+  while (remote->run_usb_thread) {
+    gint result = usb_interrupt_read(remote->usb_handle, 
+				     0x82, 
+				     inpacket, 
+				     PACKET_SIZE, 
+				     50);
+    if (result < 0 && result != -110) {
+      fprintf(stderr, "Weird error: The result code from usb_interrupt_read was: %i\n", result);
+      c_remote_unclaim_device(remote);
+    } else if (result != -110) {
+      gchar *packet_copy = g_new(gchar, PACKET_SIZE);
+      memcpy(packet_copy, inpacket, sizeof(gchar) * PACKET_SIZE);
+      g_async_queue_push(remote->usb_event_queue, packet_copy);
+    }
+  }
+  return NULL;
 }
 
+
 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->usb_handle, 
-				   0x82, 
-				   inpacket, 
-				   PACKET_SIZE, 
-				   50);
-  if (result < 0 && result != -110) {
-    rb_raise(rb_eRuntimeError, "Got result %i.", result);
+rb_remote_claim_device(VALUE self) {
+  c_remote *this;
+  C_REMOTE(self, this);
+  if (this->usb_handle == NULL) {
+    this->usb_handle = claim_device_handle();
+
+    this->usb_event_queue = g_async_queue_new_full(free);
+    this->run_usb_thread = TRUE;
+    this->usb_thread = g_thread_create(read_usb, this, TRUE, NULL);
+    return Qtrue;
+  } else {
+    return Qfalse;
   }
-  return handler(result, inpacket, user_data);
 }
 
 static Bool
@@ -181,222 +252,135 @@ true_predicate(Display *display, XEvent *event, XPointer arg) {
   return True;
 }
 
-static VALUE
-c_remote_handle_grab_data(c_remote *remote, grab_data_handler handler, gpointer user_data) {
+static mouse_event*
+fetch_mouse_event(Display *display) {
   XEvent event;
-  if (XCheckIfEvent(remote->display, &event, true_predicate, NULL) == True &&
+  if (XCheckIfEvent(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);
+    mouse_event *rval = ALLOC(mouse_event);
+    Screen *screen = XDefaultScreenOfDisplay(display);
+    rval->x = event.xmotion.x_root;
+    rval->y = event.xmotion.y_root;
+    rval->xmax = WidthOfScreen(screen);
+    rval->ymax = HeightOfScreen(screen);
+    return rval;
   } else {
-    return Qnil;
+    return 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
+rb_remote_fetch_mouse_event(VALUE self) {
+  c_remote *this;
+  C_REMOTE(self, this);
+  if (this->display == NULL) {
+    rb_raise(rb_eRuntimeError, 
+	     "You can't fetch mouse events from a %s that hasn't grabbed the pointer.", 
+	     rb_obj_classname(self));
+  } else {
+    mouse_event *event = fetch_mouse_event(this->display);
+    if (event == NULL) {
+      return Qnil;
+    } else {
+      VALUE rval = rb_hash_new();
+      rb_hash_aset(rval, ID2SYM(rb_intern("x")), INT2NUM(event->x));
+      rb_hash_aset(rval, ID2SYM(rb_intern("y")), INT2NUM(event->y));
+      rb_hash_aset(rval, ID2SYM(rb_intern("xmax")), INT2NUM(event->xmax));
+      rb_hash_aset(rval, ID2SYM(rb_intern("ymax")), INT2NUM(event->ymax));
+      free(event);
+      return rval;
     }
   }
 }
 
 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 };
-  while (1) {
-    if (gyration_handler != 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_name != Qnil && 
-	(rval = c_remote_handle_grab_data(remote, grab_handler, user_data)) != Qnil)
+rb_remote_fetch_usb_event(VALUE self) {
+  c_remote *this;
+  C_REMOTE(self, this);
+  if (this->usb_event_queue == NULL) {
+    rb_raise(rb_eRuntimeError, 
+	     "You can't fetch usb events from a %s that hasn't claimed the device.", 
+	     rb_obj_classname(self));
+  } else {
+    gpointer next_event = g_async_queue_try_pop(this->usb_event_queue);
+    if (next_event == NULL) {
+      return Qnil;
+    } else {
+      VALUE rval = rb_str_new((gchar *) next_event, 6);
+      free(next_event);
       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;
+static Display*
+grab_mouse() {
+  Display *display = XOpenDisplay(NULL);
+  if (XGrabPointer(display, 
+		   XDefaultRootWindow(display),
+		   False, 
+		   PointerMotionMask, 
+		   GrabModeAsync, 
+		   GrabModeAsync, 
+		   None, 
+		   None, 
+		   CurrentTime) != GrabSuccess) {
+    rb_raise(rb_eRuntimeError, "Failed grabbing the pointer for the root window!");
   }
-  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));
-  memcpy(subscription, 
-	 &result, 
-	 sizeof(gint));
-  memcpy(subscription + (sizeof(gint) / sizeof(gchar)), 
-	 packet,
-	 sizeof(gchar) * 6);
-  return subscription;
-}
-
-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);
-  return rb_yield_values(2, result_value, result_string);
-}
-
-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;
-  return rb_funcall(remote->rb_remote,
-		    remote->grab_callback,
-		    4,
-		    INT2NUM(x),
-		    INT2NUM(y),
-		    INT2NUM(maxx),
-		    INT2NUM(maxy));
-}
-
-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) {
-    return rb_funcall(remote->rb_remote, 
-		      *callback, 
-		      2, 
-		      INT2NUM(result), 
-		      rb_str_new(packet, PACKET_SIZE));
-  } else {
-    return Qnil;
-  }  
-}
-
-static VALUE
-rb_remote_listen(VALUE self) {
-  c_remote *this;
-  C_REMOTE(self, this);
-  return c_remote_handle_data_until(this, c_remote_call_subscription, c_remote_call_grab_handler, this);
+  return display;
 }
 
 static VALUE
-rb_remote_record(VALUE self) {
+rb_remote_ungrab_mouse(VALUE self) {
   c_remote *this;
   C_REMOTE(self, this);
-  return c_remote_handle_data_until(this, c_remote_yield_gyration_data, NULL, NULL);
+  if (this->display == NULL) {
+    return Qfalse;
+  } else {
+    ungrab_mouse(this->display);
+    this->display = NULL;
+    return Qtrue;
+  }
 }
 
 static VALUE
-rb_remote_subscribe(VALUE self, VALUE result_value, VALUE result_string, VALUE callback) {
+rb_remote_grab_mouse(VALUE self) {
   c_remote *this;
-  gchar *subscription;
-  ID *callback_id;
-  Check_Type(result_value, T_FIXNUM);
-  Check_Type(result_string, T_STRING);
-  Check_Type(callback, T_SYMBOL);
   C_REMOTE(self, this);
-  callback_id = ALLOC(ID);
-  *callback_id = rb_to_id(callback);
-  subscription = subscription_from_result_and_packet(NUM2INT(result_value), 
-						     RSTRING(result_string)->ptr);
-  g_hash_table_insert(this->subscriptions, subscription, callback_id);
-  return self;
-}
-
-static void
-g_hash_table_copy_to_rb_hash(gpointer key, gpointer value, gpointer user_data) {
-  VALUE *hash = (VALUE *) user_data;
-  gchar *subscription = (gchar *) key;
-  ID *callback_id = (ID *) value;
-  VALUE ary = rb_ary_new();
-  gint result;
-  gchar packet[PACKET_SIZE];
-  memcpy(&result, subscription, sizeof(gint));
-  memcpy(packet, subscription + (sizeof(gint) / sizeof(gchar)), sizeof(gchar) * PACKET_SIZE);
-  rb_ary_push(ary, INT2NUM(result));
-  rb_ary_push(ary, rb_str_new(packet, PACKET_SIZE));
-  rb_hash_aset(*hash, ID2SYM(*callback_id), ary);
+  if (this->display == NULL) {
+    this->display = grab_mouse();
+    return Qtrue;
+  } else {
+    return Qfalse;
+  }
 }
 
 static VALUE
-rb_remote_subscriptions(VALUE self) {
+rb_remote_get_claimed_device(VALUE self) {
   c_remote *this;
-  VALUE rval;
   C_REMOTE(self, this);
-  rval = rb_hash_new();
-  g_hash_table_foreach(this->subscriptions, g_hash_table_copy_to_rb_hash, &rval);
-  return rval;
+  if (this->usb_handle == NULL)
+    return Qfalse;
+  else
+    return Qtrue;
 }
 
 static VALUE
-rb_remote_get_grab(VALUE self) {
+rb_remote_get_grabbed_mouse(VALUE self) {
   c_remote *this;
-  VALUE rval;
   C_REMOTE(self, this);
   if (this->display == NULL)
-    return Qnil;
-  rval = rb_ary_new();
-  rb_ary_push(rval, this->display_name);
-  rb_ary_push(rval, ID2SYM(this->grab_callback));
-  return rval;
-}
-
-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->grab_callback = rb_to_id(callback);
-  this->display_name = display_name_value;
-  return display_name_value;
-}
-
-static VALUE
-rb_remote_release(VALUE self) {
-  c_remote *this;
-  C_REMOTE(self, this);
-  if (this->display_name == Qnil)
-    rb_raise(rb_eRuntimeError, "You can't release a %s that isn't grabbed.", rb_obj_classname(self));
-  this->display_name = Qnil;
-  return self;
+    return Qfalse;
+  else
+    return Qtrue;
 }
 
 #ifdef __cplusplus
 extern "C" {
 #endif
   void Init_gyruby_ext() {
+    g_thread_init(NULL);
+
     usb_init();
     usb_find_busses();
     usb_find_devices();
@@ -406,15 +390,17 @@ extern "C" {
     rb_remote = rb_define_class_under(rb_gyruby,
 				      "Remote",
 				      rb_cObject);
+
     rb_define_alloc_func(rb_remote, rb_remote_alloc);
-    rb_define_method(rb_remote, "record", rb_remote_record, 0);
-    rb_define_method(rb_remote, "subscribe", rb_remote_subscribe, 3);
     rb_define_method(rb_remote, "inspect", rb_remote_inspect, 0);
-    rb_define_method(rb_remote, "subscriptions", rb_remote_subscriptions, 0);
-    rb_define_method(rb_remote, "listen", rb_remote_listen, 0);
-    rb_define_method(rb_remote, "grab", rb_remote_grab, 2);
-    rb_define_method(rb_remote, "grabbed?", rb_remote_get_grab, 0);
-    rb_define_method(rb_remote, "release", rb_remote_release, 0);
+    rb_define_private_method(rb_remote, "grab_mouse", rb_remote_grab_mouse, 0);
+    rb_define_private_method(rb_remote, "ungrab_mouse", rb_remote_ungrab_mouse, 0);
+    rb_define_private_method(rb_remote, "claim_device", rb_remote_claim_device, 0);
+    rb_define_private_method(rb_remote, "unclaim_device", rb_remote_unclaim_device, 0);
+    rb_define_private_method(rb_remote, "fetch_usb_event", rb_remote_fetch_usb_event, 0);
+    rb_define_private_method(rb_remote, "fetch_mouse_event", rb_remote_fetch_mouse_event, 0);
+    rb_define_private_method(rb_remote, "claimed_device?", rb_remote_get_claimed_device, 0);
+    rb_define_private_method(rb_remote, "grabbed_mouse?", rb_remote_get_grabbed_mouse, 0);
   }
 #ifdef __cplusplus
 }

data/lib/gyruby/mplayer_controller.rb

@@ -0,0 +1,88 @@
+# gyruby - a ruby binding for the Gyration FiireChief remote control for LinuxMCE
+# Copyright (C) 2008  Martin Kihlgren <zond at troja dot ath dot cx>
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+require 'pathname'
+
+class MplayerController < Gyruby::Remote
+  
+  def initialize(user)
+    super()
+    subscribe("\b%\377\351\000\000") do |s|
+      volume_up
+    end
+    subscribe("\b%\377\352\000\000") do |s|
+      volume_down
+    end
+    subscribe("\b%\377\234\000\000") do |s|
+      osd_up
+    end
+    subscribe("\b%\377\235\000\000") do |s|
+      osd_down
+    end
+    subscribe("\b%\377\313\000\000", "\b%\377\000\000\000") do |key, options|
+      seek(options[:x].to_f/ options[:xmax].to_f)
+    end
+    @osd = 0
+    @user = user
+  end
+
+  private
+
+  def send_command(cmd)
+    ctrl_path = Pathname.new(File.join("/home", @user, ".mplayer", "fifo"))
+    ctrl_path.open("a") do |ctrl|
+      ctrl.puts(cmd)
+    end if ctrl_path.exist? && mplayer_running?
+  end
+
+  def seek(f)
+    puts f.inspect
+    send_command("seek #{f * 100} 1")
+  end
+
+  def osd_up
+    @osd += 1 if @osd < 3
+    send_command("osd #{@osd}")
+  end
+
+  def osd_down
+    @osd -= 1 if @osd > 0
+    send_command("osd #{@osd}")
+  end
+
+  def volume_up
+    send_command("volume 10")
+  end
+
+  def volume_down
+    send_command("volume -10")
+  end
+
+  def mplayer_running?
+    pgrep_pid = fork do
+      STDOUT.reopen(open("/dev/null", "w"))
+      args = ["/usr/bin/env",
+              "pgrep",
+              "-U", @user,
+              "mplayer"]
+      exec(*args)
+    end
+    pid, status = Process.wait2(pgrep_pid)
+    status.exitstatus == 0
+  end
+
+end

data/lib/gyruby/remote.rb

@@ -0,0 +1,92 @@
+# gyruby - a ruby binding for the Gyration FiireChief remote control for LinuxMCE
+# Copyright (C) 2008  Martin Kihlgren <zond at troja dot ath dot cx>
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+
+module Gyruby
+
+  class Remote
+
+    def initialize
+      @subscribed_buttons = {}
+      @pressed_buttons = {}
+      @mouse_buttons = {}
+      @listening = false
+    end
+
+    def subscribe(button, release = false, frequency = 10, &block)
+      if release
+        @mouse_buttons[button] = {
+          :action => :press, 
+          :block => block, 
+          :frequency => frequency,
+          :last => nil
+        }
+        @mouse_buttons[release] = {:action => :release, :press => button}
+      else
+        @subscribed_buttons[button] = block
+      end
+    end
+
+    def record(&block)
+      claim_device unless claimed_device?
+      loop do
+        event = fetch_usb_event
+        yield event unless event.nil?
+        sleep(0.001)
+      end
+    end
+
+    def listen
+      claim_device unless claimed_device?
+      loop do
+        handle_usb_event if claimed_device?
+        handle_mouse_event if grabbed_mouse?
+        sleep(0.001)
+      end
+    end
+
+    private
+
+    def handle_usb_event
+      event = fetch_usb_event
+      if block = @subscribed_buttons[event]
+        block.call(event)
+      end
+      if button_status = @mouse_buttons[event]
+        if button_status[:action] == :press
+          @pressed_buttons[event] = button_status
+          grab_mouse unless grabbed_mouse?
+        elsif button_status[:action] == :release
+          @pressed_buttons.delete(button_status[:press])
+          ungrab_mouse if grabbed_mouse? && @pressed_buttons.empty?
+        end
+      end
+    end
+
+    def handle_mouse_event
+      mouse_event = fetch_mouse_event
+      @pressed_buttons.each do |key_event, button_status|
+        button_status[:last] ||= Time.now
+        if (Time.now - button_status[:last]) > 1.0 / button_status[:frequency]
+          @mouse_buttons[key_event][:block].call(key_event, mouse_event)
+          button_status[:last] = Time.now
+        end
+      end unless mouse_event.nil?
+    end
+
+  end
+
+end

data/lib/gyruby.rb

@@ -1,2 +1,7 @@
 
-require 'gyruby_ext'
+$: << File.join(File.dirname(__FILE__))
+
+require 'gyruby_ext'
+require 'gyruby/remote'
+require 'gyruby/mplayer_controller'
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: gyruby
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.1.1
 platform: ruby
 authors: 
 - Martin Kihlgren
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-05-23 00:00:00 +02:00
+date: 2008-05-26 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -23,6 +23,8 @@ extra_rdoc_files: []
 
 files: 
 - lib/gyruby.rb
+- lib/gyruby/remote.rb
+- lib/gyruby/mplayer_controller.rb
 - ext/extconf.rb
 - ext/gyruby_ext.c
 has_rdoc: true
@@ -48,7 +50,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.0.1
+rubygems_version: 1.1.1
 signing_key: 
 specification_version: 2
 summary: A ruby binding for the Gyration FiireChief remote control for LinuxMCE.