phidgets 0.0.5 → 0.1.0

data/ext/phidgets/phidgets_text_led.c

@@ -0,0 +1,107 @@
+
+#include "phidgets.h"
+
+
+VALUE ph_textled_init(VALUE self);
+VALUE ph_textled_get_row_count(VALUE self);
+VALUE ph_textled_get_column_count(VALUE self);
+VALUE ph_textled_get_brightness(VALUE self);
+VALUE ph_textled_set_brightness(VALUE self, VALUE brightness);
+VALUE ph_textled_set_display_string(VALUE self, VALUE index, VALUE string);
+
+
+VALUE Init_phidgets_textled(VALUE ph_module, VALUE ph_common) {
+  VALUE ph_textled = rb_define_class_under(ph_module, "TextLED", ph_common);
+
+  /* Document-method: new
+   * call-seq: new
+   *
+   * Creates a Phidget TextLED object.
+   */
+  rb_define_method(ph_textled, "initialize", ph_textled_init, 0);
+
+  /* Document-method: getRowCount
+   * call-seq: getRowCount -> count
+   *
+   * Gets the number of rows supported by this display.
+   */
+  rb_define_method(ph_textled, "getRowCount", ph_textled_get_row_count, 0);
+
+  /* Document-method: getColumnCount
+   * call-seq: getColumnCount -> count
+   *
+   * Gets the number of columns per supported by this display.
+   */
+  rb_define_method(ph_textled, "getColumnCount", ph_textled_get_column_count, 0);
+
+  /* Document-method: getBrightness
+   * call-seq: getBrightness -> brightness
+   *
+   * Gets the last set brightness value.
+   */
+  rb_define_method(ph_textled, "getBrightness", ph_textled_get_brightness, 0);
+
+  /* Document-method: setBrightness
+   * call-seq: setBrightness(brightness)
+   *
+   * Sets the last set brightness value.
+   */
+  rb_define_method(ph_textled, "setBrightness", ph_textled_set_brightness, 1);
+
+  /* Document-method: setDisplayString
+   * call-seq: setDisplayString(index, string)
+   *
+   * Sets a row on the display.
+   */
+  rb_define_method(ph_textled, "setDisplayString", ph_textled_set_display_string, 2);
+
+  rb_define_alias(ph_textled, "row_count", "getRowCount");
+  rb_define_alias(ph_textled, "column_count", "getColumnCount");
+  rb_define_alias(ph_textled, "brightness", "getBrightness");
+  rb_define_alias(ph_textled, "brightness=", "setBrightness");
+  rb_define_alias(ph_textled, "display_string", "setDisplayString");
+
+  return ph_textled;
+}
+
+
+
+VALUE ph_textled_init(VALUE self) {
+  ph_data_t *ph = get_ph_data(self);
+  ph_raise(CPhidgetTextLED_create((CPhidgetTextLEDHandle *)(&(ph->handle))));
+  return self;
+}
+
+VALUE ph_textled_get_row_count(VALUE self) {
+  CPhidgetTextLEDHandle handle = (CPhidgetTextLEDHandle)get_ph_handle(self);
+  int count;
+  ph_raise(CPhidgetTextLED_getRowCount(handle, &count));
+  return INT2FIX(count);
+}
+
+VALUE ph_textled_get_column_count(VALUE self) {
+  CPhidgetTextLEDHandle handle = (CPhidgetTextLEDHandle)get_ph_handle(self);
+  int count;
+  ph_raise(CPhidgetTextLED_getColumnCount(handle, &count));
+  return INT2FIX(count);
+}
+
+VALUE ph_textled_get_brightness(VALUE self) {
+  CPhidgetTextLEDHandle handle = (CPhidgetTextLEDHandle)get_ph_handle(self);
+  int brightness;
+  ph_raise(CPhidgetTextLED_getBrightness(handle, &brightness));
+  return INT2FIX(brightness);
+}
+
+VALUE ph_textled_set_brightness(VALUE self, VALUE brightness) {
+  CPhidgetTextLEDHandle handle = (CPhidgetTextLEDHandle)get_ph_handle(self);
+  ph_raise(CPhidgetTextLED_setBrightness(handle, FIX2INT(brightness)));
+  return Qnil;
+}
+
+VALUE ph_textled_set_display_string(VALUE self, VALUE index, VALUE string) {
+  CPhidgetTextLEDHandle handle = (CPhidgetTextLEDHandle)get_ph_handle(self);
+  ph_raise(CPhidgetTextLED_setDisplayString(handle, FIX2INT(index), StringValueCStr(string)));
+  return Qnil;
+}
+

