// Create HID Manager reference

IOHIDManagerRef IOHIDManagerCreate(

                    CFAllocatorRef  inCFAllocatorRef,   // Allocator to be used during creation

                    IOOptionBits    inOptions);         // options Reserved for future use

    if (CFGetTypeID(tCFTypeRef) == IOHIDManagerGetTypeID()) {

        // this is a HID Manager reference!

    }

    if (CFGetTypeID(tCFTypeRef) == IOHIDDeviceGetTypeID()) {

        // this is a valid HID device reference

    }

// Get a HID device's transport (string)

CFStringRef IOHIDDevice_GetTransport(IOHIDDeviceRef inIOHIDDeviceRef)

{

    return IOHIDDeviceGetProperty(inIOHIDDeviceRef, CFSTR(kIOHIDTransportKey));

}

// function to get a long device property

// returns FALSE if the property isn't found or can't be converted to a long

static Boolean IOHIDDevice_GetLongProperty(

    IOHIDDeviceRef inDeviceRef,     // the HID device reference

    CFStringRef inKey,              // the kIOHIDDevice key (as a CFString)

    long * outValue)                // address where to return the output value

{

    Boolean result = FALSE;

    CFTypeRef tCFTypeRef = IOHIDDeviceGetProperty(inDeviceRef, inKey);

    if (tCFTypeRef) {

        // if this is a number

        if (CFNumberGetTypeID() == CFGetTypeID(tCFTypeRef)) {

            // get its value

            result = CFNumberGetValue((CFNumberRef) tCFTypeRef, kCFNumberSInt32Type, outValue);

        }

    }

    return result;

}   // IOHIDDevice_GetLongProperty

// Get a HID device's vendor ID (long)

long IOHIDDevice_GetVendorID(IOHIDDeviceRef inIOHIDDeviceRef)

{

    long result = 0;

    (void) IOHIDDevice_GetLongProperty(inIOHIDDeviceRef, CFSTR(kIOHIDVendorIDKey), &result);

    return result;

} // IOHIDDevice_GetVendorID

// Get a HID device's product ID (long)

long IOHIDDevice_GetProductID(IOHIDDeviceRef inIOHIDDeviceRef)

{

    long result = 0;

    (void) IOHIDDevice_GetLongProperty(inIOHIDDeviceRef, CFSTR(kIOHIDProductIDKey), &result);

    return result;

} // IOHIDDevice_GetProductID

    if (CFGetTypeID(tCFTypeRef) == IOHIDElementGetTypeID()) {

        // this is a valid HID element reference

    }

From <IOKit/hid/IOHIDKeys.h>:

#define kIOHIDElementCookieKey                      "ElementCookie"

#define kIOHIDElementTypeKey                        "Type"

#define kIOHIDElementCollectionTypeKey              "CollectionType"

#define kIOHIDElementUsageKey                       "Usage"

#define kIOHIDElementUsagePageKey                   "UsagePage"

#define kIOHIDElementMinKey                         "Min"

#define kIOHIDElementMaxKey                         "Max"

#define kIOHIDElementScaledMinKey                   "ScaledMin"

#define kIOHIDElementScaledMaxKey                   "ScaledMax"

#define kIOHIDElementSizeKey                        "Size"

#define kIOHIDElementReportSizeKey                  "ReportSize"

#define kIOHIDElementReportCountKey                 "ReportCount"

#define kIOHIDElementReportIDKey                    "ReportID"

#define kIOHIDElementIsArrayKey                     "IsArray"

#define kIOHIDElementIsRelativeKey                  "IsRelative"

#define kIOHIDElementIsWrappingKey                  "IsWrapping"

#define kIOHIDElementIsNonLinearKey                 "IsNonLinear"

#define kIOHIDElementHasPreferredStateKey           "HasPreferredState"

#define kIOHIDElementHasNullStateKey                "HasNullState"

#define kIOHIDElementFlagsKey                       "Flags"

#define kIOHIDElementUnitKey                        "Unit"

#define kIOHIDElementUnitExponentKey                "UnitExponent"

#define kIOHIDElementNameKey                        "Name"

#define kIOHIDElementValueLocationKey               "ValueLocation"

#define kIOHIDElementDuplicateIndexKey              "DuplicateIndex"

#define kIOHIDElementParentCollectionKey            "ParentCollection"

#define kIOHIDElementVendorSpecificKey              "VendorSpecific"

#define kIOHIDElementCalibrationMinKey              "CalibrationMin"

