cwiid 0.1.0

data/README.md

@@ -0,0 +1,57 @@
+cwiid
+=====
+
+**Author**:       Jan Wedekind
+**Copyright**:    2010
+**License**:      GPL
+
+Synopsis
+--------
+
+This Ruby extension provides access to a Wii Remote via L. Donnie Smith's libcwiid.
+
+Installation
+------------
+
+To install this Ruby extension, use the following command:
+
+    $ sudo gem install cwiid
+
+Alternatively you can build and install the Ruby extension from source as follows:
+
+    $ rake
+    $ sudo rake install
+
+Usage
+-----
+
+Simply run Interactive Ruby:
+
+    $ irb
+
+Here's a small example displaying the state of the accelerometer:
+
+    #!/usr/bin/env ruby
+    require 'rubygems'
+    require 'cwiid'
+    require 'hornetseye_rmagick'
+    require 'hornetseye_xorg'
+    include Hornetseye
+    include Magick
+    wiimote = WiiMote.new
+    X11Display.show do |display|
+      display.status = wiimote.buttons != WiiMote::BTN_1
+      wiimote.get_state
+      acc = wiimote.acc
+      image = Image.new 240, 240, HatchFill.new( 'white', 'lightcyan2' )
+      gc = Draw.new
+      gc.fill_opacity 0
+      gc.stroke_width 2
+      gc.stroke 'red'
+      gc.line 120, 120, acc[0], acc[2]
+      gc.stroke 'green'
+      gc.line 120, 120, acc[1], acc[2]
+      gc.draw image
+      image.to_multiarray
+    end
+

data/Rakefile

