ripped out old method of get events and build whole new method which should use a lot less CPU; its now based on arrays of structs that are built before running. There is a 2D array for (device,element) struct, t_hid_element, which holds the output symbols, thus eliminating symbol lookups for each event that is outputted; its Mac OS X only write now, GNU/Linux will come eventually...

svn path=/trunk/externals/hcs/hid/; revision=5156

7 files changed, 1405 insertions, 1254 deletions

diff --git a/Makefile b/Makefile
index a13265f..f474aee 100644
--- a/Makefile
+++ b/Makefile
@@ -13,3 +13,7 @@ clean:
 test_locations:
 	make -C $(EXTERNALS_ROOT) test_locations
 
+# for emacs
+etags:
+	etags *.[ch] linux/input.h HID\ Utilities\ Source/*.[ch] \
+		/System/Library/Frameworks/IOKit.framework/Headers/hid*/*.[ch]
diff --git a/TODO b/TODO
index 66a26dd..4cf35cf 100644
--- a/TODO
+++ b/TODO
@@ -1,6 +1,57 @@
 
+- fix up hatswitch logic... hmmm
+  on Mac OS X, just make the next element in the array always be the Y axis of
+  the hatswitch, then when receiving a hatswitch event, output, increment,
+  then output again (yes, its a hack).
 