#define kIOHIDElementCalibrationMaxKey              "CalibrationMax"

#define kIOHIDElementCalibrationSaturationMinKey    "CalibrationSaturationMin"

#define kIOHIDElementCalibrationSaturationMaxKey    "CalibrationSaturationMax"

#define kIOHIDElementCalibrationDeadZoneMinKey      "CalibrationDeadZoneMin"

#define kIOHIDElementCalibrationDeadZoneMaxKey      "CalibrationDeadZoneMax"

#define kIOHIDElementCalibrationGranularityKey      "CalibrationGranularity"

IOHIDElementGetProperty(element, CFSTR(kIOHIDElementTypeKey), &tCFNumberRef);

static Boolean IOHIDElement_GetLongProperty(

    IOHIDElementRef inElementRef,   // the HID element

    CFStringRef inKey,              // the kIOHIDElement key (as a CFString)

    long * outValue)                // address where to return the output value

{

    Boolean result = FALSE;

    CFTypeRef tCFTypeRef = IOHIDElementGetProperty(inElementRef, inKey);

    if (tCFTypeRef) {

        // if this is a number

        if (CFNumberGetTypeID() == CFGetTypeID(tCFTypeRef)) {

            // get its value

            result = CFNumberGetValue((CFNumberRef) tCFTypeRef, kCFNumberSInt32Type, outValue);

        }

    }

    return result;

}

static void IOHIDElement_SetLongProperty(

    IOHIDElementRef inElementRef,   // the HID element

    CFStringRef inKey,              // the kIOHIDElement key (as a CFString)

    long inValue)                   // the long value to be set

{

    CFNumberRef tCFNumberRef = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &inValue);

    if (tCFNumberRef) {

        IOHIDElementSetProperty(inElementRef, inKey, tCFNumberRef);

        CFRelease(tCFNumberRef);

    }

}

// access the kIOHIDElementVendorSpecificKey if it exists:

long longValue;

if (IOHIDElement_GetLongProperty(elementRef, CFSTR(kIOHIDElementVendorSpecificKey), &longValue)) {

    printf("Element 0x%08lX has a vendor specific key of value 0x%08lX.\n", elementRef, longValue);

}

// IOHIDElementCookie represent a unique identifier for a HID element within a HID device.

IOHIDElementCookie cookie = IOHIDElementGetCookie(elementRef);

// return the collection type:

//  kIOHIDElementTypeInput_Misc         = 1,

//  kIOHIDElementTypeInput_Button       = 2,

//  kIOHIDElementTypeInput_Axis         = 3,

//  kIOHIDElementTypeInput_ScanCodes    = 4,

//  kIOHIDElementTypeOutput             = 129,

//  kIOHIDElementTypeFeature            = 257,

//  kIOHIDElementTypeCollection         = 513

IOHIDElementType tType = IOHIDElementGetType(elementRef);

// If the HID element type is of type kIOHIDElementTypeCollection then

// the collection type is one of:

//  kIOHIDElementCollectionTypePhysical         = 0x00,

//  kIOHIDElementCollectionTypeApplication      = 0x01,

//  kIOHIDElementCollectionTypeLogical          = 0x02,

//  kIOHIDElementCollectionTypeReport           = 0x03,

//  kIOHIDElementCollectionTypeNamedArray       = 0x04,

//  kIOHIDElementCollectionTypeUsageSwitch      = 0x05,

//  kIOHIDElementCollectionTypeUsageModifier    = 0x06

IOHIDElementCollectionType collectionType = IOHIDElementGetCollectionType(elementRef);

// usage and usage pages are defined on the USB website at: <http://www.usb.org>

uint32_t page = IOHIDElementGetUsagePage(elementRef);

uint32_t usage = IOHIDElementGetUsage(elementRef);

// Boolean properties

Boolean isVirtual = IOHIDElementIsVirtual(elementRef);

Boolean isRelative = IOHIDElementIsRelative(elementRef);

Boolean isWrapping = IOHIDElementIsWrapping(elementRef);

Boolean isArray = IOHIDElementIsArray(elementRef);

Boolean isNonLinear = IOHIDElementIsNonLinear(elementRef);

Boolean hasPreferred = IOHIDElementHasPreferredState(elementRef);

Boolean hasNullState = IOHIDElementHasNullState(elementRef);

// the HID element name

CFStringRef name = IOHIDElementGetName(elementRef);

// element report information

uint32_t reportID = IOHIDElementGetReportID(elementRef);

uint32_t reportSize = IOHIDElementGetReportSize(elementRef);

