?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
supernova: fix for small audio vector sizes
[supercollider.git] / lang / LangPrimSource / HID_Utilities / HID_Name_Lookup.c
blobe01942a86716d4eff21bbec6d520ca66ece74171
1 //
2 // File: HID_Name_Lookup.c
3 //
4 // Disclaimer: IMPORTANT: This Apple software is supplied to you by Apple Inc. ("Apple")
5 // in consideration of your agreement to the following terms, and your use,
6 // installation, modification or redistribution of this Apple software
7 // constitutes acceptance of these terms. If you do not agree with these
8 // terms, please do not use, install, modify or redistribute this Apple
9 // software.
10 //
11 // In consideration of your agreement to abide by the following terms, and
12 // subject to these terms, Apple grants you a personal, non - exclusive
13 // license, under Apple's copyrights in this original Apple software ( the
14 // "Apple Software" ), to use, reproduce, modify and redistribute the Apple
15 // Software, with or without modifications, in source and / or binary forms;
16 // provided that if you redistribute the Apple Software in its entirety and
17 // without modifications, you must retain this notice and the following text
18 // and disclaimers in all such redistributions of the Apple Software. Neither
19 // the name, trademarks, service marks or logos of Apple Inc. may be used to
20 // endorse or promote products derived from the Apple Software without specific
21 // prior written permission from Apple. Except as expressly stated in this
22 // notice, no other rights or licenses, express or implied, are granted by
23 // Apple herein, including but not limited to any patent rights that may be
24 // infringed by your derivative works or by other works in which the Apple
25 // Software may be incorporated.
26 //
27 // The Apple Software is provided by Apple on an "AS IS" basis. APPLE MAKES NO
28 // WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED
29 // WARRANTIES OF NON - INFRINGEMENT, MERCHANTABILITY AND FITNESS FOR A
30 // PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND OPERATION
31 // ALONE OR IN COMBINATION WITH YOUR PRODUCTS.
32 //
33 // IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL OR
34 // CONSEQUENTIAL DAMAGES ( INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
35 // SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
36 // INTERRUPTION ) ARISING IN ANY WAY OUT OF THE USE, REPRODUCTION, MODIFICATION
37 // AND / OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED AND WHETHER
38 // UNDER THEORY OF CONTRACT, TORT ( INCLUDING NEGLIGENCE ), STRICT LIABILITY OR
39 // OTHERWISE, EVEN IF APPLE HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
40 //
41 // Copyright © 2002-2009 Apple Inc. All Rights Reserved.
42 //
43 //*****************************************************
44 #pragma mark - includes & imports
45 //*****************************************************
46 #include "HID_Utilities_External.h"
47 //*****************************************************
48 #pragma mark - typedefs, enums, defines, etc.
49 //*****************************************************
50 #define FAKE_MISSING_NAMES 0 // for debugging; returns the vendor, product & cookie ( or usage info ) as numbers.
51 #define VERBOSE_ELEMENT_NAMES 0 // set TRUE to include vender & product names in element names ( useful for debugging )
52
53 #define kNameKeyCFStringRef CFSTR( "Name" )
54 //*****************************************************
55 #pragma mark - local ( static ) function prototypes
56 //*****************************************************
57
58 #if 0 // currently unused
59 static SInt32 hu_SaveToXMLFile( CFPropertyListRef inCFPRef, CFURLRef inCFURLRef );
60 static SInt32 hu_XMLSave( CFPropertyListRef inCFPropertyListRef, CFStringRef inResourceName, CFStringRef inResourceExtension );
61 #endif
62 static CFPropertyListRef hu_LoadFromXMLFile( CFURLRef inCFURLRef );
63 static CFPropertyListRef hu_XMLLoad( CFStringRef inResourceName, CFStringRef inResourceExtension );
64
65 static Boolean hu_XMLSearchForElementNameByCookie( long inVendorID, long inProductID, IOHIDElementCookie inCookie, char * outCStr );
66 static Boolean hu_XMLSearchForElementNameByUsage( long inVendorID, long inProductID, long inUsagePage, long inUsage, char * outCStr );
67
68 static Boolean hu_XMLSearchForVendorNameByVendorID( long inVendorID, char * outCStr );
69 static Boolean hu_XMLSearchForProductNameByVendorProductID( long inVendorID, long inProductID, char * outCStr );
70
71 #if 0 // currently unused
72 static Boolean hu_AddVendorProductToCFDict( CFMutableDictionaryRef inCFMutableDictionaryRef, long inVendorID, CFStringRef inVendorCFStringRef, long inProductID, CFStringRef inProductCFStringRef );
73 static Boolean hu_AddDeviceElementToUsageXML( IOHIDDeviceRef inIOHIDDeviceRef, IOHIDElementRef inIOHIDElementRef );
74 #endif
75 //*****************************************************
76 #pragma mark - exported globals
77 //*****************************************************
78 #pragma mark - local ( static ) globals
79 //*****************************************************
80 static CFPropertyListRef gCookieCFPropertyListRef = NULL;
81 static CFPropertyListRef gUsageCFPropertyListRef = NULL;
82
83 //*****************************************************
84 #pragma mark - exported function implementations
85 //*****************************************************
86
87 /*************************************************************************
88 *
89 * HIDGetVendorNameFromVendorID( inVendorID, inProductID, inCookie, outCStrName )
90 *
91 * Purpose: Uses an devices vendor ID to generate a name for it.
92 *
93 * Notes: Now uses XML files to store dictionary of names
94 *
95 * Inputs: inVendorID - the elements vendor ID
96 * outCStrName - address where result will be returned
97 * Returns: Boolean - if successful
98 */
99 Boolean HIDGetVendorNameFromVendorID( long inVendorID, char * outCStrName )
100 {
101 Boolean result = FALSE;
102 * outCStrName = 0; // clear name
103
104 if ( hu_XMLSearchForVendorNameByVendorID( inVendorID, outCStrName ) )
105 return TRUE;
106
107 #if FAKE_MISSING_NAMES
108 sprintf( outCStrName, "#{ V: %ld}#", inVendorID );
109 result = TRUE;
110 #endif FAKE_MISSING_NAMES
111 return result;
112 } // HIDGetVendorNameFromVendorID
113
114 /*************************************************************************
115 *
116 * HIDGetProductNameFromVendorProductID( inVendorID, inProductID, outCStrName )
117 *
118 * Purpose: Uses an elements vendor, product & usage info to generate a name for it.
119 *
120 * Notes: Now uses XML files to store dictionary of names
121 *
122 * Inputs: inVendorID - the elements vendor ID
123 * inProductID - the elements product ID
124 * inUsagePage - the elements usage page
125 * inUsage - the elements usage
126 * outCStrName - address where result will be returned
127 * Returns: Boolean - if successful
128 */
129 Boolean HIDGetProductNameFromVendorProductID( long inVendorID, long inProductID, char * outCStrName )
130 {
131 Boolean result = FALSE;
132 * outCStrName = 0; // clear name
133
134 if ( hu_XMLSearchForProductNameByVendorProductID( inVendorID, inProductID, outCStrName ) )
135 return TRUE;
136
137 #if FAKE_MISSING_NAMES
138 sprintf( outCStrName, "#{ V: %ld, P: %ld, U: %ld: %ld}#", inVendorID, inProductID, inUsagePage, inUsage );
139 result = TRUE;
140 #endif FAKE_MISSING_NAMES
141 return result;
142 } // HIDGetProductNameFromVendorProductID
143
144 /*************************************************************************
145 *
146 * HIDGetElementNameFromVendorProductCookie( inVendorID, inProductID, inCookie, outCStrName )
147 *
148 * Purpose: Uses an elements vendor, product & cookie to generate a name for it.
149 *
150 * Notes: Now uses XML files to store dictionary of names
151 *
152 * Inputs: inVendorID - the elements vendor ID
153 * inProductID - the elements product ID
154 * inCookie - the elements cookie
155 * outCStrName - address where result will be returned
156 * Returns: Boolean - if successful
157 */
158 Boolean HIDGetElementNameFromVendorProductCookie (int inVendorID, int inProductID, IOHIDElementCookie inCookie, char * outCStrName)
159 {
160 Boolean result = FALSE;
161 *outCStrName = 0; // clear name
162
163 // Look in the XML file first
164 if ( hu_XMLSearchForElementNameByCookie( inVendorID, inProductID, inCookie, outCStrName ) )
165 return TRUE;
166
167 #if FAKE_MISSING_NAMES
168 sprintf( outCStrName, "#{ V: %ld, P: %ld, C: %ld}#", inVendorID, inProductID, inCookie );
169 #else
170 result = FALSE;
171 #endif FAKE_MISSING_NAMES
172 return result;
173 } // HIDGetElementNameFromVendorProductCookie
174
175 /*************************************************************************
176 *
177 * HIDGetElementNameFromVendorProductUsage( inVendorID, inProductID, inUsagePage, inUsage, outCStrName )
178 *
179 * Purpose: Uses an elements vendor, product & usage info to generate a name for it.
180 *
181 * Notes: Now uses XML files to store dictionary of names
182 *
183 * Inputs: inVendorID - the elements vendor ID
184 * inProductID - the elements product ID
185 * inUsagePage - the elements usage page
186 * inUsage - the elements usage
187 * outCStrName - address where result will be returned
188 * Returns: Boolean - if successful
189 */
190 Boolean HIDGetElementNameFromVendorProductUsage( long inVendorID, long inProductID, long inUsagePage, long inUsage, char * outCStrName )
191 {
192 Boolean result = FALSE;
193 * outCStrName = 0; // clear name
194
195 if ( hu_XMLSearchForElementNameByUsage( inVendorID, inProductID, inUsagePage, inUsage, outCStrName ) )
196 return TRUE;
197
198 #if FAKE_MISSING_NAMES
199 sprintf( outCStrName, "#{ V: %ld, P: %ld, U: %ld: %ld}#", inVendorID, inProductID, inUsagePage, inUsage );
200 result = TRUE;
201 #endif FAKE_MISSING_NAMES
202 return result;
203 } // HIDGetElementNameFromVendorProductUsage
204
205 #if 0 // currently unused
206 /*************************************************************************
207 *
208 * HIDAddDeviceToXML( inDevice )
209 *
210 * Purpose: Adds a devices info to the HID_device_usage_strings.plist( XML ) file
211 *
212 * Inputs: inDevice - the device
213 * Returns: Boolean - if successful
214 */
215 static Boolean HIDAddDeviceToXML( IOHIDDeviceRef inIOHIDDeviceRef )
216 {
217 Boolean result = FALSE;
218
219 if ( HIDIsValidDevice( inIOHIDDeviceRef ) ) {
220 CFStringRef vendorCFStringRef = IOHIDDevice_GetManufacturer( inIOHIDDeviceRef );
221 CFStringRef productCFStringRef = IOHIDDevice_GetProduct( inIOHIDDeviceRef );
222 if ( vendorCFStringRef && productCFStringRef ) {
223
224 #if 0 // don't update the cookie xml file
225 gCookieCFPropertyListRef = hu_XMLLoad( CFSTR( "HID_cookie_strings" ), CFSTR( "plist" ) );
226 if ( gCookieCFPropertyListRef ) {
227 CFMutableDictionaryRef tCFMutableDictionaryRef = CFDictionaryCreateMutableCopy( kCFAllocatorDefault, 0, gCookieCFPropertyListRef );
228 if ( tCFMutableDictionaryRef ) {
229 if ( hu_AddVendorProductToCFDict( tCFMutableDictionaryRef, vendorID, vendorCFStringRef, productID, productCFStringRef ) ) {
230 hu_XMLSave( tCFMutableDictionaryRef, CFSTR( "HID_cookie_strings" ), CFSTR( "plist" ) );
231 result = TRUE;
232 }
233 CFRelease( tCFMutableDictionaryRef );
234 }
235 }
236 #endif
237 if ( gUsageCFPropertyListRef )
238 CFRelease( gUsageCFPropertyListRef );
239
240 gUsageCFPropertyListRef = hu_XMLLoad( CFSTR( "HID_device_usage_strings" ), CFSTR( "plist" ) );
241 if ( gUsageCFPropertyListRef ) {
242 CFMutableDictionaryRef tCFMutableDictionaryRef = CFDictionaryCreateMutableCopy( kCFAllocatorDefault, 0, gUsageCFPropertyListRef );
243 if ( tCFMutableDictionaryRef ) {
244 long vendorID = IOHIDDevice_GetVendorID( inIOHIDDeviceRef );
245 long productID = IOHIDDevice_GetProductID( inIOHIDDeviceRef );
246 if ( hu_AddVendorProductToCFDict( tCFMutableDictionaryRef, vendorID, vendorCFStringRef, productID, productCFStringRef ) ) {
247 hu_XMLSave( tCFMutableDictionaryRef, CFSTR( "HID_device_usage_strings" ), CFSTR( "plist" ) );
248 result = TRUE;
249 }
250 CFRelease( tCFMutableDictionaryRef );
251 }
252 }
253 }
254 }
255 return result;
256 } // HIDAddDeviceToXML
257
258 /*************************************************************************
259 *
260 * HIDAddDeviceElementToXML( inDevice, inElement )
261 *
262 * Purpose: Adds a devices info to the HID_device_usage_strings.plist( XML ) file
263 *
264 * Inputs: inDevice - the device
265 * inElement - the element
266 *
267 * Returns: Boolean - if successful
268 */
269 Boolean HIDAddDeviceElementToXML( IOHIDDeviceRef inIOHIDDeviceRef, IOHIDElementRef inIOHIDElementRef )
270 {
271 Boolean result = FALSE;
272
273 if ( HIDIsValidElement( inIOHIDElementRef ) ) {
274 if ( HIDAddDeviceToXML( inIOHIDDeviceRef ) )
275 result = TRUE;
276
277 if ( hu_AddDeviceElementToUsageXML( inIOHIDDeviceRef, inIOHIDElementRef ) ) {
278 result = TRUE;
279 }
280 }
281 return result;
282 } // HIDAddDeviceElementToXML
283 #endif
284 /*************************************************************************
285 *
286 * HIDGetTypeName( inIOHIDElementType, outCStrName )
287 *
288 * Purpose: return a C string for a given element type( see IOHIDKeys.h )
289 * Notes: returns "Unknown Type" for invalid types
290 *
291 * Inputs: inIOHIDElementType - type element type
292 * outCStrName - address where to store element type string
293 *
294 * Returns: outCStrName - the element type string
295 */
296
297 void HIDGetTypeName( IOHIDElementType inIOHIDElementType, char * outCStrName )
298 {
299 switch( inIOHIDElementType ) {
300 case kIOHIDElementTypeInput_Misc: {
301 sprintf( outCStrName, "Miscellaneous Input" );
302 break;
303 }
304 case kIOHIDElementTypeInput_Button: {
305 sprintf( outCStrName, "Button Input" );
306 break;
307 }
308 case kIOHIDElementTypeInput_Axis: {
309 sprintf( outCStrName, "Axis Input" );
310 break;
311 }
312 case kIOHIDElementTypeInput_ScanCodes: {
313 sprintf( outCStrName, "Scan Code Input" );
314 break;
315 }
316 case kIOHIDElementTypeOutput: {
317 sprintf( outCStrName, "Output" );
318 break;
319 }
320 case kIOHIDElementTypeFeature: {
321 sprintf( outCStrName, "Feature" );
322 break;
323 }
324 case kIOHIDElementTypeCollection: {
325 sprintf( outCStrName, "Collection" );
326 break;
327 }
328 default: {
329 sprintf( outCStrName, "Unknown Type" );
330 break;
331 }
332 }
333 } // HIDGetTypeName
334
335
336 void HIDGetUsageName (const long valueUsagePage, const long valueUsage, char * cstrName)
337 {
338 switch (valueUsagePage)
339 {
340 case kHIDPage_Undefined:
341 switch (valueUsage)
342 {
343 default: sprintf (cstrName, "Undefined Page, Usage 0x%lx", valueUsage); break;
344 }
345 break;
346 case kHIDPage_GenericDesktop:
347 switch (valueUsage)
348 {
349 case kHIDUsage_GD_Pointer: sprintf (cstrName, "Pointer"); break;
350 case kHIDUsage_GD_Mouse: sprintf (cstrName, "Mouse"); break;
351 case kHIDUsage_GD_Joystick: sprintf (cstrName, "Joystick"); break;
352 case kHIDUsage_GD_GamePad: sprintf (cstrName, "GamePad"); break;
353 case kHIDUsage_GD_Keyboard: sprintf (cstrName, "Keyboard"); break;
354 case kHIDUsage_GD_Keypad: sprintf (cstrName, "Keypad"); break;
355 case kHIDUsage_GD_MultiAxisController: sprintf (cstrName, "Multi-Axis Controller"); break;
356
357 case kHIDUsage_GD_X: sprintf (cstrName, "X-Axis"); break;
358 case kHIDUsage_GD_Y: sprintf (cstrName, "Y-Axis"); break;
359 case kHIDUsage_GD_Z: sprintf (cstrName, "Z-Axis"); break;
360 case kHIDUsage_GD_Rx: sprintf (cstrName, "X-Rotation"); break;
361 case kHIDUsage_GD_Ry: sprintf (cstrName, "Y-Rotation"); break;
362 case kHIDUsage_GD_Rz: sprintf (cstrName, "Z-Rotation"); break;
363 case kHIDUsage_GD_Slider: sprintf (cstrName, "Slider"); break;
364 case kHIDUsage_GD_Dial: sprintf (cstrName, "Dial"); break;
365 case kHIDUsage_GD_Wheel: sprintf (cstrName, "Wheel"); break;
366 case kHIDUsage_GD_Hatswitch: sprintf (cstrName, "Hatswitch"); break;
367 case kHIDUsage_GD_CountedBuffer: sprintf (cstrName, "Counted Buffer"); break;
368 case kHIDUsage_GD_ByteCount: sprintf (cstrName, "Byte Count"); break;
369 case kHIDUsage_GD_MotionWakeup: sprintf (cstrName, "Motion Wakeup"); break;
370 case kHIDUsage_GD_Start: sprintf (cstrName, "Start"); break;
371 case kHIDUsage_GD_Select: sprintf (cstrName, "Select"); break;
372
373 case kHIDUsage_GD_Vx: sprintf (cstrName, "X-Velocity"); break;
374 case kHIDUsage_GD_Vy: sprintf (cstrName, "Y-Velocity"); break;
375 case kHIDUsage_GD_Vz: sprintf (cstrName, "Z-Velocity"); break;
376 case kHIDUsage_GD_Vbrx: sprintf (cstrName, "X-Rotation Velocity"); break;
377 case kHIDUsage_GD_Vbry: sprintf (cstrName, "Y-Rotation Velocity"); break;
378 case kHIDUsage_GD_Vbrz: sprintf (cstrName, "Z-Rotation Velocity"); break;
379 case kHIDUsage_GD_Vno: sprintf (cstrName, "Vno"); break;
380
381 case kHIDUsage_GD_SystemControl: sprintf (cstrName, "System Control"); break;
382 case kHIDUsage_GD_SystemPowerDown: sprintf (cstrName, "System Power Down"); break;
383 case kHIDUsage_GD_SystemSleep: sprintf (cstrName, "System Sleep"); break;
384 case kHIDUsage_GD_SystemWakeUp: sprintf (cstrName, "System Wake Up"); break;
385 case kHIDUsage_GD_SystemContextMenu: sprintf (cstrName, "System Context Menu"); break;
386 case kHIDUsage_GD_SystemMainMenu: sprintf (cstrName, "System Main Menu"); break;
387 case kHIDUsage_GD_SystemAppMenu: sprintf (cstrName, "System App Menu"); break;
388 case kHIDUsage_GD_SystemMenuHelp: sprintf (cstrName, "System Menu Help"); break;
389 case kHIDUsage_GD_SystemMenuExit: sprintf (cstrName, "System Menu Exit"); break;
390 case kHIDUsage_GD_SystemMenu: sprintf (cstrName, "System Menu"); break;
391 case kHIDUsage_GD_SystemMenuRight: sprintf (cstrName, "System Menu Right"); break;
392 case kHIDUsage_GD_SystemMenuLeft: sprintf (cstrName, "System Menu Left"); break;
393 case kHIDUsage_GD_SystemMenuUp: sprintf (cstrName, "System Menu Up"); break;
394 case kHIDUsage_GD_SystemMenuDown: sprintf (cstrName, "System Menu Down"); break;
395
396 case kHIDUsage_GD_DPadUp: sprintf (cstrName, "DPad Up"); break;
397 case kHIDUsage_GD_DPadDown: sprintf (cstrName, "DPad Down"); break;
398 case kHIDUsage_GD_DPadRight: sprintf (cstrName, "DPad Right"); break;
399 case kHIDUsage_GD_DPadLeft: sprintf (cstrName, "DPad Left"); break;
400
401 case kHIDUsage_GD_Reserved: sprintf (cstrName, "Reserved"); break;
402
403 default: sprintf (cstrName, "Generic Desktop Usage 0x%lx", valueUsage); break;
404 }
405 break;
406 case kHIDPage_Simulation:
407 switch (valueUsage)
408 {
409 default: sprintf (cstrName, "Simulation Usage 0x%lx", valueUsage); break;
410 }
411 break;
412 case kHIDPage_VR:
413 switch (valueUsage)
414 {
415 default: sprintf (cstrName, "VR Usage 0x%lx", valueUsage); break;
416 }
417 break;
418 case kHIDPage_Sport:
419 switch (valueUsage)
420 {
421 default: sprintf (cstrName, "Sport Usage 0x%lx", valueUsage); break;
422 }
423 break;
424 case kHIDPage_Game:
425 switch (valueUsage)
426 {
427 default: sprintf (cstrName, "Game Usage 0x%lx", valueUsage); break;
428 }
429 break;
430 case kHIDPage_KeyboardOrKeypad:
431 switch (valueUsage)
432 {
433 default: sprintf (cstrName, "Keyboard Usage 0x%lx", valueUsage); break;
434 }
435 break;
436 case kHIDPage_LEDs:
437 switch (valueUsage)
438 {
439 // some LED usages
440 case kHIDUsage_LED_IndicatorRed: sprintf (cstrName, "Red LED"); break;
441 case kHIDUsage_LED_IndicatorGreen: sprintf (cstrName, "Green LED"); break;
442 case kHIDUsage_LED_IndicatorAmber: sprintf (cstrName, "Amber LED"); break;
443 case kHIDUsage_LED_GenericIndicator: sprintf (cstrName, "Generic LED"); break;
444 case kHIDUsage_LED_SystemSuspend: sprintf (cstrName, "System Suspend LED"); break;
445 case kHIDUsage_LED_ExternalPowerConnected: sprintf (cstrName, "External Power LED"); break;
446 default: sprintf (cstrName, "LED Usage 0x%lx", valueUsage); break;
447 }
448 break;
449 case kHIDPage_Button:
450 switch (valueUsage)
451 {
452 default: sprintf (cstrName, "Button #%ld", valueUsage); break;
453 }
454 break;
455 case kHIDPage_Ordinal:
456 switch (valueUsage)
457 {
458 default: sprintf (cstrName, "Ordinal Instance %lx", valueUsage); break;
459 }
460 break;
461 case kHIDPage_Telephony:
462 switch (valueUsage)
463 {
464 default: sprintf (cstrName, "Telephony Usage 0x%lx", valueUsage); break;
465 }
466 break;
467 case kHIDPage_Consumer:
468 switch (valueUsage)
469 {
470 default: sprintf (cstrName, "Consumer Usage 0x%lx", valueUsage); break;
471 }
472 break;
473 case kHIDPage_Digitizer:
474 switch (valueUsage)
475 {
476 default: sprintf (cstrName, "Digitizer Usage 0x%lx", valueUsage); break;
477 }
478 break;
479 case kHIDPage_PID:
480 if (((valueUsage >= 0x02) && (valueUsage <= 0x1F)) || ((valueUsage >= 0x29) && (valueUsage <= 0x2F)) ||
481 ((valueUsage >= 0x35) && (valueUsage <= 0x3F)) || ((valueUsage >= 0x44) && (valueUsage <= 0x4F)) ||
482 (valueUsage == 0x8A) || (valueUsage == 0x93) || ((valueUsage >= 0x9D) && (valueUsage <= 0x9E)) ||
483 ((valueUsage >= 0xA1) && (valueUsage <= 0xA3)) || ((valueUsage >= 0xAD) && (valueUsage <= 0xFFFF)))
484 sprintf (cstrName, "PID Reserved");
485 else
486 switch (valueUsage)
487 {
488 case 0x00: sprintf (cstrName, "PID Undefined Usage"); break;
489 case kHIDUsage_PID_PhysicalInterfaceDevice: sprintf (cstrName, "Physical Interface Device"); break;
490 case kHIDUsage_PID_Normal: sprintf (cstrName, "Normal Force"); break;
491
492 case kHIDUsage_PID_SetEffectReport: sprintf (cstrName, "Set Effect Report"); break;
493 case kHIDUsage_PID_EffectBlockIndex: sprintf (cstrName, "Effect Block Index"); break;
494 case kHIDUsage_PID_ParamBlockOffset: sprintf (cstrName, "Parameter Block Offset"); break;
495 case kHIDUsage_PID_ROM_Flag: sprintf (cstrName, "ROM Flag"); break;
496
497 case kHIDUsage_PID_EffectType: sprintf (cstrName, "Effect Type"); break;
498 case kHIDUsage_PID_ET_ConstantForce: sprintf (cstrName, "Effect Type Constant Force"); break;
499 case kHIDUsage_PID_ET_Ramp: sprintf (cstrName, "Effect Type Ramp"); break;
500 case kHIDUsage_PID_ET_CustomForceData: sprintf (cstrName, "Effect Type Custom Force Data"); break;
501 case kHIDUsage_PID_ET_Square: sprintf (cstrName, "Effect Type Square"); break;
502 case kHIDUsage_PID_ET_Sine: sprintf (cstrName, "Effect Type Sine"); break;
503 case kHIDUsage_PID_ET_Triangle: sprintf (cstrName, "Effect Type Triangle"); break;
504 case kHIDUsage_PID_ET_SawtoothUp: sprintf (cstrName, "Effect Type Sawtooth Up"); break;
505 case kHIDUsage_PID_ET_SawtoothDown: sprintf (cstrName, "Effect Type Sawtooth Down"); break;
506 case kHIDUsage_PID_ET_Spring: sprintf (cstrName, "Effect Type Spring"); break;
507 case kHIDUsage_PID_ET_Damper: sprintf (cstrName, "Effect Type Damper"); break;
508 case kHIDUsage_PID_ET_Inertia: sprintf (cstrName, "Effect Type Inertia"); break;
509 case kHIDUsage_PID_ET_Friction: sprintf (cstrName, "Effect Type Friction"); break;
510 case kHIDUsage_PID_Duration: sprintf (cstrName, "Effect Duration"); break;
511 case kHIDUsage_PID_SamplePeriod: sprintf (cstrName, "Effect Sample Period"); break;
512 case kHIDUsage_PID_Gain: sprintf (cstrName, "Effect Gain"); break;
513 case kHIDUsage_PID_TriggerButton: sprintf (cstrName, "Effect Trigger Button"); break;
514 case kHIDUsage_PID_TriggerRepeatInterval: sprintf (cstrName, "Effect Trigger Repeat Interval"); break;
515
516 case kHIDUsage_PID_AxesEnable: sprintf (cstrName, "Axis Enable"); break;
517 case kHIDUsage_PID_DirectionEnable: sprintf (cstrName, "Direction Enable"); break;
518
519 case kHIDUsage_PID_Direction: sprintf (cstrName, "Direction"); break;
520
521 case kHIDUsage_PID_TypeSpecificBlockOffset: sprintf (cstrName, "Type Specific Block Offset"); break;
522
523 case kHIDUsage_PID_BlockType: sprintf (cstrName, "Block Type"); break;
524
525 case kHIDUsage_PID_SetEnvelopeReport: sprintf (cstrName, "Set Envelope Report"); break;
526 case kHIDUsage_PID_AttackLevel: sprintf (cstrName, "Envelope Attack Level"); break;
527 case kHIDUsage_PID_AttackTime: sprintf (cstrName, "Envelope Attack Time"); break;
528 case kHIDUsage_PID_FadeLevel: sprintf (cstrName, "Envelope Fade Level"); break;
529 case kHIDUsage_PID_FadeTime: sprintf (cstrName, "Envelope Fade Time"); break;
530
531 case kHIDUsage_PID_SetConditionReport: sprintf (cstrName, "Set Condition Report"); break;
532 case kHIDUsage_PID_CP_Offset: sprintf (cstrName, "Condition CP Offset"); break;
533 case kHIDUsage_PID_PositiveCoefficient: sprintf (cstrName, "Condition Positive Coefficient"); break;
534 case kHIDUsage_PID_NegativeCoefficient: sprintf (cstrName, "Condition Negative Coefficient"); break;
535 case kHIDUsage_PID_PositiveSaturation: sprintf (cstrName, "Condition Positive Saturation"); break;
536 case kHIDUsage_PID_NegativeSaturation: sprintf (cstrName, "Condition Negative Saturation"); break;
537 case kHIDUsage_PID_DeadBand: sprintf (cstrName, "Condition Dead Band"); break;
538
539 case kHIDUsage_PID_DownloadForceSample: sprintf (cstrName, "Download Force Sample"); break;
540 case kHIDUsage_PID_IsochCustomForceEnable: sprintf (cstrName, "Isoch Custom Force Enable"); break;
541
542 case kHIDUsage_PID_CustomForceDataReport: sprintf (cstrName, "Custom Force Data Report"); break;
543 case kHIDUsage_PID_CustomForceData: sprintf (cstrName, "Custom Force Data"); break;
544
545 case kHIDUsage_PID_CustomForceVendorDefinedData: sprintf (cstrName, "Custom Force Vendor Defined Data"); break;
546 case kHIDUsage_PID_SetCustomForceReport: sprintf (cstrName, "Set Custom Force Report"); break;
547 case kHIDUsage_PID_CustomForceDataOffset: sprintf (cstrName, "Custom Force Data Offset"); break;
548 case kHIDUsage_PID_SampleCount: sprintf (cstrName, "Custom Force Sample Count"); break;
549
550 case kHIDUsage_PID_SetPeriodicReport: sprintf (cstrName, "Set Periodic Report"); break;
551 case kHIDUsage_PID_Offset: sprintf (cstrName, "Periodic Offset"); break;
552 case kHIDUsage_PID_Magnitude: sprintf (cstrName, "Periodic Magnitude"); break;
553 case kHIDUsage_PID_Phase: sprintf (cstrName, "Periodic Phase"); break;
554 case kHIDUsage_PID_Period: sprintf (cstrName, "Periodic Period"); break;
555
556 case kHIDUsage_PID_SetConstantForceReport: sprintf (cstrName, "Set Constant Force Report"); break;
557
558 case kHIDUsage_PID_SetRampForceReport: sprintf (cstrName, "Set Ramp Force Report"); break;
559 case kHIDUsage_PID_RampStart: sprintf (cstrName, "Ramp Start"); break;
560 case kHIDUsage_PID_RampEnd: sprintf (cstrName, "Ramp End"); break;
561
562 case kHIDUsage_PID_EffectOperationReport: sprintf (cstrName, "Effect Operation Report"); break;
563
564 case kHIDUsage_PID_EffectOperation: sprintf (cstrName, "Effect Operation"); break;
565 case kHIDUsage_PID_OpEffectStart: sprintf (cstrName, "Op Effect Start"); break;
566 case kHIDUsage_PID_OpEffectStartSolo: sprintf (cstrName, "Op Effect Start Solo"); break;
567 case kHIDUsage_PID_OpEffectStop: sprintf (cstrName, "Op Effect Stop"); break;
568 case kHIDUsage_PID_LoopCount: sprintf (cstrName, "Op Effect Loop Count"); break;
569
570 case kHIDUsage_PID_DeviceGainReport: sprintf (cstrName, "Device Gain Report"); break;
571 case kHIDUsage_PID_DeviceGain: sprintf (cstrName, "Device Gain"); break;
572
573 case kHIDUsage_PID_PoolReport: sprintf (cstrName, "PID Pool Report"); break;
574 case kHIDUsage_PID_RAM_PoolSize: sprintf (cstrName, "RAM Pool Size"); break;
575 case kHIDUsage_PID_ROM_PoolSize: sprintf (cstrName, "ROM Pool Size"); break;
576 case kHIDUsage_PID_ROM_EffectBlockCount: sprintf (cstrName, "ROM Effect Block Count"); break;
577 case kHIDUsage_PID_SimultaneousEffectsMax: sprintf (cstrName, "Simultaneous Effects Max"); break;
578 case kHIDUsage_PID_PoolAlignment: sprintf (cstrName, "Pool Alignment"); break;
579
580 case kHIDUsage_PID_PoolMoveReport: sprintf (cstrName, "PID Pool Move Report"); break;
581 case kHIDUsage_PID_MoveSource: sprintf (cstrName, "Move Source"); break;
582 case kHIDUsage_PID_MoveDestination: sprintf (cstrName, "Move Destination"); break;
583 case kHIDUsage_PID_MoveLength: sprintf (cstrName, "Move Length"); break;
584
585 case kHIDUsage_PID_BlockLoadReport: sprintf (cstrName, "PID Block Load Report"); break;
586
587 case kHIDUsage_PID_BlockLoadStatus: sprintf (cstrName, "Block Load Status"); break;
588 case kHIDUsage_PID_BlockLoadSuccess: sprintf (cstrName, "Block Load Success"); break;
589 case kHIDUsage_PID_BlockLoadFull: sprintf (cstrName, "Block Load Full"); break;
590 case kHIDUsage_PID_BlockLoadError: sprintf (cstrName, "Block Load Error"); break;
591 case kHIDUsage_PID_BlockHandle: sprintf (cstrName, "Block Handle"); break;
592
593 case kHIDUsage_PID_BlockFreeReport: sprintf (cstrName, "PID Block Free Report"); break;
594
595 case kHIDUsage_PID_TypeSpecificBlockHandle: sprintf (cstrName, "Type Specific Block Handle"); break;
596
597 case kHIDUsage_PID_StateReport: sprintf (cstrName, "PID State Report"); break;
598 case kHIDUsage_PID_EffectPlaying: sprintf (cstrName, "Effect Playing"); break;
599
600 case kHIDUsage_PID_DeviceControlReport: sprintf (cstrName, "PID Device Control Report"); break;
601
602 case kHIDUsage_PID_DeviceControl: sprintf (cstrName, "PID Device Control"); break;
603 case kHIDUsage_PID_DC_EnableActuators: sprintf (cstrName, "Device Control Enable Actuators"); break;
604 case kHIDUsage_PID_DC_DisableActuators: sprintf (cstrName, "Device Control Disable Actuators"); break;
605 case kHIDUsage_PID_DC_StopAllEffects: sprintf (cstrName, "Device Control Stop All Effects"); break;
606 case kHIDUsage_PID_DC_DeviceReset: sprintf (cstrName, "Device Control Reset"); break;
607 case kHIDUsage_PID_DC_DevicePause: sprintf (cstrName, "Device Control Pause"); break;
608 case kHIDUsage_PID_DC_DeviceContinue: sprintf (cstrName, "Device Control Continue"); break;
609 case kHIDUsage_PID_DevicePaused: sprintf (cstrName, "Device Paused"); break;
610 case kHIDUsage_PID_ActuatorsEnabled: sprintf (cstrName, "Actuators Enabled"); break;
611 case kHIDUsage_PID_SafetySwitch: sprintf (cstrName, "Safety Switch"); break;
612 case kHIDUsage_PID_ActuatorOverrideSwitch: sprintf (cstrName, "Actuator Override Switch"); break;
613 case kHIDUsage_PID_ActuatorPower: sprintf (cstrName, "Actuator Power"); break;
614 case kHIDUsage_PID_StartDelay: sprintf (cstrName, "Start Delay"); break;
615
616 case kHIDUsage_PID_ParameterBlockSize: sprintf (cstrName, "Parameter Block Size"); break;
617 case kHIDUsage_PID_DeviceManagedPool: sprintf (cstrName, "Device Managed Pool"); break;
618 case kHIDUsage_PID_SharedParameterBlocks: sprintf (cstrName, "Shared Parameter Blocks"); break;
619
620 case kHIDUsage_PID_CreateNewEffectReport: sprintf (cstrName, "Create New Effect Report"); break;
621 case kHIDUsage_PID_RAM_PoolAvailable: sprintf (cstrName, "RAM Pool Available"); break;
622 default: sprintf (cstrName, "PID Usage 0x%lx", valueUsage); break;
623 }
624 break;
625 case kHIDPage_Unicode:
626 switch (valueUsage)
627 {
628 default: sprintf (cstrName, "Unicode Usage 0x%lx", valueUsage); break;
629 }
630 break;
631 case kHIDPage_PowerDevice:
632 if (((valueUsage >= 0x06) && (valueUsage <= 0x0F)) || ((valueUsage >= 0x26) && (valueUsage <= 0x2F)) ||
633 ((valueUsage >= 0x39) && (valueUsage <= 0x3F)) || ((valueUsage >= 0x48) && (valueUsage <= 0x4F)) ||
634 ((valueUsage >= 0x58) && (valueUsage <= 0x5F)) || (valueUsage == 0x6A) ||
635 ((valueUsage >= 0x74) && (valueUsage <= 0xFC)))
636 sprintf (cstrName, "Power Device Reserved");
637 else
638 switch (valueUsage)
639 {
640 case kHIDUsage_PD_Undefined: sprintf (cstrName, "Power Device Undefined Usage"); break;
641 case kHIDUsage_PD_iName: sprintf (cstrName, "Power Device Name Index"); break;
642 case kHIDUsage_PD_PresentStatus: sprintf (cstrName, "Power Device Present Status"); break;
643 case kHIDUsage_PD_ChangedStatus: sprintf (cstrName, "Power Device Changed Status"); break;
644 case kHIDUsage_PD_UPS: sprintf (cstrName, "Uninterruptible Power Supply"); break;
645 case kHIDUsage_PD_PowerSupply: sprintf (cstrName, "Power Supply"); break;
646
647 case kHIDUsage_PD_BatterySystem: sprintf (cstrName, "Battery System Power Module"); break;
648 case kHIDUsage_PD_BatterySystemID: sprintf (cstrName, "Battery System ID"); break;
649 case kHIDUsage_PD_Battery: sprintf (cstrName, "Battery"); break;
650 case kHIDUsage_PD_BatteryID: sprintf (cstrName, "Battery ID"); break;
651 case kHIDUsage_PD_Charger: sprintf (cstrName, "Charger"); break;
652 case kHIDUsage_PD_ChargerID: sprintf (cstrName, "Charger ID"); break;
653 case kHIDUsage_PD_PowerConverter: sprintf (cstrName, "Power Converter Power Module"); break;
654 case kHIDUsage_PD_PowerConverterID: sprintf (cstrName, "Power Converter ID"); break;
655 case kHIDUsage_PD_OutletSystem: sprintf (cstrName, "Outlet System power module"); break;
656 case kHIDUsage_PD_OutletSystemID: sprintf (cstrName, "Outlet System ID"); break;
657 case kHIDUsage_PD_Input: sprintf (cstrName, "Power Device Input"); break;
658 case kHIDUsage_PD_InputID: sprintf (cstrName, "Power Device Input ID"); break;
659 case kHIDUsage_PD_Output: sprintf (cstrName, "Power Device Output"); break;
660 case kHIDUsage_PD_OutputID: sprintf (cstrName, "Power Device Output ID"); break;
661 case kHIDUsage_PD_Flow: sprintf (cstrName, "Power Device Flow"); break;
662 case kHIDUsage_PD_FlowID: sprintf (cstrName, "Power Device Flow ID"); break;
663 case kHIDUsage_PD_Outlet: sprintf (cstrName, "Power Device Outlet"); break;
664 case kHIDUsage_PD_OutletID: sprintf (cstrName, "Power Device Outlet ID"); break;
665 case kHIDUsage_PD_Gang: sprintf (cstrName, "Power Device Gang"); break;
666 case kHIDUsage_PD_GangID: sprintf (cstrName, "Power Device Gang ID"); break;
667 case kHIDUsage_PD_PowerSummary: sprintf (cstrName, "Power Device Power Summary"); break;
668 case kHIDUsage_PD_PowerSummaryID: sprintf (cstrName, "Power Device Power Summary ID"); break;
669
670 case kHIDUsage_PD_Voltage: sprintf (cstrName, "Power Device Voltage"); break;
671 case kHIDUsage_PD_Current: sprintf (cstrName, "Power Device Current"); break;
672 case kHIDUsage_PD_Frequency: sprintf (cstrName, "Power Device Frequency"); break;
673 case kHIDUsage_PD_ApparentPower: sprintf (cstrName, "Power Device Apparent Power"); break;
674 case kHIDUsage_PD_ActivePower: sprintf (cstrName, "Power Device RMS Power"); break;
675 case kHIDUsage_PD_PercentLoad: sprintf (cstrName, "Power Device Percent Load"); break;
676 case kHIDUsage_PD_Temperature: sprintf (cstrName, "Power Device Temperature"); break;
677 case kHIDUsage_PD_Humidity: sprintf (cstrName, "Power Device Humidity"); break;
678 case kHIDUsage_PD_BadCount: sprintf (cstrName, "Power Device Bad Condition Count"); break;
679
680 case kHIDUsage_PD_ConfigVoltage: sprintf (cstrName, "Power Device Nominal Voltage"); break;
681 case kHIDUsage_PD_ConfigCurrent: sprintf (cstrName, "Power Device Nominal Current"); break;
682 case kHIDUsage_PD_ConfigFrequency: sprintf (cstrName, "Power Device Nominal Frequency"); break;
683 case kHIDUsage_PD_ConfigApparentPower: sprintf (cstrName, "Power Device Nominal Apparent Power"); break;
684 case kHIDUsage_PD_ConfigActivePower: sprintf (cstrName, "Power Device Nominal RMS Power"); break;
685 case kHIDUsage_PD_ConfigPercentLoad: sprintf (cstrName, "Power Device Nominal Percent Load"); break;
686 case kHIDUsage_PD_ConfigTemperature: sprintf (cstrName, "Power Device Nominal Temperature"); break;
687
688 case kHIDUsage_PD_ConfigHumidity: sprintf (cstrName, "Power Device Nominal Humidity"); break;
689 case kHIDUsage_PD_SwitchOnControl: sprintf (cstrName, "Power Device Switch On Control"); break;
690 case kHIDUsage_PD_SwitchOffControl: sprintf (cstrName, "Power Device Switch Off Control"); break;
691 case kHIDUsage_PD_ToggleControl: sprintf (cstrName, "Power Device Toogle Sequence Control"); break;
692 case kHIDUsage_PD_LowVoltageTransfer: sprintf (cstrName, "Power Device Min Transfer Voltage"); break;
693 case kHIDUsage_PD_HighVoltageTransfer: sprintf (cstrName, "Power Device Max Transfer Voltage"); break;
694 case kHIDUsage_PD_DelayBeforeReboot: sprintf (cstrName, "Power Device Delay Before Reboot"); break;
695 case kHIDUsage_PD_DelayBeforeStartup: sprintf (cstrName, "Power Device Delay Before Startup"); break;
696 case kHIDUsage_PD_DelayBeforeShutdown: sprintf (cstrName, "Power Device Delay Before Shutdown"); break;
697 case kHIDUsage_PD_Test: sprintf (cstrName, "Power Device Test Request/Result"); break;
698 case kHIDUsage_PD_ModuleReset: sprintf (cstrName, "Power Device Reset Request/Result"); break;
699 case kHIDUsage_PD_AudibleAlarmControl: sprintf (cstrName, "Power Device Audible Alarm Control"); break;
700
701 case kHIDUsage_PD_Present: sprintf (cstrName, "Power Device Present"); break;
702 case kHIDUsage_PD_Good: sprintf (cstrName, "Power Device Good"); break;
703 case kHIDUsage_PD_InternalFailure: sprintf (cstrName, "Power Device Internal Failure"); break;
704 case kHIDUsage_PD_VoltageOutOfRange: sprintf (cstrName, "Power Device Voltage Out Of Range"); break;
705 case kHIDUsage_PD_FrequencyOutOfRange: sprintf (cstrName, "Power Device Frequency Out Of Range"); break;
706 case kHIDUsage_PD_Overload: sprintf (cstrName, "Power Device Overload"); break;
707 case kHIDUsage_PD_OverCharged: sprintf (cstrName, "Power Device Over Charged"); break;
708 case kHIDUsage_PD_OverTemperature: sprintf (cstrName, "Power Device Over Temperature"); break;
709 case kHIDUsage_PD_ShutdownRequested: sprintf (cstrName, "Power Device Shutdown Requested"); break;
710
711 case kHIDUsage_PD_ShutdownImminent: sprintf (cstrName, "Power Device Shutdown Imminent"); break;
712 case kHIDUsage_PD_SwitchOnOff: sprintf (cstrName, "Power Device On/Off Switch Status"); break;
713 case kHIDUsage_PD_Switchable: sprintf (cstrName, "Power Device Switchable"); break;
714 case kHIDUsage_PD_Used: sprintf (cstrName, "Power Device Used"); break;
715 case kHIDUsage_PD_Boost: sprintf (cstrName, "Power Device Boosted"); break;
716 case kHIDUsage_PD_Buck: sprintf (cstrName, "Power Device Bucked"); break;
717 case kHIDUsage_PD_Initialized: sprintf (cstrName, "Power Device Initialized"); break;
718 case kHIDUsage_PD_Tested: sprintf (cstrName, "Power Device Tested"); break;
719 case kHIDUsage_PD_AwaitingPower: sprintf (cstrName, "Power Device Awaiting Power"); break;
720 case kHIDUsage_PD_CommunicationLost: sprintf (cstrName, "Power Device Communication Lost"); break;
721
722 case kHIDUsage_PD_iManufacturer: sprintf (cstrName, "Power Device Manufacturer String Index"); break;
723 case kHIDUsage_PD_iProduct: sprintf (cstrName, "Power Device Product String Index"); break;
724 case kHIDUsage_PD_iserialNumber: sprintf (cstrName, "Power Device Serial Number String Index"); break;
725 default: sprintf (cstrName, "Power Device Usage 0x%lx", valueUsage); break;
726 }
727 break;
728 case kHIDPage_BatterySystem:
729 if (((valueUsage >= 0x0A) && (valueUsage <= 0x0F)) || ((valueUsage >= 0x1E) && (valueUsage <= 0x27)) ||
730 ((valueUsage >= 0x30) && (valueUsage <= 0x3F)) || ((valueUsage >= 0x4C) && (valueUsage <= 0x5F)) ||
731 ((valueUsage >= 0x6C) && (valueUsage <= 0x7F)) || ((valueUsage >= 0x90) && (valueUsage <= 0xBF)) ||
732 ((valueUsage >= 0xC3) && (valueUsage <= 0xCF)) || ((valueUsage >= 0xDD) && (valueUsage <= 0xEF)) ||
733 ((valueUsage >= 0xF2) && (valueUsage <= 0xFF)))
734 sprintf (cstrName, "Power Device Reserved");
735 else
736 switch (valueUsage)
737 {
738 case kHIDUsage_BS_Undefined: sprintf (cstrName, "Battery System Undefined"); break;
739 case kHIDUsage_BS_SMBBatteryMode: sprintf (cstrName, "SMB Mode"); break;
740 case kHIDUsage_BS_SMBBatteryStatus: sprintf (cstrName, "SMB Status"); break;
741 case kHIDUsage_BS_SMBAlarmWarning: sprintf (cstrName, "SMB Alarm Warning"); break;
742 case kHIDUsage_BS_SMBChargerMode: sprintf (cstrName, "SMB Charger Mode"); break;
743 case kHIDUsage_BS_SMBChargerStatus: sprintf (cstrName, "SMB Charger Status"); break;
744 case kHIDUsage_BS_SMBChargerSpecInfo: sprintf (cstrName, "SMB Charger Extended Status"); break;
745 case kHIDUsage_BS_SMBSelectorState: sprintf (cstrName, "SMB Selector State"); break;
746 case kHIDUsage_BS_SMBSelectorPresets: sprintf (cstrName, "SMB Selector Presets"); break;
747 case kHIDUsage_BS_SMBSelectorInfo: sprintf (cstrName, "SMB Selector Info"); break;
748 case kHIDUsage_BS_OptionalMfgFunction1: sprintf (cstrName, "Battery System Optional SMB Mfg Function 1"); break;
749 case kHIDUsage_BS_OptionalMfgFunction2: sprintf (cstrName, "Battery System Optional SMB Mfg Function 2"); break;
750 case kHIDUsage_BS_OptionalMfgFunction3: sprintf (cstrName, "Battery System Optional SMB Mfg Function 3"); break;
751 case kHIDUsage_BS_OptionalMfgFunction4: sprintf (cstrName, "Battery System Optional SMB Mfg Function 4"); break;
752 case kHIDUsage_BS_OptionalMfgFunction5: sprintf (cstrName, "Battery System Optional SMB Mfg Function 5"); break;
753 case kHIDUsage_BS_ConnectionToSMBus: sprintf (cstrName, "Battery System Connection To System Management Bus"); break;
754 case kHIDUsage_BS_OutputConnection: sprintf (cstrName, "Battery System Output Connection Status"); break;
755 case kHIDUsage_BS_ChargerConnection: sprintf (cstrName, "Battery System Charger Connection"); break;
756 case kHIDUsage_BS_BatteryInsertion: sprintf (cstrName, "Battery System Battery Insertion"); break;
757 case kHIDUsage_BS_Usenext: sprintf (cstrName, "Battery System Use Next"); break;
758 case kHIDUsage_BS_OKToUse: sprintf (cstrName, "Battery System OK To Use"); break;
759 case kHIDUsage_BS_BatterySupported: sprintf (cstrName, "Battery System Battery Supported"); break;
760 case kHIDUsage_BS_SelectorRevision: sprintf (cstrName, "Battery System Selector Revision"); break;
761 case kHIDUsage_BS_ChargingIndicator: sprintf (cstrName, "Battery System Charging Indicator"); break;
762 case kHIDUsage_BS_ManufacturerAccess: sprintf (cstrName, "Battery System Manufacturer Access"); break;
763 case kHIDUsage_BS_RemainingCapacityLimit: sprintf (cstrName, "Battery System Remaining Capacity Limit"); break;
764 case kHIDUsage_BS_RemainingTimeLimit: sprintf (cstrName, "Battery System Remaining Time Limit"); break;
765 case kHIDUsage_BS_AtRate: sprintf (cstrName, "Battery System At Rate..."); break;
766 case kHIDUsage_BS_CapacityMode: sprintf (cstrName, "Battery System Capacity Mode"); break;
767 case kHIDUsage_BS_BroadcastToCharger: sprintf (cstrName, "Battery System Broadcast To Charger"); break;
768 case kHIDUsage_BS_PrimaryBattery: sprintf (cstrName, "Battery System Primary Battery"); break;
769 case kHIDUsage_BS_ChargeController: sprintf (cstrName, "Battery System Charge Controller"); break;
770 case kHIDUsage_BS_TerminateCharge: sprintf (cstrName, "Battery System Terminate Charge"); break;
771 case kHIDUsage_BS_TerminateDischarge: sprintf (cstrName, "Battery System Terminate Discharge"); break;
772 case kHIDUsage_BS_BelowRemainingCapacityLimit: sprintf (cstrName, "Battery System Below Remaining Capacity Limit"); break;
773 case kHIDUsage_BS_RemainingTimeLimitExpired: sprintf (cstrName, "Battery System Remaining Time Limit Expired"); break;
774 case kHIDUsage_BS_Charging: sprintf (cstrName, "Battery System Charging"); break;
775 case kHIDUsage_BS_Discharging: sprintf (cstrName, "Battery System Discharging"); break;
776 case kHIDUsage_BS_FullyCharged: sprintf (cstrName, "Battery System Fully Charged"); break;
777 case kHIDUsage_BS_FullyDischarged: sprintf (cstrName, "Battery System Fully Discharged"); break;
778 case kHIDUsage_BS_ConditioningFlag: sprintf (cstrName, "Battery System Conditioning Flag"); break;
779 case kHIDUsage_BS_AtRateOK: sprintf (cstrName, "Battery System At Rate OK"); break;
780 case kHIDUsage_BS_SMBErrorCode: sprintf (cstrName, "Battery System SMB Error Code"); break;
781 case kHIDUsage_BS_NeedReplacement: sprintf (cstrName, "Battery System Need Replacement"); break;
782 case kHIDUsage_BS_AtRateTimeToFull: sprintf (cstrName, "Battery System At Rate Time To Full"); break;
783 case kHIDUsage_BS_AtRateTimeToEmpty: sprintf (cstrName, "Battery System At Rate Time To Empty"); break;
784 case kHIDUsage_BS_AverageCurrent: sprintf (cstrName, "Battery System Average Current"); break;
785 case kHIDUsage_BS_Maxerror: sprintf (cstrName, "Battery System Max Error"); break;
786 case kHIDUsage_BS_RelativeStateOfCharge: sprintf (cstrName, "Battery System Relative State Of Charge"); break;
787 case kHIDUsage_BS_AbsoluteStateOfCharge: sprintf (cstrName, "Battery System Absolute State Of Charge"); break;
788 case kHIDUsage_BS_RemainingCapacity: sprintf (cstrName, "Battery System Remaining Capacity"); break;
789 case kHIDUsage_BS_FullChargeCapacity: sprintf (cstrName, "Battery System Full Charge Capacity"); break;
790 case kHIDUsage_BS_RunTimeToEmpty: sprintf (cstrName, "Battery System Run Time To Empty"); break;
791 case kHIDUsage_BS_AverageTimeToEmpty: sprintf (cstrName, "Battery System Average Time To Empty"); break;
792 case kHIDUsage_BS_AverageTimeToFull: sprintf (cstrName, "Battery System Average Time To Full"); break;
793 case kHIDUsage_BS_CycleCount: sprintf (cstrName, "Battery System Cycle Count"); break;
794 case kHIDUsage_BS_BattPackModelLevel: sprintf (cstrName, "Battery System Batt Pack Model Level"); break;
795 case kHIDUsage_BS_InternalChargeController: sprintf (cstrName, "Battery System Internal Charge Controller"); break;
796 case kHIDUsage_BS_PrimaryBatterySupport: sprintf (cstrName, "Battery System Primary Battery Support"); break;
797 case kHIDUsage_BS_DesignCapacity: sprintf (cstrName, "Battery System Design Capacity"); break;
798 case kHIDUsage_BS_SpecificationInfo: sprintf (cstrName, "Battery System Specification Info"); break;
799 case kHIDUsage_BS_ManufacturerDate: sprintf (cstrName, "Battery System Manufacturer Date"); break;
800 case kHIDUsage_BS_SerialNumber: sprintf (cstrName, "Battery System Serial Number"); break;
801 case kHIDUsage_BS_iManufacturerName: sprintf (cstrName, "Battery System Manufacturer Name Index"); break;
802 case kHIDUsage_BS_iDevicename: sprintf (cstrName, "Battery System Device Name Index"); break;
803 case kHIDUsage_BS_iDeviceChemistry: sprintf (cstrName, "Battery System Device Chemistry Index"); break;
804 case kHIDUsage_BS_ManufacturerData: sprintf (cstrName, "Battery System Manufacturer Data"); break;
805 case kHIDUsage_BS_Rechargable: sprintf (cstrName, "Battery System Rechargable"); break;
806 case kHIDUsage_BS_WarningCapacityLimit: sprintf (cstrName, "Battery System Warning Capacity Limit"); break;
807 case kHIDUsage_BS_CapacityGranularity1: sprintf (cstrName, "Battery System Capacity Granularity 1"); break;
808 case kHIDUsage_BS_CapacityGranularity2: sprintf (cstrName, "Battery System Capacity Granularity 2"); break;
809 case kHIDUsage_BS_iOEMInformation: sprintf (cstrName, "Battery System OEM Information Index"); break;
810 case kHIDUsage_BS_InhibitCharge: sprintf (cstrName, "Battery System Inhibit Charge"); break;
811 case kHIDUsage_BS_EnablePolling: sprintf (cstrName, "Battery System Enable Polling"); break;
812 case kHIDUsage_BS_ResetToZero: sprintf (cstrName, "Battery System Reset To Zero"); break;
813 case kHIDUsage_BS_ACPresent: sprintf (cstrName, "Battery System AC Present"); break;
814 case kHIDUsage_BS_BatteryPresent: sprintf (cstrName, "Battery System Battery Present"); break;
815 case kHIDUsage_BS_PowerFail: sprintf (cstrName, "Battery System Power Fail"); break;
816 case kHIDUsage_BS_AlarmInhibited: sprintf (cstrName, "Battery System Alarm Inhibited"); break;
817 case kHIDUsage_BS_ThermistorUnderRange: sprintf (cstrName, "Battery System Thermistor Under Range"); break;
818 case kHIDUsage_BS_ThermistorHot: sprintf (cstrName, "Battery System Thermistor Hot"); break;
819 case kHIDUsage_BS_ThermistorCold: sprintf (cstrName, "Battery System Thermistor Cold"); break;
820 case kHIDUsage_BS_ThermistorOverRange: sprintf (cstrName, "Battery System Thermistor Over Range"); break;
821 case kHIDUsage_BS_VoltageOutOfRange: sprintf (cstrName, "Battery System Voltage Out Of Range"); break;
822 case kHIDUsage_BS_CurrentOutOfRange: sprintf (cstrName, "Battery System Current Out Of Range"); break;
823 case kHIDUsage_BS_CurrentNotRegulated: sprintf (cstrName, "Battery System Current Not Regulated"); break;
824 case kHIDUsage_BS_VoltageNotRegulated: sprintf (cstrName, "Battery System Voltage Not Regulated"); break;
825 case kHIDUsage_BS_MasterMode: sprintf (cstrName, "Battery System Master Mode"); break;
826 case kHIDUsage_BS_ChargerSelectorSupport: sprintf (cstrName, "Battery System Charger Support Selector"); break;
827 case kHIDUsage_BS_ChargerSpec: sprintf (cstrName, "attery System Charger Specification"); break;
828 case kHIDUsage_BS_Level2: sprintf (cstrName, "Battery System Charger Level 2"); break;
829 case kHIDUsage_BS_Level3: sprintf (cstrName, "Battery System Charger Level 3"); break;
830 default: sprintf (cstrName, "Battery System Usage 0x%lx", valueUsage); break;
831 }
832 break;
833 case kHIDPage_AlphanumericDisplay:
834 switch (valueUsage)
835 {
836 default: sprintf (cstrName, "Alphanumeric Display Usage 0x%lx", valueUsage); break;
837 }
838 break;
839 case kHIDPage_BarCodeScanner:
840 switch (valueUsage)
841 {
842 default: sprintf (cstrName, "Bar Code Scanner Usage 0x%lx", valueUsage); break;
843 }
844 break;
845 case kHIDPage_Scale:
846 switch (valueUsage)
847 {
848 default: sprintf (cstrName, "Scale Usage 0x%lx", valueUsage); break;
849 }
850 break;
851 case kHIDPage_CameraControl:
852 switch (valueUsage)
853 {
854 default: sprintf (cstrName, "Camera Control Usage 0x%lx", valueUsage); break;
855 }
856 break;
857 case kHIDPage_Arcade:
858 switch (valueUsage)
859 {
860 default: sprintf (cstrName, "Arcade Usage 0x%lx", valueUsage); break;
861 }
862 break;
863 default:
864 if (valueUsagePage > kHIDPage_VendorDefinedStart)
865 sprintf (cstrName, "Vendor Defined Usage 0x%lx", valueUsage);
866 else
867 sprintf (cstrName, "Page: 0x%lx, Usage: 0x%lx", valueUsagePage, valueUsage);
868 break;
869 }
870 }
871
872 //*************************************************************************
873 //
874 // HIDCopyUsageName( inUsagePage, inUsage )
875 //
876 // Purpose: return a CFStringRef string for a given usage page & usage( see IOUSBHIDParser.h )
877 //
878 // Notes: returns usage page and usage values in CFString form for unknown values
879 //
880 // Inputs: inUsagePage - the usage page
881 // inUsage - the usage
882 //
883 // Returns: CFStringRef - the resultant string
884 //
885
886 CFStringRef HIDCopyUsageName( long inUsagePage, long inUsage )
887 {
888 static CFPropertyListRef tCFPropertyListRef = NULL;
889 CFStringRef result = NULL;
890
891 if ( !tCFPropertyListRef ) {
892 tCFPropertyListRef = hu_XMLLoad( CFSTR( "HID_usage_strings" ), CFSTR( "plist" ) );
893 }
894
895 if ( tCFPropertyListRef ) {
896 if ( CFDictionaryGetTypeID( ) == CFGetTypeID( tCFPropertyListRef ) ) {
897 CFStringRef pageKeyCFStringRef = CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "0x%4.4lX" ), inUsagePage );
898
899 if ( pageKeyCFStringRef ) {
900 CFDictionaryRef pageCFDictionaryRef;
901
902 if ( CFDictionaryGetValueIfPresent( tCFPropertyListRef, pageKeyCFStringRef, ( const void** ) &pageCFDictionaryRef ) ) {
903 CFStringRef pageCFStringRef;
904
905 if ( CFDictionaryGetValueIfPresent( pageCFDictionaryRef, kNameKeyCFStringRef, ( const void** ) &pageCFStringRef ) ) {
906 CFStringRef usageKeyCFStringRef = CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "0x%4.4lX" ), inUsage );
907
908 if ( usageKeyCFStringRef ) {
909 CFStringRef usageCFStringRef;
910
911 if ( CFDictionaryGetValueIfPresent( pageCFDictionaryRef, usageKeyCFStringRef, ( const void** ) &usageCFStringRef ) ) {
912 result = CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "%@ %@" ), pageCFStringRef, usageCFStringRef );
913 }
914 #if FAKE_MISSING_NAMES
915 else {
916 result = CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "%@ #%@" ), pageCFStringRef, usageKeyCFStringRef );
917 }
918 #endif
919 CFRelease( usageKeyCFStringRef );
920 }
921 } else {
922 // no name data for this page
923 }
924 } else {
925 // no data for this page
926 }
927 CFRelease( pageKeyCFStringRef );
928 }
929 }
930 // CFRelease( tCFPropertyListRef ); // Leak this!
931 // tCFPropertyListRef = NULL;
932 }
933 return result;
934 } // HIDCopyUsageName
935
936
937
938 //*****************************************************
939 #pragma mark - local ( static ) function implementations
940 //*****************************************************
941 #if 0 // currently unused
942 /*************************************************************************
943 *
944 * hu_SaveToXMLFile( inCFPRef, inCFURLRef )
945 *
946 * Purpose: save a property list into an XML file
947 *
948 * Inputs: inCFPRef - the data
949 * inCFURLRef - URL for the file
950 *
951 * Returns: SInt32 - error code ( if any )
952 */
953 static SInt32 hu_SaveToXMLFile( CFPropertyListRef inCFPRef, CFURLRef inCFURLRef )
954 {
955 CFDataRef xmlCFDataRef;
956 SInt32 error = coreFoundationUnknownErr;
957
958 // Convert the property list into XML data.
959 xmlCFDataRef = CFPropertyListCreateXMLData( kCFAllocatorDefault, inCFPRef );
960 if ( xmlCFDataRef ) {
961 // Write the XML data to the file.
962 ( void ) CFURLWriteDataAndPropertiesToResource( inCFURLRef, xmlCFDataRef, NULL, &error );
963
964 // Release the XML data
965 CFRelease( xmlCFDataRef );
966 }
967 return error;
968 } // hu_SaveToXMLFile
969 #endif
970 /*************************************************************************
971 *
972 * hu_LoadFromXMLFile( inCFURLRef )
973 *
974 * Purpose: load a property list from an XML file
975 *
976 * Inputs: inCFURLRef - URL for the file
977 *
978 * Returns: CFPropertyListRef - the data
979 */
980 static CFPropertyListRef hu_LoadFromXMLFile( CFURLRef inCFURLRef )
981 {
982 CFDataRef xmlCFDataRef;
983 CFPropertyListRef myCFPropertyListRef = NULL;
984
985 // Read the XML file.
986 SInt32 error;
987 if ( CFURLCreateDataAndPropertiesFromResource( kCFAllocatorDefault, inCFURLRef, & xmlCFDataRef, NULL, NULL, & error ) ) {
988 CFStringRef errorString;
989 // Reconstitute the dictionary using the XML data.
990 myCFPropertyListRef = CFPropertyListCreateFromXMLData( kCFAllocatorDefault, xmlCFDataRef, kCFPropertyListImmutable, & errorString );
991 // Release the XML data
992 CFRelease( xmlCFDataRef );
993 }
994 return myCFPropertyListRef;
995 } // hu_LoadFromXMLFile
996
997 #if 0 // currently unused
998 /*************************************************************************
999 *
1000 * hu_XMLSave( inCFPropertyListRef, inResourceName, inResourceExtension )
1001 *
1002 * Purpose: save a CFPropertyListRef into a resource( XML ) file
1003 *
1004 * Inputs: inCFPropertyListRef - the data
1005 * inResourceName - name of the resource file
1006 * inResourceExtension - extension of the resource file
1007 *
1008 * Returns: SInt32 - error code ( if any )
1009 */
1010 static SInt32 hu_XMLSave( CFPropertyListRef inCFPropertyListRef, CFStringRef inResourceName, CFStringRef inResourceExtension )
1011 {
1012 CFURLRef resFileCFURLRef;
1013 SInt32 error = - 1;
1014
1015 resFileCFURLRef = CFBundleCopyResourceURL( CFBundleGetMainBundle( ), inResourceName, inResourceExtension, NULL );
1016 if ( resFileCFURLRef ) {
1017 error = hu_SaveToXMLFile( inCFPropertyListRef, resFileCFURLRef );
1018 CFRelease( resFileCFURLRef );
1019 }
1020 return error;
1021 } // hu_XMLSave
1022 #endif
1023 /*************************************************************************
1024 *
1025 * hu_XMLLoad( inResourceName, inResourceExtension )
1026 *
1027 * Purpose: Load a resource( XML ) file into a CFPropertyListRef
1028 *
1029 * Inputs: inResourceName - name of the resource file
1030 * inResourceExtension - extension of the resource file
1031 *
1032 * Returns: CFPropertyListRef - the data
1033 */
1034 static CFPropertyListRef hu_XMLLoad( CFStringRef inResourceName, CFStringRef inResourceExtension )
1035 {
1036 CFURLRef resFileCFURLRef;
1037 CFPropertyListRef tCFPropertyListRef = NULL;
1038
1039 resFileCFURLRef = CFBundleCopyResourceURL( CFBundleGetMainBundle( ), inResourceName, inResourceExtension, NULL );
1040 if ( resFileCFURLRef ) {
1041 tCFPropertyListRef = hu_LoadFromXMLFile( resFileCFURLRef );
1042 CFRelease( resFileCFURLRef );
1043 }
1044 return tCFPropertyListRef;
1045 } // hu_XMLLoad
1046
1047 /*************************************************************************
1048 *
1049 * hu_XMLSearchForVendorNameByVendorID( inVendorID, outCStr )
1050 *
1051 * Purpose: Find a vendor string in the <HID_device_usage_strings.plist> resource ( XML ) file
1052 *
1053 * Inputs: inVendorID - the elements vendor ID
1054 * inProductID - the elements product ID
1055 * outCStr - address where result will be returned
1056 *
1057 * Returns: Boolean - if successful
1058 */
1059 static Boolean hu_XMLSearchForVendorNameByVendorID( long inVendorID, char * outCStr )
1060 {
1061 Boolean results = FALSE;
1062
1063 if ( ! gUsageCFPropertyListRef )
1064 gUsageCFPropertyListRef = hu_XMLLoad( CFSTR( "HID_device_usage_strings" ), CFSTR( "plist" ) );
1065
1066 if ( gUsageCFPropertyListRef ) {
1067 if ( CFDictionaryGetTypeID( ) == CFGetTypeID( gUsageCFPropertyListRef ) ) {
1068 CFDictionaryRef vendorCFDictionaryRef;
1069 CFStringRef vendorKeyCFStringRef = CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "%ld" ), inVendorID );
1070 if ( vendorKeyCFStringRef ) {
1071 if ( CFDictionaryGetValueIfPresent( gUsageCFPropertyListRef, vendorKeyCFStringRef, ( const void ** ) & vendorCFDictionaryRef ) ) {
1072 CFStringRef vendorCFStringRef = NULL;
1073 if ( CFDictionaryGetValueIfPresent( vendorCFDictionaryRef, kNameKeyCFStringRef, ( const void ** ) & vendorCFStringRef ) && vendorCFStringRef ) {
1074 // CFShow( vendorCFStringRef );
1075 results = CFStringGetCString( vendorCFStringRef, outCStr, CFStringGetLength( vendorCFStringRef ) * sizeof( UniChar ) + 1, kCFStringEncodingUTF8 );
1076 }
1077 }
1078 CFRelease( vendorKeyCFStringRef );
1079 }
1080 }
1081 // ++ CFRelease( gUsageCFPropertyListRef ); // Leak this !
1082 }
1083 return results;
1084 } // hu_XMLSearchForVendorNameByVendorID
1085
1086 /*************************************************************************
1087 *
1088 * hu_XMLSearchForProductNameByVendorProductID( inVendorID, inProductID, outCStr )
1089 *
1090 * Purpose: Find an product string in the <HID_device_usage_strings.plist> resource ( XML ) file
1091 *
1092 * Inputs: inVendorID - the elements vendor ID
1093 * inProductID - the elements product ID
1094 * outCStr - address where result will be returned
1095 *
1096 * Returns: Boolean - if successful
1097 */
1098 static Boolean hu_XMLSearchForProductNameByVendorProductID( long inVendorID, long inProductID, char * outCStr )
1099 {
1100 Boolean results = FALSE;
1101
1102 if ( ! gUsageCFPropertyListRef )
1103 gUsageCFPropertyListRef = hu_XMLLoad( CFSTR( "HID_device_usage_strings" ), CFSTR( "plist" ) );
1104
1105 if ( gUsageCFPropertyListRef ) {
1106 if ( CFDictionaryGetTypeID( ) == CFGetTypeID( gUsageCFPropertyListRef ) ) {
1107 // first we make our vendor ID key
1108 CFStringRef vendorKeyCFStringRef = CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "%ld" ), inVendorID );
1109 if ( vendorKeyCFStringRef ) {
1110 // and use it to look up our vendor dictionary
1111 CFDictionaryRef vendorCFDictionaryRef;
1112 if ( CFDictionaryGetValueIfPresent( gUsageCFPropertyListRef, vendorKeyCFStringRef, ( const void ** ) & vendorCFDictionaryRef ) ) {
1113 // pull our vendor name our of that dictionary
1114 CFStringRef vendorCFStringRef = NULL;
1115 if ( CFDictionaryGetValueIfPresent( vendorCFDictionaryRef, kNameKeyCFStringRef, ( const void ** ) & vendorCFStringRef ) ) {
1116 #if FAKE_MISSING_NAMES
1117 CFRetain( vendorCFStringRef ); // so we can CFRelease it later
1118 } else {
1119 vendorCFStringRef = CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "V: %@" ), vendorKeyCFStringRef );
1120 #endif
1121 }
1122
1123 // now we make our product ID key
1124 CFStringRef productKeyCFStringRef = CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "%ld" ), inProductID );
1125 if ( productKeyCFStringRef ) {
1126 // and use that key to look up our product dictionary in the vendor dictionary
1127 CFDictionaryRef productCFDictionaryRef;
1128 if ( CFDictionaryGetValueIfPresent( vendorCFDictionaryRef, productKeyCFStringRef, ( const void ** ) & productCFDictionaryRef ) ) {
1129 // pull our product name our of the product dictionary
1130 CFStringRef productCFStringRef = NULL;
1131 if ( CFDictionaryGetValueIfPresent( productCFDictionaryRef, kNameKeyCFStringRef, ( const void ** ) & productCFStringRef ) ) {
1132 #if FAKE_MISSING_NAMES
1133 CFRetain( productCFStringRef ); // so we can CFRelease it later
1134 } else {
1135 productCFStringRef = CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "P: %@" ), kNameKeyCFStringRef );
1136 #endif
1137 }
1138 CFStringRef fullCFStringRef = CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "%@ %@" ), vendorCFStringRef, productCFStringRef );
1139 if ( fullCFStringRef ) {
1140 // CFShow( fullCFStringRef );
1141 results = CFStringGetCString( fullCFStringRef, outCStr, CFStringGetLength( fullCFStringRef ) * sizeof( UniChar ) + 1, kCFStringEncodingUTF8 );
1142 CFRelease( fullCFStringRef );
1143 }
1144 #if FAKE_MISSING_NAMES
1145 if ( productCFStringRef ) {
1146 CFRelease( productCFStringRef );
1147 }
1148 #endif
1149 }
1150 CFRelease( productKeyCFStringRef );
1151 }
1152
1153 #if FAKE_MISSING_NAMES
1154 if ( vendorCFStringRef ) {
1155 CFRelease( vendorCFStringRef );
1156 }
1157 #endif
1158 }
1159 CFRelease( vendorKeyCFStringRef );
1160 }
1161 }
1162 // ++ CFRelease( gUsageCFPropertyListRef ); // Leak this !
1163 }
1164 return results;
1165 } // hu_XMLSearchForProductNameByVendorProductID
1166
1167 /*************************************************************************
1168 *
1169 * hu_XMLSearchForElementNameByCookie( inVendorID, inProductID, inCookie, outCStr )
1170 *
1171 * Purpose: Find an element string in the <HID_cookie_strings.plist> resource( XML ) file
1172 *
1173 * Inputs: inVendorID - the elements vendor ID
1174 * inProductID - the elements product ID
1175 * inCookie - the elements cookie
1176 * outCStr - address where result will be returned
1177 *
1178 * Returns: Boolean - if successful
1179 */
1180 static Boolean hu_XMLSearchForElementNameByCookie( long inVendorID, long inProductID, IOHIDElementCookie inCookie, char * outCStr )
1181 {
1182 Boolean results = FALSE;
1183
1184 if ( ! gCookieCFPropertyListRef )
1185 gCookieCFPropertyListRef = hu_XMLLoad( CFSTR( "HID_cookie_strings" ), CFSTR( "plist" ) );
1186
1187 if ( gCookieCFPropertyListRef ) {
1188 if ( CFDictionaryGetTypeID( ) == CFGetTypeID( gCookieCFPropertyListRef ) ) {
1189 CFStringRef vendorKeyCFStringRef = CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "%ld" ), inVendorID );
1190 if ( vendorKeyCFStringRef ) {
1191 CFDictionaryRef vendorCFDictionaryRef;
1192 if ( CFDictionaryGetValueIfPresent( gCookieCFPropertyListRef, vendorKeyCFStringRef, ( const void ** ) & vendorCFDictionaryRef ) ) {
1193 CFDictionaryRef productCFDictionaryRef;
1194 CFStringRef productKeyCFStringRef;
1195 CFStringRef vendorCFStringRef;
1196
1197 if ( CFDictionaryGetValueIfPresent( vendorCFDictionaryRef, kNameKeyCFStringRef, ( const void ** ) & vendorCFStringRef ) ) {
1198 // CFShow( vendorCFStringRef );
1199 }
1200 productKeyCFStringRef = CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "%ld" ), inProductID );
1201
1202 if ( CFDictionaryGetValueIfPresent( vendorCFDictionaryRef, productKeyCFStringRef, ( const void ** ) & productCFDictionaryRef ) ) {
1203 CFStringRef fullCFStringRef = NULL;
1204 CFStringRef cookieKeyCFStringRef;
1205 CFStringRef productCFStringRef;
1206 CFStringRef cookieCFStringRef;
1207
1208 if ( CFDictionaryGetValueIfPresent( productCFDictionaryRef, kNameKeyCFStringRef, ( const void ** ) & productCFStringRef ) ) {
1209 // CFShow( productCFStringRef );
1210 }
1211 cookieKeyCFStringRef = CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "%ld" ), inCookie );
1212
1213 if ( CFDictionaryGetValueIfPresent( productCFDictionaryRef, cookieKeyCFStringRef, ( const void ** ) & cookieCFStringRef ) ) {
1214 #if VERBOSE_ELEMENT_NAMES
1215 fullCFStringRef = CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "%@ %@ %@" ), vendorCFStringRef, productCFStringRef, cookieCFStringRef );
1216 #else
1217 fullCFStringRef = CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "%@" ), cookieCFStringRef );
1218 #endif VERBOSE_ELEMENT_NAMES
1219 // CFShow( cookieCFStringRef );
1220 }
1221 #if FAKE_MISSING_NAMES
1222 else {
1223 fullCFStringRef = CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "%@ %@ # %@" ), vendorCFStringRef, productCFStringRef, cookieKeyCFStringRef );
1224 }
1225 #endif FAKE_MISSING_NAMES
1226 if ( fullCFStringRef ) {
1227 // CFShow( fullCFStringRef );
1228 results = CFStringGetCString( fullCFStringRef, outCStr, CFStringGetLength( fullCFStringRef ) * sizeof( UniChar ) + 1, kCFStringEncodingUTF8 );
1229 CFRelease( fullCFStringRef );
1230 }
1231 CFRelease( cookieKeyCFStringRef );
1232 }
1233 CFRelease( productKeyCFStringRef );
1234 }
1235 CFRelease( vendorKeyCFStringRef );
1236 }
1237 }
1238 // ++ CFRelease( gCookieCFPropertyListRef ); // Leak this !
1239 }
1240 return results;
1241 } // hu_XMLSearchForElementNameByCookie
1242
1243 /*************************************************************************
1244 *
1245 * hu_XMLSearchForElementNameByUsage( inVendorID, inProductID, inUsagePage, inUsage, outCStr )
1246 *
1247 * Purpose: Find an element string in the <HID_device_usage_strings.plist> resource( XML ) file
1248 *
1249 * Inputs: inVendorID - the elements vendor ID
1250 * inProductID - the elements product ID
1251 * inUsagePage - the elements usage page
1252 * inUsage - the elements usage
1253 * outCStr - address where result will be returned
1254 *
1255 * Returns: Boolean - if successful
1256 */
1257 static Boolean hu_XMLSearchForElementNameByUsage( long inVendorID, long inProductID, long inUsagePage, long inUsage, char * outCStr )
1258 {
1259 Boolean results = FALSE;
1260
1261 if ( !gUsageCFPropertyListRef ) {
1262 gUsageCFPropertyListRef = hu_XMLLoad( CFSTR( "HID_device_usage_strings" ), CFSTR( "plist" ) );
1263 }
1264
1265 if ( gUsageCFPropertyListRef ) {
1266 if ( CFDictionaryGetTypeID( ) == CFGetTypeID( gUsageCFPropertyListRef ) ) {
1267 CFStringRef vendorKeyCFStringRef = CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "%ld" ), inVendorID );
1268
1269 if ( vendorKeyCFStringRef ) {
1270 CFDictionaryRef vendorCFDictionaryRef;
1271
1272 if ( CFDictionaryGetValueIfPresent( gUsageCFPropertyListRef, vendorKeyCFStringRef, ( const void ** ) &vendorCFDictionaryRef ) ) {
1273 CFStringRef vendorCFStringRef = NULL;
1274
1275 if ( CFDictionaryGetValueIfPresent( vendorCFDictionaryRef, kNameKeyCFStringRef, ( const void ** ) &vendorCFStringRef ) ) {
1276 vendorCFStringRef = CFStringCreateCopy( kCFAllocatorDefault, vendorCFStringRef );
1277 } else {
1278 vendorCFStringRef = CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "v: %ld" ), inVendorID );
1279 // CFShow( vendorCFStringRef );
1280 }
1281 CFStringRef productKeyCFStringRef = CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "%ld" ), inProductID );
1282
1283 CFDictionaryRef productCFDictionaryRef;
1284 if ( CFDictionaryGetValueIfPresent( vendorCFDictionaryRef, productKeyCFStringRef, ( const void ** ) &productCFDictionaryRef ) ) {
1285 CFStringRef fullCFStringRef = NULL;
1286
1287 CFStringRef productCFStringRef;
1288 if ( CFDictionaryGetValueIfPresent( productCFDictionaryRef, kNameKeyCFStringRef, ( const void ** ) &productCFStringRef ) ) {
1289 // CFShow( productCFStringRef );
1290 }
1291 CFStringRef usageKeyCFStringRef = CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "%ld:%ld" ), inUsagePage, inUsage );
1292 CFStringRef usageCFStringRef;
1293 if ( CFDictionaryGetValueIfPresent( productCFDictionaryRef, usageKeyCFStringRef, ( const void ** ) &usageCFStringRef ) ) {
1294 #if VERBOSE_ELEMENT_NAMES
1295 fullCFStringRef = CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "%@ %@ %@" ), vendorCFStringRef, productCFStringRef, usageCFStringRef );
1296 #else
1297 fullCFStringRef = CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "%@" ), usageCFStringRef );
1298 #endif VERBOSE_ELEMENT_NAMES
1299 // CFShow( usageCFStringRef );
1300 }
1301 #if FAKE_MISSING_NAMES
1302 else {
1303 fullCFStringRef = CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "%@ %@ # %@" ), vendorCFStringRef, productCFStringRef, usageKeyCFStringRef );
1304 }
1305 #endif FAKE_MISSING_NAMES
1306
1307 if ( fullCFStringRef ) {
1308 // CFShow( fullCFStringRef );
1309 results = CFStringGetCString( fullCFStringRef, outCStr, CFStringGetLength( fullCFStringRef ) * sizeof( UniChar ) + 1, kCFStringEncodingUTF8 );
1310 CFRelease( fullCFStringRef );
1311 }
1312 CFRelease( usageKeyCFStringRef );
1313 }
1314 if ( vendorCFStringRef ) {
1315 CFRelease( vendorCFStringRef );
1316 }
1317 CFRelease( productKeyCFStringRef );
1318 }
1319 CFRelease( vendorKeyCFStringRef );
1320 }
1321 }
1322 // ++ CFRelease( gUsageCFPropertyListRef ); // Leak this !
1323 }
1324 return results;
1325 } // hu_XMLSearchForElementNameByUsage
1326
1327 #if 0 // currently unused
1328 /*************************************************************************
1329 *
1330 * hu_AddVendorProductToCFDict( inCFMutableDictionaryRef, inVendorID, inVendorCFStringRef, inProductID, inProductCFStringRef )
1331 *
1332 * Purpose: add a vendor & product to a dictionary
1333 *
1334 * Inputs: inCFMutableDictionaryRef - the dictionary
1335 * inVendorID - the elements vendor ID
1336 * inProductID - the elements product ID
1337 * inProductCFStringRef - the string to be added
1338 *
1339 * Returns: Boolean - if successful
1340 */
1341 static Boolean hu_AddVendorProductToCFDict( CFMutableDictionaryRef inCFMutableDictionaryRef, long inVendorID, CFStringRef inVendorCFStringRef, long inProductID, CFStringRef inProductCFStringRef )
1342 {
1343 Boolean results = FALSE;
1344
1345 if ( inCFMutableDictionaryRef && ( CFDictionaryGetTypeID( ) == CFGetTypeID( inCFMutableDictionaryRef ) ) ) {
1346 CFMutableDictionaryRef vendorCFMutableDictionaryRef;
1347 CFStringRef vendorKeyCFStringRef;
1348
1349 CFMutableDictionaryRef productCFMutableDictionaryRef;
1350 CFStringRef productKeyCFStringRef;
1351
1352 // if the vendor dictionary doesn't exist
1353 vendorKeyCFStringRef = CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "%ld" ), inVendorID );
1354 if ( CFDictionaryGetValueIfPresent( inCFMutableDictionaryRef, vendorKeyCFStringRef, ( const void ** ) & vendorCFMutableDictionaryRef ) ) {
1355 // copy it.
1356 vendorCFMutableDictionaryRef = CFDictionaryCreateMutableCopy( kCFAllocatorDefault, 0, vendorCFMutableDictionaryRef );
1357 } else { // ...otherwise...
1358 // create it.
1359 vendorCFMutableDictionaryRef = CFDictionaryCreateMutable( kCFAllocatorDefault, 0, & kCFTypeDictionaryKeyCallBacks, & kCFTypeDictionaryValueCallBacks );
1360 results = TRUE;
1361 }
1362
1363 // if the vendor name key doesn't exist
1364 if ( ! CFDictionaryContainsKey( vendorCFMutableDictionaryRef, kNameKeyCFStringRef ) ) {
1365 // create it.
1366 CFDictionaryAddValue( vendorCFMutableDictionaryRef, kNameKeyCFStringRef, inVendorCFStringRef );
1367 results = TRUE;
1368 }
1369
1370 // if the product key exists in the vendor dictionary
1371 productKeyCFStringRef = CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "%ld" ), inProductID );
1372 if ( CFDictionaryGetValueIfPresent( vendorCFMutableDictionaryRef, productKeyCFStringRef, ( const void ** ) & productCFMutableDictionaryRef ) ) {
1373 // copy it.
1374 productCFMutableDictionaryRef = CFDictionaryCreateMutableCopy( kCFAllocatorDefault, 0, productCFMutableDictionaryRef );
1375 } else { // ...otherwise...
1376 // create it.
1377 productCFMutableDictionaryRef = CFDictionaryCreateMutable( kCFAllocatorDefault, 0, & kCFTypeDictionaryKeyCallBacks, & kCFTypeDictionaryValueCallBacks );
1378 results = TRUE;
1379 }
1380
1381 // if the product name key doesn't exist
1382 if ( ! CFDictionaryContainsKey( productCFMutableDictionaryRef, kNameKeyCFStringRef ) ) {
1383 // create it.
1384 CFDictionaryAddValue( productCFMutableDictionaryRef, kNameKeyCFStringRef, inProductCFStringRef );
1385 results = TRUE;
1386 }
1387
1388 if ( vendorCFMutableDictionaryRef ) {
1389 if ( productCFMutableDictionaryRef ) {
1390 if ( results )
1391 CFDictionarySetValue( vendorCFMutableDictionaryRef, productKeyCFStringRef, productCFMutableDictionaryRef );
1392 CFRelease( productCFMutableDictionaryRef );
1393 }
1394 if ( results )
1395 CFDictionarySetValue( inCFMutableDictionaryRef, vendorKeyCFStringRef, vendorCFMutableDictionaryRef );
1396 CFRelease( vendorCFMutableDictionaryRef );
1397 }
1398 if ( productKeyCFStringRef )
1399 CFRelease( productKeyCFStringRef );
1400 if ( vendorKeyCFStringRef )
1401 CFRelease( vendorKeyCFStringRef );
1402 }
1403 return results;
1404 } // hu_AddVendorProductToCFDict
1405
1406 /*************************************************************************
1407 *
1408 * hu_AddDeviceElementToUsageXML( inDevice, inElement )
1409 *
1410 * Purpose: add a device and it's elements to our usage( XML ) file
1411 *
1412 * Inputs: inDevice - the device
1413 * inElement - the element
1414 *
1415 * Returns: Boolean - if successful
1416 */
1417 static Boolean hu_AddDeviceElementToUsageXML( IOHIDDeviceRef inIOHIDDeviceRef, IOHIDElementRef inIOHIDElementRef )
1418 {
1419 Boolean results = FALSE;
1420
1421 if ( gUsageCFPropertyListRef ) {
1422 CFRelease( gUsageCFPropertyListRef );
1423 }
1424
1425 gUsageCFPropertyListRef = hu_XMLLoad( CFSTR( "HID_device_usage_strings" ), CFSTR( "plist" ) );
1426
1427 if ( gUsageCFPropertyListRef ) {
1428 CFMutableDictionaryRef tCFMutableDictionaryRef = CFDictionaryCreateMutableCopy( kCFAllocatorDefault, 0, gUsageCFPropertyListRef );
1429
1430 if ( tCFMutableDictionaryRef ) {
1431 CFMutableDictionaryRef vendorCFMutableDictionaryRef;
1432
1433 CFMutableDictionaryRef productCFMutableDictionaryRef;
1434 CFStringRef productKeyCFStringRef;
1435
1436 CFStringRef usageKeyCFStringRef;
1437
1438 // if the vendor dictionary exists...
1439 long vendorID = IOHIDDevice_GetVendorID( inIOHIDDeviceRef );
1440 CFStringRef vendorKeyCFStringRef = CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "%ld" ), vendorID );
1441 if ( vendorKeyCFStringRef ) {
1442 if ( CFDictionaryGetValueIfPresent( tCFMutableDictionaryRef, vendorKeyCFStringRef,
1443 ( const void ** ) &vendorCFMutableDictionaryRef ) ) {
1444 // ...copy it...
1445 vendorCFMutableDictionaryRef = CFDictionaryCreateMutableCopy( kCFAllocatorDefault, 0, vendorCFMutableDictionaryRef );
1446 } else { // ...otherwise...
1447 // ...create it.
1448 vendorCFMutableDictionaryRef = CFDictionaryCreateMutable( kCFAllocatorDefault,
1449 0,
1450 &kCFTypeDictionaryKeyCallBacks,
1451 &kCFTypeDictionaryValueCallBacks );
1452 results = TRUE;
1453 }
1454
1455 // if the vendor name key doesn't exist...
1456 if ( !CFDictionaryContainsKey( vendorCFMutableDictionaryRef, kNameKeyCFStringRef ) ) {
1457 CFStringRef manCFStringRef = IOHIDDevice_GetManufacturer( inIOHIDDeviceRef );
1458 // ...create it.
1459 CFDictionaryAddValue( vendorCFMutableDictionaryRef, kNameKeyCFStringRef, manCFStringRef );
1460 results = TRUE;
1461 }
1462
1463 // if the product key exists in the vendor dictionary...
1464 long productID = IOHIDDevice_GetProductID( inIOHIDDeviceRef );
1465 productKeyCFStringRef = CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "%ld" ), productID );
1466
1467 if ( CFDictionaryGetValueIfPresent( vendorCFMutableDictionaryRef, productKeyCFStringRef,
1468 ( const void ** ) &productCFMutableDictionaryRef ) ) {
1469 // ...copy it...
1470 productCFMutableDictionaryRef = CFDictionaryCreateMutableCopy( kCFAllocatorDefault, 0, productCFMutableDictionaryRef );
1471 } else { // ...otherwise...
1472 // ...create it.
1473 productCFMutableDictionaryRef = CFDictionaryCreateMutable( kCFAllocatorDefault,
1474 0,
1475 &kCFTypeDictionaryKeyCallBacks,
1476 &kCFTypeDictionaryValueCallBacks );
1477 results = TRUE;
1478 }
1479
1480 // if the product name key doesn't exist...
1481 if ( !CFDictionaryContainsKey( productCFMutableDictionaryRef, kNameKeyCFStringRef ) ) {
1482 CFStringRef productCFStringRef = IOHIDDevice_GetProduct( inIOHIDDeviceRef );
1483 // ...create it.
1484 CFDictionaryAddValue( productCFMutableDictionaryRef, kNameKeyCFStringRef, productCFStringRef );
1485 results = TRUE;
1486 }
1487
1488 // if the usage key doesn't exist in the product dictionary...
1489 uint32_t usagePage = IOHIDElementGetUsagePage( inIOHIDElementRef );
1490 uint32_t usage = IOHIDElementGetUsagePage( inIOHIDElementRef );
1491 usageKeyCFStringRef = CFStringCreateWithFormat( kCFAllocatorDefault, NULL, CFSTR( "%ld:%ld" ), usagePage, usage );
1492
1493 if ( usageKeyCFStringRef ) {
1494 if ( !CFDictionaryContainsKey( productCFMutableDictionaryRef, usageKeyCFStringRef ) ) {
1495 // find it's generic name
1496 CFStringRef usageCFStringRef = HIDCopyUsageName( usagePage, usage );
1497
1498 if ( usageCFStringRef ) {
1499 // and add that.
1500 CFDictionaryAddValue( productCFMutableDictionaryRef, usageKeyCFStringRef, usageCFStringRef );
1501 results = TRUE;
1502 CFRelease( usageCFStringRef );
1503 }
1504 }
1505 CFRelease( usageKeyCFStringRef );
1506 }
1507
1508 if ( vendorCFMutableDictionaryRef ) {
1509 if ( productCFMutableDictionaryRef ) {
1510 if ( results ) {
1511 CFDictionarySetValue( vendorCFMutableDictionaryRef, productKeyCFStringRef, productCFMutableDictionaryRef );
1512 }
1513 CFRelease( productCFMutableDictionaryRef );
1514 }
1515
1516 if ( results ) {
1517 CFDictionarySetValue( tCFMutableDictionaryRef, vendorKeyCFStringRef, vendorCFMutableDictionaryRef );
1518 }
1519 CFRelease( vendorCFMutableDictionaryRef );
1520 }
1521 CFRelease( vendorKeyCFStringRef );
1522 }
1523
1524 if ( productKeyCFStringRef ) {
1525 CFRelease( productKeyCFStringRef );
1526 }
1527
1528 if ( results ) {
1529 hu_XMLSave( tCFMutableDictionaryRef, CFSTR( "HID_device_usage_strings" ), CFSTR( "plist" ) );
1530 }
1531 CFRelease( tCFMutableDictionaryRef );
1532 }
1533 }
1534 return results;
1535 } // hu_AddDeviceElementToUsageXML
1536 #endif