-==============================================================================
+- add device type to [info(
+HIDGetUsageName(pCurrentHIDDevice->usagePage, pCurrentHIDDevice->usage, cstrDeviceName);
+
+i.e. cstrDeviceName
+
+
+
+
+______________________________________________________________________________
+= array lookups for symbols
+
+- make arrays to lookup symbols by usagepage# and usage#
+
+- advantage: much fewer symbol lookups
+
+- disadvantage: much more RAM used.
+
+implementation idea #1:
+
+make hid-specific gensym() function which checks an array for the symbol by
+#.  If it doesn't exist, it looks up the symbol and adds it to the array.  The
+array size should be dynamically allocated so that [hid] doesn't use massive
+amounts of memory.
+
+If no vendor-defined pages are used, then the array could be quite small.  If
+only one usage page is used, then it would also be not too big.  Otherwise, it
+could use 10+ megs of RAM... hmm..
+
+implementation idea #2:
+
+this array should be built by hid_build_elements_list().  Then each time it
+fetches an event using the element_pointer array, it would also get the stored
+usage_page and usage symbols, and instance t_float.  So I need to make an
+element struct like:
+
+struct _hid_element
+{
+		  void *element;
+		  t_symbol *type; // HID "usage page"
+		  t_symbol *usage; // Linux "code"
+		  t_float instance;
+		  t_float previous_value; //only output on change on abs and buttons
+} t_hid_element;
+
+For Linux input.h, instead void *element, store the type and code numbers to
+compare against
+
+______________________________________________________________________________
 = output one value per poll
 
 - for relative axes, sum up all events and output one
@@ -11,10 +62,18 @@ http://lists.apple.com/archives/mac-games-dev/2005/Oct/msg00060.html
 
 - buttons, output everything
 
-- is this at all necessary?  How often do multiple events happen in one poll period?
+- is this at all necessary?  How often do multiple events happen in one poll
+  period?  ANSWER: on Mac OS X, most hid_get_events() calls fetch multiple
+  events for each mouse axis, so yes, its probably necessary
 
 
-==============================================================================
+______________________________________________________________________________
+= [poll 1( message set to exact delay based on block size
+
+to eliminate the jitter of the messages being processed every block, have
+[poll 1( set the time to the poll size (~1.5ms for 44,100)
+
+______________________________________________________________________________
 = iterate through elements and do a proper queue of the ones we want:
 
 - also, label multiple instances of the same usage
@@ -22,11 +81,11 @@ http://lists.apple.com/archives/mac-games-dev/2005/Oct/msg00060.html
 http://mud.5341.com/msg/8455.html
 
 
-==============================================================================
+______________________________________________________________________________
 = make second inlet for poll # (for [human->pd])
 
 
-==============================================================================
+______________________________________________________________________________
 = output device data on open
 
 - Logical Min/Max i.e. [range -127 127(
@@ -34,13 +93,13 @@ http://mud.5341.com/msg/8455.html
 
 
 
-==============================================================================
+______________________________________________________________________________
 = open devices by name
 
 i.e "Trackpad" a la Max's [hi]
 
 
-==============================================================================
+______________________________________________________________________________
 = 
 = autoscaling based on Logical min/max
 
@@ -49,9 +108,9 @@ i.e "Trackpad" a la Max's [hi]
 
 - output would be handy, rather than autoscale, to save on CPU
 
+- this should probably be done in Pd space
 
-
-==============================================================================
+______________________________________________________________________________
 = test verbose names
 
 - matju says symbols are compared by pointer, so they are fast
@@ -75,13 +134,13 @@ i.e "Trackpad" a la Max's [hi]
 - change word "code" to "element"
 
 
-==============================================================================
+______________________________________________________________________________
 = event name changes
 
 - make key/button Type "button" rather than "key" (undecided on this one)
 
 
-==============================================================================
+______________________________________________________________________________
 = hid/serial
 
 - open/close status outlet
@@ -91,7 +150,7 @@ i.e "Trackpad" a la Max's [hi]
 - [tgl] 1/0 for open/close
 
 
-==============================================================================
+______________________________________________________________________________
 = linux input synch events (EV_SYN)
 
 - these seem to be generated by the Linux kernel, so they probably don't fit
@@ -100,21 +159,26 @@ i.e "Trackpad" a la Max's [hi]
   data, as they are intended.
 
 
+______________________________________________________________________________
+= writing support!
+
+- Linux example: http://www.linuxjournal.com/article/6429
+
 
-==============================================================================
+______________________________________________________________________________
 = profile [hid] object and usage
 
 - find out if [autoscale] takes a lot of CPU power, or where in [hid] is using
   CPU where it doesn't have to be
 
 
-==============================================================================
+______________________________________________________________________________
 = Report available FF effects
 
 - check against HID Utilities Source/PID.h
 
 
-==============================================================================
+______________________________________________________________________________
 = pollfn for mouse-like devices
 
 - determine whether using a pollfn is actually better than using a t_clock
@@ -127,13 +191,13 @@ i.e "Trackpad" a la Max's [hi]
 - at standard block size (64 samples), one block = ~1.5ms
 
 
-==============================================================================
+______________________________________________________________________________
 = function return values
 
 - most functions probably do not need return values
 
 
-==============================================================================
+______________________________________________________________________________
 = check out using USB timestamp 
 
 - use the USB timestamp to correctly space the output data (meh, probably
@@ -141,11 +205,21 @@ i.e "Trackpad" a la Max's [hi]
 
 
 
- /++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\
-++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ /----------------------------------------------------------------------------\
+------------------------------------------------------------------------------
    BUGS BUGS BUGS BUGS BUGS BUGS BUGS BUGS BUGS BUGS BUGS BUGS BUGS BUGS BUGS 
-++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
- \++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++/
+------------------------------------------------------------------------------
+ \----------------------------------------------------------------------------/
+
+______________________________________________________________________________
+- BUG: crashes when you try yo open "mouse" with no args
+
+
+______________________________________________________________________________
+- BUG: on Mac OS X, polling starts without hid_build_device_list()
+
+- when polling starts, hid_build_device_list() should be called before starting
+
 
 ______________________________________________________________________________
 - BUG: figure out how to prevent segfaults on mismapped devices/elements
diff --git a/doc/hid-help.pd b/doc/hid-help.pd
index 41b97c2..304fcf9 100644
--- a/doc/hid-help.pd
+++ b/doc/hid-help.pd
@@ -1,48 +1,45 @@
-#N canvas 242 96 932 657 10;
-#X msg 233 353 abs abs_y 55;
-#X floatatom 27 484 5 0 0 0 - - -;
-#X floatatom 83 484 5 0 0 0 - - -;
-#X floatatom 63 440 6 0 0 0 - - -;
-#X obj 129 122 tgl 35 0 empty empty empty 0 -6 0 8 -24198 -1 -1 25
-25;
-#X floatatom 571 385 12 0 0 1 value - -;
-#X symbolatom 531 401 15 0 0 1 event_code - -;
-#X symbolatom 492 417 15 0 0 1 event_type - -;
+#N canvas 59 45 910 595 10;
+#X floatatom 27 454 5 0 0 0 - - -;
+#X floatatom 83 454 5 0 0 0 - - -;
+#X floatatom 63 410 6 0 0 0 - - -;
+#X obj 129 92 tgl 35 0 empty empty empty 0 -6 0 8 -24198 -1 -1 25 25
+;
+#X floatatom 571 355 12 0 0 1 value - -;
+#X symbolatom 531 371 15 0 0 1 event_code - -;
+#X symbolatom 492 387 15 0 0 1 event_type - -;
 #X obj 2 2 cnv 15 900 20 empty empty [hid] 2 11 1 18 -233017 -66577
 0;
-#X text 246 368 outlet message format:;
-#X obj 772 104 ev-list;
-#X obj 772 155 ev_syn-list;
-#X obj 772 177 ev_key-list;
-#X obj 772 199 ev_rel-list;
-#X obj 772 221 ev_abs-list;
-#X obj 772 243 ev_msc-list;
-#X obj 772 265 ev_led-list;
-#X obj 772 287 ev_snd-list;
-#X obj 772 309 ev_rep-list;
-#X obj 772 331 ev_ff-list;
-#X obj 772 353 ev_ff_status-list;
-#X text 740 85 Event Types:;
-#X text 740 136 Event Codes:;
-#X floatatom 138 388 5 0 0 1 ev_syn - -;
-#X obj 111 387 +;
-#X msg 111 367 1;
+#X text 274 347 outlet message format:;
+#X obj 772 114 ev-list;
+#X obj 772 165 ev_syn-list;
+#X obj 772 187 ev_key-list;
+#X obj 772 209 ev_rel-list;
+#X obj 772 231 ev_abs-list;
+#X obj 772 253 ev_msc-list;
+#X obj 772 275 ev_led-list;
+#X obj 772 297 ev_snd-list;
+#X obj 772 319 ev_rep-list;
+#X obj 772 341 ev_ff-list;
+#X obj 772 363 ev_ff_status-list;
+#X text 740 95 Event Types:;
+#X text 740 146 Event Codes:;
+#X floatatom 138 358 5 0 0 1 ev_syn - -;
+#X obj 111 357 +;
+#X msg 111 337 1;
 #X msg 402 117 close;
 #X msg 402 96 refresh;
 #X text 463 94 refresh device list;
-#X text 537 532 For more info:;
-#X text 49 588 (C) Copyright 2004 Hans-Christoph Steiner <hans@at.or.at>
-;
-#X text 266 602 released under the GNU GPL;
-#X text 472 589 $Revision: 1.23 $$Date: 2006-05-28 20:13:58 $;
-#X text 473 602 $Author: eighthave $;
-#X msg 421 266 poll 20;
-#X msg 359 266 poll 2;
-#X text 355 251 start polling and set the poll delay in ms;
-#X text 462 28 !!! This software is very much alpha \, so any aspect
+#X text 537 502 For more info:;
+#X text 266 572 released under the GNU GPL;
+#X text 472 559 $Revision: 1.24 $$Date: 2006-06-02 20:06:51 $;
+#X text 473 572 $Author: eighthave $;
+#X msg 436 216 poll 20;
+#X msg 374 216 poll 2;
+#X text 370 201 start polling and set the poll delay in ms;
+#X text 462 48 !!! This software is very much alpha \, so any aspect
 of it could change without notice !!!;
-#X obj 16 336 route key rel abs syn;
-#X obj 9 547 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 1
+#X obj 16 306 route key rel abs syn;
+#X obj 9 517 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 1
 ;
 #N canvas 278 328 631 544 Event_Codes 0;
 #X text 28 48 (For a complete listing of Linux Input Events \, see
@@ -196,7 +193,7 @@ of it could change without notice !!!;
 #X text 138 476 BTN_BASE6;
 #X text 245 463 298;
 #X text 245 477 299;
-#X restore 774 419 pd Event_Codes;
+#X restore 774 429 pd Event_Codes;
 #N canvas 50 289 469 317 Event_Types 0;
 #X text 28 48 (For a complete listing of Linux Input Events \, see
 /usr/include/linux/input.h.);
@@ -239,101 +236,90 @@ of it could change without notice !!!;
 #X text 331 255 22;
 #X text 230 255 EV_PWR;
 #X text 61 255 Power Events (for UPS);
-#X restore 774 399 pd Event_Types;
+#X restore 774 409 pd Event_Types;
 #N canvas 0 22 450 300 Event_Values 0;
 #X text 28 48 (For a complete listing of Linux Input Events \, see
 /usr/include/linux/input.h.);
 #X obj 11 9 cnv 15 400 30 empty empty Event_Values 20 12 1 14 -261681
 -66577 0;
-#X restore 774 439 pd Event_Values;
-#X floatatom 140 484 5 0 0 0 - - -;
-#X obj 421 439 route abs_hat0x abs_hat0y abs_hat1x abs_hat1y;
-#X floatatom 421 461 7 0 0 0 - - -;
-#X msg 179 121 1;
-#X msg 179 141 0;
+#X restore 774 449 pd Event_Values;
+#X floatatom 140 454 5 0 0 0 - - -;
+#X obj 421 409 route abs_hat0x abs_hat0y abs_hat1x abs_hat1y;
+#X floatatom 421 431 7 0 0 0 - - -;
 #X msg 402 138 print;
-#X obj 304 295 hid 0;
+#X obj 304 265 hid 0;
 #X text 465 118 close the device;
 #X text 465 139 print the device and element lists;
-#X text 9 257 Any non-zero value starts polling \,;
-#X text 8 270 0 stops the polling. If the number;
-#X text 9 283 is greater than 1 \, then the poll;
-#X text 9 296 delay is set to that number.;
-#X msg 489 266 poll 2000;
-#X obj 27 464 route rel_x rel_y rel_z rel_wheel;
-#X floatatom 196 484 5 0 0 0 - - -;
-#X obj 492 366 unpack s s f;
-#X msg 203 68 open \$1;
-#X obj 203 50 hradio 15 1 0 8 empty empty empty 0 -6 0 8 -262144 -1
--1 2;
-#X floatatom 190 71 1 0 0 0 - - -;
-#X text 270 382 event_type event_code value;
-#X obj 63 419 route abs_x abs_y abs_z abs_rx abs_ry abs_rz abs_throttle
+#X text 9 227 Any non-zero value starts polling \,;
+#X text 8 240 0 stops the polling. If the number;
+#X text 9 253 is greater than 1 \, then the poll;
+#X text 9 266 delay is set to that number.;
+#X obj 27 434 route rel_x rel_y rel_z rel_wheel;
+#X floatatom 196 454 5 0 0 0 - - -;
+#X obj 492 336 unpack s s f;
+#X msg 258 125 open \$1;
+#X obj 258 107 hradio 15 1 0 8 empty empty empty 0 -6 0 8 -262144 -1
+-1 0;
+#X floatatom 247 126 1 0 0 0 - - -;
+#X text 298 361 event_type event_code value;
+#X obj 63 389 route abs_x abs_y abs_z abs_rx abs_ry abs_rz abs_throttle
 ;
-#X obj 421 477 tgl 15 0 empty empty empty 0 -6 0 8 -262144 -1 -1 0
+#X obj 421 447 tgl 15 0 empty empty empty 0 -6 0 8 -262144 -1 -1 0
 -1;
-#X floatatom 498 461 7 0 0 0 - - -;
-#X obj 498 477 tgl 15 0 empty empty empty 0 -6 0 8 -262144 -1 -1 0
+#X floatatom 498 431 7 0 0 0 - - -;
+#X obj 498 447 tgl 15 0 empty empty empty 0 -6 0 8 -262144 -1 -1 0
 1;
-#X floatatom 576 461 7 0 0 0 - - -;
-#X obj 576 477 tgl 15 0 empty empty empty 0 -6 0 8 -262144 -1 -1 0
+#X floatatom 576 431 7 0 0 0 - - -;
+#X obj 576 447 tgl 15 0 empty empty empty 0 -6 0 8 -262144 -1 -1 0
 1;
-#X floatatom 653 461 7 0 0 0 - - -;
-#X obj 653 477 tgl 15 0 empty empty empty 0 -6 0 8 -262144 -1 -1 0
+#X floatatom 653 431 7 0 0 0 - - -;
+#X obj 653 447 tgl 15 0 empty empty empty 0 -6 0 8 -262144 -1 -1 0
 1;
-#X floatatom 113 440 6 0 0 0 - - -;
-#X floatatom 163 440 6 0 0 0 - - -;
-#X floatatom 213 440 6 0 0 0 - - -;
-#X floatatom 263 440 6 0 0 0 - - -;
-#X floatatom 313 440 6 0 0 0 - - -;
-#X floatatom 363 440 6 0 0 0 - - -;
-#X obj 39 547 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 1
+#X floatatom 113 410 6 0 0 0 - - -;
+#X floatatom 163 410 6 0 0 0 - - -;
+#X floatatom 213 410 6 0 0 0 - - -;
+#X floatatom 263 410 6 0 0 0 - - -;
+#X floatatom 313 410 6 0 0 0 - - -;
+#X floatatom 363 410 6 0 0 0 - - -;
+#X obj 39 517 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 1
 ;
-#X obj 69 547 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 1
+#X obj 69 517 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 1
 ;
-#X obj 99 547 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 1
+#X obj 99 517 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0 1
 ;
-#X obj 129 547 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0
+#X obj 129 517 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0
 1;
-#X obj 159 547 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0
+#X obj 159 517 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0
 1;
-#X obj 189 547 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0
+#X obj 189 517 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0
 1;
-#X obj 219 547 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0
+#X obj 219 517 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0
 1;
-#X obj 249 547 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0
+#X obj 249 517 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0
 1;
-#X obj 279 547 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0
+#X obj 279 517 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0
 1;
-#X obj 309 547 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0
+#X obj 309 517 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0
 1;
-#X obj 339 547 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0
+#X obj 339 517 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0
 1;
-#X obj 369 547 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0
+#X obj 369 517 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0
 1;
-#X obj 399 547 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0
+#X obj 399 517 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0
 1;
-#X obj 9 505 route btn_0 btn_1 btn_2 btn_3 btn_4 btn_5 btn_6 btn_7
+#X obj 9 475 route btn_0 btn_1 btn_2 btn_3 btn_4 btn_5 btn_6 btn_7
 btn_8 btn_9 btn_10 btn_11 btn_12 btn_13 btn_14 btn_15;
-#X obj 429 547 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0
+#X obj 429 517 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0
 1;
-#X obj 459 547 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0
+#X obj 459 517 tgl 25 0 empty empty empty 0 -6 0 8 -195568 -1 -1 0
 1;
-#X obj 234 334 cyclone/prepend set;
-#X msg 37 196 debug \$1;
-#X obj 37 174 hradio 15 1 1 10 empty empty empty 0 -6 0 8 -262144 -1
--1 9;
-#X obj 646 531 pddp/pddp_open all_about_hid;
-#X obj 232 91 hradio 15 1 0 8 empty empty empty 0 -6 0 8 -262144 -1
+#X obj 262 313 cyclone/prepend set;
+#X msg 37 166 debug \$1;
+#X obj 37 144 hradio 15 1 1 10 empty empty empty 0 -6 0 8 -262144 -1
 -1 0;
-#X msg 233 111 open mouse \$1;
-#X text 541 208 Gravis/Destroyer Tiltpad;
-#X msg 400 207 open 0x047D 0x4008;
-#X obj 253 135 hradio 15 1 0 8 empty empty empty 0 -6 0 8 -262144 -1
--1 0;
-#X msg 262 155 open keyboard \$1;
-#X msg 298 190 info;
-#N canvas 477 37 395 219 see 0;
+#X obj 646 501 pddp/pddp_open all_about_hid;
+#X msg 298 160 info;
+#N canvas 477 37 399 223 see 0;
 #N canvas 247 287 550 277 route 0;
 #X obj 53 13 inlet;
 #X obj 98 225 outlet;
@@ -387,95 +373,151 @@ vendorID productID;
 #X connect 0 7 4 0;
 #X connect 2 0 0 0;
 #X connect 2 0 3 0;
-#X restore 512 290 pd see device info;
-#X msg 397 179 open 0x046d 0xc01d;
-#X text 535 179 Logitech USB-PS/2 Optical Mouse;
-#N canvas 0 22 458 308 test 1;
-#X obj 60 23 inlet;
-#X obj 61 53 route not_implemented;
-#X obj 65 100 route notimp_64;
-#X obj 165 138 print;
-#X floatatom 69 146 5 0 0 0 - - -;
+#X restore 418 286 pd see device info;
+#N canvas 0 22 380 450 open 0;
+#X obj 77 61 hradio 15 1 0 8 empty empty empty 0 -6 0 8 -262144 -1
+-1 0;
+#X msg 78 81 open mouse \$1;
+#X obj 121 201 hradio 15 1 0 8 empty empty empty 0 -6 0 8 -262144 -1
+-1 0;
+#X msg 130 221 open keyboard \$1;
+#X obj 50 13 hradio 15 1 0 8 empty empty empty 0 -6 0 8 -262144 -1
+-1 0;
+#X obj 55 417 outlet;
+#X obj 85 108 hradio 15 1 0 8 empty empty empty 0 -6 0 8 -262144 -1
+-1 0;
+#X msg 94 128 open joystick \$1;
+#X msg 59 33 open pointer \$1;
+#X obj 101 155 hradio 15 1 0 8 empty empty empty 0 -6 0 8 -262144 -1
+-1 0;
+#X msg 110 175 open gamepad \$1;
+#X obj 137 244 hradio 15 1 0 8 empty empty empty 0 -6 0 8 -262144 -1
+-1 0;
+#X msg 146 264 open keypad \$1;
+#X obj 141 291 hradio 15 1 0 8 empty empty empty 0 -6 0 8 -262144 -1
+-1 0;
+#X msg 150 311 open multiaxiscontroller \$1;
+#X text 155 342 or just open the first one:;
+#X msg 138 363 open mouse;
+#X msg 159 381 open joystick;
+#X connect 0 0 1 0;
+#X connect 1 0 5 0;
+#X connect 2 0 3 0;
+#X connect 3 0 5 0;
+#X connect 4 0 8 0;
+#X connect 6 0 7 0;
+#X connect 7 0 5 0;
+#X connect 8 0 5 0;
+#X connect 9 0 10 0;
+#X connect 10 0 5 0;
+#X connect 11 0 12 0;
+#X connect 12 0 5 0;
+#X connect 13 0 14 0;
+#X connect 14 0 5 0;
+#X connect 16 0 5 0;
+#X connect 17 0 5 0;
+#X restore 203 74 pd open by device type;
+#N canvas 88 102 470 320 open 0;
+#X text 217 82 Gravis/Destroyer Tiltpad;
+#X msg 76 81 open 0x047D 0x4008;
+#X msg 73 53 open 0x046d 0xc01d;
+#X text 211 53 Logitech USB-PS/2 Optical Mouse;
+#X obj 10 277 outlet;
+#X text 9 12 You can use the hex values of the USB vendor and product
+IDs (it is not case sensitive):;
+#X text 221 111 Overtone CUI v1.0;
+#X msg 80 110 open 0x1043 0x0015;
+#X connect 1 0 4 0;
+#X connect 2 0 4 0;
+#X connect 7 0 4 0;
+#X restore 174 52 pd open by vendor/product ID;
+#N canvas 114 93 523 432 test 0;
+#X obj 122 5 inlet;
+#X obj 66 64 route DESKTOP;
+#X obj 65 118 route DESKTOP57;
+#X obj 48 167 bng 15 250 50 0 empty empty empty 0 -6 0 8 -262144 -1
+-1;
+#X floatatom 73 172 5 0 0 0 - - -;
+#X obj 126 175 spigot;
+#X obj 124 216 print test;
+#X obj 167 152 tgl 15 0 empty empty empty 0 -6 0 8 -262144 -1 -1 0
+1;
 #X connect 0 0 1 0;
 #X connect 1 0 2 0;
+#X connect 2 0 3 0;
 #X connect 2 0 4 0;
-#X connect 2 1 3 0;
-#X restore 490 330 pd test;
-#X obj 36 63 hradio 15 1 0 8 empty empty empty 0 -6 0 8 -262144 -1
--1 0;
-#X msg 45 83 open joystick \$1;
-#X connect 4 0 49 0;
-#X connect 23 0 24 1;
+#X connect 2 0 5 0;
+#X connect 5 0 6 0;
+#X connect 7 0 5 1;
+#X restore 197 318 pd test;
+#X msg 504 216 poll 200;
+#X msg 261 332 abs abs_y 55;
+#X text 49 558 (C) Copyright 2004 Hans-Christoph Steiner <hans@at.or.at>
+;
+#X connect 3 0 45 0;
+#X connect 22 0 23 1;
+#X connect 23 0 22 0;
 #X connect 24 0 23 0;
-#X connect 25 0 24 0;
-#X connect 26 0 49 0;
-#X connect 27 0 49 0;
-#X connect 34 0 49 0;
-#X connect 35 0 49 0;
-#X connect 38 0 91 0;
-#X connect 38 1 57 0;
-#X connect 38 2 64 0;
-#X connect 38 3 25 0;
+#X connect 25 0 45 0;
+#X connect 26 0 45 0;
+#X connect 32 0 45 0;
+#X connect 33 0 45 0;
+#X connect 36 0 86 0;
+#X connect 36 1 52 0;
+#X connect 36 2 59 0;
+#X connect 36 3 24 0;
+#X connect 42 0 43 0;
+#X connect 42 1 61 0;
+#X connect 42 2 63 0;
+#X connect 42 3 65 0;
+#X connect 43 0 60 0;
 #X connect 44 0 45 0;
-#X connect 44 1 66 0;
-#X connect 44 2 68 0;
-#X connect 44 3 70 0;
-#X connect 45 0 65 0;
-#X connect 46 0 49 0;
-#X connect 47 0 49 0;
-#X connect 48 0 49 0;
-#X connect 49 0 38 0;
-#X connect 49 0 59 0;
-#X connect 49 0 94 0;
-#X connect 49 0 108 0;
-#X connect 49 1 105 0;
-#X connect 56 0 49 0;
-#X connect 57 0 1 0;
-#X connect 57 1 2 0;
-#X connect 57 2 43 0;
-#X connect 57 3 58 0;
-#X connect 59 0 7 0;
-#X connect 59 1 6 0;
-#X connect 59 2 5 0;
-#X connect 60 0 49 0;
-#X connect 61 0 60 0;
+#X connect 45 0 36 0;
+#X connect 45 0 54 0;
+#X connect 45 0 89 0;
+#X connect 45 0 97 0;
+#X connect 45 1 94 0;
+#X connect 52 0 0 0;
+#X connect 52 1 1 0;
+#X connect 52 2 41 0;
+#X connect 52 3 53 0;
+#X connect 54 0 6 0;
+#X connect 54 1 5 0;
+#X connect 54 2 4 0;
+#X connect 55 0 45 0;
+#X connect 56 0 55 0;
+#X connect 56 0 57 0;
+#X connect 59 0 2 0;
+#X connect 59 1 67 0;
+#X connect 59 2 68 0;
+#X connect 59 3 69 0;
+#X connect 59 4 70 0;
+#X connect 59 5 71 0;
+#X connect 59 6 72 0;
+#X connect 59 7 42 0;
 #X connect 61 0 62 0;
-#X connect 64 0 3 0;
-#X connect 64 1 72 0;
-#X connect 64 2 73 0;
-#X connect 64 3 74 0;
-#X connect 64 4 75 0;
-#X connect 64 5 76 0;
-#X connect 64 6 77 0;
-#X connect 64 7 44 0;
-#X connect 66 0 67 0;
-#X connect 68 0 69 0;
-#X connect 70 0 71 0;
-#X connect 91 0 39 0;
-#X connect 91 1 78 0;
-#X connect 91 2 79 0;
-#X connect 91 3 80 0;
-#X connect 91 4 81 0;
-#X connect 91 5 82 0;
-#X connect 91 6 83 0;
-#X connect 91 7 84 0;
-#X connect 91 8 85 0;
-#X connect 91 9 86 0;
-#X connect 91 10 87 0;
-#X connect 91 11 88 0;
-#X connect 91 12 89 0;
-#X connect 91 13 90 0;
-#X connect 91 14 92 0;
-#X connect 91 15 93 0;
-#X connect 94 0 0 0;
-#X connect 95 0 49 0;
-#X connect 96 0 95 0;
-#X connect 98 0 99 0;
-#X connect 99 0 49 0;
-#X connect 101 0 49 0;
-#X connect 102 0 103 0;
-#X connect 103 0 49 0;
-#X connect 104 0 49 0;
-#X connect 106 0 49 0;
-#X connect 109 0 110 0;
-#X connect 110 0 49 0;
+#X connect 63 0 64 0;
+#X connect 65 0 66 0;
+#X connect 86 0 37 0;
+#X connect 86 1 73 0;
+#X connect 86 2 74 0;
+#X connect 86 3 75 0;
+#X connect 86 4 76 0;
+#X connect 86 5 77 0;
+#X connect 86 6 78 0;
+#X connect 86 7 79 0;
+#X connect 86 8 80 0;
+#X connect 86 9 81 0;
+#X connect 86 10 82 0;
+#X connect 86 11 83 0;
+#X connect 86 12 84 0;
+#X connect 86 13 85 0;
+#X connect 86 14 87 0;
+#X connect 86 15 88 0;
+#X connect 89 0 99 0;
+#X connect 90 0 45 0;
+#X connect 91 0 90 0;
+#X connect 93 0 45 0;
+#X connect 95 0 45 0;
+#X connect 96 0 45 0;
+#X connect 98 0 45 0;
diff --git a/hid.c b/hid.c
index 741cb4b..7ee4ee8 100644
--- a/hid.c
+++ b/hid.c
@@ -122,9 +122,9 @@ static unsigned int name_to_usage(char *usage_name)
 }
 
 
-static t_int get_device_number_from_arguments(int argc, t_atom *argv)
+static short get_device_number_from_arguments(int argc, t_atom *argv)
 {
-	t_int device_number = -1;
+	short device_number = -1;
 	unsigned short usage_number;
 	unsigned int usage;
 	unsigned short vendor_id;
@@ -135,11 +135,10 @@ static t_int get_device_number_from_arguments(int argc, t_atom *argv)
 
 	if(argc == 1)
 	{
-		post("one arg");
 		first_argument = atom_getsymbolarg(0,argc,argv);
 		if(first_argument == &s_) 
 		{ // single float arg means device
-			device_number = (unsigned short) atom_getfloatarg(0,argc,argv);
+			device_number = (short) atom_getfloatarg(0,argc,argv);
 			if(device_number < 0) device_number = -1;
 			debug_print(LOG_DEBUG,"[hid] setting device# to %d",device_number);
 		}
@@ -164,32 +163,38 @@ static t_int get_device_number_from_arguments(int argc, t_atom *argv)
 			atom_string(argv, usage_string, MAXPDSTRING-1);
 			usage = name_to_usage(usage_string);
 			usage_number = atom_getfloatarg(1,argc,argv);
-			debug_print(LOG_DEBUG,"[hid] looking for %s at #%d",usage_string,usage_number);
+			debug_print(LOG_DEBUG,"[hid] looking for %s at #%d",
+						usage_string,usage_number);
 			device_number = get_device_number_from_usage_list(usage_number,
 															  usage >> 16, 
 															  usage & 0xffff);
 		}
 		else
 		{ /* two symbols means idVendor and idProduct in hex */
-			vendor_id = (unsigned short) strtol(first_argument->s_name, NULL, 16);
-			product_id = (unsigned short) strtol(second_argument->s_name, NULL, 16);
+			vendor_id = 
+				(unsigned short) strtol(first_argument->s_name, NULL, 16);
+			product_id = 
+				(unsigned short) strtol(second_argument->s_name, NULL, 16);
 			device_number = get_device_number_by_id(vendor_id,product_id);
 		}
 	}
 	return(device_number);
 }
 
-void hid_output_event(t_hid *x, t_symbol *type, t_symbol *code, t_float value)
-{
-	t_atom event_data[3];
-	
-	SETSYMBOL(event_data, type);	
-	SETSYMBOL(event_data + 1, code);
-	SETFLOAT(event_data + 2, value);
 
-	outlet_anything(x->x_data_outlet,atom_gensym(event_data),2,event_data+1);
+void hid_output_event(t_hid *x, t_hid_element *output_data)
+{
+	if( (output_data->value != output_data->previous_value) ||
+		(output_data->relative) )  // relative data should always be output
+	{
+		t_atom event_data[2];
+		SETSYMBOL(event_data, output_data->name);
+		SETFLOAT(event_data + 1, output_data->value);
+		outlet_anything(x->x_data_outlet,output_data->type,2,event_data);
+	}
 }
 
+
 /* stop polling the device */
 static void stop_poll(t_hid* x) 
 {
@@ -212,36 +217,39 @@ void hid_poll(t_hid* x, t_float f)
 {
 	debug_print(LOG_DEBUG,"hid_poll");
   
-/*	if the user sets the delay less than one, ignore */
-	if( f > 0 ) 	
+/*	if the user sets the delay less than 2, set to block size */
+	if( f > 2 )
 		x->x_delay = (t_int)f;
-
-	if( (!x->x_device_open) && (x->x_device_number > -1) )
-		hid_open(x,gensym("open"),0,NULL);
-	
-	if(!x->x_started) 
+	else if( f > 0 ) //TODO make this the actual time between message processing
+		x->x_delay = 1.54; 
+	if(x->x_device_number > -1) 
 	{
-		clock_delay(x->x_clock, x->x_delay);
-		debug_print(LOG_DEBUG,"[hid] polling started");
-		x->x_started = 1;
-	} 
+		if(!x->x_device_open) 
+			hid_open(x,gensym("open"),0,NULL);
+		if(!x->x_started) 
+		{
+			clock_delay(x->x_clock, x->x_delay);
+			debug_print(LOG_DEBUG,"[hid] polling started");
+			x->x_started = 1;
+		} 
+	}
 }
 
 static void hid_set_from_float(t_hid *x, t_floatarg f)
 {
 /* values greater than 1 set the polling delay time */
 /* 1 and 0 for start/stop so you can use a [tgl] */
-	if (f > 1)
+	if(f > 1)
 	{
 		x->x_delay = (t_int)f;
 		hid_poll(x,f);
 	}
-	else if (f == 1) 
+	else if(f == 1) 
 	{
-		if (! x->x_started)
-		hid_poll(x,f);
+		if(! x->x_started)
+			hid_poll(x,f);
 	}
-	else if (f == 0) 		
+	else if(f == 0) 		
 	{
 		stop_poll(x);
 	}
@@ -280,7 +288,7 @@ static void hid_open(t_hid *x, t_symbol *s, int argc, t_atom *argv)
 /* store running state to be restored after the device has been opened */
 	t_int started = x->x_started;
 	
-	int device_number = get_device_number_from_arguments(argc, argv);
+	short device_number = get_device_number_from_arguments(argc, argv);
 	if(device_number > -1)
 	{
 		if( (device_number != x->x_device_number) && (x->x_device_open) ) 
diff --git a/hid.h b/hid.h
index b4db8bb..bd31b88 100644
--- a/hid.h
+++ b/hid.h
@@ -15,7 +15,7 @@
 #define HID_MAJOR_VERSION 0
 #define HID_MINOR_VERSION 7
 
-/* static char *version = "$Revision: 1.23 $"; */
+/* static char *version = "$Revision: 1.24 $"; */
 
 /*------------------------------------------------------------------------------
  * GLOBAL DEFINES
@@ -26,6 +26,13 @@
 /* this is set to simplify data structures (arrays instead of linked lists) */
 #define MAX_DEVICES 128
 
+/* think 64 is the limit per device as defined in the OS */
+#define MAX_ELEMENTS 64
+
+/* this is limited so that the object doesn't cause a click getting too many
+ * events from the OS's event queue */
+#define MAX_EVENTS_PER_POLL 64
+
 /*------------------------------------------------------------------------------
  *  CLASS DEF
  */
@@ -33,7 +40,7 @@ typedef struct _hid
 {
 	t_object            x_obj;
 	t_int               x_fd;
-	t_int               x_device_number;
+	short               x_device_number;
 //	unsigned short      vendor_id;    // USB idVendor for current device
 //	unsigned short      product_id;   // USB idProduct for current device
 	t_int               x_has_ff;
@@ -64,6 +71,28 @@ extern unsigned short global_debug_level;
 /* next I need to make a data structure to hold the data to be output for this
  * poll.  This should probably be an array for efficiency */
 
+
+typedef struct _hid_element
+{
+#ifdef __linux__
+	//GNU/Linux store type and code to compare against
+#else
+	void *os_pointer;  // pRecElement on Mac OS X; 
+#endif /* __linux__ */
+	t_symbol *type; // Linux "type"; HID "usagePage"
+	t_symbol *name; // Linux "code"; HID "usage"
+	unsigned char polled; // is it polled or queued? (maybe only on Mac OS X?)
+	unsigned char relative; // relative data gets output everytime
+	t_float instance; // usage page/usage instance # ([absolute throttle 2 163( 
+	t_int value; // output the sum of events in a poll for relative axes
+	t_int previous_value; //only output on change on abs and buttons
+} t_hid_element;
+
+/* store element structs to eliminate symbol table lookups, etc. */
+t_hid_element *element[MAX_DEVICES][MAX_ELEMENTS];
+/* number of active elements per device */
+unsigned short element_count[MAX_DEVICES]; 
+
 /*------------------------------------------------------------------------------
  *  FUNCTION PROTOTYPES FOR DIFFERENT PLATFORMS
  */
@@ -71,20 +100,23 @@ extern unsigned short global_debug_level;
 /* support functions */
 void debug_print(t_int debug_level, const char *fmt, ...);
 void debug_error(t_hid *x, t_int debug_level, const char *fmt, ...);
+void hid_output_event(t_hid *x, t_hid_element *output_data);
+/* the old way
 void hid_output_event(t_hid *x, t_symbol *type, t_symbol *code, t_float value);
+*/
 
 /* generic, cross-platform functions implemented in a separate file for each
  * platform 
  */
-t_int hid_open_device(t_hid *x, t_int device_number);
+t_int hid_open_device(t_hid *x, short device_number);
 t_int hid_close_device(t_hid *x);
 void hid_build_device_list(void);
-t_int hid_get_events(t_hid *x);
+void hid_get_events(t_hid *x);
 void hid_print(t_hid* x); /* print info to the console */
 void hid_platform_specific_info(t_hid* x); /* device info on the status outlet */
 void hid_platform_specific_free(t_hid *x);
-t_int get_device_number_by_id(unsigned short vendor_id, unsigned short product_id);
-t_int get_device_number_from_usage_list(t_int device_number, 
+short get_device_number_by_id(unsigned short vendor_id, unsigned short product_id);
+short get_device_number_from_usage_list(short device_number, 
 										unsigned short usage_page, 
 										unsigned short usage);
 
diff --git a/hid_darwin.c b/hid_darwin.c
index 66fe4f1..cfe3319 100644
--- a/hid_darwin.c
+++ b/hid_darwin.c
@@ -62,9 +62,17 @@
 
 extern t_int hid_instance_count;
 
-/* store device pointers */
+/* store device pointers so I don't have to query them all the time */
 pRecDevice device_pointer[MAX_DEVICES];
 
+
+// this stuff is moving to the t_hid_element struct
+
+/* store element pointers for elements that are not queued (absolute axes) */
+//pRecElement element[MAX_DEVICES][MAX_ELEMENTS];
+/* number of active elements per device */
+//unsigned short element_count[MAX_DEVICES]; 
+
 /*==============================================================================
  * FUNCTION PROTOTYPES
  *==============================================================================
@@ -82,85 +90,148 @@ char *convertEventsFromDarwinToLinux(pRecElement element);
  * This function is needed to translate the USB HID relative flag into the
  * [hid]/linux style events
  */
-void convertAxis(pRecElement element, char *linux_type, char *linux_code, char *axis) 
+void convert_axis_to_symbols(pRecElement pCurrentHIDElement, t_hid_element *new_element, char *axis) 
 {
-	if (element->relative) 
+	char buffer[MAXPDSTRING];
+	if (pCurrentHIDElement->relative) 
 	{ 
-		sprintf(linux_type,"rel"); 
-		sprintf(linux_code,"rel_%s",axis); 
+		new_element->type = gensym("rel"); 
+		snprintf(buffer, sizeof(buffer), "rel_%s", axis); 
+		new_element->name = gensym(buffer);
 	}
 	else 
 	{ 
-		sprintf(linux_type,"abs"); 
-		sprintf(linux_code,"abs_%s",axis); 
+		new_element->type = gensym("abs"); 
+		snprintf(buffer, sizeof(buffer), "abs_%s", axis); 
+		new_element->name = gensym(buffer);
 	}
 }
 
 
-void convertDarwinElementToLinuxTypeCode(pRecElement element, char *linux_type, char *linux_code) 
+void get_usage_symbols(pRecElement pCurrentHIDElement, t_hid_element *new_element) 
 {
-//	t_int button_offset = 0;
+//	debug_print(LOG_DEBUG,"get_usage_symbols");
+	char buffer[MAXPDSTRING];
 
-	switch(element->type)
+	if(new_element == NULL)
 	{
-		case kIOHIDElementTypeInput_Button:
-			sprintf(linux_type, "key");
-			break;
+		debug_print(LOG_EMERG,"[hid] new_element == NULL!!  This is a bug, please report it.");
+		return;
+	}
+	if(pCurrentHIDElement == NULL)
+	{
+		debug_print(LOG_EMERG,"[hid] pCurrentHIDElement == NULL!!  This is a bug, please report it.");
+		return;
 	}
 
-	switch (element->usagePage)
+	switch(pCurrentHIDElement->type)
 	{
-		case kHIDPage_GenericDesktop:
-			switch (element->usage)
-			{
-				case kHIDUsage_GD_X: convertAxis(element, linux_type, linux_code, "x"); break;
-				case kHIDUsage_GD_Y: convertAxis(element, linux_type, linux_code, "y"); break;
-				case kHIDUsage_GD_Z: convertAxis(element, linux_type, linux_code, "z"); break;
-				case kHIDUsage_GD_Rx: convertAxis(element, linux_type, linux_code, "rx"); break;
-				case kHIDUsage_GD_Ry: convertAxis(element, linux_type, linux_code, "ry"); break;
-				case kHIDUsage_GD_Rz: convertAxis(element, linux_type, linux_code, "rz"); break;
-				case kHIDUsage_GD_Wheel: 
-					sprintf(linux_type,"rel");sprintf(linux_code,"rel_wheel");break;
-				case kHIDUsage_GD_Slider:
-					sprintf(linux_type,"abs");sprintf(linux_code,"abs_throttle");break;
-			}
+	case kIOHIDElementTypeInput_Button:
+		new_element->type = gensym("key");
+		break;
+	}
+	switch (pCurrentHIDElement->usagePage)
+	{
+	case kHIDPage_GenericDesktop:
+		switch (pCurrentHIDElement->usage)
+		{
+		case kHIDUsage_GD_X: convert_axis_to_symbols(pCurrentHIDElement, new_element, "x"); break;
+		case kHIDUsage_GD_Y: convert_axis_to_symbols(pCurrentHIDElement, new_element, "y"); break;
+		case kHIDUsage_GD_Z: convert_axis_to_symbols(pCurrentHIDElement, new_element, "z"); break;
+		case kHIDUsage_GD_Rx: convert_axis_to_symbols(pCurrentHIDElement, new_element, "rx"); break;
+		case kHIDUsage_GD_Ry: convert_axis_to_symbols(pCurrentHIDElement, new_element, "ry"); break;
+		case kHIDUsage_GD_Rz: convert_axis_to_symbols(pCurrentHIDElement, new_element, "rz"); break;
+		case kHIDUsage_GD_Slider:
+			new_element->type = gensym("abs");
+			new_element->name = gensym("abs_throttle");
 			break;
-		case kHIDPage_Simulation:
-			switch (element->usage)
-			{
-				case kHIDUsage_Sim_Rudder: 
-					sprintf(linux_type,"abs");sprintf(linux_code,"abs_rz");break;
-				case kHIDUsage_Sim_Throttle:
-					sprintf(linux_type,"abs");sprintf(linux_code,"abs_throttle");break;
-			}
+		case kHIDUsage_GD_Dial:
+			new_element->type = gensym("abs");
+			new_element->name = gensym("abs_ry");
 			break;
-		case kHIDPage_KeyboardOrKeypad:
-			sprintf(linux_type, "key"); 
-			/* temporary kludge until I feel like writing the translation table */
-			sprintf(linux_code, "key_%ld", element->usage); 
+		case kHIDUsage_GD_Wheel: 
+			new_element->type = gensym("rel"); 
+			new_element->name = gensym("rel_wheel");
 			break;
-		case kHIDPage_Button:
-			sprintf(linux_type, "key"); 
-			/* HID Manager button numbers start at 1, [hid] start at 0 */
-			sprintf(linux_code, "btn_%ld", element->usage - 1); 
+		case kHIDUsage_GD_Hatswitch:
+			// this is still a mystery how to handle
+			new_element->type = gensym("abs"); 
+			new_element->name = gensym("hatswitch");
 			break;
-		case kHIDPage_LEDs:
-			/* temporary kludge until I feel like writing the translation table */
-			sprintf(linux_type, "led"); 
-			sprintf(linux_code, "led_%ld", element->usage); 
+		default:
+			new_element->type = gensym("DESKTOP");
+			snprintf(buffer, sizeof(buffer), "DESKTOP%ld", pCurrentHIDElement->usage); 
+			new_element->name = gensym(buffer);
+		}
+		break;
+	case kHIDPage_Simulation:
+		switch (pCurrentHIDElement->usage)
+		{
+		case kHIDUsage_Sim_Rudder: 
+			new_element->type = gensym("abs");
+			new_element->name = gensym("abs_rz");
 			break;
-		case kHIDPage_PID:
-			/* temporary kludge until I feel like writing the translation table */
-			sprintf(linux_type, "ff"); 
-			sprintf(linux_code, "ff_%ld", element->usage); 
+		case kHIDUsage_Sim_Throttle:
+			new_element->type = gensym("abs");
+			new_element->name = gensym("abs_throttle");
 			break;
 		default:
-			/* temporary kludge until I feel like writing the translation table */
-			sprintf(linux_type, "not_implemented"); 
-			sprintf(linux_code, "notimp_%ld", element->usage); 
+			new_element->type = gensym("SIMULATION");
+			snprintf(buffer, sizeof(buffer), "SIMULATION%ld", pCurrentHIDElement->usage); 
+			new_element->name = gensym(buffer);
+		}
+		break;
+	case kHIDPage_KeyboardOrKeypad:
+		new_element->type = gensym("key"); 
+		/* temporary kludge until I feel like writing the translation table */
+		snprintf(buffer, sizeof(buffer), "key_%ld", pCurrentHIDElement->usage); 
+		new_element->name = gensym(buffer);
+		break;
+	case kHIDPage_Button:
+		new_element->type = gensym("key"); 
+		/* HID Manager button numbers start at 1, [hid] start at 0 */
+		snprintf(buffer, sizeof(buffer), "btn_%ld", pCurrentHIDElement->usage - 1); 
+		new_element->name = gensym(buffer);
+		break;
+	case kHIDPage_LEDs:
+		/* temporary kludge until I feel like writing the translation table */
+		new_element->type = gensym("led"); 
+		snprintf(buffer, sizeof(buffer), "led_%ld", pCurrentHIDElement->usage); 
+		new_element->name = gensym(buffer);
+		break;
+	case kHIDPage_PID:
+		/* temporary kludge until I feel like writing the translation table */
+		new_element->type = gensym("ff"); 
+		snprintf(buffer, sizeof(buffer), "ff_%ld", pCurrentHIDElement->usage); 
+		new_element->name = gensym(buffer);
+		break;
+	default:
+		/* the rest are "vendor defined" so no translation table is possible */
+		snprintf(buffer, sizeof(buffer), "0x%04x", (unsigned int) pCurrentHIDElement->usagePage); 
+		new_element->type = gensym(buffer); 
+		snprintf(buffer, sizeof(buffer), "0x%04x", (unsigned int) pCurrentHIDElement->usage); 
+		new_element->name = gensym(buffer);
+	}
+}
+
+
+static t_float get_type_name_instance(t_symbol *type, t_symbol *name, 
+									   int argc, t_hid_element **argv) 
+{
+	int i;
+	int instance_count = 0;
+	for(i=0; i<argc; ++i)
+	{
+		if( (argv[i]->name == name) && (argv[i]->type == type) )
+		{
+			++instance_count;
+//			post("found %d instances of %s %s", instance_count, type->s_name, name->s_name);
+		}
 	}
+	return((t_float) instance_count);
 }
 
+
 /*
  * Linux input events report hatswitches as absolute axes with -1, 0, 1 as
  * possible values.  MacOS X HID Manager reports hatswitches as a specific
@@ -169,52 +240,72 @@ void convertDarwinElementToLinuxTypeCode(pRecElement element, char *linux_type,
  */
 
 /* 
- * hmm, not sure how to implement this cleanly yet, so I left the code
- * inline in hid_get_events().
-void hid_convert_hatswitch_values(IOHIDEventStruct event, char *linux_type, char *linux_code)
-{
-}
+ * hmm, not sure how to implement this cleanly yet, 
+ * MacOS X represents this as one event, while [hid] represents it as two
+ * distinct axes.  So the conversion requires an added hid_output_event().
+ void hid_convert_hatswitch_values(IOHIDEventStruct event, t_symbol *type, t_atom *usage)
+ {
+			case 0: 
+				name = gensym("abs_hat0y");value = 1;
+				hid_output_event(x, type, name, value);
+				name = gensym("abs_hat0x");value = 0;
+				break;
+			case 1: 
+				name = gensym("abs_hat0y");value = 1;
+				hid_output_event(x, type, name, value);
+				name = gensym("abs_hat0x");value = 1;
+				break;
+			case 2: 
+				name = gensym("abs_hat0y");value = 0;
+				hid_output_event(x, type, name, value);
+				name = gensym("abs_hat0x");value = 1;
+				break;
+			case 3: 
+				name = gensym("abs_hat0y");value = -1;
+				hid_output_event(x, type, name, value);
+				name = gensym("abs_hat0x");value = 1;
+				break;
+			case 4: 
+				name = gensym("abs_hat0y");value = -1;
+				hid_output_event(x, type, name, value);
+				name = gensym("abs_hat0x");value = 0;
+				break;
+			case 5: 
+				name = gensym("abs_hat0y");value = -1;
+				hid_output_event(x, type, name, value);
+				name = gensym("abs_hat0x");value = -1;
+				break;
+			case 6: 
+				name = gensym("abs_hat0y");value = 0;
+				hid_output_event(x, type, name, value);
+				name = gensym("abs_hat0x");value = -1;
+				break;
+			case 7: 
+				name = gensym("abs_hat0y");value = 1;
+				hid_output_event(x, type, name, value);
+				name = gensym("abs_hat0x");value = -1;
+				break;
+			case 8: 
+				name = gensym("abs_hat0y");value = 0;
+				hid_output_event(x, type, name, value);
+				name = gensym("abs_hat0x");value = 0;
+				break;
+			}
+
+ }
 */
 
 /* ============================================================================== */
 /* DARWIN-SPECIFIC SUPPORT FUNCTIONS */
 /* ============================================================================== */
 
-pRecDevice hid_get_device_by_number(t_int device_number)
-{
-	pRecDevice pCurrentHIDDevice;
-	t_int i, numdevs;
-
-// TODO: implement this using the global array built by hid_build_device_list()
-
-/*
- *	If the specified device is greater than the total number of devices, return
- *	an error.
- */
-	numdevs = (t_int) HIDCountDevices();
-	if (device_number >= numdevs) {
-		error("[hid]: no such device, \"%d\", only %d devices found\n",device_number,numdevs);
-		return (NULL);
-	}
-/*
- *	The most recently discovered HID is the first element of the list here.  I
- *	want the oldest to be number 0 rather than the newest, so I use (numdevs -
- *	device_number - 1).
- */
-	pCurrentHIDDevice = HIDGetFirstDevice();
-	for(i=0; i < numdevs - device_number - 1; ++i)
-		pCurrentHIDDevice = HIDGetNextDevice(pCurrentHIDDevice);
-
-	return pCurrentHIDDevice;
-}
-
-t_int get_device_number_by_id(unsigned short vendor_id, unsigned short product_id)
+short get_device_number_by_id(unsigned short vendor_id, unsigned short product_id)
 {
 	debug_print(LOG_DEBUG,"get_device_number_from_usage_list");
 
 	pRecDevice    pCurrentHIDDevice;
 	t_int i;
-	t_int return_device_number = -1;
+	short return_device_number = -1;
 
 	if( !HIDHaveDeviceList() ) hid_build_device_list();
 
@@ -240,14 +331,14 @@ t_int get_device_number_by_id(unsigned short vendor_id, unsigned short product_i
 	return(return_device_number);
 }
 
-t_int get_device_number_from_usage_list(t_int device_number, 
+short get_device_number_from_usage_list(short device_number, 
 										unsigned short usage_page, unsigned short usage)
 {
-	debug_print(LOG_DEBUG,"get_device_number_from_usage_list");
+//	debug_print(LOG_DEBUG,"get_device_number_from_usage_list");
 
 	pRecDevice    pCurrentHIDDevice;
 	t_int i;
-	t_int return_device_number = -1;
+	short return_device_number = -1;
 	t_int total_devices = 0;
 	char cstrDeviceName[MAXPDSTRING];
 
@@ -291,97 +382,111 @@ t_int get_device_number_from_usage_list(t_int device_number,
 		return(-1);
 }
 
-/*
+
 void hid_build_element_list(t_hid *x) 
 {
-	   if ( HIDIsValidDevice( device ) ) {
-       elRec = HIDGetFirstDeviceElement( js_devices[id].device,
-kHIDElementTypeInput );
-       if ( elRec ) {
-           switch (elRec->usagePage) {
-               case kHIDPage_GenericDesktop:
-                   switch ( elRec->usage ) {
-                       case kHIDUsage_GD_X:
-                               x_axis = elRec;
-                               break;
-                       case kHIDUsage_GD_Y:
-                               y_axis = elRec;
-                               break;
-                       case kHIDUsage_GD_GamePad:
-                               pad = elRec;
-                               break;
-                       //etc
-                   }
-           }
-      //if the right element was not found, continue looping through the
-      //rest of the elements by calling HIDGetNextDeviceElement() until you
-      //find the right one or it returns NULL
-   }
-
-   // only queue buttons and relative axes
-   if ( HIDIsValidElement( devicePtr, elementPtr ) ) {
-       HIDQueueElement (devicePtr, elementPtr);
-   }
-
-   // for absolute axes, poll them
-   if ( HIDIsValidElement( devicePtr, elementPtr ) )  {
-       value = HIDGetElementValue(devicePtr, elementPtr);
-   }
+	char type_name[256];
+	char usage_name[256];
+	pRecElement pCurrentHIDElement;
+	pRecDevice pCurrentHIDDevice = device_pointer[x->x_device_number];
+	t_hid_element *new_element;
+  
+	element_count[x->x_device_number] = 0;
+	if( HIDIsValidDevice(pCurrentHIDDevice) ) 
+	{
+		/* queuing one element at a time only works for the first element, so
+		 * try queuing the whole device, then removing specific elements from
+		 * the queue */
+		HIDQueueDevice(pCurrentHIDDevice);
+		pCurrentHIDElement = HIDGetFirstDeviceElement( pCurrentHIDDevice,
+													   kHIDElementTypeInput );
+		while( pCurrentHIDElement != NULL) 
+		{
+			/* these two functions just get the pretty names for display */
+			HIDGetTypeName((IOHIDElementType) pCurrentHIDElement->type, type_name);
+			HIDGetUsageName(pCurrentHIDElement->usagePage, 
+							pCurrentHIDElement->usage, usage_name);
+
+			new_element = getbytes(sizeof(t_hid_element));
+			new_element->os_pointer = (void *) pCurrentHIDElement;
+			get_usage_symbols(pCurrentHIDElement, new_element);
+			new_element->relative = pCurrentHIDElement->relative;
+			new_element->instance = get_type_name_instance(new_element->type, 
+														   new_element->name,
+														   element_count[x->x_device_number],
+														   element[x->x_device_number]);
+			
+			if( (pCurrentHIDElement->usagePage == kHIDPage_GenericDesktop) &&
+				(!pCurrentHIDElement->relative) )
+			{
+				switch(pCurrentHIDElement->usage)
+				{
+				case kHIDUsage_GD_X:
+				case kHIDUsage_GD_Y:
+				case kHIDUsage_GD_Z:
+				case kHIDUsage_GD_Rx:
+				case kHIDUsage_GD_Ry:
+				case kHIDUsage_GD_Rz:
+				case kHIDUsage_GD_Slider:
+				case kHIDUsage_GD_Dial:
+				case kHIDUsage_GD_Wheel:
+					//case kHIDUsage_GD_Hatswitch: // hatswitches are more like buttons, so queue them
+					debug_print(LOG_INFO,"[hid] storing absolute axis to poll %s, %s (0x%04x 0x%04x)",
+								type_name, usage_name, pCurrentHIDElement->usagePage, pCurrentHIDElement->usage);
+					if(HIDDequeueElement(pCurrentHIDDevice,pCurrentHIDElement) != kIOReturnSuccess)
+						debug_print(LOG_ERR,"[hid] could not dequeue element");
+					new_element->polled = 1;
+					break;
+				default:
+					debug_print(LOG_CRIT,"[hid] SKIPPED %s, %s (0x%04x 0x%04x)x", type_name, usage_name,
+								pCurrentHIDElement->usagePage, pCurrentHIDElement->usage);
+				}
+			}
+			else
+			{
+				debug_print(LOG_INFO,"[hid] queuing element %s, %s (0x%04x 0x%04x)",type_name, usage_name,
+							pCurrentHIDElement->usagePage, pCurrentHIDElement->usage);
+			}
+			post("\tlogical min %d max %d",pCurrentHIDElement->minReport,pCurrentHIDElement->maxReport);
+			
+			element[x->x_device_number][element_count[x->x_device_number]] = new_element;
+			++element_count[x->x_device_number];
+			pCurrentHIDElement = HIDGetNextDeviceElement(pCurrentHIDElement, kHIDElementTypeInput);
+		}
+	}
 }
-*/
 
-t_int hid_print_element_list(t_hid *x)
+void hid_print_element_list(t_hid *x)
 {
-	debug_print(LOG_DEBUG,"hid_print_element_list");
-
-	UInt32 i;
+//	debug_print(LOG_DEBUG,"hid_print_element_list");
+	int i;
 	pRecElement	pCurrentHIDElement;
 	pRecDevice pCurrentHIDDevice;
-	UInt32 numElements;
-	char type[256];
-	char code[256];
+	t_hid_element *current_element;
 	char type_name[256];
 	char usage_name[256];
 
-//	pCurrentHIDDevice = hid_get_device_by_number(x->x_device_number);
 	pCurrentHIDDevice = device_pointer[x->x_device_number];
 	if ( ! HIDIsValidDevice(pCurrentHIDDevice) )
 	{
 		error("[hid]: device %d is not a valid device\n",x->x_device_number);
-		return(1);
+		return;
 	}
-
-	pCurrentHIDElement = HIDGetFirstDeviceElement(pCurrentHIDDevice, kHIDElementTypeInput);
-	numElements = HIDCountDeviceElements(pCurrentHIDDevice, kHIDElementTypeInput);
-	
-	DEBUG(post("[hid] found %d elements:",numElements););
-	
-	post("");
-	post("  TYPE\tCODE\tEVENT NAME");
+	post("[hid] found %d elements:",element_count[x->x_device_number]);
+	post("\n  TYPE\tCODE\t#\tEVENT NAME");
 	post("-----------------------------------------------------------");
-	for(i=0; i<numElements; i++)
+	for(i=0; i<element_count[x->x_device_number]; i++)
 	{
+		current_element = element[x->x_device_number][i];
+		pCurrentHIDElement = (pRecElement) current_element->os_pointer;
 		HIDGetTypeName((IOHIDElementType) pCurrentHIDElement->type, type_name);
 		HIDGetUsageName(pCurrentHIDElement->usagePage, 
-							 pCurrentHIDElement->usage, usage_name);
-
-		/* some events need more processing than others */
-		switch(pCurrentHIDElement->usage)
-		{
-			case kHIDUsage_GD_Hatswitch:
-				post("  %s\t%s\t%s, %s","abs","abs_hat0x",type_name,usage_name);
-				post("  %s\t%s\t%s, %s","abs","abs_hat0y",type_name,usage_name);
-				break;
-			default:
-				convertDarwinElementToLinuxTypeCode(pCurrentHIDElement,type,code);
-				post("  %s\t%s\t%s, %s",type,code,type_name,usage_name);
-		}
-		
-		pCurrentHIDElement = HIDGetNextDeviceElement (pCurrentHIDElement, kHIDElementTypeInput);
+						pCurrentHIDElement->usage, usage_name);
+		post("  %s\t%s\t%d\t%s, %s", current_element->type->s_name,
+			 current_element->name->s_name,(int) current_element->instance,
+			 type_name, usage_name);
 	}
 	post("");
-
-	return (0);	
 }
 
 
@@ -394,15 +499,15 @@ void hid_ff_print( t_hid *x )
 	if ( x->x_has_ff ) 
 	{
 		result = FFDeviceGetForceFeedbackProperty( (FFDeviceObjectReference) x->x_ff_device, 
-																 FFPROP_AUTOCENTER, 
-																 &value, 
-																 (IOByteCount) sizeof( value ) );
+												   FFPROP_AUTOCENTER, 
+												   &value, 
+												   (IOByteCount) sizeof( value ) );
 		if ( result == FF_OK ) post( "autocenter: %d",value );
 
 		result = FFDeviceGetForceFeedbackProperty( (FFDeviceObjectReference) x->x_ff_device, 
-																 FFPROP_FFGAIN, 
-																 &value, 
-																 (IOByteCount) sizeof( value ) );
+												   FFPROP_FFGAIN, 
+												   &value, 
+												   (IOByteCount) sizeof( value ) );
 		if ( result == FF_OK ) post( "gain: %d", value );
 	}
 
@@ -412,9 +517,8 @@ void hid_ff_print( t_hid *x )
 
 void hid_print_device_list(t_hid *x) 
 {
-	char cstrDeviceName [256];
-	t_int i,numdevs;
-//	UInt32 usagePage, usage;
+	char device_type_buffer[256];
+	t_int i, numdevs;
 	pRecDevice pCurrentHIDDevice = NULL;
 
 	if( HIDHaveDeviceList() )
@@ -425,25 +529,18 @@ void hid_print_device_list(t_hid *x)
 		/* display device list in console */
 		for(i=0; i < numdevs; i++)
 		{
-//			pCurrentHIDDevice = hid_get_device_by_number(i);
 			pCurrentHIDDevice = device_pointer[i];
-			debug_print(LOG_INFO,"Device %d: '%s' '%s' version %d",
-						i,
-						pCurrentHIDDevice->manufacturer,
-						pCurrentHIDDevice->product,
-						pCurrentHIDDevice->version);
-			//usage
-			HIDGetUsageName(pCurrentHIDDevice->usagePage, 
-								  pCurrentHIDDevice->usage, 
-								  cstrDeviceName);
-			debug_print(LOG_INFO,"\t\tcstrDeviceName: %s",cstrDeviceName);
-			debug_print(LOG_INFO,"\t\tusage page: 0x%04x\tusage: 0x%04x",
-						pCurrentHIDDevice->usagePage,
-						pCurrentHIDDevice->usage);
-			debug_print(LOG_INFO,"\t\tvendorID: 0x%04x\tproductID: 0x%04x\tlocID: 0x%08x",
-						  pCurrentHIDDevice->vendorID,
-						  pCurrentHIDDevice->productID,
-						  pCurrentHIDDevice->locID);
+			post("__________________________________________________");
+			post("Device %d: '%s' '%s' version %d @ location 0x%08x", i, 
+				 pCurrentHIDDevice->manufacturer, pCurrentHIDDevice->product, 
+				 pCurrentHIDDevice->version,pCurrentHIDDevice->locID);
+			HIDGetUsageName(pCurrentHIDDevice->usagePage, pCurrentHIDDevice->usage, 
+							device_type_buffer);
+			post("\tdevice type: %s\tusage page: 0x%04x\tusage: 0x%04x",
+				 device_type_buffer, pCurrentHIDDevice->usagePage,
+				 pCurrentHIDDevice->usage);
+			post("\tvendorID: 0x%04x\tproductID: 0x%04x",
+				 pCurrentHIDDevice->vendorID, pCurrentHIDDevice->productID);
 		}
 		post("");
 	}
@@ -491,13 +588,13 @@ void hid_platform_specific_info(t_hid *x)
 							 1, output_atom);
             /* vendor id */
 			sprintf(vendor_id_string,"0x%04x",
-					 (unsigned int)pCurrentHIDDevice->vendorID);
+					(unsigned int)pCurrentHIDDevice->vendorID);
 			SETSYMBOL(output_atom, gensym(vendor_id_string));
 			outlet_anything( x->x_status_outlet, gensym("vendorID"), 
 							 1, output_atom);
             /* product id */
 			sprintf(product_id_string,"0x%04x",
-					 (unsigned int)pCurrentHIDDevice->productID);
+					(unsigned int)pCurrentHIDDevice->productID);
 			SETSYMBOL(output_atom, gensym(product_id_string));
 			outlet_anything( x->x_status_outlet, gensym("productID"), 
 							 1, output_atom);
@@ -506,6 +603,175 @@ void hid_platform_specific_info(t_hid *x)
 	freebytes(output_atom,sizeof(t_atom));
 }
 
+/* ============================================================================== */
+/* Pd [hid] FUNCTIONS */
+/* ============================================================================== */
+
+void hid_get_events(t_hid *x)
+{
+	//debug_print(LOG_DEBUG,"hid_get_events");
+	
+	unsigned int i;
+	pRecDevice  pCurrentHIDDevice;
+	t_hid_element *current_element;
+	IOHIDEventStruct event;
+
+	pCurrentHIDDevice = device_pointer[x->x_device_number];
+
+	/* get the queued events first and store them */
+//	while( (HIDGetEvent(pCurrentHIDDevice, (void*) &event)) && (event_counter < MAX_EVENTS_PER_POLL) ) 
+	while(HIDGetEvent(pCurrentHIDDevice, (void*) &event))
+	{
+		i=0;
+		do {
+			current_element = element[x->x_device_number][i];
+			++i;
+		} while( (i < element_count[x->x_device_number]) && 
+				 (((pRecElement)current_element->os_pointer)->cookie != 
+				  (IOHIDElementCookie) event.elementCookie) );
+		
+		current_element->value = event.value;
+		debug_print(LOG_DEBUG,"output this: %s %s %d prev %d",current_element->type->s_name,
+			 current_element->name->s_name, current_element->value, 
+			 current_element->previous_value);
+	}
+	/* absolute axes don't need to be queued, they can just be polled */
+	for(i=0; i< element_count[x->x_device_number]; ++i)
+	{
+		current_element = element[x->x_device_number][i];
+		if(current_element->polled) 
+		{
+			current_element->value = 
+				HIDGetElementValue(pCurrentHIDDevice, 
+								   (pRecElement)current_element->os_pointer);
+		}
+		if(current_element->previous_value != current_element->value)
+		{
+			hid_output_event(x, current_element);
+			if(!current_element->relative)
+				current_element->previous_value = current_element->value;
+		}
+	}
+}
+
+
+t_int hid_open_device(t_hid *x, short device_number)
+{
+	debug_print(LOG_DEBUG,"hid_open_device");
+
+	t_int result = 0;
+	pRecDevice pCurrentHIDDevice = NULL;
+
+	io_service_t hidDevice = 0;
+	FFDeviceObjectReference ffDeviceReference = NULL;
+
+/* rebuild device list to make sure the list is current */
+	if( !HIDHaveDeviceList() ) hid_build_device_list();
+	
+//	pCurrentHIDDevice = hid_get_device_by_number(device_number);
+	pCurrentHIDDevice = device_pointer[device_number];
+	if( HIDIsValidDevice(pCurrentHIDDevice) )
+	{
+		x->x_device_number = device_number;
+	}
+	else
+	{
+		debug_error(x,LOG_ERR,"[hid]: device %d is not a valid device\n",device_number);
+		return(1);
+	}
+	debug_print(LOG_WARNING,"[hid] opened device %d: %s %s",
+				device_number, pCurrentHIDDevice->manufacturer, pCurrentHIDDevice->product);
+
+	hid_build_element_list(x);
+
+	hidDevice = AllocateHIDObjectFromRecDevice( pCurrentHIDDevice );
+	if( FFIsForceFeedback(hidDevice) == FF_OK ) 
+	{
+		debug_print(LOG_WARNING,"\tdevice has Force Feedback support");
+		if( FFCreateDevice(hidDevice,&ffDeviceReference) == FF_OK ) 
+		{
+			x->x_has_ff = 1;
+			x->x_ff_device = ffDeviceReference;
+		}
+		else
+		{
+			x->x_has_ff = 0;
+			post("[hid]: FF device creation failed!");
+			return( -1 );
+		}
+	}
+	return(result);
+}
+
+
+t_int hid_close_device(t_hid *x)
+{
+	debug_print(LOG_DEBUG,"hid_close_device");
+
+	t_int result = 0;
+//	pRecDevice pCurrentHIDDevice = hid_get_device_by_number(x->x_device_number);
+	pRecDevice pCurrentHIDDevice = device_pointer[x->x_device_number];
+
+	HIDDequeueDevice(pCurrentHIDDevice);
+// this doesn't seem to be needed at all, but why not use it?
+//   result = HIDCloseReleaseInterface(pCurrentHIDDevice);
+	
+	return(result);
+}
+
+
+void hid_build_device_list(void)
+{
+	int device_number = 0;
+	pRecDevice pCurrentHIDDevice;
+	
+	debug_print(LOG_DEBUG,"hid_build_device_list");
+
+	debug_print(LOG_WARNING,"[hid] Building device list...");
+	if(HIDBuildDeviceList (0, 0)) 
+		post("[hid]: no HID devices found\n");
+
+/*	The most recently discovered HID is the first element of the list here.  I
+ *	want the oldest to be number 0 rather than the newest. */
+	device_number = (int) HIDCountDevices();
+	pCurrentHIDDevice = HIDGetFirstDevice();
+	while(pCurrentHIDDevice != NULL)
+	{
+		--device_number;
+		if(device_number < MAX_DEVICES)
+			device_pointer[device_number] = pCurrentHIDDevice;
+		pCurrentHIDDevice = HIDGetNextDevice(pCurrentHIDDevice);
+	}
+	
+	debug_print(LOG_WARNING,"[hid] completed device list.");
+}
+
+
+void hid_print(t_hid *x)
+{
+	if( !HIDHaveDeviceList() ) hid_build_device_list();
+	hid_print_device_list(x);
+	if(x->x_device_open) 
+	{
+		hid_print_element_list(x);
+		hid_ff_print(x);
+	}
+}
+
+
+void hid_platform_specific_free(t_hid *x)
+{
+	debug_print(LOG_DEBUG,"hid_platform_specific_free");
+/* only call this if the last instance is being freed */
+	if (hid_instance_count < 1) 
+	{
+		DEBUG(post("RELEASE ALL hid_instance_count: %d", hid_instance_count););
+		HIDReleaseAllDeviceQueues();
+		HIDReleaseDeviceList();
+	}
+}
+
+
 /* ============================================================================== 
  * FORCE FEEDBACK
  * ============================================================================== */
@@ -634,290 +900,14 @@ t_int hid_ff_motors( t_hid *x, t_float value )
 
 t_int hid_ff_fftest ( t_hid *x, t_float value)
 {
-	debug_print(LOG_DEBUG,"hid_get_events");
+	debug_print(LOG_DEBUG,"hid_ff_fftest");
 	
 	return( 0 );
 }
 
-/* ============================================================================== */
-/* Pd [hid] FUNCTIONS */
-/* ============================================================================== */
-
-t_int hid_get_events(t_hid *x)
-{
-	//debug_print(LOG_DEBUG,"hid_get_events");
-
-	SInt32 value;
-	pRecDevice  pCurrentHIDDevice;
-	pRecElement pCurrentHIDElement;
-	IOHIDEventStruct event;
-	char type[256];
-	char code[256];
-	char event_output_string[256];
-//	t_atom event_data[4];
-
-	int event_counter = 0;
-//	Boolean result;
-
-//	pCurrentHIDDevice = hid_get_device_by_number(x->x_device_number);
-	pCurrentHIDDevice = device_pointer[x->x_device_number];
-
-	if(!pCurrentHIDDevice) 
-	{
-		post("[hid] can't find current device %d.  Was it unplugged?",x->x_device_number);
-		return (1);
-	}
-
-	while( (HIDGetEvent(pCurrentHIDDevice, (void*) &event)) && (event_counter < 64) ) 
-	{
-		value = event.value;
-		//post("found event: %d",value);
-		IOHIDElementCookie cookie = (IOHIDElementCookie) event.elementCookie;
-
-		// find the pRecElement using the cookie
-		pCurrentHIDElement =  HIDGetFirstDeviceElement (pCurrentHIDDevice, kHIDElementTypeIO); 
-		while (pCurrentHIDElement && (pCurrentHIDElement->cookie != cookie))
-			pCurrentHIDElement = HIDGetNextDeviceElement (pCurrentHIDElement, kHIDElementTypeIO);
-
-		DEBUG(
-		HIDGetElementNameFromVendorProductCookie(
-			pCurrentHIDDevice->vendorID, pCurrentHIDDevice->productID,
-			(long) pCurrentHIDElement->cookie, event_output_string);
-		); //end DEBUG
-		
-		/* some events need more processing than others */
-		switch(pCurrentHIDElement->usage)
-		{
-			case kHIDUsage_GD_Hatswitch:
-				sprintf(type,"abs");
-				switch (value)
-				{
-/*
- * MacOS X represents this as one event, while [hid] represents it as two
- * distinct axes.  So the conversion requires an added hid_output_event().
+/* ---------------------------------------------------------------------------------------------------- 
+ * the big monster look up table (not used yet)
  */
-					case 0: 
-						sprintf(code,"abs_hat0y");value = 1;
-						hid_output_event(x,gensym(type),gensym(code),(t_float)value);
-						sprintf(code,"abs_hat0x");value = 0;
-						break;
-					case 1: 
-						sprintf(code,"abs_hat0y");value = 1;
-						hid_output_event(x,gensym(type),gensym(code),(t_float)value);
-						sprintf(code,"abs_hat0x");value = 1;
-						break;
-					case 2: 
-						sprintf(code,"abs_hat0y");value = 0;
-						hid_output_event(x,gensym(type),gensym(code),(t_float)value);
-						sprintf(code,"abs_hat0x");value = 1;
-						break;
-					case 3: 
-						sprintf(code,"abs_hat0y");value = -1;
-						hid_output_event(x,gensym(type),gensym(code),(t_float)value);
-						sprintf(code,"abs_hat0x");value = 1;
-						break;
-					case 4: 
-						sprintf(code,"abs_hat0y");value = -1;
-						hid_output_event(x,gensym(type),gensym(code),(t_float)value);
-						sprintf(code,"abs_hat0x");value = 0;
-						break;
-					case 5: 
-						sprintf(code,"abs_hat0y");value = -1;
-						hid_output_event(x,gensym(type),gensym(code),(t_float)value);
-						sprintf(code,"abs_hat0x");value = -1;
-						break;
-					case 6: 
-						sprintf(code,"abs_hat0y");value = 0;
-						hid_output_event(x,gensym(type),gensym(code),(t_float)value);
-						sprintf(code,"abs_hat0x");value = -1;
-						break;
-					case 7: 
-						sprintf(code,"abs_hat0y");value = 1;
-						hid_output_event(x,gensym(type),gensym(code),(t_float)value);
-						sprintf(code,"abs_hat0x");value = -1;
-						break;
-					case 8: 
-						sprintf(code,"abs_hat0y");value = 0;
-						hid_output_event(x,gensym(type),gensym(code),(t_float)value);
-						sprintf(code,"abs_hat0x");value = 0;
-						break;
-				}
-				hid_output_event(x,gensym(type),gensym(code),(t_float)value);
-				break;
-			default:
-				convertDarwinElementToLinuxTypeCode(pCurrentHIDElement,type,code);
-				hid_output_event(x,gensym(type),gensym(code),(t_float)value);
-		}
-
-//		DEBUG(post("type: %s    code: %s   event name: %s",type,code,event_output_string););
-
-		
-		++event_counter;
-	}
-	DEBUG(
-//	if(event_counter)
-//		post("output %d events",event_counter);
-	);
-/* 	/\* get the first element *\/ */
-/* 	pCurrentHIDElement =  HIDGetFirstDeviceElement (pCurrentHIDDevice, kHIDElementTypeIO); */
-/* 	/\* cycle thru all elements *\/ */
-/* 	while (pCurrentHIDElement) */
-/* 	{ */
-/* 		//value = HIDGetElementValue (pCurrentHIDDevice, pCurrentHIDElement); */
-		
-/* 		if (pCurrentHIDElement) */
-/* 		{ */
-/* 			value = HIDGetElementValue (pCurrentHIDDevice, pCurrentHIDElement); */
-/* 			post("current value: %d", value); */
-/* 			// if it's not a button and it's not a hatswitch then calibrate */
-/* /\* 			if(( pCurrentHIDElement->type != kIOHIDElementTypeInput_Button ) && *\/ */
-/* /\* 				( pCurrentHIDElement->usagePage == 0x01 && pCurrentHIDElement->usage != kHIDUsage_GD_Hatswitch))  *\/ */
-/* /\* 				value = HIDCalibrateValue ( value, pCurrentHIDElement ); *\/ */
-
-/* 			/\* type *\/ */
-/* 			//HIDGetTypeName(pCurrentHIDElement->type,type); */
-/* 			convertDarwinToLinuxType((IOHIDElementType) pCurrentHIDElement->type, event_output_string); */
-/* 			SETSYMBOL(event_data, gensym(event_output_string)); */
-/* 			/\* code *\/ */
-/* 			HIDGetUsageName(pCurrentHIDElement->usagePage, pCurrentHIDElement->usage, event_output_string); */
-/* 			SETSYMBOL(event_data + 1, gensym(event_output_string)); */
-/* 			/\* value *\/ */
-/* 			SETFLOAT(event_data + 2, (t_float)value); */
-/* 			/\* time *\/ */
-/* 			// TODO temp space filler for testing, got to find where I get the event time */
-/* 			SETFLOAT(event_data + 3, (t_float)value); */
-/* //			SETFLOAT(event_data + 3, (t_float)(hid_input_event.time).tv_sec); */
-/* 			outlet_anything(x->x_obj.te_outlet,atom_gensym(event_data),3,event_data+1);  */
-/* 		} */
-/* 		pCurrentHIDElement = HIDGetNextDeviceElement (pCurrentHIDElement, kHIDElementTypeIO); */
-/* 	} */
-	return (0);	
-}
-
-
-t_int hid_open_device(t_hid *x, t_int device_number)
-{
-	debug_print(LOG_DEBUG,"hid_open_device");
-
-	t_int result = 0;
-	pRecDevice pCurrentHIDDevice = NULL;
-
-	io_service_t hidDevice = 0;
-	FFDeviceObjectReference ffDeviceReference = NULL;
-
-/* rebuild device list to make sure the list is current */
-	if( !HIDHaveDeviceList() ) hid_build_device_list();
-	
-//	pCurrentHIDDevice = hid_get_device_by_number(device_number);
-	pCurrentHIDDevice = device_pointer[device_number];
-	if( HIDIsValidDevice(pCurrentHIDDevice) )
-	{
-		x->x_device_number = device_number;
-	}
-	else
-	{
-		debug_error(x,LOG_ERR,"[hid]: device %d is not a valid device\n",device_number);
-		return(1);
-	}
-	debug_print(LOG_WARNING,"[hid] opened device %d: %s %s",
-		  device_number, pCurrentHIDDevice->manufacturer, pCurrentHIDDevice->product);
-
-	//hid_build_element_list(x);
-
-	hidDevice = AllocateHIDObjectFromRecDevice( pCurrentHIDDevice );
-	if( FFIsForceFeedback(hidDevice) == FF_OK ) 
-	{
-		debug_print(LOG_WARNING,"\tdevice has Force Feedback support");
-		if( FFCreateDevice(hidDevice,&ffDeviceReference) == FF_OK ) 
-		{
-			x->x_has_ff = 1;
-			x->x_ff_device = ffDeviceReference;
-		}
-		else
-		{
-			x->x_has_ff = 0;
-			post("[hid]: FF device creation failed!");
-			return( -1 );
-		}
-	}
-	
-
-	HIDQueueDevice(pCurrentHIDDevice);
-// TODO: queue all elements except absolute axes, those can just be polled
-/*   if ( HIDIsValidElement( devicePtr, elementPtr ) )  {
-       value = HIDGetElementValue(devicePtr, elementPtr);
-   }
-*/
-	return(result);
-}
-
-
-t_int hid_close_device(t_hid *x)
-{
-	debug_print(LOG_DEBUG,"hid_close_device");
-
-	t_int result = 0;
-//	pRecDevice pCurrentHIDDevice = hid_get_device_by_number(x->x_device_number);
-	pRecDevice pCurrentHIDDevice = device_pointer[x->x_device_number];
-
-	HIDDequeueDevice(pCurrentHIDDevice);
-// this doesn't seem to be needed at all, but why not use it?
-//   result = HIDCloseReleaseInterface(pCurrentHIDDevice);
-	
-	return(result);
-}
-
-
-void hid_build_device_list(void)
-{
-	int device_number = 0;
-	pRecDevice pCurrentHIDDevice;
-	
-	debug_print(LOG_DEBUG,"hid_build_device_list");
-
-	debug_print(LOG_WARNING,"[hid] Building device list...");
-	if(HIDBuildDeviceList (0, 0)) 
-		post("[hid]: no HID devices found\n");
-
-/*	The most recently discovered HID is the first element of the list here.  I
- *	want the oldest to be number 0 rather than the newest. */
-	device_number = (int) HIDCountDevices();
-	pCurrentHIDDevice = HIDGetFirstDevice();
-	while(pCurrentHIDDevice != NULL)
-	{
-		--device_number;
-		if(device_number < MAX_DEVICES)
-			device_pointer[device_number] = pCurrentHIDDevice;
-		pCurrentHIDDevice = HIDGetNextDevice(pCurrentHIDDevice);
-	}
-	
-	debug_print(LOG_WARNING,"[hid] completed device list.");
-}
-
-
-void hid_print(t_hid *x)
-{
-	hid_print_device_list(x);
-	
-	if(x->x_device_open) 
-	{
-		hid_print_element_list(x);
-		hid_ff_print( x );
-	}
-}
-
-
-void hid_platform_specific_free(t_hid *x)
-{
-	debug_print(LOG_DEBUG,"hid_platform_specific_free");
-/* only call this if the last instance is being freed */
-	if (hid_instance_count < 1) 
-	{
-		DEBUG(post("RELEASE ALL hid_instance_count: %d", hid_instance_count););
-		HIDReleaseAllDeviceQueues();
-		HIDReleaseDeviceList();
-	}
-}
 
 //void HIDGetUsageName (const long valueUsagePage, const long valueUsage, char * cstrName)
 char *convertEventsFromDarwinToLinux(pRecElement element)
@@ -929,541 +919,542 @@ char *convertEventsFromDarwinToLinux(pRecElement element)
 
     switch (element->usagePage)
     {
-        case kHIDPage_Undefined:
+	case kHIDPage_Undefined:
+		switch (element->usage)
+		{
+		default: sprintf (cstrName, "Undefined Page, Usage 0x%lx", element->usage); break;
+		}
+		break;
+	case kHIDPage_GenericDesktop:
+		switch (element->usage)
+		{
+		case kHIDUsage_GD_Pointer: sprintf (cstrName, "Pointer"); break;
+		case kHIDUsage_GD_Mouse: sprintf (cstrName, "Mouse"); break;
+		case kHIDUsage_GD_Joystick: sprintf (cstrName, "Joystick"); break;
+		case kHIDUsage_GD_GamePad: sprintf (cstrName, "GamePad"); break;
+		case kHIDUsage_GD_Keyboard: sprintf (cstrName, "Keyboard"); break;
+		case kHIDUsage_GD_Keypad: sprintf (cstrName, "Keypad"); break;
+		case kHIDUsage_GD_MultiAxisController: sprintf (cstrName, "Multi-Axis Controller"); break;
+
+		case kHIDUsage_GD_X: sprintf (cstrName, "X-Axis"); break;
+		case kHIDUsage_GD_Y: sprintf (cstrName, "Y-Axis"); break;
+		case kHIDUsage_GD_Z: sprintf (cstrName, "Z-Axis"); break;
+		case kHIDUsage_GD_Rx: sprintf (cstrName, "X-Rotation"); break;
+		case kHIDUsage_GD_Ry: sprintf (cstrName, "Y-Rotation"); break;
+		case kHIDUsage_GD_Rz: sprintf (cstrName, "Z-Rotation"); break;
+		case kHIDUsage_GD_Slider: sprintf (cstrName, "Slider"); break;
+		case kHIDUsage_GD_Dial: sprintf (cstrName, "Dial"); break;
+		case kHIDUsage_GD_Wheel: sprintf (cstrName, "Wheel"); break;
+		case kHIDUsage_GD_Hatswitch: sprintf (cstrName, "Hatswitch"); break;
+		case kHIDUsage_GD_CountedBuffer: sprintf (cstrName, "Counted Buffer"); break;
+		case kHIDUsage_GD_ByteCount: sprintf (cstrName, "Byte Count"); break;
+		case kHIDUsage_GD_MotionWakeup: sprintf (cstrName, "Motion Wakeup"); break;
+		case kHIDUsage_GD_Start: sprintf (cstrName, "Start"); break;
+		case kHIDUsage_GD_Select: sprintf (cstrName, "Select"); break;
+
+		case kHIDUsage_GD_Vx: sprintf (cstrName, "X-Velocity"); break;
+		case kHIDUsage_GD_Vy: sprintf (cstrName, "Y-Velocity"); break;
+		case kHIDUsage_GD_Vz: sprintf (cstrName, "Z-Velocity"); break;
+		case kHIDUsage_GD_Vbrx: sprintf (cstrName, "X-Rotation Velocity"); break;
+		case kHIDUsage_GD_Vbry: sprintf (cstrName, "Y-Rotation Velocity"); break;
+		case kHIDUsage_GD_Vbrz: sprintf (cstrName, "Z-Rotation Velocity"); break;
+		case kHIDUsage_GD_Vno: sprintf (cstrName, "Vno"); break;
+
+		case kHIDUsage_GD_SystemControl: sprintf (cstrName, "System Control"); break;
+		case kHIDUsage_GD_SystemPowerDown: sprintf (cstrName, "System Power Down"); break;
+		case kHIDUsage_GD_SystemSleep: sprintf (cstrName, "System Sleep"); break;
+		case kHIDUsage_GD_SystemWakeUp: sprintf (cstrName, "System Wake Up"); break;
+		case kHIDUsage_GD_SystemContextMenu: sprintf (cstrName, "System Context Menu"); break;
+		case kHIDUsage_GD_SystemMainMenu: sprintf (cstrName, "System Main Menu"); break;
+		case kHIDUsage_GD_SystemAppMenu: sprintf (cstrName, "System App Menu"); break;
+		case kHIDUsage_GD_SystemMenuHelp: sprintf (cstrName, "System Menu Help"); break;
+		case kHIDUsage_GD_SystemMenuExit: sprintf (cstrName, "System Menu Exit"); break;
+		case kHIDUsage_GD_SystemMenu: sprintf (cstrName, "System Menu"); break;
+		case kHIDUsage_GD_SystemMenuRight: sprintf (cstrName, "System Menu Right"); break;
+		case kHIDUsage_GD_SystemMenuLeft: sprintf (cstrName, "System Menu Left"); break;
+		case kHIDUsage_GD_SystemMenuUp: sprintf (cstrName, "System Menu Up"); break;
+		case kHIDUsage_GD_SystemMenuDown: sprintf (cstrName, "System Menu Down"); break;
+
+		case kHIDUsage_GD_DPadUp: sprintf (cstrName, "DPad Up"); break;
+		case kHIDUsage_GD_DPadDown: sprintf (cstrName, "DPad Down"); break;
+		case kHIDUsage_GD_DPadRight: sprintf (cstrName, "DPad Right"); break;
+		case kHIDUsage_GD_DPadLeft: sprintf (cstrName, "DPad Left"); break;
+
+		case kHIDUsage_GD_Reserved: sprintf (cstrName, "Reserved"); break;
+
+		default: sprintf (cstrName, "Generic Desktop Usage 0x%lx", element->usage); break;
+		}
+		break;
+	case kHIDPage_Simulation:
+		switch (element->usage)
+		{
+		default: sprintf (cstrName, "Simulation Usage 0x%lx", element->usage); break;
+		}
+		break;
+	case kHIDPage_VR:
+		switch (element->usage)
+		{
+		default: sprintf (cstrName, "VR Usage 0x%lx", element->usage); break;
+		}
+		break;
+	case kHIDPage_Sport:
+		switch (element->usage)
+		{
+		default: sprintf (cstrName, "Sport Usage 0x%lx", element->usage); break;
+		}
+		break;
+	case kHIDPage_Game:
+		switch (element->usage)
+		{
+		default: sprintf (cstrName, "Game Usage 0x%lx", element->usage); break;
+		}
+		break;
+	case kHIDPage_KeyboardOrKeypad:
+		switch (element->usage)
+		{
+		default: sprintf (cstrName, "Keyboard Usage 0x%lx", element->usage); break;
+		}
+		break;
+	case kHIDPage_LEDs:
+		switch (element->usage)
+		{
+			// some LED usages
+		case kHIDUsage_LED_IndicatorRed: sprintf (cstrName, "Red LED"); break;
+		case kHIDUsage_LED_IndicatorGreen: sprintf (cstrName, "Green LED"); break;
+		case kHIDUsage_LED_IndicatorAmber: sprintf (cstrName, "Amber LED"); break;
+		case kHIDUsage_LED_GenericIndicator: sprintf (cstrName, "Generic LED"); break;
+		case kHIDUsage_LED_SystemSuspend: sprintf (cstrName, "System Suspend LED"); break;
+		case kHIDUsage_LED_ExternalPowerConnected: sprintf (cstrName, "External Power LED"); break;
+		default: sprintf (cstrName, "LED Usage 0x%lx", element->usage); break;
+		}
+		break;
+	case kHIDPage_Button:
+		switch (element->usage)
+		{
+		default: sprintf (cstrName, "Button #%ld", element->usage); break;
+		}
+		break;
+	case kHIDPage_Ordinal:
+		switch (element->usage)
+		{
+		default: sprintf (cstrName, "Ordinal Instance %lx", element->usage); break;
+		}
+		break;
+	case kHIDPage_Telephony:
+		switch (element->usage)
+		{
+		default: sprintf (cstrName, "Telephony Usage 0x%lx", element->usage); break;
+		}
+		break;
+	case kHIDPage_Consumer:
+		switch (element->usage)
+		{
+		default: sprintf (cstrName, "Consumer Usage 0x%lx", element->usage); break;
+		}
+		break;
+	case kHIDPage_Digitizer:
+		switch (element->usage)
+		{
+		default: sprintf (cstrName, "Digitizer Usage 0x%lx", element->usage); break;
+		}
+		break;
+	case kHIDPage_PID:
+		if (((element->usage >= 0x02) && (element->usage <= 0x1F)) || ((element->usage >= 0x29) && (element->usage <= 0x2F)) ||
+			((element->usage >= 0x35) && (element->usage <= 0x3F)) || ((element->usage >= 0x44) && (element->usage <= 0x4F)) ||
+			(element->usage == 0x8A) || (element->usage == 0x93)  || ((element->usage >= 0x9D) && (element->usage <= 0x9E)) ||
+			((element->usage >= 0xA1) && (element->usage <= 0xA3)) || ((element->usage >= 0xAD) && (element->usage <= 0xFFFF)))
+			sprintf (cstrName, "PID Reserved");
+		else
 			switch (element->usage)
-            {
-                default: sprintf (cstrName, "Undefined Page, Usage 0x%lx", element->usage); break;
-            }
-            break;
-        case kHIDPage_GenericDesktop:
-            switch (element->usage)
-            {
-                case kHIDUsage_GD_Pointer: sprintf (cstrName, "Pointer"); break;
-                case kHIDUsage_GD_Mouse: sprintf (cstrName, "Mouse"); break;
-                case kHIDUsage_GD_Joystick: sprintf (cstrName, "Joystick"); break;
-                case kHIDUsage_GD_GamePad: sprintf (cstrName, "GamePad"); break;
-                case kHIDUsage_GD_Keyboard: sprintf (cstrName, "Keyboard"); break;
-                case kHIDUsage_GD_Keypad: sprintf (cstrName, "Keypad"); break;
-                case kHIDUsage_GD_MultiAxisController: sprintf (cstrName, "Multi-Axis Controller"); break;
-
-                case kHIDUsage_GD_X: sprintf (cstrName, "X-Axis"); break;
-                case kHIDUsage_GD_Y: sprintf (cstrName, "Y-Axis"); break;
-                case kHIDUsage_GD_Z: sprintf (cstrName, "Z-Axis"); break;
-                case kHIDUsage_GD_Rx: sprintf (cstrName, "X-Rotation"); break;
-                case kHIDUsage_GD_Ry: sprintf (cstrName, "Y-Rotation"); break;
-                case kHIDUsage_GD_Rz: sprintf (cstrName, "Z-Rotation"); break;
-                case kHIDUsage_GD_Slider: sprintf (cstrName, "Slider"); break;
-                case kHIDUsage_GD_Dial: sprintf (cstrName, "Dial"); break;
-                case kHIDUsage_GD_Wheel: sprintf (cstrName, "Wheel"); break;
-                case kHIDUsage_GD_Hatswitch: sprintf (cstrName, "Hatswitch"); break;
-                case kHIDUsage_GD_CountedBuffer: sprintf (cstrName, "Counted Buffer"); break;
-                case kHIDUsage_GD_ByteCount: sprintf (cstrName, "Byte Count"); break;
-                case kHIDUsage_GD_MotionWakeup: sprintf (cstrName, "Motion Wakeup"); break;
-                case kHIDUsage_GD_Start: sprintf (cstrName, "Start"); break;
-                case kHIDUsage_GD_Select: sprintf (cstrName, "Select"); break;
-
-                case kHIDUsage_GD_Vx: sprintf (cstrName, "X-Velocity"); break;
-                case kHIDUsage_GD_Vy: sprintf (cstrName, "Y-Velocity"); break;
-                case kHIDUsage_GD_Vz: sprintf (cstrName, "Z-Velocity"); break;
-                case kHIDUsage_GD_Vbrx: sprintf (cstrName, "X-Rotation Velocity"); break;
-                case kHIDUsage_GD_Vbry: sprintf (cstrName, "Y-Rotation Velocity"); break;
-                case kHIDUsage_GD_Vbrz: sprintf (cstrName, "Z-Rotation Velocity"); break;
-                case kHIDUsage_GD_Vno: sprintf (cstrName, "Vno"); break;
-
-                case kHIDUsage_GD_SystemControl: sprintf (cstrName, "System Control"); break;
-                case kHIDUsage_GD_SystemPowerDown: sprintf (cstrName, "System Power Down"); break;
-                case kHIDUsage_GD_SystemSleep: sprintf (cstrName, "System Sleep"); break;
-                case kHIDUsage_GD_SystemWakeUp: sprintf (cstrName, "System Wake Up"); break;
-                case kHIDUsage_GD_SystemContextMenu: sprintf (cstrName, "System Context Menu"); break;
-                case kHIDUsage_GD_SystemMainMenu: sprintf (cstrName, "System Main Menu"); break;
-                case kHIDUsage_GD_SystemAppMenu: sprintf (cstrName, "System App Menu"); break;
-                case kHIDUsage_GD_SystemMenuHelp: sprintf (cstrName, "System Menu Help"); break;
-                case kHIDUsage_GD_SystemMenuExit: sprintf (cstrName, "System Menu Exit"); break;
-                case kHIDUsage_GD_SystemMenu: sprintf (cstrName, "System Menu"); break;
-                case kHIDUsage_GD_SystemMenuRight: sprintf (cstrName, "System Menu Right"); break;
-                case kHIDUsage_GD_SystemMenuLeft: sprintf (cstrName, "System Menu Left"); break;
-                case kHIDUsage_GD_SystemMenuUp: sprintf (cstrName, "System Menu Up"); break;
-                case kHIDUsage_GD_SystemMenuDown: sprintf (cstrName, "System Menu Down"); break;
-
-                case kHIDUsage_GD_DPadUp: sprintf (cstrName, "DPad Up"); break;
-                case kHIDUsage_GD_DPadDown: sprintf (cstrName, "DPad Down"); break;
-                case kHIDUsage_GD_DPadRight: sprintf (cstrName, "DPad Right"); break;
-                case kHIDUsage_GD_DPadLeft: sprintf (cstrName, "DPad Left"); break;
-
-                case kHIDUsage_GD_Reserved: sprintf (cstrName, "Reserved"); break;
-
-                default: sprintf (cstrName, "Generic Desktop Usage 0x%lx", element->usage); break;
-            }
-            break;
-        case kHIDPage_Simulation:
-            switch (element->usage)
-            {
-                default: sprintf (cstrName, "Simulation Usage 0x%lx", element->usage); break;
-            }
-            break;
-        case kHIDPage_VR:
-            switch (element->usage)
-            {
-                default: sprintf (cstrName, "VR Usage 0x%lx", element->usage); break;
-            }
-            break;
-        case kHIDPage_Sport:
-            switch (element->usage)
-            {
-                default: sprintf (cstrName, "Sport Usage 0x%lx", element->usage); break;
-            }
-            break;
-        case kHIDPage_Game:
-            switch (element->usage)
-            {
-                default: sprintf (cstrName, "Game Usage 0x%lx", element->usage); break;
-            }
-            break;
-        case kHIDPage_KeyboardOrKeypad:
-            switch (element->usage)
-            {
-                default: sprintf (cstrName, "Keyboard Usage 0x%lx", element->usage); break;
-            }
-            break;
-        case kHIDPage_LEDs:
-            switch (element->usage)
-            {
-				// some LED usages
-				case kHIDUsage_LED_IndicatorRed: sprintf (cstrName, "Red LED"); break;
-				case kHIDUsage_LED_IndicatorGreen: sprintf (cstrName, "Green LED"); break;
-				case kHIDUsage_LED_IndicatorAmber: sprintf (cstrName, "Amber LED"); break;
-				case kHIDUsage_LED_GenericIndicator: sprintf (cstrName, "Generic LED"); break;
-				case kHIDUsage_LED_SystemSuspend: sprintf (cstrName, "System Suspend LED"); break;
-				case kHIDUsage_LED_ExternalPowerConnected: sprintf (cstrName, "External Power LED"); break;
-				default: sprintf (cstrName, "LED Usage 0x%lx", element->usage); break;
-            }
-            break;
-        case kHIDPage_Button:
-            switch (element->usage)
-            {
-                default: sprintf (cstrName, "Button #%ld", element->usage); break;
-            }
-            break;
-        case kHIDPage_Ordinal:
-            switch (element->usage)
-            {
-                default: sprintf (cstrName, "Ordinal Instance %lx", element->usage); break;
-            }
-            break;
-        case kHIDPage_Telephony:
-            switch (element->usage)
-            {
-                default: sprintf (cstrName, "Telephony Usage 0x%lx", element->usage); break;
-            }
-            break;
-        case kHIDPage_Consumer:
-            switch (element->usage)
-            {
-                default: sprintf (cstrName, "Consumer Usage 0x%lx", element->usage); break;
-            }
-            break;
-        case kHIDPage_Digitizer:
-            switch (element->usage)
-            {
-                default: sprintf (cstrName, "Digitizer Usage 0x%lx", element->usage); break;
-            }
-            break;
-        case kHIDPage_PID:
-			if (((element->usage >= 0x02) && (element->usage <= 0x1F)) || ((element->usage >= 0x29) && (element->usage <= 0x2F)) ||
-	   ((element->usage >= 0x35) && (element->usage <= 0x3F)) || ((element->usage >= 0x44) && (element->usage <= 0x4F)) ||
-	   (element->usage == 0x8A) || (element->usage == 0x93)  || ((element->usage >= 0x9D) && (element->usage <= 0x9E)) ||
-	   ((element->usage >= 0xA1) && (element->usage <= 0xA3)) || ((element->usage >= 0xAD) && (element->usage <= 0xFFFF)))
-                sprintf (cstrName, "PID Reserved");
-			else
-				switch (element->usage)
-				{
-					case 0x00: sprintf (cstrName, "PID Undefined Usage"); break;
-					case kHIDUsage_PID_PhysicalInterfaceDevice: sprintf (cstrName, "Physical Interface Device"); break;
-					case kHIDUsage_PID_Normal: sprintf (cstrName, "Normal Force"); break;
-
-					case kHIDUsage_PID_SetEffectReport: sprintf (cstrName, "Set Effect Report"); break;
-					case kHIDUsage_PID_EffectBlockIndex: sprintf (cstrName, "Effect Block Index"); break;
-					case kHIDUsage_PID_ParamBlockOffset: sprintf (cstrName, "Parameter Block Offset"); break;
-					case kHIDUsage_PID_ROM_Flag: sprintf (cstrName, "ROM Flag"); break;
-
-					case kHIDUsage_PID_EffectType: sprintf (cstrName, "Effect Type"); break;
-					case kHIDUsage_PID_ET_ConstantForce: sprintf (cstrName, "Effect Type Constant Force"); break;
-					case kHIDUsage_PID_ET_Ramp: sprintf (cstrName, "Effect Type Ramp"); break;
-					case kHIDUsage_PID_ET_CustomForceData: sprintf (cstrName, "Effect Type Custom Force Data"); break;
-					case kHIDUsage_PID_ET_Square: sprintf (cstrName, "Effect Type Square"); break;
-					case kHIDUsage_PID_ET_Sine: sprintf (cstrName, "Effect Type Sine"); break;
-					case kHIDUsage_PID_ET_Triangle: sprintf (cstrName, "Effect Type Triangle"); break;
-					case kHIDUsage_PID_ET_SawtoothUp: sprintf (cstrName, "Effect Type Sawtooth Up"); break;
-					case kHIDUsage_PID_ET_SawtoothDown: sprintf (cstrName, "Effect Type Sawtooth Down"); break;
-					case kHIDUsage_PID_ET_Spring: sprintf (cstrName, "Effect Type Spring"); break;
-					case kHIDUsage_PID_ET_Damper: sprintf (cstrName, "Effect Type Damper"); break;
-					case kHIDUsage_PID_ET_Inertia: sprintf (cstrName, "Effect Type Inertia"); break;
-					case kHIDUsage_PID_ET_Friction: sprintf (cstrName, "Effect Type Friction"); break;
-					case kHIDUsage_PID_Duration: sprintf (cstrName, "Effect Duration"); break;
-					case kHIDUsage_PID_SamplePeriod: sprintf (cstrName, "Effect Sample Period"); break;
-					case kHIDUsage_PID_Gain: sprintf (cstrName, "Effect Gain"); break;
-					case kHIDUsage_PID_TriggerButton: sprintf (cstrName, "Effect Trigger Button"); break;
-					case kHIDUsage_PID_TriggerRepeatInterval: sprintf (cstrName, "Effect Trigger Repeat Interval"); break;
-
-					case kHIDUsage_PID_AxesEnable: sprintf (cstrName, "Axis Enable"); break;
-					case kHIDUsage_PID_DirectionEnable: sprintf (cstrName, "Direction Enable"); break;
-
-					case kHIDUsage_PID_Direction: sprintf (cstrName, "Direction"); break;
-
-					case kHIDUsage_PID_TypeSpecificBlockOffset: sprintf (cstrName, "Type Specific Block Offset"); break;
-
-					case kHIDUsage_PID_BlockType: sprintf (cstrName, "Block Type"); break;
-
-					case kHIDUsage_PID_SetEnvelopeReport: sprintf (cstrName, "Set Envelope Report"); break;
-					case kHIDUsage_PID_AttackLevel: sprintf (cstrName, "Envelope Attack Level"); break;
-					case kHIDUsage_PID_AttackTime: sprintf (cstrName, "Envelope Attack Time"); break;
-					case kHIDUsage_PID_FadeLevel: sprintf (cstrName, "Envelope Fade Level"); break;
-					case kHIDUsage_PID_FadeTime: sprintf (cstrName, "Envelope Fade Time"); break;
-
-					case kHIDUsage_PID_SetConditionReport: sprintf (cstrName, "Set Condition Report"); break;
-					case kHIDUsage_PID_CP_Offset: sprintf (cstrName, "Condition CP Offset"); break;
-					case kHIDUsage_PID_PositiveCoefficient: sprintf (cstrName, "Condition Positive Coefficient"); break;
-					case kHIDUsage_PID_NegativeCoefficient: sprintf (cstrName, "Condition Negative Coefficient"); break;
-					case kHIDUsage_PID_PositiveSaturation: sprintf (cstrName, "Condition Positive Saturation"); break;
-					case kHIDUsage_PID_NegativeSaturation: sprintf (cstrName, "Condition Negative Saturation"); break;
-					case kHIDUsage_PID_DeadBand: sprintf (cstrName, "Condition Dead Band"); break;
-
-					case kHIDUsage_PID_DownloadForceSample: sprintf (cstrName, "Download Force Sample"); break;
-					case kHIDUsage_PID_IsochCustomForceEnable: sprintf (cstrName, "Isoch Custom Force Enable"); break;
-
-					case kHIDUsage_PID_CustomForceDataReport: sprintf (cstrName, "Custom Force Data Report"); break;
-					case kHIDUsage_PID_CustomForceData: sprintf (cstrName, "Custom Force Data"); break;
-
-					case kHIDUsage_PID_CustomForceVendorDefinedData: sprintf (cstrName, "Custom Force Vendor Defined Data"); break;
-					case kHIDUsage_PID_SetCustomForceReport: sprintf (cstrName, "Set Custom Force Report"); break;
-					case kHIDUsage_PID_CustomForceDataOffset: sprintf (cstrName, "Custom Force Data Offset"); break;
-					case kHIDUsage_PID_SampleCount: sprintf (cstrName, "Custom Force Sample Count"); break;
-
-					case kHIDUsage_PID_SetPeriodicReport: sprintf (cstrName, "Set Periodic Report"); break;
-					case kHIDUsage_PID_Offset: sprintf (cstrName, "Periodic Offset"); break;
-					case kHIDUsage_PID_Magnitude: sprintf (cstrName, "Periodic Magnitude"); break;
-					case kHIDUsage_PID_Phase: sprintf (cstrName, "Periodic Phase"); break;
-					case kHIDUsage_PID_Period: sprintf (cstrName, "Periodic Period"); break;
-
-					case kHIDUsage_PID_SetConstantForceReport: sprintf (cstrName, "Set Constant Force Report"); break;
-
-					case kHIDUsage_PID_SetRampForceReport: sprintf (cstrName, "Set Ramp Force Report"); break;
-					case kHIDUsage_PID_RampStart: sprintf (cstrName, "Ramp Start"); break;
-					case kHIDUsage_PID_RampEnd: sprintf (cstrName, "Ramp End"); break;
-
-					case kHIDUsage_PID_EffectOperationReport: sprintf (cstrName, "Effect Operation Report"); break;
-
-					case kHIDUsage_PID_EffectOperation: sprintf (cstrName, "Effect Operation"); break;
-					case kHIDUsage_PID_OpEffectStart: sprintf (cstrName, "Op Effect Start"); break;
-					case kHIDUsage_PID_OpEffectStartSolo: sprintf (cstrName, "Op Effect Start Solo"); break;
-					case kHIDUsage_PID_OpEffectStop: sprintf (cstrName, "Op Effect Stop"); break;
-					case kHIDUsage_PID_LoopCount: sprintf (cstrName, "Op Effect Loop Count"); break;
-
-					case kHIDUsage_PID_DeviceGainReport: sprintf (cstrName, "Device Gain Report"); break;
-					case kHIDUsage_PID_DeviceGain: sprintf (cstrName, "Device Gain"); break;
-
-					case kHIDUsage_PID_PoolReport: sprintf (cstrName, "PID Pool Report"); break;
-					case kHIDUsage_PID_RAM_PoolSize: sprintf (cstrName, "RAM Pool Size"); break;
-					case kHIDUsage_PID_ROM_PoolSize: sprintf (cstrName, "ROM Pool Size"); break;
-					case kHIDUsage_PID_ROM_EffectBlockCount: sprintf (cstrName, "ROM Effect Block Count"); break;
-					case kHIDUsage_PID_SimultaneousEffectsMax: sprintf (cstrName, "Simultaneous Effects Max"); break;
-					case kHIDUsage_PID_PoolAlignment: sprintf (cstrName, "Pool Alignment"); break;
-
-					case kHIDUsage_PID_PoolMoveReport: sprintf (cstrName, "PID Pool Move Report"); break;
-					case kHIDUsage_PID_MoveSource: sprintf (cstrName, "Move Source"); break;
-					case kHIDUsage_PID_MoveDestination: sprintf (cstrName, "Move Destination"); break;
-					case kHIDUsage_PID_MoveLength: sprintf (cstrName, "Move Length"); break;
-
-					case kHIDUsage_PID_BlockLoadReport: sprintf (cstrName, "PID Block Load Report"); break;
-
-					case kHIDUsage_PID_BlockLoadStatus: sprintf (cstrName, "Block Load Status"); break;
-					case kHIDUsage_PID_BlockLoadSuccess: sprintf (cstrName, "Block Load Success"); break;
-					case kHIDUsage_PID_BlockLoadFull: sprintf (cstrName, "Block Load Full"); break;
-					case kHIDUsage_PID_BlockLoadError: sprintf (cstrName, "Block Load Error"); break;
-					case kHIDUsage_PID_BlockHandle: sprintf (cstrName, "Block Handle"); break;
-
-					case kHIDUsage_PID_BlockFreeReport: sprintf (cstrName, "PID Block Free Report"); break;
-
-					case kHIDUsage_PID_TypeSpecificBlockHandle: sprintf (cstrName, "Type Specific Block Handle"); break;
-
-					case kHIDUsage_PID_StateReport: sprintf (cstrName, "PID State Report"); break;
-					case kHIDUsage_PID_EffectPlaying: sprintf (cstrName, "Effect Playing"); break;
-
-					case kHIDUsage_PID_DeviceControlReport: sprintf (cstrName, "PID Device Control Report"); break;
-
-					case kHIDUsage_PID_DeviceControl: sprintf (cstrName, "PID Device Control"); break;
-					case kHIDUsage_PID_DC_EnableActuators: sprintf (cstrName, "Device Control Enable Actuators"); break;
-					case kHIDUsage_PID_DC_DisableActuators: sprintf (cstrName, "Device Control Disable Actuators"); break;
-					case kHIDUsage_PID_DC_StopAllEffects: sprintf (cstrName, "Device Control Stop All Effects"); break;
-					case kHIDUsage_PID_DC_DeviceReset: sprintf (cstrName, "Device Control Reset"); break;
-					case kHIDUsage_PID_DC_DevicePause: sprintf (cstrName, "Device Control Pause"); break;
-					case kHIDUsage_PID_DC_DeviceContinue: sprintf (cstrName, "Device Control Continue"); break;
-					case kHIDUsage_PID_DevicePaused: sprintf (cstrName, "Device Paused"); break;
-					case kHIDUsage_PID_ActuatorsEnabled: sprintf (cstrName, "Actuators Enabled"); break;
-					case kHIDUsage_PID_SafetySwitch: sprintf (cstrName, "Safety Switch"); break;
-					case kHIDUsage_PID_ActuatorOverrideSwitch: sprintf (cstrName, "Actuator Override Switch"); break;
-					case kHIDUsage_PID_ActuatorPower: sprintf (cstrName, "Actuator Power"); break;
-					case kHIDUsage_PID_StartDelay: sprintf (cstrName, "Start Delay"); break;
-
-					case kHIDUsage_PID_ParameterBlockSize: sprintf (cstrName, "Parameter Block Size"); break;
-					case kHIDUsage_PID_DeviceManagedPool: sprintf (cstrName, "Device Managed Pool"); break;
-					case kHIDUsage_PID_SharedParameterBlocks: sprintf (cstrName, "Shared Parameter Blocks"); break;
-
-					case kHIDUsage_PID_CreateNewEffectReport: sprintf (cstrName, "Create New Effect Report"); break;
-					case kHIDUsage_PID_RAM_PoolAvailable: sprintf (cstrName, "RAM Pool Available"); break;
-					default: sprintf (cstrName, "PID Usage 0x%lx", element->usage); break;
-				}
-					break;
-        case kHIDPage_Unicode:
-            switch (element->usage)
-            {
-                default: sprintf (cstrName, "Unicode Usage 0x%lx", element->usage); break;
-            }
-            break;
-        case kHIDPage_PowerDevice:
-			if (((element->usage >= 0x06) && (element->usage <= 0x0F)) || ((element->usage >= 0x26) && (element->usage <= 0x2F)) ||
-	   ((element->usage >= 0x39) && (element->usage <= 0x3F)) || ((element->usage >= 0x48) && (element->usage <= 0x4F)) ||
-	   ((element->usage >= 0x58) && (element->usage <= 0x5F)) || (element->usage == 0x6A) ||
-	   ((element->usage >= 0x74) && (element->usage <= 0xFC)))
-                sprintf (cstrName, "Power Device Reserved");
-			else
-				switch (element->usage)
-				{
-					case kHIDUsage_PD_Undefined: sprintf (cstrName, "Power Device Undefined Usage"); break;
-					case kHIDUsage_PD_iName: sprintf (cstrName, "Power Device Name Index"); break;
-					case kHIDUsage_PD_PresentStatus: sprintf (cstrName, "Power Device Present Status"); break;
-					case kHIDUsage_PD_ChangedStatus: sprintf (cstrName, "Power Device Changed Status"); break;
-					case kHIDUsage_PD_UPS: sprintf (cstrName, "Uninterruptible Power Supply"); break;
-					case kHIDUsage_PD_PowerSupply: sprintf (cstrName, "Power Supply"); break;
-
-					case kHIDUsage_PD_BatterySystem: sprintf (cstrName, "Battery System Power Module"); break;
-					case kHIDUsage_PD_BatterySystemID: sprintf (cstrName, "Battery System ID"); break;
-					case kHIDUsage_PD_Battery: sprintf (cstrName, "Battery"); break;
-					case kHIDUsage_PD_BatteryID: sprintf (cstrName, "Battery ID"); break;
-					case kHIDUsage_PD_Charger: sprintf (cstrName, "Charger"); break;
-					case kHIDUsage_PD_ChargerID: sprintf (cstrName, "Charger ID"); break;
-					case kHIDUsage_PD_PowerConverter: sprintf (cstrName, "Power Converter Power Module"); break;
-					case kHIDUsage_PD_PowerConverterID: sprintf (cstrName, "Power Converter ID"); break;
-					case kHIDUsage_PD_OutletSystem: sprintf (cstrName, "Outlet System power module"); break;
-					case kHIDUsage_PD_OutletSystemID: sprintf (cstrName, "Outlet System ID"); break;
-					case kHIDUsage_PD_Input: sprintf (cstrName, "Power Device Input"); break;
-					case kHIDUsage_PD_InputID: sprintf (cstrName, "Power Device Input ID"); break;
-					case kHIDUsage_PD_Output: sprintf (cstrName, "Power Device Output"); break;
-					case kHIDUsage_PD_OutputID: sprintf (cstrName, "Power Device Output ID"); break;
-					case kHIDUsage_PD_Flow: sprintf (cstrName, "Power Device Flow"); break;
-					case kHIDUsage_PD_FlowID: sprintf (cstrName, "Power Device Flow ID"); break;
-					case kHIDUsage_PD_Outlet: sprintf (cstrName, "Power Device Outlet"); break;
-					case kHIDUsage_PD_OutletID: sprintf (cstrName, "Power Device Outlet ID"); break;
-					case kHIDUsage_PD_Gang: sprintf (cstrName, "Power Device Gang"); break;
-					case kHIDUsage_PD_GangID: sprintf (cstrName, "Power Device Gang ID"); break;
-					case kHIDUsage_PD_PowerSummary: sprintf (cstrName, "Power Device Power Summary"); break;
-					case kHIDUsage_PD_PowerSummaryID: sprintf (cstrName, "Power Device Power Summary ID"); break;
-
-					case kHIDUsage_PD_Voltage: sprintf (cstrName, "Power Device Voltage"); break;
-					case kHIDUsage_PD_Current: sprintf (cstrName, "Power Device Current"); break;
-					case kHIDUsage_PD_Frequency: sprintf (cstrName, "Power Device Frequency"); break;
-					case kHIDUsage_PD_ApparentPower: sprintf (cstrName, "Power Device Apparent Power"); break;
-					case kHIDUsage_PD_ActivePower: sprintf (cstrName, "Power Device RMS Power"); break;
-					case kHIDUsage_PD_PercentLoad: sprintf (cstrName, "Power Device Percent Load"); break;
-					case kHIDUsage_PD_Temperature: sprintf (cstrName, "Power Device Temperature"); break;
-					case kHIDUsage_PD_Humidity: sprintf (cstrName, "Power Device Humidity"); break;
-					case kHIDUsage_PD_BadCount: sprintf (cstrName, "Power Device Bad Condition Count"); break;
-
-					case kHIDUsage_PD_ConfigVoltage: sprintf (cstrName, "Power Device Nominal Voltage"); break;
-					case kHIDUsage_PD_ConfigCurrent: sprintf (cstrName, "Power Device Nominal Current"); break;
-					case kHIDUsage_PD_ConfigFrequency: sprintf (cstrName, "Power Device Nominal Frequency"); break;
-					case kHIDUsage_PD_ConfigApparentPower: sprintf (cstrName, "Power Device Nominal Apparent Power"); break;
-					case kHIDUsage_PD_ConfigActivePower: sprintf (cstrName, "Power Device Nominal RMS Power"); break;
-					case kHIDUsage_PD_ConfigPercentLoad: sprintf (cstrName, "Power Device Nominal Percent Load"); break;
-					case kHIDUsage_PD_ConfigTemperature: sprintf (cstrName, "Power Device Nominal Temperature"); break;
-
-					case kHIDUsage_PD_ConfigHumidity: sprintf (cstrName, "Power Device Nominal Humidity"); break;
-					case kHIDUsage_PD_SwitchOnControl: sprintf (cstrName, "Power Device Switch On Control"); break;
-					case kHIDUsage_PD_SwitchOffControl: sprintf (cstrName, "Power Device Switch Off Control"); break;
-					case kHIDUsage_PD_ToggleControl: sprintf (cstrName, "Power Device Toogle Sequence Control"); break;
-					case kHIDUsage_PD_LowVoltageTransfer: sprintf (cstrName, "Power Device Min Transfer Voltage"); break;
-					case kHIDUsage_PD_HighVoltageTransfer: sprintf (cstrName, "Power Device Max Transfer Voltage"); break;
-					case kHIDUsage_PD_DelayBeforeReboot: sprintf (cstrName, "Power Device Delay Before Reboot"); break;
-					case kHIDUsage_PD_DelayBeforeStartup: sprintf (cstrName, "Power Device Delay Before Startup"); break;
-					case kHIDUsage_PD_DelayBeforeShutdown: sprintf (cstrName, "Power Device Delay Before Shutdown"); break;
-					case kHIDUsage_PD_Test: sprintf (cstrName, "Power Device Test Request/Result"); break;
-					case kHIDUsage_PD_ModuleReset: sprintf (cstrName, "Power Device Reset Request/Result"); break;
-					case kHIDUsage_PD_AudibleAlarmControl: sprintf (cstrName, "Power Device Audible Alarm Control"); break;
-
-					case kHIDUsage_PD_Present: sprintf (cstrName, "Power Device Present"); break;
-					case kHIDUsage_PD_Good: sprintf (cstrName, "Power Device Good"); break;
-					case kHIDUsage_PD_InternalFailure: sprintf (cstrName, "Power Device Internal Failure"); break;
-					case kHIDUsage_PD_VoltageOutOfRange: sprintf (cstrName, "Power Device Voltage Out Of Range"); break;
-					case kHIDUsage_PD_FrequencyOutOfRange: sprintf (cstrName, "Power Device Frequency Out Of Range"); break;
-					case kHIDUsage_PD_Overload: sprintf (cstrName, "Power Device Overload"); break;
-					case kHIDUsage_PD_OverCharged: sprintf (cstrName, "Power Device Over Charged"); break;
-					case kHIDUsage_PD_OverTemperature: sprintf (cstrName, "Power Device Over Temperature"); break;
-					case kHIDUsage_PD_ShutdownRequested: sprintf (cstrName, "Power Device Shutdown Requested"); break;
-
-					case kHIDUsage_PD_ShutdownImminent: sprintf (cstrName, "Power Device Shutdown Imminent"); break;
-					case kHIDUsage_PD_SwitchOnOff: sprintf (cstrName, "Power Device On/Off Switch Status"); break;
-					case kHIDUsage_PD_Switchable: sprintf (cstrName, "Power Device Switchable"); break;
-					case kHIDUsage_PD_Used: sprintf (cstrName, "Power Device Used"); break;
-					case kHIDUsage_PD_Boost: sprintf (cstrName, "Power Device Boosted"); break;
-					case kHIDUsage_PD_Buck: sprintf (cstrName, "Power Device Bucked"); break;
-					case kHIDUsage_PD_Initialized: sprintf (cstrName, "Power Device Initialized"); break;
-					case kHIDUsage_PD_Tested: sprintf (cstrName, "Power Device Tested"); break;
-					case kHIDUsage_PD_AwaitingPower: sprintf (cstrName, "Power Device Awaiting Power"); break;
-					case kHIDUsage_PD_CommunicationLost: sprintf (cstrName, "Power Device Communication Lost"); break;
-
-					case kHIDUsage_PD_iManufacturer: sprintf (cstrName, "Power Device Manufacturer String Index"); break;
-					case kHIDUsage_PD_iProduct: sprintf (cstrName, "Power Device Product String Index"); break;
-					case kHIDUsage_PD_iserialNumber: sprintf (cstrName, "Power Device Serial Number String Index"); break;
-					default: sprintf (cstrName, "Power Device Usage 0x%lx", element->usage); break;
-				}
-					break;
-        case kHIDPage_BatterySystem:
-			if (((element->usage >= 0x0A) && (element->usage <= 0x0F)) || ((element->usage >= 0x1E) && (element->usage <= 0x27)) ||
-	   ((element->usage >= 0x30) && (element->usage <= 0x3F)) || ((element->usage >= 0x4C) && (element->usage <= 0x5F)) ||
-	   ((element->usage >= 0x6C) && (element->usage <= 0x7F)) || ((element->usage >= 0x90) && (element->usage <= 0xBF)) ||
-	   ((element->usage >= 0xC3) && (element->usage <= 0xCF)) || ((element->usage >= 0xDD) && (element->usage <= 0xEF)) ||
-	   ((element->usage >= 0xF2) && (element->usage <= 0xFF)))
-                sprintf (cstrName, "Power Device Reserved");
-			else
-				switch (element->usage)
-				{
-					case kHIDUsage_BS_Undefined: sprintf (cstrName, "Battery System Undefined"); break;
-					case kHIDUsage_BS_SMBBatteryMode: sprintf (cstrName, "SMB Mode"); break;
-					case kHIDUsage_BS_SMBBatteryStatus: sprintf (cstrName, "SMB Status"); break;
-					case kHIDUsage_BS_SMBAlarmWarning: sprintf (cstrName, "SMB Alarm Warning"); break;
-					case kHIDUsage_BS_SMBChargerMode: sprintf (cstrName, "SMB Charger Mode"); break;
-					case kHIDUsage_BS_SMBChargerStatus: sprintf (cstrName, "SMB Charger Status"); break;
-					case kHIDUsage_BS_SMBChargerSpecInfo: sprintf (cstrName, "SMB Charger Extended Status"); break;
-					case kHIDUsage_BS_SMBSelectorState: sprintf (cstrName, "SMB Selector State"); break;
-					case kHIDUsage_BS_SMBSelectorPresets: sprintf (cstrName, "SMB Selector Presets"); break;
-					case kHIDUsage_BS_SMBSelectorInfo: sprintf (cstrName, "SMB Selector Info"); break;
-					case kHIDUsage_BS_OptionalMfgFunction1: sprintf (cstrName, "Battery System Optional SMB Mfg Function 1"); break;
-					case kHIDUsage_BS_OptionalMfgFunction2: sprintf (cstrName, "Battery System Optional SMB Mfg Function 2"); break;
-					case kHIDUsage_BS_OptionalMfgFunction3: sprintf (cstrName, "Battery System Optional SMB Mfg Function 3"); break;
-					case kHIDUsage_BS_OptionalMfgFunction4: sprintf (cstrName, "Battery System Optional SMB Mfg Function 4"); break;
-					case kHIDUsage_BS_OptionalMfgFunction5: sprintf (cstrName, "Battery System Optional SMB Mfg Function 5"); break;
-					case kHIDUsage_BS_ConnectionToSMBus: sprintf (cstrName, "Battery System Connection To System Management Bus"); break;
-					case kHIDUsage_BS_OutputConnection: sprintf (cstrName, "Battery System Output Connection Status"); break;
-					case kHIDUsage_BS_ChargerConnection: sprintf (cstrName, "Battery System Charger Connection"); break;
-					case kHIDUsage_BS_BatteryInsertion: sprintf (cstrName, "Battery System Battery Insertion"); break;
-					case kHIDUsage_BS_Usenext: sprintf (cstrName, "Battery System Use Next"); break;
-					case kHIDUsage_BS_OKToUse: sprintf (cstrName, "Battery System OK To Use"); break;
-					case kHIDUsage_BS_BatterySupported: sprintf (cstrName, "Battery System Battery Supported"); break;
-					case kHIDUsage_BS_SelectorRevision: sprintf (cstrName, "Battery System Selector Revision"); break;
-					case kHIDUsage_BS_ChargingIndicator: sprintf (cstrName, "Battery System Charging Indicator"); break;
-					case kHIDUsage_BS_ManufacturerAccess: sprintf (cstrName, "Battery System Manufacturer Access"); break;
-					case kHIDUsage_BS_RemainingCapacityLimit: sprintf (cstrName, "Battery System Remaining Capacity Limit"); break;
-					case kHIDUsage_BS_RemainingTimeLimit: sprintf (cstrName, "Battery System Remaining Time Limit"); break;
-					case kHIDUsage_BS_AtRate: sprintf (cstrName, "Battery System At Rate..."); break;
-					case kHIDUsage_BS_CapacityMode: sprintf (cstrName, "Battery System Capacity Mode"); break;
-					case kHIDUsage_BS_BroadcastToCharger: sprintf (cstrName, "Battery System Broadcast To Charger"); break;
-					case kHIDUsage_BS_PrimaryBattery: sprintf (cstrName, "Battery System Primary Battery"); break;
-					case kHIDUsage_BS_ChargeController: sprintf (cstrName, "Battery System Charge Controller"); break;
-					case kHIDUsage_BS_TerminateCharge: sprintf (cstrName, "Battery System Terminate Charge"); break;
-					case kHIDUsage_BS_TerminateDischarge: sprintf (cstrName, "Battery System Terminate Discharge"); break;
-					case kHIDUsage_BS_BelowRemainingCapacityLimit: sprintf (cstrName, "Battery System Below Remaining Capacity Limit"); break;
-					case kHIDUsage_BS_RemainingTimeLimitExpired: sprintf (cstrName, "Battery System Remaining Time Limit Expired"); break;
-					case kHIDUsage_BS_Charging: sprintf (cstrName, "Battery System Charging"); break;
-					case kHIDUsage_BS_Discharging: sprintf (cstrName, "Battery System Discharging"); break;
-					case kHIDUsage_BS_FullyCharged: sprintf (cstrName, "Battery System Fully Charged"); break;
-					case kHIDUsage_BS_FullyDischarged: sprintf (cstrName, "Battery System Fully Discharged"); break;
-					case kHIDUsage_BS_ConditioningFlag: sprintf (cstrName, "Battery System Conditioning Flag"); break;
-					case kHIDUsage_BS_AtRateOK: sprintf (cstrName, "Battery System At Rate OK"); break;
-					case kHIDUsage_BS_SMBErrorCode: sprintf (cstrName, "Battery System SMB Error Code"); break;
-					case kHIDUsage_BS_NeedReplacement: sprintf (cstrName, "Battery System Need Replacement"); break;
-					case kHIDUsage_BS_AtRateTimeToFull: sprintf (cstrName, "Battery System At Rate Time To Full"); break;
-					case kHIDUsage_BS_AtRateTimeToEmpty: sprintf (cstrName, "Battery System At Rate Time To Empty"); break;
-					case kHIDUsage_BS_AverageCurrent: sprintf (cstrName, "Battery System Average Current"); break;
-					case kHIDUsage_BS_Maxerror: sprintf (cstrName, "Battery System Max Error"); break;
-					case kHIDUsage_BS_RelativeStateOfCharge: sprintf (cstrName, "Battery System Relative State Of Charge"); break;
-					case kHIDUsage_BS_AbsoluteStateOfCharge: sprintf (cstrName, "Battery System Absolute State Of Charge"); break;
-					case kHIDUsage_BS_RemainingCapacity: sprintf (cstrName, "Battery System Remaining Capacity"); break;
-					case kHIDUsage_BS_FullChargeCapacity: sprintf (cstrName, "Battery System Full Charge Capacity"); break;
-					case kHIDUsage_BS_RunTimeToEmpty: sprintf (cstrName, "Battery System Run Time To Empty"); break;
-					case kHIDUsage_BS_AverageTimeToEmpty: sprintf (cstrName, "Battery System Average Time To Empty"); break;
-					case kHIDUsage_BS_AverageTimeToFull: sprintf (cstrName, "Battery System Average Time To Full"); break;
-					case kHIDUsage_BS_CycleCount: sprintf (cstrName, "Battery System Cycle Count"); break;
-					case kHIDUsage_BS_BattPackModelLevel: sprintf (cstrName, "Battery System Batt Pack Model Level"); break;
-					case kHIDUsage_BS_InternalChargeController: sprintf (cstrName, "Battery System Internal Charge Controller"); break;
-					case kHIDUsage_BS_PrimaryBatterySupport: sprintf (cstrName, "Battery System Primary Battery Support"); break;
-					case kHIDUsage_BS_DesignCapacity: sprintf (cstrName, "Battery System Design Capacity"); break;
-					case kHIDUsage_BS_SpecificationInfo: sprintf (cstrName, "Battery System Specification Info"); break;
-					case kHIDUsage_BS_ManufacturerDate: sprintf (cstrName, "Battery System Manufacturer Date"); break;
-					case kHIDUsage_BS_SerialNumber: sprintf (cstrName, "Battery System Serial Number"); break;
-					case kHIDUsage_BS_iManufacturerName: sprintf (cstrName, "Battery System Manufacturer Name Index"); break;
-					case kHIDUsage_BS_iDevicename: sprintf (cstrName, "Battery System Device Name Index"); break;
-					case kHIDUsage_BS_iDeviceChemistry: sprintf (cstrName, "Battery System Device Chemistry Index"); break;
-					case kHIDUsage_BS_ManufacturerData: sprintf (cstrName, "Battery System Manufacturer Data"); break;
-					case kHIDUsage_BS_Rechargable: sprintf (cstrName, "Battery System Rechargable"); break;
-					case kHIDUsage_BS_WarningCapacityLimit: sprintf (cstrName, "Battery System Warning Capacity Limit"); break;
-					case kHIDUsage_BS_CapacityGranularity1: sprintf (cstrName, "Battery System Capacity Granularity 1"); break;
-					case kHIDUsage_BS_CapacityGranularity2: sprintf (cstrName, "Battery System Capacity Granularity 2"); break;
-					case kHIDUsage_BS_iOEMInformation: sprintf (cstrName, "Battery System OEM Information Index"); break;
-					case kHIDUsage_BS_InhibitCharge: sprintf (cstrName, "Battery System Inhibit Charge"); break;
-					case kHIDUsage_BS_EnablePolling: sprintf (cstrName, "Battery System Enable Polling"); break;
-					case kHIDUsage_BS_ResetToZero: sprintf (cstrName, "Battery System Reset To Zero"); break;
-					case kHIDUsage_BS_ACPresent: sprintf (cstrName, "Battery System AC Present"); break;
-					case kHIDUsage_BS_BatteryPresent: sprintf (cstrName, "Battery System Battery Present"); break;
-					case kHIDUsage_BS_PowerFail: sprintf (cstrName, "Battery System Power Fail"); break;
-					case kHIDUsage_BS_AlarmInhibited: sprintf (cstrName, "Battery System Alarm Inhibited"); break;
-					case kHIDUsage_BS_ThermistorUnderRange: sprintf (cstrName, "Battery System Thermistor Under Range"); break;
-					case kHIDUsage_BS_ThermistorHot: sprintf (cstrName, "Battery System Thermistor Hot"); break;
-					case kHIDUsage_BS_ThermistorCold: sprintf (cstrName, "Battery System Thermistor Cold"); break;
-					case kHIDUsage_BS_ThermistorOverRange: sprintf (cstrName, "Battery System Thermistor Over Range"); break;
-					case kHIDUsage_BS_VoltageOutOfRange: sprintf (cstrName, "Battery System Voltage Out Of Range"); break;
-					case kHIDUsage_BS_CurrentOutOfRange: sprintf (cstrName, "Battery System Current Out Of Range"); break;
-					case kHIDUsage_BS_CurrentNotRegulated: sprintf (cstrName, "Battery System Current Not Regulated"); break;
-					case kHIDUsage_BS_VoltageNotRegulated: sprintf (cstrName, "Battery System Voltage Not Regulated"); break;
-					case kHIDUsage_BS_MasterMode: sprintf (cstrName, "Battery System Master Mode"); break;
-					case kHIDUsage_BS_ChargerSelectorSupport: sprintf (cstrName, "Battery System Charger Support Selector"); break;
-					case kHIDUsage_BS_ChargerSpec: sprintf (cstrName, "attery System Charger Specification"); break;
-					case kHIDUsage_BS_Level2: sprintf (cstrName, "Battery System Charger Level 2"); break;
-					case kHIDUsage_BS_Level3: sprintf (cstrName, "Battery System Charger Level 3"); break;
-					default: sprintf (cstrName, "Battery System Usage 0x%lx", element->usage); break;
-				}
-					break;
-        case kHIDPage_AlphanumericDisplay:
-            switch (element->usage)
-            {
-                default: sprintf (cstrName, "Alphanumeric Display Usage 0x%lx", element->usage); break;
-            }
-            break;
-		case kHIDPage_BarCodeScanner:
-            switch (element->usage)
-            {
-                default: sprintf (cstrName, "Bar Code Scanner Usage 0x%lx", element->usage); break;
-            }
-            break;
-        case kHIDPage_Scale:
-            switch (element->usage)
-            {
-                default: sprintf (cstrName, "Scale Usage 0x%lx", element->usage); break;
-            }
-            break;
-        case kHIDPage_CameraControl:
-            switch (element->usage)
-            {
-                default: sprintf (cstrName, "Camera Control Usage 0x%lx", element->usage); break;
-            }
-            break;
-        case kHIDPage_Arcade:
-            switch (element->usage)
-            {
-                default: sprintf (cstrName, "Arcade Usage 0x%lx", element->usage); break;
-            }
-            break;
-        default:
-			if (element->usagePage > kHIDPage_VendorDefinedStart)
-				sprintf (cstrName, "Vendor Defined Usage 0x%lx", element->usage);
-			else
-				sprintf (cstrName, "Page: 0x%lx, Usage: 0x%lx", element->usagePage, element->usage);
-            break;
+			{
+			case 0x00: sprintf (cstrName, "PID Undefined Usage"); break;
+			case kHIDUsage_PID_PhysicalInterfaceDevice: sprintf (cstrName, "Physical Interface Device"); break;
+			case kHIDUsage_PID_Normal: sprintf (cstrName, "Normal Force"); break;
+
+			case kHIDUsage_PID_SetEffectReport: sprintf (cstrName, "Set Effect Report"); break;
+			case kHIDUsage_PID_EffectBlockIndex: sprintf (cstrName, "Effect Block Index"); break;
+			case kHIDUsage_PID_ParamBlockOffset: sprintf (cstrName, "Parameter Block Offset"); break;
+			case kHIDUsage_PID_ROM_Flag: sprintf (cstrName, "ROM Flag"); break;
+
+			case kHIDUsage_PID_EffectType: sprintf (cstrName, "Effect Type"); break;
+			case kHIDUsage_PID_ET_ConstantForce: sprintf (cstrName, "Effect Type Constant Force"); break;
+			case kHIDUsage_PID_ET_Ramp: sprintf (cstrName, "Effect Type Ramp"); break;
+			case kHIDUsage_PID_ET_CustomForceData: sprintf (cstrName, "Effect Type Custom Force Data"); break;
+			case kHIDUsage_PID_ET_Square: sprintf (cstrName, "Effect Type Square"); break;
+			case kHIDUsage_PID_ET_Sine: sprintf (cstrName, "Effect Type Sine"); break;
+			case kHIDUsage_PID_ET_Triangle: sprintf (cstrName, "Effect Type Triangle"); break;
+			case kHIDUsage_PID_ET_SawtoothUp: sprintf (cstrName, "Effect Type Sawtooth Up"); break;
+			case kHIDUsage_PID_ET_SawtoothDown: sprintf (cstrName, "Effect Type Sawtooth Down"); break;
+			case kHIDUsage_PID_ET_Spring: sprintf (cstrName, "Effect Type Spring"); break;
+			case kHIDUsage_PID_ET_Damper: sprintf (cstrName, "Effect Type Damper"); break;
+			case kHIDUsage_PID_ET_Inertia: sprintf (cstrName, "Effect Type Inertia"); break;
+			case kHIDUsage_PID_ET_Friction: sprintf (cstrName, "Effect Type Friction"); break;
+			case kHIDUsage_PID_Duration: sprintf (cstrName, "Effect Duration"); break;
+			case kHIDUsage_PID_SamplePeriod: sprintf (cstrName, "Effect Sample Period"); break;
+			case kHIDUsage_PID_Gain: sprintf (cstrName, "Effect Gain"); break;
+			case kHIDUsage_PID_TriggerButton: sprintf (cstrName, "Effect Trigger Button"); break;
+			case kHIDUsage_PID_TriggerRepeatInterval: sprintf (cstrName, "Effect Trigger Repeat Interval"); break;
+
+			case kHIDUsage_PID_AxesEnable: sprintf (cstrName, "Axis Enable"); break;
+			case kHIDUsage_PID_DirectionEnable: sprintf (cstrName, "Direction Enable"); break;
+
+			case kHIDUsage_PID_Direction: sprintf (cstrName, "Direction"); break;
+
+			case kHIDUsage_PID_TypeSpecificBlockOffset: sprintf (cstrName, "Type Specific Block Offset"); break;
+
+			case kHIDUsage_PID_BlockType: sprintf (cstrName, "Block Type"); break;
+
+			case kHIDUsage_PID_SetEnvelopeReport: sprintf (cstrName, "Set Envelope Report"); break;
+			case kHIDUsage_PID_AttackLevel: sprintf (cstrName, "Envelope Attack Level"); break;
+			case kHIDUsage_PID_AttackTime: sprintf (cstrName, "Envelope Attack Time"); break;
+			case kHIDUsage_PID_FadeLevel: sprintf (cstrName, "Envelope Fade Level"); break;
+			case kHIDUsage_PID_FadeTime: sprintf (cstrName, "Envelope Fade Time"); break;
+
+			case kHIDUsage_PID_SetConditionReport: sprintf (cstrName, "Set Condition Report"); break;
+			case kHIDUsage_PID_CP_Offset: sprintf (cstrName, "Condition CP Offset"); break;
+			case kHIDUsage_PID_PositiveCoefficient: sprintf (cstrName, "Condition Positive Coefficient"); break;
+			case kHIDUsage_PID_NegativeCoefficient: sprintf (cstrName, "Condition Negative Coefficient"); break;
+			case kHIDUsage_PID_PositiveSaturation: sprintf (cstrName, "Condition Positive Saturation"); break;
+			case kHIDUsage_PID_NegativeSaturation: sprintf (cstrName, "Condition Negative Saturation"); break;
+			case kHIDUsage_PID_DeadBand: sprintf (cstrName, "Condition Dead Band"); break;
+
+			case kHIDUsage_PID_DownloadForceSample: sprintf (cstrName, "Download Force Sample"); break;
+			case kHIDUsage_PID_IsochCustomForceEnable: sprintf (cstrName, "Isoch Custom Force Enable"); break;
+
+			case kHIDUsage_PID_CustomForceDataReport: sprintf (cstrName, "Custom Force Data Report"); break;
+			case kHIDUsage_PID_CustomForceData: sprintf (cstrName, "Custom Force Data"); break;
+
+			case kHIDUsage_PID_CustomForceVendorDefinedData: sprintf (cstrName, "Custom Force Vendor Defined Data"); break;
+			case kHIDUsage_PID_SetCustomForceReport: sprintf (cstrName, "Set Custom Force Report"); break;
+			case kHIDUsage_PID_CustomForceDataOffset: sprintf (cstrName, "Custom Force Data Offset"); break;
+			case kHIDUsage_PID_SampleCount: sprintf (cstrName, "Custom Force Sample Count"); break;
+
+			case kHIDUsage_PID_SetPeriodicReport: sprintf (cstrName, "Set Periodic Report"); break;
+			case kHIDUsage_PID_Offset: sprintf (cstrName, "Periodic Offset"); break;
+			case kHIDUsage_PID_Magnitude: sprintf (cstrName, "Periodic Magnitude"); break;
+			case kHIDUsage_PID_Phase: sprintf (cstrName, "Periodic Phase"); break;
+			case kHIDUsage_PID_Period: sprintf (cstrName, "Periodic Period"); break;
+
+			case kHIDUsage_PID_SetConstantForceReport: sprintf (cstrName, "Set Constant Force Report"); break;
+
+			case kHIDUsage_PID_SetRampForceReport: sprintf (cstrName, "Set Ramp Force Report"); break;
+			case kHIDUsage_PID_RampStart: sprintf (cstrName, "Ramp Start"); break;
+			case kHIDUsage_PID_RampEnd: sprintf (cstrName, "Ramp End"); break;
+
+			case kHIDUsage_PID_EffectOperationReport: sprintf (cstrName, "Effect Operation Report"); break;
+
+			case kHIDUsage_PID_EffectOperation: sprintf (cstrName, "Effect Operation"); break;
+			case kHIDUsage_PID_OpEffectStart: sprintf (cstrName, "Op Effect Start"); break;
+			case kHIDUsage_PID_OpEffectStartSolo: sprintf (cstrName, "Op Effect Start Solo"); break;
+			case kHIDUsage_PID_OpEffectStop: sprintf (cstrName, "Op Effect Stop"); break;
+			case kHIDUsage_PID_LoopCount: sprintf (cstrName, "Op Effect Loop Count"); break;
+
+			case kHIDUsage_PID_DeviceGainReport: sprintf (cstrName, "Device Gain Report"); break;
+			case kHIDUsage_PID_DeviceGain: sprintf (cstrName, "Device Gain"); break;
+
+			case kHIDUsage_PID_PoolReport: sprintf (cstrName, "PID Pool Report"); break;
+			case kHIDUsage_PID_RAM_PoolSize: sprintf (cstrName, "RAM Pool Size"); break;
+			case kHIDUsage_PID_ROM_PoolSize: sprintf (cstrName, "ROM Pool Size"); break;
+			case kHIDUsage_PID_ROM_EffectBlockCount: sprintf (cstrName, "ROM Effect Block Count"); break;
+			case kHIDUsage_PID_SimultaneousEffectsMax: sprintf (cstrName, "Simultaneous Effects Max"); break;
+			case kHIDUsage_PID_PoolAlignment: sprintf (cstrName, "Pool Alignment"); break;
+
+			case kHIDUsage_PID_PoolMoveReport: sprintf (cstrName, "PID Pool Move Report"); break;
+			case kHIDUsage_PID_MoveSource: sprintf (cstrName, "Move Source"); break;
+			case kHIDUsage_PID_MoveDestination: sprintf (cstrName, "Move Destination"); break;
+			case kHIDUsage_PID_MoveLength: sprintf (cstrName, "Move Length"); break;
+
+			case kHIDUsage_PID_BlockLoadReport: sprintf (cstrName, "PID Block Load Report"); break;
+
+			case kHIDUsage_PID_BlockLoadStatus: sprintf (cstrName, "Block Load Status"); break;
+			case kHIDUsage_PID_BlockLoadSuccess: sprintf (cstrName, "Block Load Success"); break;
+			case kHIDUsage_PID_BlockLoadFull: sprintf (cstrName, "Block Load Full"); break;
+			case kHIDUsage_PID_BlockLoadError: sprintf (cstrName, "Block Load Error"); break;
+			case kHIDUsage_PID_BlockHandle: sprintf (cstrName, "Block Handle"); break;
+
+			case kHIDUsage_PID_BlockFreeReport: sprintf (cstrName, "PID Block Free Report"); break;
+
+			case kHIDUsage_PID_TypeSpecificBlockHandle: sprintf (cstrName, "Type Specific Block Handle"); break;
+
+			case kHIDUsage_PID_StateReport: sprintf (cstrName, "PID State Report"); break;
+			case kHIDUsage_PID_EffectPlaying: sprintf (cstrName, "Effect Playing"); break;
+
+			case kHIDUsage_PID_DeviceControlReport: sprintf (cstrName, "PID Device Control Report"); break;
+
+			case kHIDUsage_PID_DeviceControl: sprintf (cstrName, "PID Device Control"); break;
+			case kHIDUsage_PID_DC_EnableActuators: sprintf (cstrName, "Device Control Enable Actuators"); break;
+			case kHIDUsage_PID_DC_DisableActuators: sprintf (cstrName, "Device Control Disable Actuators"); break;
+			case kHIDUsage_PID_DC_StopAllEffects: sprintf (cstrName, "Device Control Stop All Effects"); break;
+			case kHIDUsage_PID_DC_DeviceReset: sprintf (cstrName, "Device Control Reset"); break;
+			case kHIDUsage_PID_DC_DevicePause: sprintf (cstrName, "Device Control Pause"); break;
+			case kHIDUsage_PID_DC_DeviceContinue: sprintf (cstrName, "Device Control Continue"); break;
+			case kHIDUsage_PID_DevicePaused: sprintf (cstrName, "Device Paused"); break;
+			case kHIDUsage_PID_ActuatorsEnabled: sprintf (cstrName, "Actuators Enabled"); break;
+			case kHIDUsage_PID_SafetySwitch: sprintf (cstrName, "Safety Switch"); break;
+			case kHIDUsage_PID_ActuatorOverrideSwitch: sprintf (cstrName, "Actuator Override Switch"); break;
+			case kHIDUsage_PID_ActuatorPower: sprintf (cstrName, "Actuator Power"); break;
+			case kHIDUsage_PID_StartDelay: sprintf (cstrName, "Start Delay"); break;
+
+			case kHIDUsage_PID_ParameterBlockSize: sprintf (cstrName, "Parameter Block Size"); break;
+			case kHIDUsage_PID_DeviceManagedPool: sprintf (cstrName, "Device Managed Pool"); break;
+			case kHIDUsage_PID_SharedParameterBlocks: sprintf (cstrName, "Shared Parameter Blocks"); break;
+
+			case kHIDUsage_PID_CreateNewEffectReport: sprintf (cstrName, "Create New Effect Report"); break;
+			case kHIDUsage_PID_RAM_PoolAvailable: sprintf (cstrName, "RAM Pool Available"); break;
+			default: sprintf (cstrName, "PID Usage 0x%lx", element->usage); break;
+			}
+		break;
+	case kHIDPage_Unicode:
+		switch (element->usage)
+		{
+		default: sprintf (cstrName, "Unicode Usage 0x%lx", element->usage); break;
+		}
+		break;
+	case kHIDPage_PowerDevice:
+		if (((element->usage >= 0x06) && (element->usage <= 0x0F)) || ((element->usage >= 0x26) && (element->usage <= 0x2F)) ||
+			((element->usage >= 0x39) && (element->usage <= 0x3F)) || ((element->usage >= 0x48) && (element->usage <= 0x4F)) ||
+			((element->usage >= 0x58) && (element->usage <= 0x5F)) || (element->usage == 0x6A) ||
+			((element->usage >= 0x74) && (element->usage <= 0xFC)))
+			sprintf (cstrName, "Power Device Reserved");
+		else
+			switch (element->usage)
+			{
+			case kHIDUsage_PD_Undefined: sprintf (cstrName, "Power Device Undefined Usage"); break;
+			case kHIDUsage_PD_iName: sprintf (cstrName, "Power Device Name Index"); break;
+			case kHIDUsage_PD_PresentStatus: sprintf (cstrName, "Power Device Present Status"); break;
+			case kHIDUsage_PD_ChangedStatus: sprintf (cstrName, "Power Device Changed Status"); break;
+			case kHIDUsage_PD_UPS: sprintf (cstrName, "Uninterruptible Power Supply"); break;
+			case kHIDUsage_PD_PowerSupply: sprintf (cstrName, "Power Supply"); break;
+
+			case kHIDUsage_PD_BatterySystem: sprintf (cstrName, "Battery System Power Module"); break;
+			case kHIDUsage_PD_BatterySystemID: sprintf (cstrName, "Battery System ID"); break;
+			case kHIDUsage_PD_Battery: sprintf (cstrName, "Battery"); break;
+			case kHIDUsage_PD_BatteryID: sprintf (cstrName, "Battery ID"); break;
+			case kHIDUsage_PD_Charger: sprintf (cstrName, "Charger"); break;
+			case kHIDUsage_PD_ChargerID: sprintf (cstrName, "Charger ID"); break;
+			case kHIDUsage_PD_PowerConverter: sprintf (cstrName, "Power Converter Power Module"); break;
+			case kHIDUsage_PD_PowerConverterID: sprintf (cstrName, "Power Converter ID"); break;
+			case kHIDUsage_PD_OutletSystem: sprintf (cstrName, "Outlet System power module"); break;
+			case kHIDUsage_PD_OutletSystemID: sprintf (cstrName, "Outlet System ID"); break;
+			case kHIDUsage_PD_Input: sprintf (cstrName, "Power Device Input"); break;
+			case kHIDUsage_PD_InputID: sprintf (cstrName, "Power Device Input ID"); break;
+			case kHIDUsage_PD_Output: sprintf (cstrName, "Power Device Output"); break;
+			case kHIDUsage_PD_OutputID: sprintf (cstrName, "Power Device Output ID"); break;
+			case kHIDUsage_PD_Flow: sprintf (cstrName, "Power Device Flow"); break;
+			case kHIDUsage_PD_FlowID: sprintf (cstrName, "Power Device Flow ID"); break;
+			case kHIDUsage_PD_Outlet: sprintf (cstrName, "Power Device Outlet"); break;
+			case kHIDUsage_PD_OutletID: sprintf (cstrName, "Power Device Outlet ID"); break;
+			case kHIDUsage_PD_Gang: sprintf (cstrName, "Power Device Gang"); break;
+			case kHIDUsage_PD_GangID: sprintf (cstrName, "Power Device Gang ID"); break;
+			case kHIDUsage_PD_PowerSummary: sprintf (cstrName, "Power Device Power Summary"); break;
+			case kHIDUsage_PD_PowerSummaryID: sprintf (cstrName, "Power Device Power Summary ID"); break;
+
+			case kHIDUsage_PD_Voltage: sprintf (cstrName, "Power Device Voltage"); break;
+			case kHIDUsage_PD_Current: sprintf (cstrName, "Power Device Current"); break;
+			case kHIDUsage_PD_Frequency: sprintf (cstrName, "Power Device Frequency"); break;
+			case kHIDUsage_PD_ApparentPower: sprintf (cstrName, "Power Device Apparent Power"); break;
+			case kHIDUsage_PD_ActivePower: sprintf (cstrName, "Power Device RMS Power"); break;
+			case kHIDUsage_PD_PercentLoad: sprintf (cstrName, "Power Device Percent Load"); break;
+			case kHIDUsage_PD_Temperature: sprintf (cstrName, "Power Device Temperature"); break;
+			case kHIDUsage_PD_Humidity: sprintf (cstrName, "Power Device Humidity"); break;
+			case kHIDUsage_PD_BadCount: sprintf (cstrName, "Power Device Bad Condition Count"); break;
+
+			case kHIDUsage_PD_ConfigVoltage: sprintf (cstrName, "Power Device Nominal Voltage"); break;
+			case kHIDUsage_PD_ConfigCurrent: sprintf (cstrName, "Power Device Nominal Current"); break;
+			case kHIDUsage_PD_ConfigFrequency: sprintf (cstrName, "Power Device Nominal Frequency"); break;
+			case kHIDUsage_PD_ConfigApparentPower: sprintf (cstrName, "Power Device Nominal Apparent Power"); break;
+			case kHIDUsage_PD_ConfigActivePower: sprintf (cstrName, "Power Device Nominal RMS Power"); break;
+			case kHIDUsage_PD_ConfigPercentLoad: sprintf (cstrName, "Power Device Nominal Percent Load"); break;
+			case kHIDUsage_PD_ConfigTemperature: sprintf (cstrName, "Power Device Nominal Temperature"); break;
+
+			case kHIDUsage_PD_ConfigHumidity: sprintf (cstrName, "Power Device Nominal Humidity"); break;
+			case kHIDUsage_PD_SwitchOnControl: sprintf (cstrName, "Power Device Switch On Control"); break;
+			case kHIDUsage_PD_SwitchOffControl: sprintf (cstrName, "Power Device Switch Off Control"); break;
+			case kHIDUsage_PD_ToggleControl: sprintf (cstrName, "Power Device Toogle Sequence Control"); break;
+			case kHIDUsage_PD_LowVoltageTransfer: sprintf (cstrName, "Power Device Min Transfer Voltage"); break;
+			case kHIDUsage_PD_HighVoltageTransfer: sprintf (cstrName, "Power Device Max Transfer Voltage"); break;
+			case kHIDUsage_PD_DelayBeforeReboot: sprintf (cstrName, "Power Device Delay Before Reboot"); break;
+			case kHIDUsage_PD_DelayBeforeStartup: sprintf (cstrName, "Power Device Delay Before Startup"); break;
+			case kHIDUsage_PD_DelayBeforeShutdown: sprintf (cstrName, "Power Device Delay Before Shutdown"); break;
+			case kHIDUsage_PD_Test: sprintf (cstrName, "Power Device Test Request/Result"); break;
+			case kHIDUsage_PD_ModuleReset: sprintf (cstrName, "Power Device Reset Request/Result"); break;
+			case kHIDUsage_PD_AudibleAlarmControl: sprintf (cstrName, "Power Device Audible Alarm Control"); break;
+
+			case kHIDUsage_PD_Present: sprintf (cstrName, "Power Device Present"); break;
+			case kHIDUsage_PD_Good: sprintf (cstrName, "Power Device Good"); break;
+			case kHIDUsage_PD_InternalFailure: sprintf (cstrName, "Power Device Internal Failure"); break;
+			case kHIDUsage_PD_VoltageOutOfRange: sprintf (cstrName, "Power Device Voltage Out Of Range"); break;
+			case kHIDUsage_PD_FrequencyOutOfRange: sprintf (cstrName, "Power Device Frequency Out Of Range"); break;
+			case kHIDUsage_PD_Overload: sprintf (cstrName, "Power Device Overload"); break;
+			case kHIDUsage_PD_OverCharged: sprintf (cstrName, "Power Device Over Charged"); break;
+			case kHIDUsage_PD_OverTemperature: sprintf (cstrName, "Power Device Over Temperature"); break;
+			case kHIDUsage_PD_ShutdownRequested: sprintf (cstrName, "Power Device Shutdown Requested"); break;
+
+			case kHIDUsage_PD_ShutdownImminent: sprintf (cstrName, "Power Device Shutdown Imminent"); break;
+			case kHIDUsage_PD_SwitchOnOff: sprintf (cstrName, "Power Device On/Off Switch Status"); break;
+			case kHIDUsage_PD_Switchable: sprintf (cstrName, "Power Device Switchable"); break;
+			case kHIDUsage_PD_Used: sprintf (cstrName, "Power Device Used"); break;
+			case kHIDUsage_PD_Boost: sprintf (cstrName, "Power Device Boosted"); break;
+			case kHIDUsage_PD_Buck: sprintf (cstrName, "Power Device Bucked"); break;
+			case kHIDUsage_PD_Initialized: sprintf (cstrName, "Power Device Initialized"); break;
+			case kHIDUsage_PD_Tested: sprintf (cstrName, "Power Device Tested"); break;
+			case kHIDUsage_PD_AwaitingPower: sprintf (cstrName, "Power Device Awaiting Power"); break;
+			case kHIDUsage_PD_CommunicationLost: sprintf (cstrName, "Power Device Communication Lost"); break;
+
+			case kHIDUsage_PD_iManufacturer: sprintf (cstrName, "Power Device Manufacturer String Index"); break;
+			case kHIDUsage_PD_iProduct: sprintf (cstrName, "Power Device Product String Index"); break;
+			case kHIDUsage_PD_iserialNumber: sprintf (cstrName, "Power Device Serial Number String Index"); break;
+			default: sprintf (cstrName, "Power Device Usage 0x%lx", element->usage); break;
+			}
+		break;
+	case kHIDPage_BatterySystem:
+		if (((element->usage >= 0x0A) && (element->usage <= 0x0F)) || ((element->usage >= 0x1E) && (element->usage <= 0x27)) ||
+			((element->usage >= 0x30) && (element->usage <= 0x3F)) || ((element->usage >= 0x4C) && (element->usage <= 0x5F)) ||
+			((element->usage >= 0x6C) && (element->usage <= 0x7F)) || ((element->usage >= 0x90) && (element->usage <= 0xBF)) ||
+			((element->usage >= 0xC3) && (element->usage <= 0xCF)) || ((element->usage >= 0xDD) && (element->usage <= 0xEF)) ||
+			((element->usage >= 0xF2) && (element->usage <= 0xFF)))
+			sprintf (cstrName, "Power Device Reserved");
+		else
+			switch (element->usage)
+			{
+			case kHIDUsage_BS_Undefined: sprintf (cstrName, "Battery System Undefined"); break;
+			case kHIDUsage_BS_SMBBatteryMode: sprintf (cstrName, "SMB Mode"); break;
+			case kHIDUsage_BS_SMBBatteryStatus: sprintf (cstrName, "SMB Status"); break;
+			case kHIDUsage_BS_SMBAlarmWarning: sprintf (cstrName, "SMB Alarm Warning"); break;
+			case kHIDUsage_BS_SMBChargerMode: sprintf (cstrName, "SMB Charger Mode"); break;
+			case kHIDUsage_BS_SMBChargerStatus: sprintf (cstrName, "SMB Charger Status"); break;
+			case kHIDUsage_BS_SMBChargerSpecInfo: sprintf (cstrName, "SMB Charger Extended Status"); break;
+			case kHIDUsage_BS_SMBSelectorState: sprintf (cstrName, "SMB Selector State"); break;
+			case kHIDUsage_BS_SMBSelectorPresets: sprintf (cstrName, "SMB Selector Presets"); break;
+			case kHIDUsage_BS_SMBSelectorInfo: sprintf (cstrName, "SMB Selector Info"); break;
+			case kHIDUsage_BS_OptionalMfgFunction1: sprintf (cstrName, "Battery System Optional SMB Mfg Function 1"); break;
+			case kHIDUsage_BS_OptionalMfgFunction2: sprintf (cstrName, "Battery System Optional SMB Mfg Function 2"); break;
+			case kHIDUsage_BS_OptionalMfgFunction3: sprintf (cstrName, "Battery System Optional SMB Mfg Function 3"); break;
+			case kHIDUsage_BS_OptionalMfgFunction4: sprintf (cstrName, "Battery System Optional SMB Mfg Function 4"); break;
+			case kHIDUsage_BS_OptionalMfgFunction5: sprintf (cstrName, "Battery System Optional SMB Mfg Function 5"); break;
+			case kHIDUsage_BS_ConnectionToSMBus: sprintf (cstrName, "Battery System Connection To System Management Bus"); break;
+			case kHIDUsage_BS_OutputConnection: sprintf (cstrName, "Battery System Output Connection Status"); break;
+			case kHIDUsage_BS_ChargerConnection: sprintf (cstrName, "Battery System Charger Connection"); break;
+			case kHIDUsage_BS_BatteryInsertion: sprintf (cstrName, "Battery System Battery Insertion"); break;
+			case kHIDUsage_BS_Usenext: sprintf (cstrName, "Battery System Use Next"); break;
+			case kHIDUsage_BS_OKToUse: sprintf (cstrName, "Battery System OK To Use"); break;
+			case kHIDUsage_BS_BatterySupported: sprintf (cstrName, "Battery System Battery Supported"); break;
+			case kHIDUsage_BS_SelectorRevision: sprintf (cstrName, "Battery System Selector Revision"); break;
+			case kHIDUsage_BS_ChargingIndicator: sprintf (cstrName, "Battery System Charging Indicator"); break;
+			case kHIDUsage_BS_ManufacturerAccess: sprintf (cstrName, "Battery System Manufacturer Access"); break;
+			case kHIDUsage_BS_RemainingCapacityLimit: sprintf (cstrName, "Battery System Remaining Capacity Limit"); break;
+			case kHIDUsage_BS_RemainingTimeLimit: sprintf (cstrName, "Battery System Remaining Time Limit"); break;
+			case kHIDUsage_BS_AtRate: sprintf (cstrName, "Battery System At Rate..."); break;
+			case kHIDUsage_BS_CapacityMode: sprintf (cstrName, "Battery System Capacity Mode"); break;
+			case kHIDUsage_BS_BroadcastToCharger: sprintf (cstrName, "Battery System Broadcast To Charger"); break;
+			case kHIDUsage_BS_PrimaryBattery: sprintf (cstrName, "Battery System Primary Battery"); break;
+			case kHIDUsage_BS_ChargeController: sprintf (cstrName, "Battery System Charge Controller"); break;
+			case kHIDUsage_BS_TerminateCharge: sprintf (cstrName, "Battery System Terminate Charge"); break;
+			case kHIDUsage_BS_TerminateDischarge: sprintf (cstrName, "Battery System Terminate Discharge"); break;
+			case kHIDUsage_BS_BelowRemainingCapacityLimit: sprintf (cstrName, "Battery System Below Remaining Capacity Limit"); break;
+			case kHIDUsage_BS_RemainingTimeLimitExpired: sprintf (cstrName, "Battery System Remaining Time Limit Expired"); break;
+			case kHIDUsage_BS_Charging: sprintf (cstrName, "Battery System Charging"); break;
+			case kHIDUsage_BS_Discharging: sprintf (cstrName, "Battery System Discharging"); break;
+			case kHIDUsage_BS_FullyCharged: sprintf (cstrName, "Battery System Fully Charged"); break;
+			case kHIDUsage_BS_FullyDischarged: sprintf (cstrName, "Battery System Fully Discharged"); break;
+			case kHIDUsage_BS_ConditioningFlag: sprintf (cstrName, "Battery System Conditioning Flag"); break;
+			case kHIDUsage_BS_AtRateOK: sprintf (cstrName, "Battery System At Rate OK"); break;
+			case kHIDUsage_BS_SMBErrorCode: sprintf (cstrName, "Battery System SMB Error Code"); break;
+			case kHIDUsage_BS_NeedReplacement: sprintf (cstrName, "Battery System Need Replacement"); break;
+			case kHIDUsage_BS_AtRateTimeToFull: sprintf (cstrName, "Battery System At Rate Time To Full"); break;
+			case kHIDUsage_BS_AtRateTimeToEmpty: sprintf (cstrName, "Battery System At Rate Time To Empty"); break;
+			case kHIDUsage_BS_AverageCurrent: sprintf (cstrName, "Battery System Average Current"); break;
+			case kHIDUsage_BS_Maxerror: sprintf (cstrName, "Battery System Max Error"); break;
+			case kHIDUsage_BS_RelativeStateOfCharge: sprintf (cstrName, "Battery System Relative State Of Charge"); break;
+			case kHIDUsage_BS_AbsoluteStateOfCharge: sprintf (cstrName, "Battery System Absolute State Of Charge"); break;
+			case kHIDUsage_BS_RemainingCapacity: sprintf (cstrName, "Battery System Remaining Capacity"); break;
+			case kHIDUsage_BS_FullChargeCapacity: sprintf (cstrName, "Battery System Full Charge Capacity"); break;
+			case kHIDUsage_BS_RunTimeToEmpty: sprintf (cstrName, "Battery System Run Time To Empty"); break;
+			case kHIDUsage_BS_AverageTimeToEmpty: sprintf (cstrName, "Battery System Average Time To Empty"); break;
+			case kHIDUsage_BS_AverageTimeToFull: sprintf (cstrName, "Battery System Average Time To Full"); break;
+			case kHIDUsage_BS_CycleCount: sprintf (cstrName, "Battery System Cycle Count"); break;
+			case kHIDUsage_BS_BattPackModelLevel: sprintf (cstrName, "Battery System Batt Pack Model Level"); break;
+			case kHIDUsage_BS_InternalChargeController: sprintf (cstrName, "Battery System Internal Charge Controller"); break;
+			case kHIDUsage_BS_PrimaryBatterySupport: sprintf (cstrName, "Battery System Primary Battery Support"); break;
+			case kHIDUsage_BS_DesignCapacity: sprintf (cstrName, "Battery System Design Capacity"); break;
+			case kHIDUsage_BS_SpecificationInfo: sprintf (cstrName, "Battery System Specification Info"); break;
+			case kHIDUsage_BS_ManufacturerDate: sprintf (cstrName, "Battery System Manufacturer Date"); break;
+			case kHIDUsage_BS_SerialNumber: sprintf (cstrName, "Battery System Serial Number"); break;
+			case kHIDUsage_BS_iManufacturerName: sprintf (cstrName, "Battery System Manufacturer Name Index"); break;
+			case kHIDUsage_BS_iDevicename: sprintf (cstrName, "Battery System Device Name Index"); break;
+			case kHIDUsage_BS_iDeviceChemistry: sprintf (cstrName, "Battery System Device Chemistry Index"); break;
+			case kHIDUsage_BS_ManufacturerData: sprintf (cstrName, "Battery System Manufacturer Data"); break;
+			case kHIDUsage_BS_Rechargable: sprintf (cstrName, "Battery System Rechargable"); break;
+			case kHIDUsage_BS_WarningCapacityLimit: sprintf (cstrName, "Battery System Warning Capacity Limit"); break;
+			case kHIDUsage_BS_CapacityGranularity1: sprintf (cstrName, "Battery System Capacity Granularity 1"); break;
+			case kHIDUsage_BS_CapacityGranularity2: sprintf (cstrName, "Battery System Capacity Granularity 2"); break;
+			case kHIDUsage_BS_iOEMInformation: sprintf (cstrName, "Battery System OEM Information Index"); break;
+			case kHIDUsage_BS_InhibitCharge: sprintf (cstrName, "Battery System Inhibit Charge"); break;
+			case kHIDUsage_BS_EnablePolling: sprintf (cstrName, "Battery System Enable Polling"); break;
+			case kHIDUsage_BS_ResetToZero: sprintf (cstrName, "Battery System Reset To Zero"); break;
+			case kHIDUsage_BS_ACPresent: sprintf (cstrName, "Battery System AC Present"); break;
+			case kHIDUsage_BS_BatteryPresent: sprintf (cstrName, "Battery System Battery Present"); break;
+			case kHIDUsage_BS_PowerFail: sprintf (cstrName, "Battery System Power Fail"); break;
+			case kHIDUsage_BS_AlarmInhibited: sprintf (cstrName, "Battery System Alarm Inhibited"); break;
+			case kHIDUsage_BS_ThermistorUnderRange: sprintf (cstrName, "Battery System Thermistor Under Range"); break;
+			case kHIDUsage_BS_ThermistorHot: sprintf (cstrName, "Battery System Thermistor Hot"); break;
+			case kHIDUsage_BS_ThermistorCold: sprintf (cstrName, "Battery System Thermistor Cold"); break;
+			case kHIDUsage_BS_ThermistorOverRange: sprintf (cstrName, "Battery System Thermistor Over Range"); break;
+			case kHIDUsage_BS_VoltageOutOfRange: sprintf (cstrName, "Battery System Voltage Out Of Range"); break;
+			case kHIDUsage_BS_CurrentOutOfRange: sprintf (cstrName, "Battery System Current Out Of Range"); break;
+			case kHIDUsage_BS_CurrentNotRegulated: sprintf (cstrName, "Battery System Current Not Regulated"); break;
+			case kHIDUsage_BS_VoltageNotRegulated: sprintf (cstrName, "Battery System Voltage Not Regulated"); break;
+			case kHIDUsage_BS_MasterMode: sprintf (cstrName, "Battery System Master Mode"); break;
+			case kHIDUsage_BS_ChargerSelectorSupport: sprintf (cstrName, "Battery System Charger Support Selector"); break;
+			case kHIDUsage_BS_ChargerSpec: sprintf (cstrName, "attery System Charger Specification"); break;
+			case kHIDUsage_BS_Level2: sprintf (cstrName, "Battery System Charger Level 2"); break;
+			case kHIDUsage_BS_Level3: sprintf (cstrName, "Battery System Charger Level 3"); break;
+			default: sprintf (cstrName, "Battery System Usage 0x%lx", element->usage); break;
+			}
+		break;
+	case kHIDPage_AlphanumericDisplay:
+		switch (element->usage)
+		{
+		default: sprintf (cstrName, "Alphanumeric Display Usage 0x%lx", element->usage); break;
+		}
+		break;
+	case kHIDPage_BarCodeScanner:
+		switch (element->usage)
+		{
+		default: sprintf (cstrName, "Bar Code Scanner Usage 0x%lx", element->usage); break;
+		}
+		break;
+	case kHIDPage_Scale:
+		switch (element->usage)
+		{
+		default: sprintf (cstrName, "Scale Usage 0x%lx", element->usage); break;
+		}
+		break;
+	case kHIDPage_CameraControl:
+		switch (element->usage)
+		{
+		default: sprintf (cstrName, "Camera Control Usage 0x%lx", element->usage); break;
+		}
+		break;
+	case kHIDPage_Arcade:
+		switch (element->usage)
+		{
+		default: sprintf (cstrName, "Arcade Usage 0x%lx", element->usage); break;
+		}
+		break;
+	default:
+		if (element->usagePage > kHIDPage_VendorDefinedStart)
+			sprintf (cstrName, "Vendor Defined Usage 0x%lx", element->usage);
+		else
+			sprintf (cstrName, "Page: 0x%lx, Usage: 0x%lx", element->usagePage, element->usage);
+		break;
     }
 	 
-	 return(cstrName);
+	return(cstrName);
 }
 
 
 
 
 #endif  /* #ifdef __APPLE__ */
+
diff --git a/hid_linux.c b/hid_linux.c
index 05d8fa8..93b3b3b 100644
--- a/hid_linux.c
+++ b/hid_linux.c
@@ -348,7 +348,7 @@ void hid_ff_print( t_hid *x )
 /* Pd [hid] FUNCTIONS */
 /* ------------------------------------------------------------------------------ */
 
-t_int hid_get_events(t_hid *x)
+void hid_get_events(t_hid *x)
 {
     debug_print(LOG_DEBUG,"hid_get_events");
 
@@ -362,7 +362,7 @@ t_int hid_get_events(t_hid *x)
  */
     struct input_event hid_input_event;
 
-    if (x->x_fd < 0) return 0;
+    if (x->x_fd < 0) return;
 
     while( read (x->x_fd, &(hid_input_event), sizeof(struct input_event)) > -1 )
     {
@@ -398,7 +398,7 @@ t_int hid_get_events(t_hid *x)
         //post("output %d events",event_counter);
 	);
 	
-    return (0);
+    return;
 }
 
 
@@ -420,7 +420,7 @@ t_int hid_open_device(t_hid *x, t_int device_number)
     x->x_fd = -1;
   
     x->x_device_number = device_number;
-    sprintf(dev_handle_name,"/dev/input/event%d",(int)x->x_device_number);
+    sprintf(dev_handle_name,"/dev/input/event%d",x->x_device_number);
 
     if (dev_handle_name) 
     {