@@ -0,0 +1,177 @@
+#!/usr/bin/env ruby
+require 'date'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rake/loaders/makefile'
+require 'rbconfig'
+
+PKG_NAME = 'cwiid'
+PKG_VERSION = '0.1.0'
+CFG = RbConfig::CONFIG
+CXX = ENV[ 'CXX' ] || 'g++'
+RB_FILES = FileList[ 'lib/**/*.rb' ]
+CC_FILES = FileList[ 'ext/*.cc' ]
+HH_FILES = FileList[ 'ext/*.hh' ] + FileList[ 'ext/*.tcc' ]
+TC_FILES = FileList[ 'test/tc_*.rb' ]
+TS_FILES = FileList[ 'test/ts_*.rb' ]
+SO_FILE = "ext/cwiid.#{CFG[ 'DLEXT' ]}"
+PKG_FILES = [ 'Rakefile', 'README.md', 'COPYING', '.document' ] +
+            RB_FILES + CC_FILES + HH_FILES + TS_FILES + TC_FILES
+BIN_FILES = [ 'README.md', 'COPYING', '.document', SO_FILE ] +
+            RB_FILES + TS_FILES + TC_FILES
+SUMMARY = %q{Using the Wii Remote with Ruby}
+DESCRIPTION = %q{This Ruby extension provides an inerface to access a Wii Remote using the libcwiid library.}
+AUTHOR = %q{Jan Wedekind}
+EMAIL = %q{jan@wedesoft.de}
+HOMEPAGE = %q{http://wedesoft.github.com/cwiid/}
+
+OBJ = CC_FILES.ext 'o'
+$CXXFLAGS = "-DNDEBUG #{CFG[ 'CPPFLAGS' ]} #{CFG[ 'CFLAGS' ]}"
+if CFG[ 'rubyhdrdir' ]
+  $CXXFLAGS = "#{$CXXFLAGS} -I#{CFG[ 'rubyhdrdir' ]} " + 
+              "-I#{CFG[ 'rubyhdrdir' ]}/#{CFG[ 'arch' ]}"
+else
+  $CXXFLAGS = "#{$CXXFLAGS} -I#{CFG[ 'archdir' ]}"
+end
+$LIBRUBYARG = "-L#{CFG[ 'libdir' ]} #{CFG[ 'LIBRUBYARG' ]} #{CFG[ 'LDFLAGS' ]} " +
+              "#{CFG[ 'SOLIBS' ]} #{CFG[ 'DLDLIBS' ]}"
+$SITELIBDIR = CFG[ 'sitelibdir' ]
+$SITEARCHDIR = CFG[ 'sitearchdir' ]
+$LDSHARED = CFG[ 'LDSHARED' ][ CFG[ 'LDSHARED' ].index( ' ' ) .. -1 ]
+
+task :default => :all
+
+desc 'Compile Ruby extension (default)'
+task :all => [ SO_FILE ]
+
+file SO_FILE => OBJ do |t|
+   sh "#{CXX} -shared -o #{t.name} #{OBJ} -lcwiid #{$LIBRUBYARG}"
+end
+
+task :test => [ SO_FILE ]
+
+desc 'Install Ruby extension'
+task :install => :all do
+  verbose true do
+    for f in RB_FILES do
+      FileUtils.mkdir_p "#{$SITELIBDIR}/#{File.dirname f.gsub( /^lib\//, '' )}"
+      FileUtils.cp_r f, "#{$SITELIBDIR}/#{f.gsub( /^lib\//, '' )}"
+    end
+    FileUtils.mkdir_p $SITEARCHDIR
+    FileUtils.cp SO_FILE, "#{$SITEARCHDIR}/#{File.basename SO_FILE}"
+  end
+end
+
+desc 'Uninstall Ruby extension'
+task :uninstall do
+  verbose true do
+    for f in RB_FILES do
+      FileUtils.rm_f "#{$SITELIBDIR}/#{f.gsub /^lib\//, ''}"
+    end
+    FileUtils.rm_f "#{$SITEARCHDIR}/#{File.basename SO_FILE}"
+  end
+end
+
+Rake::TestTask.new do |t|
+  t.libs << 'ext'
+  t.test_files = TC_FILES
+end
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new :yard do |y|
+    y.options << '--no-private'
+    y.files << FileList[ 'lib/**/*.rb' ]
+  end
+rescue LoadError
+  STDERR.puts 'Please install \'yard\' if you want to generate documentation'
+end
+
+Rake::PackageTask.new PKG_NAME, PKG_VERSION do |p|
+  p.need_tar = true
+  p.package_files = PKG_FILES
+end
+
+begin
+  require 'rubygems'
+  require 'rubygems/builder'
+  $SPEC = Gem::Specification.new do |s|
+    s.name = PKG_NAME
+    s.version = PKG_VERSION
+    s.platform = Gem::Platform::RUBY
+    s.date = Date.today.to_s
+    s.summary = SUMMARY
+    s.description = DESCRIPTION
+    s.author = AUTHOR
+    s.email = EMAIL
+    s.homepage = HOMEPAGE
+    s.files = PKG_FILES
+    s.test_files = TC_FILES
+    s.require_paths = [ 'lib', 'ext' ]
+    s.extensions = %w{Rakefile}
+    s.has_rdoc = 'yard'
+    s.extra_rdoc_files = []
+    s.rdoc_options = %w{--no-private}
+    s.add_development_dependency %q{rake}
+  end
+  GEM_SOURCE = "#{PKG_NAME}-#{PKG_VERSION}.gem"
+  $BINSPEC = Gem::Specification.new do |s|
+    s.name = PKG_NAME
+    s.version = PKG_VERSION
+    s.platform = Gem::Platform::CURRENT
+    s.date = Date.today.to_s
+    s.summary = SUMMARY
+    s.description = DESCRIPTION
+    s.author = AUTHOR
+    s.email = EMAIL
+    s.homepage = HOMEPAGE
+    s.files = BIN_FILES
+    s.test_files = TC_FILES
+    s.require_paths = [ 'lib', 'ext' ]
+    s.has_rdoc = 'yard'
+    s.extra_rdoc_files = []
+    s.rdoc_options = %w{--no-private}
+  end
+  GEM_BINARY = "#{PKG_NAME}-#{PKG_VERSION}-#{$BINSPEC.platform}.gem"
+  desc "Build the gem file #{GEM_SOURCE}"
+  task :gem => [ "pkg/#{GEM_SOURCE}" ]
+  file "pkg/#{GEM_SOURCE}" => [ 'pkg' ] + $SPEC.files do
+    when_writing 'Creating GEM' do
+      Gem::Builder.new( $SPEC ).build
+      verbose true do
+        FileUtils.mv GEM_SOURCE, "pkg/#{GEM_SOURCE}"
+      end
+    end
+  end
+  desc "Build the gem file #{GEM_BINARY}"
+  task :gem_binary => [ "pkg/#{GEM_BINARY}" ]
+  file "pkg/#{GEM_BINARY}" => [ 'pkg' ] + $BINSPEC.files do
+    when_writing 'Creating binary GEM' do
+      Gem::Builder.new( $BINSPEC ).build
+      verbose true do
+        FileUtils.mv GEM_BINARY, "pkg/#{GEM_BINARY}"
+      end
+    end
+  end
+rescue LoadError
+  STDERR.puts 'Please install \'rubygems\' if you want to create Gem packages'
+end
+
+rule '.o' => '.cc' do |t|
+   sh "#{CXX} #{$CXXFLAGS} -c -o #{t.name} #{t.source}"
+end
+
+file ".depends.mf" do |t|
+  sh "g++ -MM #{CC_FILES.join ' '} | " +
+    "sed -e :a -e N -e 's/\\n/\\$/g' -e ta | " +
+    "sed -e 's/ *\\\\\\$ */ /g' -e 's/\\$/\\n/g' | sed -e 's/^/ext\\//' > #{t.name}"
+end
+CC_FILES.each do |t|
+  file t.ext(".o") => t
+end
+import ".depends.mf"
+
+CLEAN.include 'ext/*.o'
+CLOBBER.include SO_FILE, 'doc', '.yardoc', '.depends.mf'
+

data/ext/error.hh

@@ -0,0 +1,50 @@
+/* HornetsEye - Computer Vision with Ruby
+   Copyright (C) 2006, 2007, 2008, 2009, 2010   Jan Wedekind
+
+   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 3 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, see <http://www.gnu.org/licenses/>. */
+#ifndef ERROR_HH
+#define ERROR_HH
+
+#include <exception>
+#include <sstream>
+
+class Error: public std::exception
+{
+public:
+  Error(void) {}
+  Error( Error &e ): std::exception( e )
+    { m_message << e.m_message.str(); }
+  virtual ~Error(void) throw() {}
+  template< typename T >
+  std::ostream &operator<<( const T &t )
+    { m_message << t; return m_message; }
+  std::ostream &operator<<( std::ostream& (*__pf)(std::ostream&) )
+    { (*__pf)( m_message ); return m_message; }
+  virtual const char* what(void) const throw() {
+    temp = m_message.str();
+    return temp.c_str();
+  }
+protected:
+  std::ostringstream m_message;
+  mutable std::string temp;
+};
+
+#define ERRORMACRO( condition, class, params, message ) \
+  if ( !( condition ) ) {                               \
+    class _e params;                                    \
+    _e << message;                                      \
+    throw _e;                                           \
+  };
+
+#endif

data/ext/init.cc

@@ -0,0 +1,35 @@
+/* ruby-cwiid - Wii Remote interface.
+   Copyright (C) 2010 Jan Wedekind
+
+   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 3 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, see <http://www.gnu.org/licenses/>. */
+#include "wiimote.hh"
+#ifdef WIN32
+#define DLLEXPORT __declspec(dllexport)
+#define DLLLOCAL
+#else
+#define DLLEXPORT __attribute__ ((visibility("default")))
+#define DLLLOCAL __attribute__ ((visibility("hidden")))
+#endif
+
+extern "C" DLLEXPORT void Init_cwiid(void);
+
+extern "C" {
+
+  void Init_cwiid(void)
+  {
+    WiiMote::registerRubyClass();
+    rb_require( "cwiid_ext.rb" );
+  }
+
+}

data/ext/rubyinc.hh

@@ -0,0 +1,54 @@
+/* HornetsEye - Computer Vision with Ruby
+   Copyright (C) 2006, 2007   Jan Wedekind
+
+   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 3 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, see <http://www.gnu.org/licenses/>. */
+#ifndef HORNETSEYE_RUBYINC_HH
+#define HORNETSEYE_RUBYINC_HH
+
+#ifdef RSHIFT
+#undef RSHIFT
+#endif
+
+#define gettimeofday rubygettimeofday
+#define timezone rubygettimezone
+#include <ruby.h>
+// #include <version.h>
+#undef timezone
+#undef gettimeofday
+#ifdef read
+#undef read
+#endif
+#ifdef write
+#undef write
+#endif
+#ifdef RGB
+#undef RGB
+#endif
+
+#ifndef RUBY_VERSION_NUMBER
+#define RUBY_VERSION_NUMBER ( RUBY_VERSION_MAJOR * 10000 + \
+                              RUBY_VERSION_MINOR * 100 + \
+                              RUBY_VERSION_TEENY )
+#endif
+
+#ifndef RUBY_METHOD_FUNC
+#define RUBY_METHOD_FUNC(func) ((VALUE (*)(ANYARGS))func)
+#endif
+
+#ifndef xfree
+#define xfree free
+#endif
+
+#endif
+