data/ext/phidgets/phidgets_weight_sensor.c

@@ -0,0 +1,113 @@
+
+#include "phidgets.h"
+
+
+VALUE ph_weight_init(VALUE self);
+VALUE ph_weight_get_weight(VALUE self);
+VALUE ph_weight_get_weight_change_trigger(VALUE self);
+VALUE ph_weight_set_weight_change_trigger(VALUE self, VALUE trigger);
+
+#ifdef PH_CALLBACK
+VALUE ph_weight_set_on_weight_change_handler(VALUE self, VALUE handler);
+int ph_weight_on_weight_change(CPhidgetWeightSensorHandle phid, void *userPtr, double weight);
+#endif
+
+
+VALUE Init_phidgets_weight(VALUE ph_module, VALUE ph_common) {
+  VALUE ph_weight = rb_define_class_under(ph_module, "WeightSensor", ph_common);
+
+  /* Document-method: new
+   * call-seq: new
+   *
+   * Creates a Phidget WeightSensor object.
+   */
+  rb_define_method(ph_weight, "initialize", ph_weight_init, 0);
+
+  /* Document-method: getWeight
+   * call-seq: getWeight -> weight
+   *
+   * Gets the sensed weight.
+   */
+  rb_define_method(ph_weight, "getWeight", ph_weight_get_weight, 0);
+
+  /* Document-method: getWeightChangeTrigger
+   * call-seq: getWeightChangeTrigger -> trigger
+   *
+   * Gets the weight change trigger.
+   */
+  rb_define_method(ph_weight, "getWeightChangeTrigger", ph_weight_get_weight_change_trigger, 0);
+
+  /* Document-method: setWeightChangeTrigger
+   * call-seq: setWeightChangeTrigger(trigger)
+   *
+   * Sets the weight change trigger.
+   */
+  rb_define_method(ph_weight, "setWeightChangeTrigger", ph_weight_set_weight_change_trigger, 1);
+
+#ifdef PH_CALLBACK
+  rb_define_private_method(ph_weight, "ext_setOnWeightChangeHandler", ph_weight_set_on_weight_change_handler, 1);
+#endif
+
+  rb_define_alias(ph_weight, "weight", "getWeight");
+  rb_define_alias(ph_weight, "weight_change_trigger", "getWeightChangeTrigger");
+  rb_define_alias(ph_weight, "weight_change_trigger=", "setWeightChangeTrigger");
+
+  return ph_weight;
+}
+
+
+
+VALUE ph_weight_init(VALUE self) {
+  ph_data_t *ph = get_ph_data(self);
+  ph_raise(CPhidgetWeightSensor_create((CPhidgetWeightSensorHandle *)(&(ph->handle))));
+  return self;
+}
+
+VALUE ph_weight_get_weight(VALUE self) {
+  CPhidgetWeightSensorHandle handle = (CPhidgetWeightSensorHandle)get_ph_handle(self);
+  double weight;
+  ph_raise(CPhidgetWeightSensor_getWeight(handle, &weight));
+  return rb_float_new(weight);
+}
+
+VALUE ph_weight_get_weight_change_trigger(VALUE self) {
+  CPhidgetWeightSensorHandle handle = (CPhidgetWeightSensorHandle)get_ph_handle(self);
+  double trigger;
+  ph_raise(CPhidgetWeightSensor_getWeightChangeTrigger(handle, &trigger));
+  return rb_float_new(trigger);
+}
+
+VALUE ph_weight_set_weight_change_trigger(VALUE self, VALUE trigger) {
+  CPhidgetWeightSensorHandle handle = (CPhidgetWeightSensorHandle)get_ph_handle(self);
+  ph_raise(CPhidgetWeightSensor_setWeightChangeTrigger(handle, NUM2DBL(trigger)));
+  return Qnil;
+}
+
+
+#ifdef PH_CALLBACK
+VALUE ph_weight_set_on_weight_change_handler(VALUE self, VALUE handler) {
+  ph_data_t *ph = get_ph_data(self);
+  ph_callback_data_t *callback_data = &ph->dev_callback_1;
+  if( TYPE(handler) == T_NIL ) {
+    callback_data->exit = true;
+    ph_raise(CPhidgetWeightSensor_set_OnWeightChange_Handler((CPhidgetWeightSensorHandle)ph->handle, NULL, (void *)NULL));
+  } else {
+    callback_data->called = false;
+    callback_data->exit = false;
+    callback_data->phidget = self;
+    callback_data->callback = handler;
+    ph_raise(CPhidgetWeightSensor_set_OnWeightChange_Handler((CPhidgetWeightSensorHandle)ph->handle, ph_weight_on_weight_change, (void *)callback_data));
+    ph_callback_thread(callback_data);
+  }
+  return Qnil;
+}
+
+
+int ph_weight_on_weight_change(CPhidgetWeightSensorHandle phid, void *userPtr, double weight) {
+  ph_callback_data_t *callback_data = ((ph_callback_data_t *)userPtr);
+  callback_data->called = true;
+  return EPHIDGET_OK;
+}
+
+#endif
+