uint32_t reportCount = IOHIDElementGetReportCount(elementRef);

// element unit & exponent

uint32_t unit = IOHIDElementGetUnit(elementRef);

uint32_t unitExp = IOHIDElementGetUnitExponent(elementRef);

// logical & physical minimums & maximums

CFIndex logicalMin = IOHIDElementGetLogicalMin(elementRef);

CFIndex logicalMax = IOHIDElementGetLogicalMax(elementRef);

CFIndex physicalMin = IOHIDElementGetPhysicalMin(elementRef);

CFIndex physicalMax = IOHIDElementGetPhysicalMax(elementRef);

// return the HID device that a element belongs to

IOHIDDeviceRef deviceRef = IOHIDElementGetDevice(elementRef);

// return the collection element that a HID element belongs to (if any)

IOHIDElementRef elementRef = IOHIDElementGetParent(elementRef);

// return the child elements of a collection element (if any)

CFArrayRef tCFArrayRef = IOHIDElementGetChildren(elementRef);

// Create HID queue reference

IOHIDQueueRef IOHIDQueueCreate(

                    CFAllocatorRef  inCFAllocatorRef,   // Allocator to be used during creation

                    IOHIDDeviceRef  inIOHIDDeviceRef,   // the HID device to be associated with this queue

                    CFIndex         inDepth,            // the maximum number of values to queue

                    IOOptionBits    inOptions)          // options (currently reserved)

    if (CFGetTypeID(tCFTypeRef) == IOHIDQueueGetTypeID()) {

        // this is a valid HID queue reference!

    }

void IOHIDQueueStart(IOHIDQueueRef inIOHIDQueueRef);

void IOHIDQueueStop(IOHIDQueueRef inIOHIDQueueRef);

IOHIDDeviceRef IOHIDQueueGetDevice(IOHIDQueueRef inIOHIDQueueRef);

CFIndex IOHIDQueueGetDepth(IOHIDQueueRef inIOHIDQueueRef);

void IOHIDQueueSetDepth(IOHIDQueueRef inIOHIDQueueRef, CFIndex inDepth);

void IOHIDQueueAddElement(IOHIDQueueRef inIOHIDQueueRef, IOHIDElementRef inIOHIDElementRef);

void IOHIDQueueRemoveElement(IOHIDQueueRef inIOHIDQueueRef, IOHIDElementRef inIOHIDElementRef);

Boolean IOHIDQueueContainsElement(IOHIDQueueRef inIOHIDQueueRef, IOHIDElementRef inIOHIDElementRef);

IOHIDValueRef IOHIDQueueCopyNextValue(IOHIDQueueRef inIOHIDQueueRef);

IOHIDValueRef IOHIDQueueCopyNextValueWithTimeout(IOHIDQueueRef inIOHIDQueueRef, CFTimeInterval inTimeout);

void IOHIDQueueRegisterValueAvailableCallback(

                                IOHIDQueueRef inIOHIDQueueRef,   // reference to the HID queue

                                IOHIDCallback inCallback,        // address of the callback routine

                                void *        inContext);        // context passed to callback

// Schedule a HID queue with a runloop

void IOHIDQueueScheduleWithRunLoop(IOHIDQueueRef       inIOHIDQueueRef,     // reference to the HID queue

                                    CFRunLoopRef        inRunLoop,          // Run loop to be scheduled with

                                    CFStringRef         inRunLoopMode);     // Run loop mode for scheduling

// Unschedule a HID queue from a runloop

void IOHIDQueueUnscheduleFromRunLoop(

                        IOHIDQueueRef   inIOHIDQueueRef,    // reference to the HID queue

                        CFRunLoopRef    inRunLoop,          // Run loop to be unscheduling from

                        CFStringRef     inRunLoopMode);     // Run loop mode for unscheduling

IOHIDQueueScheduleWithRunLoop(inIOHIDQueueRef, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);

static void Handle_ValueAvailableCallback(

                void *   inContext, // context from IOHIDQueueRegisterValueAvailableCallback

                IOReturn inResult,  // the inResult

                void *   inSender,  // IOHIDQueueRef of the queue

) {

    printf("%s(context: %p, result: %p, sender: %p).\n",

        __PRETTY_FUNCTION__, inContext, (void *) inResult, inSender);

    do {

        IOHIDValueRef valueRef = IOHIDQueueCopyNextValueWithTimeout((IOHIDQueueRef) inSender, 0.);

        if (!valueRef) break;

        // process the HID value reference

        .

        .

        .

        CFRelease(valueRef);    // Don't forget to release our HID value reference

    } while (1) ;

}   // Handle_ValueAvailableCallback