data/ext/wiimote.cc

@@ -0,0 +1,333 @@
+/* ruby-cwiid - Wii Remote interface.
+   Copyright (C) 2010 Jan Wedekind
+
+   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 3 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, see <http://www.gnu.org/licenses/>. */
+#include "wiimote.hh"
+
+using namespace std;
+
+VALUE WiiMote::cRubyClass = Qnil;
+
+WiiMote *WiiMote::current = NULL;
+
+static void staticErr( cwiid_wiimote_t *wiimote, const char *s, va_list ap )
+{
+  WiiMote::current->err( s, ap );
+}
+
+WiiMote::WiiMote(void) throw (Error):
+  m_wiimote(NULL), m_error(false)
+{
+  bdaddr_t bdaddrAny = { { 0, 0, 0, 0, 0, 0 } };
+  current = this;
+  cwiid_set_err( staticErr );
+  memset( &m_state, 0, sizeof(m_state) );
+  m_wiimote = cwiid_open( &bdaddrAny, 0 );
+  ERRORMACRO( !m_error, Error, , "Failed to connect to Wii Remote: "
+              << m_errorMsg );
+}
+
+WiiMote::~WiiMote(void)
+{
+  close();
+}
+
+void WiiMote::close(void)
+{
+  if ( m_wiimote != NULL ) {
+    cwiid_close( m_wiimote );
+    m_wiimote = NULL;
+    current = NULL;
+    cwiid_set_err( cwiid_err_default );
+  };
+}
+
+void WiiMote::requestStatus(void) throw (Error)
+{
+  m_error = false;
+  cwiid_request_status( m_wiimote );
+  ERRORMACRO( !m_error, Error, , "Status request error: " << m_errorMsg );
+}
+
+void WiiMote::getState(void) throw (Error)
+{
+  m_error = false;
+  cwiid_get_state( m_wiimote, &m_state );
+  ERRORMACRO( !m_error, Error, , "Error getting state: " << m_errorMsg );
+}
+
+unsigned char WiiMote::getRptMode(void)
+{
+  return m_state.rpt_mode;
+}
+
+void WiiMote::setRptMode( unsigned char mode ) throw (Error)
+{
+  m_error = false;
+  cwiid_set_rpt_mode( m_wiimote, mode );
+  ERRORMACRO( !m_error, Error, , "Error setting RPT mode: " << m_errorMsg );
+  m_state.rpt_mode = mode;
+}
+
+unsigned char WiiMote::getBattery(void)
+{
+  return m_state.battery;
+}
+
+unsigned char WiiMote::getLED(void)
+{
+  return m_state.led;
+}
+
+void WiiMote::setLED( unsigned char state ) throw (Error)
+{
+  m_error = false;
+  cwiid_set_led( m_wiimote, state );
+  ERRORMACRO( !m_error, Error, , "Error setting LED state: " << m_errorMsg );
+  m_state.led = state;
+}
+
+bool WiiMote::getRumble(void)
+{
+  return m_state.rumble != 0;
+}
+
+void WiiMote::setRumble( bool state ) throw( Error )
+{
+  m_error = false;
+  cwiid_set_rumble( m_wiimote, state ? 1 : 0 );
+  ERRORMACRO( !m_error, Error, , "Error setting rumble state: " << m_errorMsg );
+  m_state.rumble = state ? 1 : 0;
+}
+
+unsigned short int WiiMote::getButtons(void)
+{
+  return m_state.buttons;
+}
+
+unsigned char WiiMote::getAcc( int id )
+{
+  return m_state.acc[ id ];
+}
+
+bool WiiMote::irValid( int i )
+{
+  return m_state.ir_src[ i ].valid != 0;
+}
+
+unsigned short int WiiMote::getIRX( int i )
+{
+  return m_state.ir_src[ i ].pos[ CWIID_X ];
+}
+
+unsigned short int WiiMote::getIRY( int i )
+{
+  return m_state.ir_src[ i ].pos[ CWIID_Y ];
+}
+
+char WiiMote::getIRSize( int i )
+{
+  return m_state.ir_src[ i ].size;
+}
+
+void WiiMote::err( const char *s, va_list ap )
+{
+  char buffer[4096];
+  vsnprintf( &buffer[0], sizeof(buffer), s, ap );
+  m_errorMsg = buffer;
+  m_error = true;
+}
+
+VALUE WiiMote::registerRubyClass(void)
+{
+  cRubyClass = rb_define_class( "WiiMote", rb_cObject );
+  rb_define_const( cRubyClass, "RPT_STATUS", INT2NUM( CWIID_RPT_STATUS ) );
+  rb_define_const( cRubyClass, "RPT_BTN", INT2NUM( CWIID_RPT_BTN ) );
+  rb_define_const( cRubyClass, "RPT_ACC", INT2NUM( CWIID_RPT_ACC ) );
+  rb_define_const( cRubyClass, "RPT_IR", INT2NUM( CWIID_RPT_IR ) );
+  rb_define_const( cRubyClass, "RPT_NUNCHUK", INT2NUM( CWIID_RPT_NUNCHUK ) );
+  rb_define_const( cRubyClass, "RPT_CLASSIC", INT2NUM( CWIID_RPT_CLASSIC ) );
+  rb_define_const( cRubyClass, "RPT_BALANCE", INT2NUM( CWIID_RPT_BALANCE ) );
+  rb_define_const( cRubyClass, "RPT_MOTIONPLUS", INT2NUM( CWIID_RPT_MOTIONPLUS ) );
+  rb_define_const( cRubyClass, "BTN_2", INT2NUM( CWIID_BTN_2 ) );
+  rb_define_const( cRubyClass, "BTN_1", INT2NUM( CWIID_BTN_1 ) );
+  rb_define_const( cRubyClass, "BTN_B", INT2NUM( CWIID_BTN_B ) );
+  rb_define_const( cRubyClass, "BTN_A", INT2NUM( CWIID_BTN_A ) );
+  rb_define_const( cRubyClass, "BTN_MINUS", INT2NUM( CWIID_BTN_MINUS ) );
+  rb_define_const( cRubyClass, "BTN_HOME", INT2NUM( CWIID_BTN_HOME ) );
+  rb_define_const( cRubyClass, "BTN_LEFT", INT2NUM( CWIID_BTN_LEFT ) );
+  rb_define_const( cRubyClass, "BTN_RIGHT", INT2NUM( CWIID_BTN_RIGHT ) );
+  rb_define_const( cRubyClass, "BTN_DOWN", INT2NUM( CWIID_BTN_DOWN ) );
+  rb_define_const( cRubyClass, "BTN_UP", INT2NUM( CWIID_BTN_UP ) );
+  rb_define_const( cRubyClass, "BTN_PLUS", INT2NUM( CWIID_BTN_PLUS ) );
+  rb_define_const( cRubyClass, "LED1_ON", INT2NUM( CWIID_LED1_ON ) );
+  rb_define_const( cRubyClass, "LED2_ON", INT2NUM( CWIID_LED2_ON ) );
+  rb_define_const( cRubyClass, "LED3_ON", INT2NUM( CWIID_LED3_ON ) );
+  rb_define_const( cRubyClass, "LED4_ON", INT2NUM( CWIID_LED4_ON ) );
+  rb_define_const( cRubyClass, "BATTERY_MAX", INT2NUM( CWIID_BATTERY_MAX ) );
+  rb_define_singleton_method( cRubyClass, "new",
+                              RUBY_METHOD_FUNC( wrapNew ), 0 );
+  rb_define_method( cRubyClass, "close",
+                    RUBY_METHOD_FUNC( wrapClose ), 0 );
+  rb_define_method( cRubyClass, "request_status",
+                    RUBY_METHOD_FUNC( wrapRequestStatus ), 0 );
+  rb_define_method( cRubyClass, "get_state",
+                    RUBY_METHOD_FUNC( wrapGetState ), 0 );
+  rb_define_method( cRubyClass, "rpt_mode",
+                    RUBY_METHOD_FUNC( wrapGetRptMode ), 0 );
+  rb_define_method( cRubyClass, "rpt_mode=",
+                    RUBY_METHOD_FUNC( wrapSetRptMode ), 1 );
+  rb_define_method( cRubyClass, "battery",
+                    RUBY_METHOD_FUNC( wrapGetBattery ), 0 );
+  rb_define_method( cRubyClass, "led",
+                    RUBY_METHOD_FUNC( wrapGetLED ), 0 );
+  rb_define_method( cRubyClass, "led=",
+                    RUBY_METHOD_FUNC( wrapSetLED ), 1 );
+  rb_define_method( cRubyClass, "rumble",
+                    RUBY_METHOD_FUNC( wrapGetRumble ), 0 );
+  rb_define_method( cRubyClass, "rumble=",
+                    RUBY_METHOD_FUNC( wrapSetRumble ), 1 );
+  rb_define_method( cRubyClass, "buttons",
+                    RUBY_METHOD_FUNC( wrapGetButtons ), 0 );
+  rb_define_method( cRubyClass, "acc",
+                    RUBY_METHOD_FUNC( wrapGetAcc ), 0 );
+  rb_define_method( cRubyClass, "ir",
+                    RUBY_METHOD_FUNC( wrapGetIR ), 0 );
+  return cRubyClass;
+}
+
+void WiiMote::deleteRubyObject( void *ptr )
+{
+  delete (WiiMotePtr *)ptr;
+}
+
+VALUE WiiMote::wrapNew( VALUE rbClass )
+{
+  VALUE retVal = Qnil;
+  try {
+    WiiMotePtr ptr( new WiiMote );
+    retVal = Data_Wrap_Struct( rbClass, 0, deleteRubyObject,
+                               new WiiMotePtr( ptr ) );
+  } catch ( exception &e ) {
+    rb_raise( rb_eRuntimeError, "%s", e.what() );
+  };
+  return retVal;
+}
+
+VALUE WiiMote::wrapClose( VALUE rbSelf )
+{
+  WiiMotePtr *self; Data_Get_Struct( rbSelf, WiiMotePtr, self );
+  (*self)->close();
+  return rbSelf;
+}
+
+VALUE WiiMote::wrapRequestStatus( VALUE rbSelf )
+{
+  WiiMotePtr *self; Data_Get_Struct( rbSelf, WiiMotePtr, self );
+  (*self)->requestStatus();
+  return rbSelf;
+}
+
+VALUE WiiMote::wrapGetState( VALUE rbSelf )
+{
+  WiiMotePtr *self; Data_Get_Struct( rbSelf, WiiMotePtr, self );
+  (*self)->getState();
+  return rbSelf;
+}
+
+VALUE WiiMote::wrapGetRptMode( VALUE rbSelf )
+{
+  WiiMotePtr *self; Data_Get_Struct( rbSelf, WiiMotePtr, self );
+  (*self)->getRptMode();
+  return rbSelf;
+}
+
+VALUE WiiMote::wrapSetRptMode( VALUE rbSelf, VALUE rbMode )
+{
+  try {
+    WiiMotePtr *self; Data_Get_Struct( rbSelf, WiiMotePtr, self );
+    (*self)->setRptMode( NUM2INT( rbMode ) );
+  } catch ( exception &e ) {
+    rb_raise( rb_eRuntimeError, "%s", e.what() );
+  };
+  return rbMode;
+}  
+
+VALUE WiiMote::wrapGetBattery( VALUE rbSelf )
+{
+  WiiMotePtr *self; Data_Get_Struct( rbSelf, WiiMotePtr, self );
+  return INT2NUM( (*self)->getBattery() );
+}  
+
+VALUE WiiMote::wrapGetLED( VALUE rbSelf )
+{
+  WiiMotePtr *self; Data_Get_Struct( rbSelf, WiiMotePtr, self );
+  return INT2NUM( (*self)->getLED() );
+}  
+
+VALUE WiiMote::wrapSetLED( VALUE rbSelf, VALUE rbState )
+{
+  try {
+    WiiMotePtr *self; Data_Get_Struct( rbSelf, WiiMotePtr, self );
+    (*self)->setLED( NUM2INT( rbState ) );
+  } catch ( exception &e ) {
+    rb_raise( rb_eRuntimeError, "%s", e.what() );
+  };
+  return rbState;
+}  
+
+VALUE WiiMote::wrapGetRumble( VALUE rbSelf )
+{
+  WiiMotePtr *self; Data_Get_Struct( rbSelf, WiiMotePtr, self );
+  return (*self)->getRumble() ? Qtrue : Qfalse;
+}  
+
+VALUE WiiMote::wrapSetRumble( VALUE rbSelf, VALUE rbState )
+{
+  try {
+    WiiMotePtr *self; Data_Get_Struct( rbSelf, WiiMotePtr, self );
+    (*self)->setRumble( rbState == Qtrue );
+  } catch ( exception &e ) {
+    rb_raise( rb_eRuntimeError, "%s", e.what() );
+  };
+  return rbState;
+}  
+
+VALUE WiiMote::wrapGetButtons( VALUE rbSelf )
+{
+  WiiMotePtr *self; Data_Get_Struct( rbSelf, WiiMotePtr, self );
+  return INT2NUM( (*self)->getButtons() );
+}  
+
+VALUE WiiMote::wrapGetAcc( VALUE rbSelf )
+{
+  WiiMotePtr *self; Data_Get_Struct( rbSelf, WiiMotePtr, self );
+  return rb_ary_new3( 3, INT2NUM( (*self)->getAcc( 0 ) ),
+                         INT2NUM( (*self)->getAcc( 1 ) ),
+                         INT2NUM( (*self)->getAcc( 2 ) ) );
+}  
+
+VALUE WiiMote::wrapGetIR( VALUE rbSelf )
+{
+  VALUE rbRetVal = rb_ary_new();
+  WiiMotePtr *self; Data_Get_Struct( rbSelf, WiiMotePtr, self );
+  for ( int i=0; i<CWIID_IR_SRC_COUNT; i++ )
+    if ( (*self)->irValid( i ) )
+      rb_ary_push( rbRetVal, rb_ary_new3( 3,
+                                          INT2NUM( (*self)->getIRX( i ) ),
+                                          INT2NUM( (*self)->getIRY( i ) ),
+                                          INT2NUM( (*self)->getIRSize( i ) ) ) );
+  return rbRetVal;
+}
+