data/lib/phidgets/accelerometer.rb

@@ -0,0 +1,25 @@
+
+
+module Phidgets
+  class Accelerometer < Common
+
+    unless RUBY_VERSION < '1.9.0'
+
+      # call-seq:
+      #   setOnAccelerationChangeHandler(proc=nil, &block)
+      #
+      # Sets an acceleration change event handler. This is called when the acceleration changes by more then the change trigger.
+      #
+      def setOnAccelerationChangeHandler(cb_proc = nil, &cb_block)
+        @on_acceleration_change_thread.kill if defined? @on_acceleration_change_thread
+        callback = cb_proc || cb_block
+        @on_acceleration_change_thread = Thread.new {ext_setOnAccelerationChangeHandler(callback)}
+      end
+
+      alias :on_acceleration_change :setOnAccelerationChangeHandler
+
+    end
+
+  end
+end
+

data/lib/phidgets/advanced_servo.rb

@@ -0,0 +1,49 @@
+
+
+module Phidgets
+  class AdvancedServo < Common
+
+    unless RUBY_VERSION < '1.9.0'
+
+      # call-seq:
+      #   setOnVelocityChangeHandler(proc=nil, &block)
+      #
+      # Sets a velocity change event handler. This is called when the velocity changes.
+      #
+      def setOnVelocityChangeHandler(cb_proc = nil, &cb_block)
+        @on_velocity_change_thread.kill if defined? @on_velocity_change_thread
+        callback = cb_proc || cb_block
+        @on_velocity_change_thread = Thread.new {ext_setOnVelocityChangeHandler(callback)}
+      end
+
+      # call-seq:
+      #   setOnPositionChangeHandler(proc=nil, &block)
+      #
+      # Sets a position change event handler. This is called when the position changes.
+      #
+      def setOnPositionChangeHandler(cb_proc = nil, &cb_block)
+        @on_position_change_thread.kill if defined? @on_position_change_thread
+        callback = cb_proc || cb_block
+        @on_position_change_thread = Thread.new {ext_setOnPositionChangeHandler(callback)}
+      end
+
+      # call-seq:
+      #   setOnCurrentChangeHandler(proc=nil, &block)
+      #
+      # Sets a current change event handler. This is called when the current draw changes.
+      #
+      def setOnCurrentChangeHandler(cb_proc = nil, &cb_block)
+        @on_current_change_thread.kill if defined? @on_current_change_thread
+        callback = cb_proc || cb_block
+        @on_current_change_thread = Thread.new {ext_setOnCurrentChangeHandler(callback)}
+      end
+
+      alias :on_velocity_change :setOnVelocityChangeHandler
+      alias :on_position_change :setOnPositionChangeHandler
+      alias :on_current_change :setOnCurrentChangeHandler
+
+    end
+
+  end
+end
+