IOHIDTransactionRef IOHIDTransactionCreate(

                        CFAllocatorRef  inCFAllocatorRef,   // Allocator to be used during creation

                        IOHIDDeviceRef  inIOHIDDeviceRef,   // the HID device for this transaction

                        IOHIDTransactionDirectionType   inDirection,  // The direction: in or out

                        IOOptionBits    inOptions);         // options (currently reserved)

    if (CFGetTypeID(tCFTypeRef) == IOHIDTransactionGetTypeID()) {

        // this is a valid HID transaction reference!

    }

// Obtain the HID device associated with a transaction

IOHIDDeviceRef IOHIDTransactionGetDevice(

                                    IOHIDTransactionRef inIOHIDTransactionRef); // HID transaction reference

// Obtain the direction of the transaction.

IOHIDTransactionDirectionType IOHIDTransactionGetDirection(

                                    IOHIDTransactionRef IOHIDTransactionRef);   // HID transaction reference

// Sets the direction of the transaction

void IOHIDTransactionSetDirection(IOHIDTransactionRef IOHIDTransactionRef,      // HID transaction reference

                                   IOHIDTransactionDirectionType direction);    // The direction: in or out

void IOHIDTransactionAddElement(

            IOHIDTransactionRef inIOHIDTransactionRef,  // HID transaction reference

            IOHIDElementRef     inIOHIDElementRef);     // the HID element to associate with this transaction

void IOHIDTransactionRemoveElement(

            IOHIDTransactionRef inIOHIDTransactionRef,  // HID transaction reference

            IOHIDElementRef     inIOHIDElementRef);     // the HID element to associate with this transaction

// Queries the transaction to determine if elemement has been added.

Boolean IOHIDTransactionContainsElement(

                    IOHIDTransactionRef inIOHIDTransactionRef, // HID transaction reference

                    IOHIDElementRef     inIOHIDElementRef);    // the HID element to test for

void IOHIDTransactionSetValue(IOHIDTransactionRef  inIOHIDTransactionRef,   // HID transaction reference

                                IOHIDElementRef     inIOHIDElementRef,      // the HID element

                                IOHIDValueRef       inIOHIDValueRef,        // the HID element value

                                IOOptionBits        inOptions);             // options

// Obtains the HID value for a transaction element.

IOHIDValueRef IOHIDTransactionGetValue(

                                IOHIDTransactionRef inIOHIDTransactionRef,  // HID transaction reference

                                IOHIDElementRef     inIOHIDElementRef,      // the HID element

                                IOOptionBits        inOptions);             // options

// Clears element transaction values.

void IOHIDTransactionClear(IOHIDTransactionRef inIOHIDTransactionRef);  // HID transaction reference

// Synchronously commits element transaction to the HID device.

IOReturn IOHIDTransactionCommit(IOHIDTransactionRef inIOHIDTransactionRef); // HID transaction reference

// Asynchronously commits element transaction to the HID device.

IOReturn IOHIDTransactionCommitWithCallback(

                        IOHIDTransactionRef inIOHIDTransactionRef,  // HID transaction reference

                        CFTimeInterval      inTimeout,              // timeout duration

                        IOHIDCallback       inCallback,             // address of the callback routine

                        void *              inContext);             // Pointer to be passed to the callback

// Schedule a HID transaction with a runloop

void IOHIDTransactionScheduleWithRunLoop(

        IOHIDTransactionRef inIOHIDTransactionRef,  // reference to the HID transaction

        CFRunLoopRef        inRunLoop,              // Run loop to be scheduled with

        CFStringRef         inRunLoopMode);         // Run loop mode for scheduling

// Unschedule a HID transaction from a runloop

void IOHIDTransactionUnscheduleFromRunLoop(

        IOHIDTransactionRef inIOHIDTransactionRef,  // reference to the HID transaction

        CFRunLoopRef        inRunLoop,              // Run loop to be unscheduling from

        CFStringRef         inRunLoopMode);         // Run loop mode for unscheduling

IOHIDTransactionScheduleWithRunLoop(inIOHIDTransactionRef, CFRunLoopGetCurrent(), kCFRunLoopDefaultMode);

IOHIDValueRef IOHIDValueCreateWithIntegerValue(

            CFAllocatorRef  inCFAllocatorRef,   // Allocator to be used during creation

            IOHIDElementRef inIOHIDElementRef,  // the HID element to be associated with this value

            uint64_t        inTimeStamp,        // OS AbsoluteTime

            CFIndex         inValue);           // the integer (32-bit) value used to create this HID value

