gyruby 0.0.1

data/ext/extconf.rb

@@ -0,0 +1,68 @@
+# gyruby - a ruby binding for the Gyration FiireChief remote control for LinuxMCE
+# Copyright (C) 2007  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 'mkmf'
+
+def crash(s)
+  puts "--------------------------------------------------"
+  puts " extconf failure: #{s}"
+  puts "--------------------------------------------------"
+  exit 1
+end
+
+unless find_executable("pkg-config")
+  crash("pkg-config needed")
+end
+
+$CFLAGS += " -std=c99 -Wall -I. " + `pkg-config --cflags glib-2.0`.strip
+$LIBS += " " + `pkg-config --libs glib-2.0`
+
+unless have_library('glib-2.0')
+  crash "libglib-2.0 needed"
+end
+
+unless have_library("X11")
+  crash "libX11 needed"
+end
+
+unless find_header('X11/Xlib.h', "/usr/include", "/usr/local/include")
+  crash "X11/Xlib.h needed"
+end
+
+unless have_library('usb')
+  crash "libusb needed"
+end
+
+unless find_header('usb.h', "/usr/include", "/usr/local/include")
+  crash "usb.h needed"
+end
+
+if ARGV.include?("-d")
+  $CFLAGS += " -D GYRUBY_DEBUG" 
+end
+
+if ARGV.include?("-O0")
+  $CFLAGS.gsub!(/-O./, "-O0")
+else
+  $CFLAGS.gsub!(/-O./, "-O3")
+end
+
+if ARGV.include?("-gdb")
+  $CFLAGS += " -g -gdwarf-2 -g3"
+end
+
+create_makefile("gyruby_ext")

data/ext/gyruby_ext.c

@@ -0,0 +1,409 @@
+// 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.
+
+#include <usb.h>
+#include <stdio.h>
+#include "ruby.h"
+#include <glib.h>
+#include <X11/Xlib.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))
+
+#define PACKET_SIZE 6
+#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;
+} c_remote;
+
+typedef gpointer
+(*gyration_data_handler)(gint result, gchar *data, gpointer user_data);
+
+typedef gpointer
+(*grab_data_handler)(gint x, gint y, gpointer user_data);
+
+static VALUE rb_remote;
+
+static gchar*
+c_remote_inspect(c_remote *remote) {
+  gchar *buffer = g_new(gchar, BUFFER_UNIT);
+  snprintf(buffer, BUFFER_UNIT, "<%s:%p>",
+	   rb_obj_classname(remote->rb_remote),
+	   remote);
+  return buffer;
+}
+
+static void
+c_remote_free(c_remote *remote) {
+  g_hash_table_destroy(remote->subscriptions);
+  if (remote->handle != NULL) {
+    if (usb_close(remote->handle) < 0) {
+      gchar *buffer = c_remote_inspect(remote);
+      fprintf(stderr, "Unable to close usb handle! Freeing %s anyway.", buffer);
+      free(buffer);
+    }
+  }
+  free(remote);
+}
+
+static void
+g_hash_table_mark_value_pointers(gpointer key, gpointer value, gpointer user_data) {
+  VALUE *callback = (VALUE *) value;
+  rb_gc_mark(*callback);
+}
+
+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);
+}
+
+static VALUE
+rb_remote_inspect(VALUE self) {
+  c_remote *this;
+  gchar *buffer;
+  VALUE rval;
+  C_REMOTE(self, this);
+  buffer = c_remote_inspect(this);
+  rval = rb_str_new2(buffer);
+  free(buffer);
+  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 VALUE 
+rb_remote_alloc(VALUE class) {
+  c_remote *remote = ALLOC(c_remote);
+  remote->handle = NULL;
+  remote->subscriptions = g_hash_table_new_full(subscription_hash, subscription_equal, free, free);
+  remote->display = NULL;
+  remote->display_name = Qnil;
+  return RB_REMOTE(remote, class);
+}
+
+static VALUE
+rb_gyruby_set_debug(VALUE self, VALUE arg) {
+  Check_Type(arg, T_FIXNUM);
+  usb_set_debug(NUM2INT(arg));
+  return arg;
+}
+
+static void
+c_remote_fetch_handle(c_remote *remote) {
+  if (remote->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);
+	}
+      }
+    }
+  }
+}
+
+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) {
+      char dname[32];
+      if (usb_get_driver_np(remote->handle, 1, dname, 31) == 0) {
+	if (usb_detach_kernel_driver_np(remote->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) {
+	    rb_raise(rb_eRuntimeError, "Failed claiming device. Succeded in detaching kernel driver for device. But still failed claiming device.");
+	  }
+	}
+      } else {
+	rb_raise(rb_eRuntimeError, "Failed claiming device. Also failed getting kernel driver for device.");
+      }
+    }
+  }
+}
+
+static gpointer
+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, 
+				   0x82, 
+				   inpacket, 
+				   PACKET_SIZE, 
+				   50);
+  if (result < 0 && result != -110) {
+    rb_raise(rb_eRuntimeError, "Got result %i.", result);
+  }
+  return handler(result, inpacket, user_data);
+}
+
+static Bool
+true_predicate(Display *display, XEvent *event, XPointer arg) {
+  return True;
+}
+
+static gpointer
+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;
+}
+
+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;
+  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)
+      return rval;
+    if (grab_handler != NULL && 
+	remote->display != NULL && 
+	(rval = c_remote_handle_grab_data(remote, grab_handler, user_data)) != NULL)
+      return rval;
+    rb_thread_wait_for(wait_time);
+  }
+  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 gpointer
+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);
+}
+
+static gpointer
+c_remote_call_grab_handler(gint x, gint y, 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);
+}
+
+static gpointer
+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);
+  } else {
+    return NULL;
+  }  
+}
+
+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);
+}
+
+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);
+}
+
+static VALUE
+rb_remote_subscribe(VALUE self, VALUE result_value, VALUE result_string, VALUE callback) {
+  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);
+}
+
+static VALUE
+rb_remote_subscriptions(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;
+}
+
+static VALUE
+rb_remote_get_grab(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);
+  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;
+}
+
+static VALUE
+rb_remote_release(VALUE self) {
+  c_remote *this;
+  C_REMOTE(self, this);
+  if (this->display == NULL)
+    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;
+  return self;
+}
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+  void Init_gyruby_ext() {
+    usb_init();
+    usb_find_busses();
+    usb_find_devices();
+
+    VALUE rb_gyruby = rb_define_module("Gyruby");
+    rb_define_singleton_method(rb_gyruby, "debug=", rb_gyruby_set_debug, 1);
+    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);
+  }
+#ifdef __cplusplus
+}
+#endif
+

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification 
+name: gyruby
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Martin Kihlgren
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-05-23 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: 
+email: gyruby at troja dot ath dot cx
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: []
+
+files: 
+- ext/extconf.rb
+- ext/gyruby_ext.c
+has_rdoc: true
+homepage: 
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: A ruby binding for the Gyration FiireChief remote control for LinuxMCE.
+test_files: []
+