data/lib/phidgets/analog.rb

@@ -0,0 +1,8 @@
+
+
+module Phidgets
+  class Analog < Common
+
+  end
+end
+

data/lib/phidgets/bridge.rb

@@ -0,0 +1,25 @@
+
+
+module Phidgets
+  class Bridge < Common
+
+    unless RUBY_VERSION < '1.9.0'
+
+      # call-seq:
+      #   setOnBridgeDataHandler(proc=nil, &block)
+      #
+      # Sets a bridge data event handler. This is called at a set rate as defined by data rate.
+      #
+      def setOnBridgeDataHandler(cb_proc = nil, &cb_block)
+        @on_bridge_data_thread.kill if defined? @on_bridge_data_thread
+        callback = cb_proc || cb_block
+        @on_bridge_data_thread = Thread.new {ext_setOnBridgeDataHandler(callback)}
+      end
+
+      alias :on_bridge_data :setOnBridgeDataHandler
+
+    end
+
+  end
+end
+

data/lib/phidgets/common.rb

@@ -1,200 +1,85 @@
 
 module Phidgets
-
-  extern "int CPhidget_open(void *, int)"
-  extern "int CPhidget_openRemote(void *, int, void *, void *)"
-  extern "int CPhidget_openRemoteIP(void *, int, void *, int, void *)"
-  extern "int CPhidget_close(void *)"
-  extern "int CPhidget_delete(void *)"
-  extern "int CPhidget_getDeviceName(void *, void *)"
-  extern "int CPhidget_getSerialNumber(void *, int *)"
-  extern "int CPhidget_getDeviceVersion(void *, int *)"
-  extern "int CPhidget_getDeviceStatus(void *, int *)"
-  extern "int CPhidget_getDeviceType(void *, void *)"
-  extern "int CPhidget_getDeviceLabel(void *, void *)"
-  extern "int CPhidget_setDeviceLabel(void *, void *)"
-  extern "int CPhidget_waitForAttachment(void *, int)"
-  extern "int CPhidget_getServerID(void *, void *)"
-  extern "int CPhidget_getServerAddress(void *, void *, int *)"
-  extern "int CPhidget_getServerStatus(void *, int *)"
-  extern "int CPhidget_getDeviceID(void *, int *)"
-  extern "int CPhidget_getDeviceClass(void *, int *)"
-
   class Common
 