IOHIDValueRef IOHIDValueCreateWithBytes(

            CFAllocatorRef  inCFAllocatorRef,   // Allocator to be used during creation

            IOHIDElementRef inIOHIDElementRef,  // the HID element to be associated with this value

            uint64_t        inTimeStamp,        // OS AbsoluteTime

            const uint8_t * inBytes,            // a pointer to the data used to create this HID value

            CFIndex         inLength);          // the length of the data used to create this HID value

IOHIDValueRef IOHIDValueCreateWithBytesNoCopy(

            CFAllocatorRef  inCFAllocatorRef,   // Allocator to be used during creation

            IOHIDElementRef inIOHIDElementRef,  // the HID element to be associated with this value

            uint64_t        inTimeStamp,        // OS AbsoluteTime

            const uint8_t * inBytes,            // a pointer to the data used to create this HID value

            CFIndex         inLength);          // the length of the data used to create this HID value

    if (CFGetTypeID(tCFTypeRef) == IOHIDValueGetTypeID()) {

        // this is a valid HID value reference!

    }

// Returns the HID element value associated with this HID value reference.

IOHIDElementRef IOHIDValueGetElement(IOHIDValueRef inIOHIDValueRef);

// Returns the timestamp value associated with this HID value reference.

uint64_t IOHIDValueGetTimeStamp(IOHIDValueRef inIOHIDValueRef);

// Returns an integer representation for this HID value reference.

CFIndex IOHIDValueGetIntegerValue(IOHIDValueRef inIOHIDValueRef);

// Returns the size, in bytes, of the data associated with this HID value reference.

CFIndex IOHIDValueGetLength(IOHIDValueRef inIOHIDValueRef);

// Returns a byte pointer to the data associated with this HID value reference.

const uint8_t * IOHIDValueGetBytePtr(IOHIDValueRef inIOHIDValueRef)

// return the scaled value of a HID value reference

double_t IOHIDValueGetScaledValue(IOHIDValueRef inIOHIDValueRef, IOHIDValueScaleType inType);

static void IOHIDElement_SetDoubleProperty(

                                IOHIDElementRef inElementRef,   // the HID element

                                CFStringRef     inKey,          // the kIOHIDElement key (as a CFString)

                                double          inValue)        // the double value to be set

{

    CFNumberRef tCFNumberRef = CFNumberCreate(kCFAllocatorDefault, kCFNumberDoubleType, &inValue);

    if (tCFNumberRef) {

        IOHIDElementSetProperty(inElementRef, inKey, tCFNumberRef);

        CFRelease(tCFNumberRef);

    }

}

// These define the range of the returned scaled values

IOHIDElement_SetDoubleProperty(elementRef, CFSTR(kIOHIDElementCalibrationMinKey), -32.);

IOHIDElement_SetDoubleProperty(elementRef, CFSTR(kIOHIDElementCalibrationMaxKey), +32.);

// these define the range of values expected from the device (logical values)

IOHIDElement_SetDoubleProperty(elementRef, CFSTR(kIOHIDElementCalibrationSaturationMinKey), 5.);

IOHIDElement_SetDoubleProperty(elementRef, CFSTR(kIOHIDElementCalibrationSaturationMaxKey), 250.);

// these define the range of the dead zone (logical values)

IOHIDElement_SetDoubleProperty(elementRef, CFSTR(kIOHIDElementCalibrationDeadZoneMinKey), 124.);

IOHIDElement_SetDoubleProperty(elementRef, CFSTR(kIOHIDElementCalibrationDeadZoneMaxKey), 130.);

// this defines the granularity of the returned scaled values

IOHIDElement_SetDoubleProperty(elementRef, CFSTR(kIOHIDElementCalibrationGranularityKey), 0.1);

// first a convenience function to access HID element properties stored as doubles:

static Boolean IOHIDElement_GetDoubleProperty(

    IOHIDElementRef inElementRef,   // the HID element

    CFStringRef inKey,              // the kIOHIDElement key (as a CFString)

    double * outValue)              // address where to return the output value

{

    Boolean result = FALSE;

    CFTypeRef tCFTypeRef = IOHIDElementGetProperty(inElementRef, inKey);

    if (tCFTypeRef) {

        // if this is a number

        if (CFNumberGetTypeID() == CFGetTypeID(tCFTypeRef)) {

            // get its value

            result = CFNumberGetValue((CFNumberRef) tCFTypeRef, kCFNumberDoubleType, outValue);

        }

    }

    return result;

}

double_t IOHIDValueGetScaledValue(IOHIDValueRef inValue, IOHIDValueScaleType inType)

{

    IOHIDElementRef element = IOHIDValueGetElement(inValue);

    double_t logicalValue = IOHIDValueGetIntegerValue(inValue);

    double_t logicalMin = IOHIDElementGetLogicalMin(element);

    double_t logicalMax = IOHIDElementGetLogicalMax(element);

    double_t scaledMin = 0;

    double_t scaledMax = 0;

    double_t granularity = 0.;

    double_t returnValue = 0.;

    switch (inType) {

        case kIOHIDValueScaleTypeCalibrated: {

            double_t calibrateMin = 0.;

            (void) IOHIDElement_GetDoubleProperty(element,

                        CFSTR(kIOHIDElementCalibrationMinKey), &calibrateMin);

            double_t calibrateMax = 0.;

            (void) IOHIDElement_GetDoubleProperty(element,

                        CFSTR(kIOHIDElementCalibrationMaxKey), &calibrateMax);

            // if there are calibration min/max values...

            if (calibrateMin != calibrateMax) {

                // ...use them...

                scaledMin = calibrateMin;

                scaledMax = calibrateMax;

            } else {

                // ...otherwise use +/- 1.0

                scaledMin = -1.;

                scaledMax = +1.;

            }

            double_t saturationMin = 0.;

            (void) IOHIDElement_GetDoubleProperty(element,

                        CFSTR(kIOHIDElementCalibrationSaturationMinKey), &saturationMin);

            double_t saturationMax = 0.;

            (void) IOHIDElement_GetDoubleProperty(element,

                        CFSTR(kIOHIDElementCalibrationSaturationMaxKey), &saturationMax);

            // if there are saturation min/max values...

            if (saturationMin != saturationMax) {

                // .. and the logical value is less than the minimum saturated value...

                if (logicalValue <= saturationMin) {

                    // ...then return the minimum scaled value

                    return scaledMin;

                } else

                // otherwise if the logical value is greater than the maximum saturated value...

                if (logicalValue >= saturationMax) {

                    // ...return the maximum scaled value.

                    return scaledMax;

                } else

                // otherwise use the min/max saturated values for the logical min/max

                {

                    logicalMin = saturationMin;

                    logicalMax = saturationMax;

                }

            }

            double_t deadzoneMin = 0.;

            (void) IOHIDElement_GetDoubleProperty(element,

                        CFSTR(kIOHIDElementCalibrationDeadZoneMinKey), &deadzoneMin);

            double_t deadzoneMax = 0.;

            (void) IOHIDElement_GetDoubleProperty(element,

                        CFSTR(kIOHIDElementCalibrationDeadZoneMaxKey), &deadzoneMax);

            // if there are deadzone min/max values...

            if (deadzoneMin != deadzoneMax) {

                    double_t scaledMid = (scaledMin + scaledMax) / 2.;

                // if the logical value is less than the deadzone min...

                if (logicalValue < deadzoneMin) {

                    // ...then use the deadzone min as our logical max...

                    logicalMax = deadzoneMin;

                    // ...and the middle of our scaled range as our scaled max.

                    scaledMax = scaledMid;

                } // otherwise if the logical value is greater than the deadzone max...

                else if (logicalValue > deadzoneMax) {

                    // ...then use the deadzone max as our logical min...

                    logicalMin = deadzoneMax;

                    // ...and the middle of our scaled range as our scaled min.

                    scaledMin = scaledMid;

                } else {

                    // otherwise return the middle of our scaled range

                    return scaledMid;

                }

            }

            (void) IOHIDElement_GetDoubleProperty(element,

                        CFSTR(kIOHIDElementCalibrationGranularityKey), &granularity);

            break;

        }

        case kIOHIDValueScaleTypePhysical: {

            scaledMin = IOHIDElementGetPhysicalMin(element);

            scaledMax = IOHIDElementGetPhysicalMax(element);

            break;

        }

        default: {

            return returnValue; // should be 0.0

        }

    }

    double_t logicalRange = logicalMax - logicalMin;

    double_t scaledRange = scaledMax - scaledMin;

    returnValue = ((logicalValue - logicalMin) * scaledRange / logicalRange) + scaledMin;

    if (granularity) {

        returnValue = round(returnValue / granularity) * granularity;

    }

    return returnValue;

}