-    # Opens a Phidget.
-    # === Parameters
-    # * _serial_number_ = Serial number. Specify -1 to open any.
-    # * _timeout_       = Time to wait for attachment. Specify 0 to not wait.
-    def open(serial_number=-1, timeout=0)
-      r = Phidgets.send(FUNCTION_PREFIX + 'Phidget_open', @handle, serial_number.to_i)
-      raise Phidgets::Exception.new(r) if r != 0
-      waitForAttachment(timeout) if timeout > 0
-    end
-
-    # Opens a Phidget remotely by ServerID. Note that this requires Bonjour (mDNS) to be running on both the host and the server.
-    # === Parameters
-    # * _serial_number_ = Serial number. Specify -1 to open any.
-    # * _server_        = Server ID. Specify nil to open any.
-    # * _password_      = Password. Can be nil if the server is running unsecured.
-    # * _timeout_       = Time to wait for attachment. Specify 0 to not wait.
-    def openRemote(serial_number=-1, server=nil, password=nil, timeout=0)
-      r = Phidgets.send(FUNCTION_PREFIX + 'Phidget_openRemote', @handle, serial_number.to_i, server, password)
-      raise Phidgets::Exception.new(r) if r != 0
-      waitForAttachment(timeout) if timeout > 0
-    end
-
-    # Opens a Phidget remotely by address and port.
-    # === Parameters
-    # * _serial_number_ = Serial number. Specify -1 to open any.
-    # * _address_       = Address. This can be a hostname or IP address.
-    # * _port_          = Port number. Default is 5001.
-    # * _password_      = Password. Can be nil if the server is running unsecured.
-    # * _timeout_       = Time to wait for attachment. Specify 0 to not wait.
-    def openRemoteIP(serial_number, address, port=5001, password=nil, timeout=0)
-      r = Phidgets.send(FUNCTION_PREFIX + 'Phidget_openRemoteIP', @handle, serial_number.to_i, address, port.to_i, password)
-      raise Phidgets::Exception.new(r) if r != 0
-      waitForAttachment(timeout) if timeout > 0
-    end
-
-    # Closes a Phidget.
-    def close
-      r = Phidgets.send(FUNCTION_PREFIX + 'Phidget_close', @handle)
-      raise Phidgets::Exception.new(r) if r != 0
-    end
-
-    # Frees a Phidget handle.
-    def delete
-      @handle.free = nil
-      r = Phidgets.send(FUNCTION_PREFIX + 'Phidget_delete', @handle)
-      raise Phidgets::Exception.new(r) if r != 0
-    end
-
-    # Gets the specific name of a Phidget.
-    def getDeviceName
-      ptr = Phidgets.malloc(SIZEOF_VOIDP)
-      r = Phidgets.send(FUNCTION_PREFIX + 'Phidget_getDeviceName', @handle, ptr.ref)
-      raise Phidgets::Exception.new(r) if r != 0
-      ptr.free = nil
-      ptr.to_s
-    end
-
-    # Gets the serial number of a Phidget.
-    def getSerialNumber
-      sn = Phidgets.malloc(SIZEOF_INT)
-      r = Phidgets.send(FUNCTION_PREFIX + 'Phidget_getSerialNumber', @handle, sn.ref)
-      raise Phidgets::Exception.new(r) if r != 0
-      sn.free = nil
-      sn.to_i
-    end
-
-    # Gets the firmware version of a Phidget.
-    def getDeviceVersion
-      ver = Phidgets.malloc(SIZEOF_INT)
-      r = Phidgets.send(FUNCTION_PREFIX + 'Phidget_getDeviceVersion', @handle, ver.ref)
-      raise Phidgets::Exception.new(r) if r != 0
-      ver.free = nil
-      ver.to_i
-    end
-
-    # Gets the attached status of a Phidget.
-    def getDeviceStatus
-      stat = Phidgets.malloc(SIZEOF_INT)
-      r = Phidgets.send(FUNCTION_PREFIX + 'Phidget_getDeviceStatus', @handle, stat.ref)
-      raise Phidgets::Exception.new(r) if r != 0
-      stat.free = nil
-      stat.to_i
-    end
-
-    # Gets the type (class) of a Phidget.
-    def getDeviceType
-      ptr = Phidgets.malloc(SIZEOF_VOIDP)
-      r = Phidgets.send(FUNCTION_PREFIX + 'Phidget_getDeviceType', @handle, ptr.ref)
-      raise Phidgets::Exception.new(r) if r != 0
-      ptr.free = nil
-      ptr.to_s
-    end
-
-    # Gets the label of a Phidget.
-    def getDeviceLabel
-      ptr = Phidgets.malloc(SIZEOF_VOIDP)
-      r = Phidgets.send(FUNCTION_PREFIX + 'Phidget_getDeviceLabel', @handle, ptr.ref)
-      raise Phidgets::Exception.new(r) if r != 0
-      ptr.free = nil
-      ptr.to_s
-    end
-
-    # Sets the label of a Phidget. Note that this is not supported on very old Phidgets, and not yet supported in Windows.
-    # === Parameters
-    # * _label_ = A string containing the label to be set.
-    def setDeviceLabel(label)
-      r = Phidgets.send(FUNCTION_PREFIX + 'Phidget_setDeviceLabel', @handle, label)
-      raise Phidgets::Exception.new(r) if r != 0
-    end
-
-    # Waits for attachment to happen. This can be called right after calling open, as an alternative to using the attach handler.
-    # === Parameters
-    # * _timeout_ = Time to wait for the attachment. Specify 0 to wait forever.
-    def waitForAttachment(timeout)
-      r = Phidgets.send(FUNCTION_PREFIX + 'Phidget_waitForAttachment', @handle, timeout.to_i)
-      raise Phidgets::Exception.new(r) if r != 0
-    end
-
-    # Gets the server ID of a remotely opened Phidget. This will fail if the Phidget was opened locally.
-    def getServerID
-      ptr = Phidgets.malloc(SIZEOF_VOIDP)
-      r = Phidgets.send(FUNCTION_PREFIX + 'Phidget_getServerID', @handle, ptr.ref)
-      raise Phidgets::Exception.new(r) if r != 0
-      ptr.free = nil
-      ptr.to_s
-    end
-
-    # Gets the address and port of a remotely opened Phidget. This will fail if the Phidget was opened locally.
-    def getServerAddress
-      ptr = Phidgets.malloc(SIZEOF_VOIDP)
-      port = Phidgets.malloc(SIZEOF_INT)
-      r = Phidgets.send(FUNCTION_PREFIX + 'Phidget_getServerAddress', @handle, ptr.ref, port.ref)
-      raise Phidgets::Exception.new(r) if r != 0
-      ptr.free = nil
-      port.free = nil
-      [ptr.to_s, port.to_i]
-    end
-
-    # Gets the connected to server status of a remotely opened Phidget. This will fail if the Phidget was opened locally.
-    def getServerStatus
-      stat = Phidgets.malloc(SIZEOF_INT)
-      r = Phidgets.send(FUNCTION_PREFIX + 'Phidget_getServerStatus', @handle, stat.ref)
-      raise Phidgets::Exception.new(r) if r != 0
-      stat.free = nil
-      stat.to_i
-    end
-
-    # Gets the device ID of a Phidget.
-    def getDeviceID
-      dev = Phidgets.malloc(SIZEOF_INT)
-      r = Phidgets.send(FUNCTION_PREFIX + 'Phidget_getDeviceID', @handle, dev.ref)
-      raise Phidgets::Exception.new(r) if r != 0
-      dev.free = nil
-      dev.to_i
-    end
+    # call-seq:
+    #   open(args)
+    #
+    # Opens a Phidget. Will attempt to make the correct open call (openLabel, openRemote, openRemoteIP, etc)
+    # based on the arguments passed in. Args can either be a serial number or a hash of arguments. If it is a
+    # hash, the following keys may be used: :serial_number, :label, :server_id, :address, :port, :password.
+    #
+    def open(args)
+      args = {:serial_number => args.to_i} unless args.is_a? Hash
+      if args.key? :server_id
+        return open_remote(args[:serial_number], args[:server_id], args[:password]) if args.key? :serial_number
+        return open_label_remote(args[:label], args[:server_id], args[:password]) if args.key? :label
+      elsif args.key? :address
+        return open_remote_ip(args[:serial_number], args[:address], args[:port], args[:password]) if args.key? :serial_number
+        return open_label_remote_ip(args[:label], args[:address], args[:port], args[:password]) if args.key? :label
+      else
+        return ext_open(args[:serial_number]) if args.key? :serial_number
+        return open_label(args[:label]) if args.key? :label
+      end
+      raise Phidgets::Error::InvalidArg.new
+    end
+
+
+    unless RUBY_VERSION < '1.9.0'
+
+      # call-seq:
+      #   setOnAttachHandler(proc=nil, &block)
+      #
+      # Sets an attach handler callback function. This is called when this Phidget is plugged into the system, and is ready for use.
+      #
+      def setOnAttachHandler(cb_proc = nil, &cb_block)
+        @on_attach_thread.kill if defined? @on_attach_thread
+        callback = cb_proc || cb_block
+        @on_attach_thread = Thread.new {ext_setOnAttachHandler(callback)}
+      end
+
+      # call-seq:
+      #   setOnDetachHandler(proc=nil, &block)
+      #
+      # Sets a detach handler callback function. This is called when this Phidget is unplugged from the system.
+      #
+      def setOnDetachHandler(cb_proc = nil, &cb_block)
+        @on_detach_thread.kill if defined? @on_detach_thread
+        callback = cb_proc || cb_block
+        @on_detach_thread = Thread.new {ext_setOnDetachHandler(callback)}
+      end
+
+      # call-seq:
+      #   setOnServerConnectHandler(proc=nil, &block)
+      #
+      # Sets a server connect handler callback function. This is used for opening Phidgets remotely,
+      # and is called when a connection to the sever has been made.
+      #
+      def setOnServerConnectHandler(cb_proc = nil, &cb_block)
+        @on_server_connect_thread.kill if defined? @on_server_connect_thread
+        callback = cb_proc || cb_block
+        @on_server_connect_thread = Thread.new {ext_setOnServerConnectHandler(callback)}
+      end
+
+      # call-seq:
+      #   setOnServerDisconnectHandler(proc=nil, &block)
+      #
+      # Sets a server disconnect handler callback function. This is used for opening Phidgets remotely,
+      # and is called when a connection to the server has been lost.
+      #
+      def setOnServerDisconnectHandler(cb_proc = nil, &cb_block)
+        @on_server_disconnect_thread.kill if defined? @on_server_disconnect_thread
+        callback = cb_proc || cb_block
+        @on_server_disconnect_thread = Thread.new {ext_setOnServerDisconnectHandler(callback)}
+      end
+
+      alias :on_attach :setOnAttachHandler
+      alias :on_detach :setOnDetachHandler
+      alias :on_server_connect :setOnServerConnectHandler
+      alias :on_server_disconnect :setOnServerDisconnectHandler
 
-    # Gets the class of a Phidget.
-    def getDeviceClass
-      dev = Phidgets.malloc(SIZEOF_INT)
-      r = Phidgets.send(FUNCTION_PREFIX + 'Phidget_getDeviceClass', @handle, dev.ref)
-      raise Phidgets::Exception.new(r) if r != 0
-      dev.free = nil
-      dev.to_i
-    end
-
-
-    private
-
-    def initialize
-      @handle = Phidgets.malloc(SIZEOF_VOIDP)
     end
 
   end
-
 end
 

data/lib/phidgets/dictionary.rb

@@ -0,0 +1,53 @@
+
+module Phidgets
+  class Dictionary
+
+    # call-seq:
+    #   open(args)
+    #
+    # Opens a Dictionary. Will attempt to make the correct open call (openRemote, openRemoteIP) based
+    # on the arguments passed in. Args is a hash and the following keys may be used:
+    # :server_id, :address, :port, :password.
+    #
+    def open(args)
+      if args.key? :server_id
+        return open_remote(args[:server_id], args[:password])
+      elsif args.key? :address
+        return open_remote_ip(args[:address], args[:port], args[:password])
+      end
+      raise Phidgets::Error::InvalidArg.new
+    end
+
+
+    unless RUBY_VERSION < '1.9.0'
+
+      # call-seq:
+      #   setOnServerConnectHandler(proc=nil, &block)
+      #
+      # Sets a server connect handler callback function. This is called when a connection to the sever has been made.
+      #
+      def setOnServerConnectHandler(cb_proc = nil, &cb_block)
+        @on_server_connect_thread.kill if defined? @on_server_connect_thread
+        callback = cb_proc || cb_block
+        @on_server_connect_thread = Thread.new {ext_setOnServerConnectHandler(callback)}
+      end
+
+      # call-seq:
+      #   setOnServerDisconnectHandler(proc=nil, &block)
+      #
+      # Sets a server disconnect handler callback function. This is called when a connection to the server has been lost.
+      #
+      def setOnServerDisconnectHandler(cb_proc = nil, &cb_block)
+        @on_server_disconnect_thread.kill if defined? @on_server_disconnect_thread
+        callback = cb_proc || cb_block
+        @on_server_disconnect_thread = Thread.new {ext_setOnServerDisconnectHandler(callback)}
+      end
+
+      alias :on_server_connect :setOnServerConnectHandler
+      alias :on_server_disconnect :setOnServerDisconnectHandler
+
+    end
+
+  end
+end
+