1/* 2 * 3 * @APPLE_LICENSE_HEADER_START@ 4 * 5 * Copyright (c) 1999-2003 Apple Computer, Inc. All Rights Reserved. 6 * 7 * This file contains Original Code and/or Modifications of Original Code 8 * as defined in and that are subject to the Apple Public Source License 9 * Version 2.0 (the 'License'). You may not use this file except in 10 * compliance with the License. Please obtain a copy of the License at 11 * http://www.opensource.apple.com/apsl/ and read it before using this 12 * file. 13 * 14 * The Original Code and all software distributed under the License are 15 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 16 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, 17 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 19 * Please see the License for the specific language governing rights and 20 * limitations under the License. 21 * 22 * @APPLE_LICENSE_HEADER_END@ 23 */ 24 25#ifndef _IOKIT_HID_IOHIDEVENTDATA_H 26#define _IOKIT_HID_IOHIDEVENTDATA_H 27 28#include <IOKit/IOTypes.h> 29#include <IOKit/hid/IOHIDEventTypes.h> 30 31#ifdef KERNEL 32 #include <IOKit/IOLib.h> 33 34 #define IOHIDEventRef IOHIDEvent * 35#else 36 #include <IOKit/hid/IOHIDEvent.h> 37 38 typedef struct IOHIDEventData IOHIDEventData; 39#endif 40 41//============================================================================== 42// IOHIDEventData Declarations 43//============================================================================== 44 45enum { 46 kIOHIDEventOptionIgnore = 0xf0000000, 47 kIOHIDEventOptionIsRepeat = 0x00010000 48}; 49 50#define IOHIDEVENT_BASE \ 51 uint32_t size; \ 52 IOHIDEventType type; \ 53 uint32_t options; \ 54 uint8_t depth; \ 55 uint8_t reserved[3];\ 56 57/*! 58 @typedef IOHIDEventData 59 @abstract 60 @discussion 61 @field size Size, in bytes, of the memory detailing this 62 particular event 63 @field type Type of this particular event 64 @field options Event specific options 65*/ 66 67struct IOHIDEventData{ 68 IOHIDEVENT_BASE; 69}; 70 71typedef struct __attribute__((packed)) _IOHIDVendorDefinedEventData { 72 IOHIDEVENT_BASE; 73 uint16_t usagePage; 74 uint16_t usage; 75 uint32_t version; 76 uint32_t length; 77 uint8_t data[0]; 78} IOHIDVendorDefinedEventData; 79 80enum { 81 kIOHIDKeyboardIsRepeat = kIOHIDEventOptionIsRepeat // DEPRECATED 82}; 83 84typedef struct _IOHIDKeyboardEventData { 85 IOHIDEVENT_BASE; // options = kHIDKeyboardRepeat 86 uint16_t usagePage; 87 uint16_t usage; 88 boolean_t down; 89} IOHIDKeyboardEventData; 90 91 92enum { 93 kIOHIDTransducerRange = 0x00010000, 94 kIOHIDTransducerTouch = 0x00020000, 95 kIOHIDTransducerInvert = 0x00040000, 96 kIOHIDTransducerDisplayIntegrated = 0x00080000 97}; 98 99enum { 100 kIOHIDDigitizerOrientationTypeTilt = 0, 101 kIOHIDDigitizerOrientationTypePolar, 102 kIOHIDDigitizerOrientationTypeQuality 103}; 104typedef uint8_t IOHIDDigitizerOrientationType; 105 106#define IOHIDAXISEVENT_BASE \ 107 struct { \ 108 IOFixed x; \ 109 IOFixed y; \ 110 IOFixed z; \ 111 } position; 112 113typedef struct _IOHIDAxisEventData { 114 IOHIDEVENT_BASE; // options = kHIDAxisRelative 115 IOHIDAXISEVENT_BASE; 116} IOHIDAxisEventData, IOHIDTranslationData, IOHIDRotationEventData, IOHIDScrollEventData, IOHIDScaleEventData, IOHIDVelocityData, IOHIDOrientationEventData; 117 118typedef struct _IOHIDMotionEventData { 119 IOHIDEVENT_BASE; // options = kHIDAxisRelative 120 IOHIDAXISEVENT_BASE; 121 uint32_t motionType; 122 uint32_t motionSubType; 123 uint32_t motionSequence; 124} IOHIDMotionEventData, IOHIDAccelerometerEventData, IOHIDGyroEventData, IOHIDCompassEventData; 125 126typedef struct _IOHIDAmbientLightSensorEventData { 127 IOHIDEVENT_BASE; // options = kHIDAxisRelative 128 uint32_t level; 129 uint32_t ch0; 130 uint32_t ch1; 131 uint32_t ch2; 132 uint32_t ch3; 133 Boolean brightnessChanged; 134} IOHIDAmbientLightSensorEventData; 135 136typedef struct _IOHIDTemperatureEventData { 137 IOHIDEVENT_BASE; 138 IOFixed level; 139} IOHIDTemperatureEventData; 140 141typedef struct _IOHIDProximityEventData { 142 IOHIDEVENT_BASE; 143 uint32_t detectionMask; 144 uint32_t level; 145} IOHIDProximityEventData; 146 147typedef struct _IOHIDProgressEventData { 148 IOHIDEVENT_BASE; 149 uint32_t eventType; 150 IOFixed level; 151} IOHIDProgressEventData, IOHIDBiometricEventData; 152 153typedef struct _IOHIDZoomToggleEventData { 154 IOHIDEVENT_BASE; 155} IOHIDZoomToggleEventData; 156 157#define IOHIDBUTTONEVENT_BASE \ 158 struct { \ 159 uint32_t buttonMask; \ 160 IOFixed pressure; \ 161 uint8_t buttonNumber; \ 162 uint8_t clickState; \ 163 } button; 164 165typedef struct _IOHIDButtonEventData { 166 IOHIDEVENT_BASE; 167 IOHIDBUTTONEVENT_BASE; 168} IOHIDButtonEventData; 169 170typedef struct _IOHIDPointerEventData { 171 IOHIDEVENT_BASE; 172 IOHIDAXISEVENT_BASE; 173 IOHIDBUTTONEVENT_BASE; 174} IOHIDPointerEventData, IOHIDMouseEventData; 175 176typedef struct _IOHIDMultiAxisPointerEventData { 177 IOHIDEVENT_BASE; 178 IOHIDAXISEVENT_BASE; 179 IOHIDBUTTONEVENT_BASE; 180 struct { 181 IOFixed x; 182 IOFixed y; 183 IOFixed z; 184 } rotation; 185 186} IOHIDMultiAxisPointerEventData; 187 188 189typedef struct _IOHIDDigitizerEventData { 190 IOHIDEVENT_BASE; // options = kIOHIDTransducerRange, kHIDTransducerTouch, kHIDTransducerInvert 191 IOHIDAXISEVENT_BASE; 192 193 uint32_t transducerIndex; 194 uint32_t transducerType; // could overload this to include that both the hand and finger id. 195 uint32_t identity; // Specifies a unique ID of the current transducer action. 196 uint32_t eventMask; // the type of event that has occurred: range, touch, position 197 uint32_t childEventMask; // CHILD: the type of event that has occurred: range, touch, position 198 199 uint32_t buttonMask; // Bit field representing the current button state 200 // Pressure field are assumed to be scaled from 0.0 to 1.0 201 IOFixed pressure; // Force exerted against the digitizer surface by the transducer. 202 IOFixed auxPressure; // Force exerted directly by the user on a transducer sensor. 203 204 IOFixed twist; // Specifies the clockwise rotation of the cursor around its own major axis. Unsure it the device should declare units via properties or event. My first inclination is force degrees as the is the unit already expected by AppKit, Carbon and OpenGL. 205 uint32_t orientationType; // Specifies the orientation type used by the transducer. 206 union { 207 struct { // X Tilt and Y Tilt are used together to specify the tilt away from normal of a digitizer transducer. In its normal position, the values of X Tilt and Y Tilt for a transducer are both zero. 208 IOFixed x; // This quantity is used in conjunction with Y Tilt to represent the tilt away from normal of a transducer, such as a stylus. The X Tilt value represents the plane angle between the Y-Z plane and the plane containing the transducer axis and the Y axis. A positive X Tilt is to the right. 209 IOFixed y; // This value represents the angle between the X-Z and transducer-X planes. A positive Y Tilt is toward the user. 210 } tilt; 211 struct { // X Tilt and Y Tilt are used together to specify the tilt away from normal of a digitizer transducer. In its normal position, the values of X Tilt and Y Tilt for a transducer are both zero. 212 IOFixed altitude; //The angle with the X-Y plane though a signed, semicicular range. Positive values specify an angle downward and toward the positive Z axis. 213 IOFixed azimuth; // Specifies the counter clockwise rotation of the cursor around the Z axis though a full circular range. 214 } polar; 215 struct { 216 IOFixed quality; // If set, indicates that the transducer is sensed to be in a relatively noise-free region of digitizing. 217 IOFixed density; 218 IOFixed irregularity; 219 IOFixed majorRadius; // units in mm 220 IOFixed minorRadius; // units in mm 221 } quality; 222 }orientation; 223} IOHIDDigitizerEventData; 224 225typedef struct _IOHIDSwipeEventData { 226 IOHIDEVENT_BASE; 227 IOHIDAXISEVENT_BASE; 228 IOHIDSwipeMask swipeMask; // legacy 229 IOHIDGestureMotion gestureMotion; // horizontal, vertical, scale, rotate, tap, etc 230 IOHIDGestureFlavor flavor; // event flavor for routing purposes 231 IOFixed progress; // progress of gesture, as a fraction (1.0 = 100%) 232} IOHIDSwipeEventData, 233 IOHIDNavagationSwipeEventData, 234 IOHIDDockSwipeEventData, 235 IOHIDFluidTouchGestureData, 236 IOHIDBoundaryScrollData; 237 238typedef struct _IOHIDSymbolicHotKeyEventData { 239 IOHIDEVENT_BASE; 240 uint32_t hotKey; 241} IOHIDSymbolicHotKeyEventData; 242 243enum { 244 kIOHIDSymbolicHotKeyOptionIsCGSHotKey = 0x00010000, 245}; 246 247typedef struct _IOHIDPowerEventData { 248 IOHIDEVENT_BASE; 249 int64_t measurement; // 48.16 signed fixed point 250 uint32_t powerType; 251 uint32_t powerSubType; 252} IOHIDPowerEventData; 253 254/*! 255 @typedef IOHIDSystemQueueElement 256 @abstract Memory structure defining the layout of each event queue element 257 @discussion The IOHIDEventQueueElement represents a portion of mememory in the 258 new IOHIDEventQueue. It is possible that a event queue element 259 can contain multiple interpretations of a given event. The first 260 event is always considered the primary event. 261 @field timeStamp Time at which event was dispatched 262 @field senderID RegistryID of sending service 263 @field options Options for further developement 264 @field eventCount The number of events contained in this transaction 265 @field payload Begining offset of contiguous mememory that contains the 266 pertinent attribute and event data 267*/ 268typedef struct __attribute__((packed)) _IOHIDSystemQueueElement { 269 uint64_t timeStamp; 270 uint64_t creationTimeStamp; 271 uint64_t senderID; 272 uint32_t options; 273 uint32_t attributeLength; 274 uint32_t eventCount; 275 uint8_t payload[0]; 276} IOHIDSystemQueueElement; 277 278//****************************************************************************** 279// MACROS 280//****************************************************************************** 281 282#define IOHIDEventFieldEventType(field) ((field >> 16) & 0xffff) 283#define IOHIDEventFieldOffset(field) (field & 0xffff) 284#define IOHIDEventGetSize(type,size) \ 285{ \ 286 switch ( type ) { \ 287 case kIOHIDEventTypeNULL: \ 288 case kIOHIDEventTypeVendorDefined:\ 289 size = sizeof(IOHIDVendorDefinedEventData);\ 290 break; \ 291 case kIOHIDEventTypeKeyboard: \ 292 size = sizeof(IOHIDKeyboardEventData);\ 293 break; \ 294 case kIOHIDEventTypeTranslation:\ 295 case kIOHIDEventTypeRotation: \ 296 case kIOHIDEventTypeScroll: \ 297 case kIOHIDEventTypeScale: \ 298 case kIOHIDEventTypeVelocity: \ 299 case kIOHIDEventTypeOrientation:\ 300 size = sizeof(IOHIDAxisEventData);\ 301 break; \ 302 case kIOHIDEventTypeAccelerometer:\ 303 case kIOHIDEventTypeGyro:\ 304 case kIOHIDEventTypeCompass:\ 305 size = sizeof(IOHIDMotionEventData);\ 306 break;\ 307 case kIOHIDEventTypeAmbientLightSensor:\ 308 size = sizeof(IOHIDAmbientLightSensorEventData);\ 309 break; \ 310 case kIOHIDEventTypeProximity: \ 311 size = sizeof(IOHIDProximityEventData);\ 312 break; \ 313 case kIOHIDEventTypeButton: \ 314 size = sizeof(IOHIDButtonEventData);\ 315 break; \ 316 case kIOHIDEventTypeDigitizer: \ 317 size = sizeof(IOHIDDigitizerEventData);\ 318 break; \ 319 case kIOHIDEventTypeTemperature:\ 320 size = sizeof(IOHIDTemperatureEventData);\ 321 break; \ 322 case kIOHIDEventTypeNavigationSwipe:\ 323 case kIOHIDEventTypeDockSwipe:\ 324 case kIOHIDEventTypeFluidTouchGesture:\ 325 case kIOHIDEventTypeBoundaryScroll:\ 326 size = sizeof(IOHIDSwipeEventData);\ 327 break; \ 328 case kIOHIDEventTypeMultiAxisPointer:\ 329 size = sizeof(IOHIDMultiAxisPointerEventData);\ 330 break;\ 331 case kIOHIDEventTypePointer:\ 332 size = sizeof(IOHIDPointerEventData);\ 333 break; \ 334 case kIOHIDEventTypeBiometric:\ 335 case kIOHIDEventTypeProgress:\ 336 size = sizeof(IOHIDProgressEventData);\ 337 break; \ 338 case kIOHIDEventTypeZoomToggle:\ 339 size = sizeof(IOHIDZoomToggleEventData);\ 340 break; \ 341 case kIOHIDEventTypeSymbolicHotKey:\ 342 size = sizeof(IOHIDSymbolicHotKeyEventData);\ 343 break; \ 344 case kIOHIDEventTypePower:\ 345 size = sizeof(IOHIDPowerEventData);\ 346 break; \ 347 default: \ 348 size = 0; \ 349 break; \ 350 } \ 351} 352#define IOHIDEventGetQueueElementSize(type,size)\ 353{ \ 354 IOHIDEventGetSize(type,size); \ 355 size += sizeof(IOHIDSystemQueueElement); \ 356} 357 358#ifdef KERNEL 359 #define IOHIDEventValueFloat(value, isFixed) (isFixed ? value : value>>16) 360 #define IOHIDEventValueFixed(value, isFixed) (isFixed ? value : value<<16) 361 #define IOHIDEventGetEventWithOptions(event, type, options) event->getEvent(type, options) 362 #define GET_EVENTDATA(event) event->_data 363#else 364 #define IOHIDEventValueFloat(value, isFixed) (isFixed ? value : value / 65536.0) 365 #define IOHIDEventValueFixed(value, isFixed) (isFixed ? value : value * 65536) 366 #define GET_EVENTDATA(event) event->eventData 367#endif 368 369//============================================================================== 370// IOHIDEventGetValue MACRO 371//============================================================================== 372#define GET_EVENTDATA_VALUE(eventData, fieldEvType, fieldOffset, value, isFixed)\ 373{ \ 374 switch ( fieldEvType ) { \ 375 case kIOHIDEventTypeNULL: \ 376 switch ( fieldOffset ) { \ 377 case IOHIDEventFieldOffset(kIOHIDEventFieldIsRelative): \ 378 value = (eventData->options & kIOHIDEventOptionIsAbsolute) == 0; \ 379 break; \ 380 case IOHIDEventFieldOffset(kIOHIDEventFieldIsCollection): \ 381 value = (eventData->options & kIOHIDEventOptionIsCollection) != 0; \ 382 break; \ 383 case IOHIDEventFieldOffset(kIOHIDEventFieldIsPixelUnits): \ 384 value = (eventData->options & kIOHIDEventOptionIsPixelUnits) != 0; \ 385 break; \ 386 case IOHIDEventFieldOffset(kIOHIDEventFieldIsCenterOrigin): \ 387 value = (eventData->options & kIOHIDEventOptionIsCenterOrigin) != 0; \ 388 break; \ 389 case IOHIDEventFieldOffset(kIOHIDEventFieldIsBuiltIn): \ 390 value = (eventData->options & kIOHIDEventOptionIsBuiltIn) != 0; \ 391 break; \ 392 }; break; \ 393 case kIOHIDEventTypeVendorDefined: \ 394 { \ 395 IOHIDVendorDefinedEventData * sysDef = (IOHIDVendorDefinedEventData*)eventData; \ 396 switch ( fieldOffset ) { \ 397 case IOHIDEventFieldOffset(kIOHIDEventFieldVendorDefinedUsagePage): \ 398 value = sysDef->usagePage; \ 399 break; \ 400 case IOHIDEventFieldOffset(kIOHIDEventFieldVendorDefinedUsage): \ 401 value = sysDef->usage; \ 402 break; \ 403 case IOHIDEventFieldOffset(kIOHIDEventFieldVendorDefinedVersion): \ 404 value = sysDef->version; \ 405 break; \ 406 case IOHIDEventFieldOffset(kIOHIDEventFieldVendorDefinedDataLength): \ 407 value = sysDef->length; \ 408 break; \ 409 case IOHIDEventFieldOffset(kIOHIDEventFieldVendorDefinedData): \ 410 if (sysDef->data) \ 411 value = *((typeof(value)*) sysDef->data); \ 412 break; \ 413 }; \ 414 } \ 415 break; \ 416 case kIOHIDEventTypeBiometric: \ 417 case kIOHIDEventTypeProgress: \ 418 { \ 419 IOHIDProgressEventData * progress = (IOHIDProgressEventData*)eventData; \ 420 switch ( fieldOffset ) { \ 421 /* case IOHIDEventFieldOffset(kIOHIDEventFieldBiometricEventType): */\ 422 case IOHIDEventFieldOffset(kIOHIDEventFieldProgressEventType): \ 423 value = progress->eventType; \ 424 break; \ 425 /* case IOHIDEventFieldOffset(kIOHIDEventFieldBiometricLevel): */\ 426 case IOHIDEventFieldOffset(kIOHIDEventFieldProgressLevel): \ 427 value = IOHIDEventValueFloat(progress->level, isFixed); \ 428 break; \ 429 }; \ 430 } \ 431 break; \ 432 case kIOHIDEventTypeButton: \ 433 { \ 434 IOHIDButtonEventData * button = (IOHIDButtonEventData*)eventData; \ 435 switch ( fieldOffset ) { \ 436 case IOHIDEventFieldOffset(kIOHIDEventFieldButtonMask): \ 437 value = button->button.buttonMask; \ 438 break; \ 439 case IOHIDEventFieldOffset(kIOHIDEventFieldButtonNumber): \ 440 value = button->button.buttonNumber; \ 441 break; \ 442 case IOHIDEventFieldOffset(kIOHIDEventFieldButtonClickCount): \ 443 value = button->button.clickState; \ 444 break; \ 445 case IOHIDEventFieldOffset(kIOHIDEventFieldButtonPressure): \ 446 value = IOHIDEventValueFloat(button->button.pressure, isFixed); \ 447 break; \ 448 }; \ 449 } \ 450 break; \ 451 case kIOHIDEventTypeCompass: \ 452 case kIOHIDEventTypeGyro: \ 453 case kIOHIDEventTypeAccelerometer: \ 454 { \ 455 IOHIDMotionEventData * motion = (IOHIDMotionEventData*)eventData; \ 456 switch ( fieldOffset ) { \ 457 /*case IOHIDEventFieldOffset(kIOHIDEventFieldCompassX): */\ 458 /*case IOHIDEventFieldOffset(kIOHIDEventFieldGyroX): */\ 459 case IOHIDEventFieldOffset(kIOHIDEventFieldAccelerometerX): \ 460 value = IOHIDEventValueFloat(motion->position.x, isFixed); \ 461 break; \ 462 /*case IOHIDEventFieldOffset(kIOHIDEventFieldCompassY): */\ 463 /*case IOHIDEventFieldOffset(kIOHIDEventFieldGyroY): */\ 464 case IOHIDEventFieldOffset(kIOHIDEventFieldAccelerometerY): \ 465 value = IOHIDEventValueFloat(motion->position.y, isFixed); \ 466 break; \ 467 /*case IOHIDEventFieldOffset(kIOHIDEventFieldCompassZ): */\ 468 /*case IOHIDEventFieldOffset(kIOHIDEventFieldGyroZ): */\ 469 case IOHIDEventFieldOffset(kIOHIDEventFieldAccelerometerZ): \ 470 value = IOHIDEventValueFloat(motion->position.z, isFixed); \ 471 break; \ 472 /*case IOHIDEventFieldOffset(kIOHIDEventFieldCompassType): */\ 473 /*case IOHIDEventFieldOffset(kIOHIDEventFieldGyroType): */\ 474 case IOHIDEventFieldOffset(kIOHIDEventFieldAccelerometerType): \ 475 value = motion->motionType; \ 476 break; \ 477 /*case IOHIDEventFieldOffset(kIOHIDEventFieldCompassSubType): */\ 478 /*case IOHIDEventFieldOffset(kIOHIDEventFieldGyroSubType): */\ 479 case IOHIDEventFieldOffset(kIOHIDEventFieldAccelerometerSubType): \ 480 value = motion->motionSubType; \ 481 break; \ 482 /*case IOHIDEventFieldOffset(kIOHIDEventFieldCompassSequence): */\ 483 /*case IOHIDEventFieldOffset(kIOHIDEventFieldGyroSequence): */\ 484 case IOHIDEventFieldOffset(kIOHIDEventFieldAccelerometerSequence): \ 485 value = motion->motionSequence; \ 486 break; \ 487 }; \ 488 } \ 489 break; \ 490 case kIOHIDEventTypePointer: \ 491 { \ 492 IOHIDPointerEventData * pointer = (IOHIDPointerEventData*)eventData; \ 493 switch ( fieldOffset ) { \ 494 case IOHIDEventFieldOffset(kIOHIDEventFieldPointerX): \ 495 value = IOHIDEventValueFloat(pointer->position.x, isFixed); \ 496 break; \ 497 case IOHIDEventFieldOffset(kIOHIDEventFieldPointerY): \ 498 value = IOHIDEventValueFloat(pointer->position.y, isFixed); \ 499 break; \ 500 case IOHIDEventFieldOffset(kIOHIDEventFieldPointerZ): \ 501 value = IOHIDEventValueFloat(pointer->position.z, isFixed); \ 502 break; \ 503 case IOHIDEventFieldOffset(kIOHIDEventFieldPointerButtonMask): \ 504 value = pointer->button.buttonMask; \ 505 break; \ 506 case IOHIDEventFieldOffset(kIOHIDEventFieldPointerNumber): \ 507 value = pointer->button.buttonNumber; \ 508 break; \ 509 case IOHIDEventFieldOffset(kIOHIDEventFieldPointerClickCount): \ 510 value = pointer->button.clickState; \ 511 break; \ 512 case IOHIDEventFieldOffset(kIOHIDEventFieldPointerPressure): \ 513 value = IOHIDEventValueFloat(pointer->button.pressure, isFixed); \ 514 break; \ 515 }; \ 516 } \ 517 break; \ 518 case kIOHIDEventTypeMultiAxisPointer: \ 519 { \ 520 IOHIDMultiAxisPointerEventData * pointer = (IOHIDMultiAxisPointerEventData*)eventData; \ 521 switch ( fieldOffset ) { \ 522 case IOHIDEventFieldOffset(kIOHIDEventFieldMultiAxisPointerX): \ 523 value = IOHIDEventValueFloat(pointer->position.x, isFixed); \ 524 break; \ 525 case IOHIDEventFieldOffset(kIOHIDEventFieldMultiAxisPointerY): \ 526 value = IOHIDEventValueFloat(pointer->position.y, isFixed); \ 527 break; \ 528 case IOHIDEventFieldOffset(kIOHIDEventFieldMultiAxisPointerZ): \ 529 value = IOHIDEventValueFloat(pointer->position.z, isFixed); \ 530 break; \ 531 case IOHIDEventFieldOffset(kIOHIDEventFieldMultiAxisPointerButtonMask): \ 532 value = pointer->button.buttonMask; \ 533 break; \ 534 case IOHIDEventFieldOffset(kIOHIDEventFieldMultiAxisPointerNumber): \ 535 value = pointer->button.buttonNumber; \ 536 break; \ 537 case IOHIDEventFieldOffset(kIOHIDEventFieldMultiAxisPointerClickCount): \ 538 value = pointer->button.clickState; \ 539 break; \ 540 case IOHIDEventFieldOffset(kIOHIDEventFieldMultiAxisPointerPressure): \ 541 value = IOHIDEventValueFloat(pointer->button.pressure, isFixed); \ 542 break; \ 543 case IOHIDEventFieldOffset(kIOHIDEventFieldMultiAxisPointerRx): \ 544 value = IOHIDEventValueFloat(pointer->rotation.x, isFixed); \ 545 break; \ 546 case IOHIDEventFieldOffset(kIOHIDEventFieldMultiAxisPointerRy): \ 547 value = IOHIDEventValueFloat(pointer->rotation.y, isFixed); \ 548 break; \ 549 case IOHIDEventFieldOffset(kIOHIDEventFieldMultiAxisPointerRz): \ 550 value = IOHIDEventValueFloat(pointer->rotation.z, isFixed); \ 551 break; \ 552 }; \ 553 } \ 554 break; \ 555 case kIOHIDEventTypeNavigationSwipe: \ 556 case kIOHIDEventTypeDockSwipe: \ 557 case kIOHIDEventTypeFluidTouchGesture: \ 558 case kIOHIDEventTypeBoundaryScroll: \ 559 { \ 560 IOHIDSwipeEventData * swipe = (IOHIDSwipeEventData *)eventData; \ 561 switch ( fieldOffset ) { \ 562 case IOHIDEventFieldOffset(kIOHIDEventFieldSwipeMask): \ 563 /* 564 case IOHIDEventFieldOffset(kIOHIDEventFieldNavigationSwipeMask): \ 565 case IOHIDEventFieldOffset(kIOHIDEventFieldDockSwipeMask): \ 566 case IOHIDEventFieldOffset(kIOHIDEventFieldFluidTouchGestureMask): \ 567 case IOHIDEventFieldOffset(kIOHIDEventFieldBoundaryScrollMask): \ 568 */ \ 569 value = swipe->swipeMask; \ 570 break; \ 571 case IOHIDEventFieldOffset(kIOHIDEventFieldSwipeMotion): \ 572 /* 573 case IOHIDEventFieldOffset(kIOHIDEventFieldNavigationSwipeMotion): \ 574 case IOHIDEventFieldOffset(kIOHIDEventFieldDockSwipeMotion): \ 575 case IOHIDEventFieldOffset(kIOHIDEventFieldFluidTouchGestureMotion): \ 576 case IOHIDEventFieldOffset(kIOHIDEventFieldBoundaryScrollMotion): \ 577 */ \ 578 value = swipe->gestureMotion; \ 579 break; \ 580 case IOHIDEventFieldOffset(kIOHIDEventFieldSwipeProgress): \ 581 /* 582 case IOHIDEventFieldOffset(kIOHIDEventFieldNavigationSwipeProgress): \ 583 case IOHIDEventFieldOffset(kIOHIDEventFieldDockSwipeProgress): \ 584 case IOHIDEventFieldOffset(kIOHIDEventFieldFluidTouchGestureProgress): \ 585 case IOHIDEventFieldOffset(kIOHIDEventFieldBoundaryScrollProgress): \ 586 */ \ 587 value = IOHIDEventValueFloat(swipe->progress, isFixed); \ 588 break; \ 589 case IOHIDEventFieldOffset(kIOHIDEventFieldSwipePositionX): \ 590 /* 591 case IOHIDEventFieldOffset(kIOHIDEventFieldNavigationSwipePositionX): \ 592 case IOHIDEventFieldOffset(kIOHIDEventFieldDockSwipePositionX): \ 593 case IOHIDEventFieldOffset(kIOHIDEventFieldFluidTouchGesturePositionX): \ 594 case IOHIDEventFieldOffset(kIOHIDEventFieldBoundaryScrollPositionX): \ 595 */ \ 596 value = IOHIDEventValueFloat(swipe->position.x, isFixed); \ 597 break; \ 598 case IOHIDEventFieldOffset(kIOHIDEventFieldSwipePositionY): \ 599 /* 600 case IOHIDEventFieldOffset(kIOHIDEventFieldNavigationSwipePositionY): \ 601 case IOHIDEventFieldOffset(kIOHIDEventFieldDockSwipePositionY): \ 602 case IOHIDEventFieldOffset(kIOHIDEventFieldFluidTouchGesturePositionY): \ 603 case IOHIDEventFieldOffset(kIOHIDEventFieldBoundaryScrollPositionY): \ 604 */ \ 605 value = IOHIDEventValueFloat(swipe->position.y, isFixed); \ 606 break; \ 607 case IOHIDEventFieldOffset(kIOHIDEventFieldSwipeFlavor): \ 608 /* 609 case IOHIDEventFieldOffset(kIOHIDEventFieldNavigationSwipeFlavor): \ 610 case IOHIDEventFieldOffset(kIOHIDEventFieldDockSwipeFlavor): \ 611 case IOHIDEventFieldOffset(kIOHIDEventFieldFluidTouchGestureFlavor): \ 612 case IOHIDEventFieldOffset(kIOHIDEventFieldBoundaryScrollFlavor): \ 613 */ \ 614 value = swipe->flavor; \ 615 break; \ 616 }; \ 617 } \ 618 break; \ 619 case kIOHIDEventTypeTemperature: \ 620 { \ 621 IOHIDTemperatureEventData * temp = (IOHIDTemperatureEventData *)eventData; \ 622 switch ( fieldOffset ) { \ 623 case IOHIDEventFieldOffset(kIOHIDEventFieldTemperatureLevel): \ 624 value = IOHIDEventValueFloat(temp->level, isFixed);\ 625 break; \ 626 }; \ 627 } \ 628 break; \ 629 case kIOHIDEventTypeTranslation: \ 630 case kIOHIDEventTypeRotation: \ 631 case kIOHIDEventTypeScroll: \ 632 case kIOHIDEventTypeScale: \ 633 case kIOHIDEventTypeVelocity: \ 634 case kIOHIDEventTypeOrientation: \ 635 { \ 636 IOHIDAxisEventData * axis = (IOHIDAxisEventData *)eventData; \ 637 switch ( fieldOffset ) { \ 638 case IOHIDEventFieldOffset(kIOHIDEventFieldTranslationX): \ 639 /* \ 640 case IOHIDEventFieldOffset(kIOHIDEventFieldRotationX): \ 641 case IOHIDEventFieldOffset(kIOHIDEventFieldScrollX): \ 642 case IOHIDEventFieldOffset(kIOHIDEventFieldScaleX): \ 643 case IOHIDEventFieldOffset(kIOHIDEventFieldVelocityX): \ 644 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerX); \ 645 case IOHIDEventFieldOffset(kIOHIDEventFieldOrientationRadius): \ 646 */ \ 647 value = IOHIDEventValueFloat(axis->position.x, isFixed); \ 648 break; \ 649 case IOHIDEventFieldOffset(kIOHIDEventFieldTranslationY): \ 650 /* \ 651 case IOHIDEventFieldOffset(kIOHIDEventFieldRotationY): \ 652 case IOHIDEventFieldOffset(kIOHIDEventFieldScrollY): \ 653 case IOHIDEventFieldOffset(kIOHIDEventFieldScaleY): \ 654 case IOHIDEventFieldOffset(kIOHIDEventFieldVelocityY): \ 655 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerY); \ 656 case IOHIDEventFieldOffset(kIOHIDEventFieldOrientationAzimuth): \ 657 */ \ 658 value = IOHIDEventValueFloat(axis->position.y, isFixed); \ 659 break; \ 660 case IOHIDEventFieldOffset(kIOHIDEventFieldTranslationZ): \ 661 /* \ 662 case IOHIDEventFieldOffset(kIOHIDEventFieldRotationZ): \ 663 case IOHIDEventFieldOffset(kIOHIDEventFieldScrollZ): \ 664 case IOHIDEventFieldOffset(kIOHIDEventFieldScaleZ): \ 665 case IOHIDEventFieldOffset(kIOHIDEventFieldVelocityZ): \ 666 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerZ); \ 667 case IOHIDEventFieldOffset(kIOHIDEventFieldOrientationAltitude):\ 668 */ \ 669 value = IOHIDEventValueFloat(axis->position.z, isFixed); \ 670 break; \ 671 case IOHIDEventFieldOffset(kIOHIDEventFieldScrollIsPixels): \ 672 value = ((axis->options & kIOHIDEventOptionPixelUnits) != 0);\ 673 break; \ 674 }; \ 675 } \ 676 break; \ 677 case kIOHIDEventTypeAmbientLightSensor: \ 678 { \ 679 IOHIDAmbientLightSensorEventData * alsEvent = (IOHIDAmbientLightSensorEventData *)eventData;\ 680 switch ( fieldOffset ) { \ 681 case IOHIDEventFieldOffset(kIOHIDEventFieldAmbientLightSensorLevel): \ 682 value = alsEvent->level; \ 683 break; \ 684 case IOHIDEventFieldOffset(kIOHIDEventFieldAmbientLightSensorRawChannel0): \ 685 value = alsEvent->ch0; \ 686 break; \ 687 case IOHIDEventFieldOffset(kIOHIDEventFieldAmbientLightSensorRawChannel1): \ 688 value = alsEvent->ch1; \ 689 break; \ 690 case IOHIDEventFieldOffset(kIOHIDEventFieldAmbientLightSensorRawChannel2): \ 691 value = alsEvent->ch2; \ 692 break; \ 693 case IOHIDEventFieldOffset(kIOHIDEventFieldAmbientLightSensorRawChannel3): \ 694 value = alsEvent->ch3; \ 695 break; \ 696 case IOHIDEventFieldOffset(kIOHIDEventFieldAmbientLightDisplayBrightnessChanged): \ 697 value = alsEvent->brightnessChanged; \ 698 break; \ 699 }; \ 700 } \ 701 break; \ 702 case kIOHIDEventTypeProximity: \ 703 { \ 704 IOHIDProximityEventData * proxEvent = (IOHIDProximityEventData *)eventData;\ 705 switch ( fieldOffset ) { \ 706 case IOHIDEventFieldOffset(kIOHIDEventFieldProximityDetectionMask): \ 707 value = proxEvent->detectionMask; \ 708 break; \ 709 case IOHIDEventFieldOffset(kIOHIDEventFieldProximityLevel): \ 710 value = proxEvent->level; \ 711 break; \ 712 }; \ 713 } \ 714 break; \ 715 case kIOHIDEventTypeKeyboard: \ 716 { \ 717 IOHIDKeyboardEventData * keyEvent = (IOHIDKeyboardEventData *)eventData;\ 718 switch ( fieldOffset ) { \ 719 case IOHIDEventFieldOffset(kIOHIDEventFieldKeyboardUsagePage): \ 720 value = keyEvent->usagePage; \ 721 break; \ 722 case IOHIDEventFieldOffset(kIOHIDEventFieldKeyboardUsage): \ 723 value = keyEvent->usage; \ 724 break; \ 725 case IOHIDEventFieldOffset(kIOHIDEventFieldKeyboardDown): \ 726 value = keyEvent->down; \ 727 break; \ 728 case IOHIDEventFieldOffset(kIOHIDEventFieldKeyboardRepeat): \ 729 value = (keyEvent->options & kIOHIDEventOptionIsRepeat);\ 730 break; \ 731 }; \ 732 } \ 733 break; \ 734 case kIOHIDEventTypeDigitizer: \ 735 { \ 736 IOHIDDigitizerEventData * digEvent = (IOHIDDigitizerEventData *)eventData; \ 737 switch ( fieldOffset ) { \ 738 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerX): \ 739 value = IOHIDEventValueFloat(digEvent->position.x, isFixed); \ 740 break; \ 741 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerY): \ 742 value = IOHIDEventValueFloat(digEvent->position.y, isFixed); \ 743 break; \ 744 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerZ): \ 745 value = IOHIDEventValueFloat(digEvent->position.z, isFixed); \ 746 break; \ 747 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerButtonMask): \ 748 value = digEvent->buttonMask; \ 749 break; \ 750 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerType): \ 751 value = digEvent->transducerType; \ 752 break; \ 753 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerIndex): \ 754 value = digEvent->transducerIndex; \ 755 break; \ 756 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerIdentity): \ 757 value = digEvent->identity; \ 758 break; \ 759 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerEventMask): \ 760 value = digEvent->eventMask; \ 761 break; \ 762 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerChildEventMask): \ 763 value = digEvent->childEventMask; \ 764 break; \ 765 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerRange): \ 766 value = (digEvent->options & kIOHIDTransducerRange) != 0;\ 767 break; \ 768 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerIsDisplayIntegrated): \ 769 value = (digEvent->options & kIOHIDTransducerDisplayIntegrated) != 0; \ 770 break; \ 771 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerTouch): \ 772 value = (digEvent->options & kIOHIDTransducerTouch) != 0;\ 773 break; \ 774 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerCollection): \ 775 value = (digEvent->options & kIOHIDEventOptionIsCollection) != 0;\ 776 break; \ 777 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerPressure): \ 778 value = IOHIDEventValueFloat(digEvent->pressure, isFixed); \ 779 break; \ 780 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerAuxiliaryPressure): \ 781 value = IOHIDEventValueFloat(digEvent->auxPressure, isFixed); \ 782 break; \ 783 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerTwist): \ 784 value = IOHIDEventValueFloat(digEvent->twist, isFixed); \ 785 break; \ 786 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerTiltX): \ 787 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerTiltY): \ 788 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerAltitude): \ 789 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerAzimuth): \ 790 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerQuality): \ 791 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerDensity): \ 792 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerIrregularity): \ 793 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerMajorRadius): \ 794 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerMinorRadius): \ 795 switch ( digEvent->orientationType ) {\ 796 case kIOHIDDigitizerOrientationTypeTilt:\ 797 switch ( fieldOffset ) {\ 798 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerTiltX): \ 799 value = IOHIDEventValueFloat(digEvent->orientation.tilt.x, isFixed); \ 800 break; \ 801 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerTiltY): \ 802 value = IOHIDEventValueFloat(digEvent->orientation.tilt.y, isFixed); \ 803 break; \ 804 }; \ 805 break; \ 806 case kIOHIDDigitizerOrientationTypePolar:\ 807 switch ( fieldOffset ) {\ 808 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerAltitude): \ 809 value = IOHIDEventValueFloat(digEvent->orientation.polar.altitude, isFixed); \ 810 break; \ 811 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerAzimuth): \ 812 value = IOHIDEventValueFloat(digEvent->orientation.polar.azimuth, isFixed); \ 813 break; \ 814 }; \ 815 break; \ 816 case kIOHIDDigitizerOrientationTypeQuality:\ 817 switch ( fieldOffset ) {\ 818 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerQuality): \ 819 value = IOHIDEventValueFloat(digEvent->orientation.quality.quality, isFixed); \ 820 break; \ 821 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerDensity): \ 822 value = IOHIDEventValueFloat(digEvent->orientation.quality.density, isFixed); \ 823 break; \ 824 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerIrregularity): \ 825 value = IOHIDEventValueFloat(digEvent->orientation.quality.irregularity, isFixed); \ 826 break; \ 827 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerMajorRadius): \ 828 value = IOHIDEventValueFloat(digEvent->orientation.quality.majorRadius, isFixed); \ 829 break; \ 830 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerMinorRadius): \ 831 value = IOHIDEventValueFloat(digEvent->orientation.quality.minorRadius, isFixed); \ 832 break; \ 833 }; \ 834 break; \ 835 }; \ 836 break; \ 837 }; \ 838 } \ 839 break; \ 840 case kIOHIDEventTypeZoomToggle: \ 841 { \ 842 /* IOHIDZoomToggleEventData * zoom = (IOHIDZoomToggleEventData *)eventData; */\ 843 switch ( fieldOffset ) { \ 844 }; \ 845 } \ 846 break; \ 847 case kIOHIDEventTypeSymbolicHotKey: \ 848 { \ 849 IOHIDSymbolicHotKeyEventData * symbolicEvent = (IOHIDSymbolicHotKeyEventData *)eventData; \ 850 switch ( fieldOffset ) { \ 851 case IOHIDEventFieldOffset(kIOHIDEventFieldSymbolicHotKeyValue): \ 852 value = symbolicEvent->hotKey; \ 853 break; \ 854 case IOHIDEventFieldOffset(kIOHIDEventFieldSymbolicHotKeyIsCGSEvent): \ 855 value = (symbolicEvent->options & kIOHIDSymbolicHotKeyOptionIsCGSHotKey) != 0; \ 856 break; \ 857 }; \ 858 } \ 859 break; \ 860 case kIOHIDEventTypePower: \ 861 {\ 862 IOHIDPowerEventData * pwrEvent = (IOHIDPowerEventData *)eventData; \ 863 switch ( fieldOffset ) {\ 864 case IOHIDEventFieldOffset(kIOHIDEventFieldPowerMeasurement): \ 865 value = IOHIDEventValueFloat(pwrEvent->measurement, isFixed); \ 866 break; \ 867 case IOHIDEventFieldOffset(kIOHIDEventFieldPowerType): \ 868 value = pwrEvent->powerType; \ 869 break; \ 870 case IOHIDEventFieldOffset(kIOHIDEventFieldPowerSubType): \ 871 value = pwrEvent->powerSubType; \ 872 break; \ 873 }; \ 874 } \ 875 break; \ 876 }; \ 877} 878 879#define GET_EVENT_VALUE(event, field, value, options) \ 880{ IOHIDEventType fieldEvType = IOHIDEventFieldEventType(field); \ 881 uint32_t fieldOffset = IOHIDEventFieldOffset(field); \ 882 IOHIDEventRef ev = (fieldEvType == kIOHIDEventTypeNULL) ? event : NULL; \ 883 if ( ev || (ev = IOHIDEventGetEventWithOptions(event, fieldEvType, options)) ) {\ 884 GET_EVENTDATA_VALUE(GET_EVENTDATA(ev),fieldEvType,fieldOffset,value, false);\ 885 } \ 886} 887 888#define GET_EVENT_VALUE_FIXED(event, field, value, options) \ 889{ IOHIDEventType fieldEvType = IOHIDEventFieldEventType(field); \ 890 uint32_t fieldOffset = IOHIDEventFieldOffset(field); \ 891 IOHIDEventRef ev = (fieldEvType == kIOHIDEventTypeNULL) ? event : NULL; \ 892 if ( ev || (ev = IOHIDEventGetEventWithOptions(event, fieldEvType, options)) ) {\ 893 GET_EVENTDATA_VALUE(GET_EVENTDATA(ev),fieldEvType,fieldOffset,value, true);\ 894 } \ 895} 896 897//============================================================================== 898// IOHIDEventSetValue MACRO 899//============================================================================== 900#define SET_EVENTDATA_VALUE(eventData, fieldEvType, fieldOffset, value, isFixed) \ 901{ switch ( fieldEvType ) { \ 902 case kIOHIDEventTypeNULL: \ 903 { \ 904 switch ( fieldOffset ) { \ 905 case IOHIDEventFieldOffset(kIOHIDEventFieldIsRelative): \ 906 if ( value ) \ 907 eventData->options &= ~kIOHIDEventOptionIsAbsolute; \ 908 else \ 909 eventData->options |= kIOHIDEventOptionIsAbsolute; \ 910 break; \ 911 case IOHIDEventFieldOffset(kIOHIDEventFieldIsCollection): \ 912 if ( value ) \ 913 eventData->options |= kIOHIDEventOptionIsCollection; \ 914 else \ 915 eventData->options &= ~kIOHIDEventOptionIsCollection; \ 916 break; \ 917 case IOHIDEventFieldOffset(kIOHIDEventFieldIsPixelUnits): \ 918 if ( value ) \ 919 eventData->options |= kIOHIDEventOptionIsPixelUnits; \ 920 else \ 921 eventData->options &= ~kIOHIDEventOptionIsPixelUnits; \ 922 break; \ 923 case IOHIDEventFieldOffset(kIOHIDEventFieldIsCenterOrigin): \ 924 if ( value ) \ 925 eventData->options |= kIOHIDEventOptionIsCenterOrigin; \ 926 else \ 927 eventData->options &= ~kIOHIDEventOptionIsCenterOrigin; \ 928 break; \ 929 case IOHIDEventFieldOffset(kIOHIDEventFieldIsBuiltIn): \ 930 if ( value ) \ 931 eventData->options |= kIOHIDEventOptionIsBuiltIn; \ 932 else \ 933 eventData->options &= ~kIOHIDEventOptionIsBuiltIn; \ 934 break; \ 935 }; \ 936 } \ 937 break; \ 938 case kIOHIDEventTypeVendorDefined: \ 939 { \ 940 IOHIDVendorDefinedEventData * sysDef = (IOHIDVendorDefinedEventData*)eventData; \ 941 switch ( fieldOffset ) { \ 942 case IOHIDEventFieldOffset(kIOHIDEventFieldVendorDefinedUsagePage): \ 943 sysDef->usagePage = value; \ 944 break; \ 945 case IOHIDEventFieldOffset(kIOHIDEventFieldVendorDefinedUsage): \ 946 sysDef->usage = value; \ 947 break; \ 948 case IOHIDEventFieldOffset(kIOHIDEventFieldVendorDefinedVersion): \ 949 sysDef->version = value; \ 950 break; \ 951 case IOHIDEventFieldOffset(kIOHIDEventFieldVendorDefinedData): \ 952 if (sysDef->data) \ 953 *((typeof(value)*) sysDef->data) = value; \ 954 break; \ 955 }; \ 956 } \ 957 break; \ 958 case kIOHIDEventTypeBiometric: \ 959 case kIOHIDEventTypeProgress: \ 960 { \ 961 IOHIDProgressEventData * progress = (IOHIDProgressEventData*)eventData; \ 962 switch ( fieldOffset ) { \ 963 /* case IOHIDEventFieldOffset(kIOHIDEventFieldBiometricEventType): */\ 964 case IOHIDEventFieldOffset(kIOHIDEventFieldProgressEventType): \ 965 progress->eventType = value; \ 966 break; \ 967 /* case IOHIDEventFieldOffset(kIOHIDEventFieldBiometricLevel): */\ 968 case IOHIDEventFieldOffset(kIOHIDEventFieldProgressLevel): \ 969 progress->level = IOHIDEventValueFixed(value, isFixed); \ 970 break; \ 971 }; \ 972 } \ 973 break; \ 974 case kIOHIDEventTypeButton: \ 975 { \ 976 IOHIDButtonEventData * button = (IOHIDButtonEventData*)eventData; \ 977 switch ( fieldOffset ) { \ 978 case IOHIDEventFieldOffset(kIOHIDEventFieldButtonMask): \ 979 button->button.buttonMask = value; \ 980 break; \ 981 case IOHIDEventFieldOffset(kIOHIDEventFieldButtonNumber): \ 982 button->button.buttonNumber = value; \ 983 break; \ 984 case IOHIDEventFieldOffset(kIOHIDEventFieldButtonClickCount): \ 985 button->button.clickState = value; \ 986 break; \ 987 case IOHIDEventFieldOffset(kIOHIDEventFieldButtonPressure): \ 988 button->button.pressure = IOHIDEventValueFixed(value, isFixed); \ 989 break; \ 990 }; \ 991 } \ 992 break; \ 993 case kIOHIDEventTypeCompass: \ 994 case kIOHIDEventTypeGyro: \ 995 case kIOHIDEventTypeAccelerometer: \ 996 { \ 997 IOHIDMotionEventData * motion = (IOHIDMotionEventData*)eventData; \ 998 switch ( fieldOffset ) { \ 999 /*case IOHIDEventFieldOffset(kIOHIDEventFieldCompassX): */\ 1000 /*case IOHIDEventFieldOffset(kIOHIDEventFieldGyroX): */\ 1001 case IOHIDEventFieldOffset(kIOHIDEventFieldAccelerometerX): \ 1002 motion->position.x = IOHIDEventValueFixed(value, isFixed); \ 1003 break; \ 1004 /*case IOHIDEventFieldOffset(kIOHIDEventFieldCompassY): */\ 1005 /*case IOHIDEventFieldOffset(kIOHIDEventFieldGyroY): */\ 1006 case IOHIDEventFieldOffset(kIOHIDEventFieldAccelerometerY): \ 1007 motion->position.y = IOHIDEventValueFixed(value, isFixed); \ 1008 break; \ 1009 /*case IOHIDEventFieldOffset(kIOHIDEventFieldCompassZ): */\ 1010 /*case IOHIDEventFieldOffset(kIOHIDEventFieldGyroZ): */\ 1011 case IOHIDEventFieldOffset(kIOHIDEventFieldAccelerometerZ): \ 1012 motion->position.z = IOHIDEventValueFixed(value, isFixed); \ 1013 break; \ 1014 /*case IOHIDEventFieldOffset(kIOHIDEventFieldCompassType): */\ 1015 /*case IOHIDEventFieldOffset(kIOHIDEventFieldGyroType): */\ 1016 case IOHIDEventFieldOffset(kIOHIDEventFieldAccelerometerType): \ 1017 motion->motionType = value; \ 1018 break; \ 1019 /*case IOHIDEventFieldOffset(kIOHIDEventFieldCompassSubType): */\ 1020 /*case IOHIDEventFieldOffset(kIOHIDEventFieldGyroSubType): */\ 1021 case IOHIDEventFieldOffset(kIOHIDEventFieldAccelerometerSubType): \ 1022 motion->motionSubType = value; \ 1023 break; \ 1024 /*case IOHIDEventFieldOffset(kIOHIDEventFieldCompassSequence): */\ 1025 /*case IOHIDEventFieldOffset(kIOHIDEventFieldGyroSequence): */\ 1026 case IOHIDEventFieldOffset(kIOHIDEventFieldAccelerometerSequence): \ 1027 motion->motionSequence = value; \ 1028 break; \ 1029 }; \ 1030 } \ 1031 break; \ 1032 case kIOHIDEventTypePointer: \ 1033 { \ 1034 IOHIDPointerEventData * pointer = (IOHIDPointerEventData*)eventData; \ 1035 switch ( fieldOffset ) { \ 1036 case IOHIDEventFieldOffset(kIOHIDEventFieldPointerX): \ 1037 pointer->position.x = IOHIDEventValueFixed(value, isFixed); \ 1038 break; \ 1039 case IOHIDEventFieldOffset(kIOHIDEventFieldPointerY): \ 1040 pointer->position.y = IOHIDEventValueFixed(value, isFixed); \ 1041 break; \ 1042 case IOHIDEventFieldOffset(kIOHIDEventFieldPointerZ): \ 1043 pointer->position.z = IOHIDEventValueFixed(value, isFixed); \ 1044 break; \ 1045 case IOHIDEventFieldOffset(kIOHIDEventFieldPointerButtonMask): \ 1046 pointer->button.buttonMask = value; \ 1047 break; \ 1048 case IOHIDEventFieldOffset(kIOHIDEventFieldPointerNumber): \ 1049 pointer->button.buttonNumber = value; \ 1050 break; \ 1051 case IOHIDEventFieldOffset(kIOHIDEventFieldPointerClickCount): \ 1052 pointer->button.clickState = value; \ 1053 break; \ 1054 case IOHIDEventFieldOffset(kIOHIDEventFieldPointerPressure): \ 1055 pointer->button.pressure = IOHIDEventValueFixed(value, isFixed); \ 1056 break; \ 1057 }; \ 1058 } \ 1059 break; \ 1060 case kIOHIDEventTypeMultiAxisPointer: \ 1061 { \ 1062 IOHIDMultiAxisPointerEventData * pointer = (IOHIDMultiAxisPointerEventData*)eventData; \ 1063 switch ( fieldOffset ) { \ 1064 case IOHIDEventFieldOffset(kIOHIDEventFieldMultiAxisPointerX): \ 1065 pointer->position.x = IOHIDEventValueFixed(value, isFixed); \ 1066 break; \ 1067 case IOHIDEventFieldOffset(kIOHIDEventFieldMultiAxisPointerY): \ 1068 pointer->position.y = IOHIDEventValueFixed(value, isFixed); \ 1069 break; \ 1070 case IOHIDEventFieldOffset(kIOHIDEventFieldMultiAxisPointerZ): \ 1071 pointer->position.z = IOHIDEventValueFixed(value, isFixed); \ 1072 break; \ 1073 case IOHIDEventFieldOffset(kIOHIDEventFieldMultiAxisPointerButtonMask): \ 1074 pointer->button.buttonMask = value; \ 1075 break; \ 1076 case IOHIDEventFieldOffset(kIOHIDEventFieldMultiAxisPointerNumber): \ 1077 pointer->button.buttonNumber = value; \ 1078 break; \ 1079 case IOHIDEventFieldOffset(kIOHIDEventFieldMultiAxisPointerClickCount): \ 1080 pointer->button.clickState = value; \ 1081 break; \ 1082 case IOHIDEventFieldOffset(kIOHIDEventFieldMultiAxisPointerPressure): \ 1083 pointer->button.pressure = IOHIDEventValueFixed(value, isFixed); \ 1084 break; \ 1085 case IOHIDEventFieldOffset(kIOHIDEventFieldMultiAxisPointerRx): \ 1086 pointer->rotation.x = IOHIDEventValueFixed(value, isFixed); \ 1087 break; \ 1088 case IOHIDEventFieldOffset(kIOHIDEventFieldMultiAxisPointerRy): \ 1089 pointer->rotation.y = IOHIDEventValueFixed(value, isFixed); \ 1090 break; \ 1091 case IOHIDEventFieldOffset(kIOHIDEventFieldMultiAxisPointerRz): \ 1092 pointer->rotation.z = IOHIDEventValueFixed(value, isFixed); \ 1093 break; \ 1094 }; \ 1095 } \ 1096 break; \ 1097 case kIOHIDEventTypeNavigationSwipe: \ 1098 case kIOHIDEventTypeDockSwipe: \ 1099 case kIOHIDEventTypeFluidTouchGesture: \ 1100 case kIOHIDEventTypeBoundaryScroll: \ 1101 { \ 1102 IOHIDSwipeEventData * swipe = (IOHIDSwipeEventData *)eventData; \ 1103 switch ( fieldOffset ) { \ 1104 case IOHIDEventFieldOffset(kIOHIDEventFieldSwipeMask): \ 1105 /* \ 1106 case IOHIDEventFieldOffset(kIOHIDEventFieldNavigationSwipeMask): \ 1107 case IOHIDEventFieldOffset(kIOHIDEventFieldDockSwipeMask): \ 1108 case IOHIDEventFieldOffset(kIOHIDEventFieldFluidTouchGestureMask): \ 1109 case IOHIDEventFieldOffset(kIOHIDEventFieldBoundaryScrollMask): \ 1110 */ \ 1111 swipe->swipeMask = value;\ 1112 break; \ 1113 case IOHIDEventFieldOffset(kIOHIDEventFieldSwipeMotion): \ 1114 /* \ 1115 case IOHIDEventFieldOffset(kIOHIDEventFieldNavigationSwipeMotion): \ 1116 case IOHIDEventFieldOffset(kIOHIDEventFieldDockSwipeMotion): \ 1117 case IOHIDEventFieldOffset(kIOHIDEventFieldFluidTouchGestureMotion): \ 1118 case IOHIDEventFieldOffset(kIOHIDEventFieldBoundaryScrollMotion): \ 1119 */ \ 1120 swipe->gestureMotion = value;\ 1121 break; \ 1122 case IOHIDEventFieldOffset(kIOHIDEventFieldSwipeProgress): \ 1123 /* \ 1124 case IOHIDEventFieldOffset(kIOHIDEventFieldNavigationSwipeProgress): \ 1125 case IOHIDEventFieldOffset(kIOHIDEventFieldDockSwipeProgress): \ 1126 case IOHIDEventFieldOffset(kIOHIDEventFieldFluidTouchGestureProgress): \ 1127 case IOHIDEventFieldOffset(kIOHIDEventFieldBoundaryScrollProgress): \ 1128 */ \ 1129 swipe->progress = IOHIDEventValueFixed(value, isFixed);\ 1130 break; \ 1131 case IOHIDEventFieldOffset(kIOHIDEventFieldSwipePositionX): \ 1132 /* \ 1133 case IOHIDEventFieldOffset(kIOHIDEventFieldNavigationSwipePositionX): \ 1134 case IOHIDEventFieldOffset(kIOHIDEventFieldDockSwipePositionX): \ 1135 case IOHIDEventFieldOffset(kIOHIDEventFieldFluidTouchGesturePositionX): \ 1136 case IOHIDEventFieldOffset(kIOHIDEventFieldBoundaryScrollPositionX): \ 1137 */ \ 1138 swipe->position.x = IOHIDEventValueFixed(value, isFixed);\ 1139 break; \ 1140 case IOHIDEventFieldOffset(kIOHIDEventFieldSwipePositionY): \ 1141 /* \ 1142 case IOHIDEventFieldOffset(kIOHIDEventFieldNavigationSwipePositionY): \ 1143 case IOHIDEventFieldOffset(kIOHIDEventFieldDockSwipePositionY): \ 1144 case IOHIDEventFieldOffset(kIOHIDEventFieldFluidTouchGesturePositionY): \ 1145 case IOHIDEventFieldOffset(kIOHIDEventFieldBoundaryScrollPositionY): \ 1146 */ \ 1147 swipe->position.y = IOHIDEventValueFixed(value, isFixed);\ 1148 break; \ 1149 case IOHIDEventFieldOffset(kIOHIDEventFieldSwipeFlavor): \ 1150 /* 1151 case IOHIDEventFieldOffset(kIOHIDEventFieldNavigationSwipeFlavor): \ 1152 case IOHIDEventFieldOffset(kIOHIDEventFieldDockSwipeFlavor): \ 1153 case IOHIDEventFieldOffset(kIOHIDEventFieldFluidTouchGestureFlavor): \ 1154 case IOHIDEventFieldOffset(kIOHIDEventFieldBoundaryScrollFlavor): \ 1155 */ \ 1156 swipe->flavor = value; \ 1157 break; \ 1158 }; \ 1159 } \ 1160 break; \ 1161 case kIOHIDEventTypeTemperature: \ 1162 { \ 1163 IOHIDTemperatureEventData * temp = (IOHIDTemperatureEventData *)eventData; \ 1164 switch ( fieldOffset ) { \ 1165 case IOHIDEventFieldOffset(kIOHIDEventFieldTemperatureLevel): \ 1166 temp->level = IOHIDEventValueFixed(value, isFixed);\ 1167 break; \ 1168 }; \ 1169 } \ 1170 break; \ 1171 case kIOHIDEventTypeTranslation: \ 1172 case kIOHIDEventTypeRotation: \ 1173 case kIOHIDEventTypeScroll: \ 1174 case kIOHIDEventTypeScale: \ 1175 case kIOHIDEventTypeVelocity: \ 1176 case kIOHIDEventTypeOrientation: \ 1177 { \ 1178 IOHIDAxisEventData * axis = (IOHIDAxisEventData *)eventData; \ 1179 switch ( fieldOffset ) { \ 1180 case IOHIDEventFieldOffset(kIOHIDEventFieldTranslationX): \ 1181 /* \ 1182 case IOHIDEventFieldOffset(kIOHIDEventFieldRotationX): \ 1183 case IOHIDEventFieldOffset(kIOHIDEventFieldScrollX): \ 1184 case IOHIDEventFieldOffset(kIOHIDEventFieldScaleX): \ 1185 case IOHIDEventFieldOffset(kIOHIDEventFieldVelocityX): \ 1186 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerX); \ 1187 case IOHIDEventFieldOffset(kIOHIDEventFieldOrientationRadius): \ 1188 */ \ 1189 axis->position.x = IOHIDEventValueFixed(value, isFixed); \ 1190 break; \ 1191 case IOHIDEventFieldOffset(kIOHIDEventFieldTranslationY): \ 1192 /* \ 1193 case IOHIDEventFieldOffset(kIOHIDEventFieldRotationY): \ 1194 case IOHIDEventFieldOffset(kIOHIDEventFieldScrollY): \ 1195 case IOHIDEventFieldOffset(kIOHIDEventFieldScaleY): \ 1196 case IOHIDEventFieldOffset(kIOHIDEventFieldVelocityY): \ 1197 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerY); \ 1198 case IOHIDEventFieldOffset(kIOHIDEventFieldOrientationAzimuth): \ 1199 */ \ 1200 axis->position.y = IOHIDEventValueFixed(value, isFixed); \ 1201 break; \ 1202 case IOHIDEventFieldOffset(kIOHIDEventFieldTranslationZ): \ 1203 /* \ 1204 case IOHIDEventFieldOffset(kIOHIDEventFieldRotationZ): \ 1205 case IOHIDEventFieldOffset(kIOHIDEventFieldScrollZ): \ 1206 case IOHIDEventFieldOffset(kIOHIDEventFieldScaleZ): \ 1207 case IOHIDEventFieldOffset(kIOHIDEventFieldVelocityZ): \ 1208 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerZ); \ 1209 case IOHIDEventFieldOffset(kIOHIDEventFieldOrientationAltitude):\ 1210 */ \ 1211 axis->position.z = IOHIDEventValueFixed(value, isFixed); \ 1212 break; \ 1213 case IOHIDEventFieldOffset(kIOHIDEventFieldScrollIsPixels): \ 1214 if ( value ) \ 1215 axis->options |= kIOHIDEventOptionPixelUnits; \ 1216 else \ 1217 axis->options &= ~kIOHIDEventOptionPixelUnits; \ 1218 break; \ 1219 }; \ 1220 } \ 1221 break; \ 1222 case kIOHIDEventTypeAmbientLightSensor: \ 1223 { \ 1224 IOHIDAmbientLightSensorEventData * alsEvent = (IOHIDAmbientLightSensorEventData *)eventData;\ 1225 switch ( fieldOffset ) { \ 1226 case IOHIDEventFieldOffset(kIOHIDEventFieldAmbientLightSensorLevel): \ 1227 alsEvent->level = value; \ 1228 break; \ 1229 case IOHIDEventFieldOffset(kIOHIDEventFieldAmbientLightSensorRawChannel0): \ 1230 alsEvent->ch0 = value; \ 1231 break; \ 1232 case IOHIDEventFieldOffset(kIOHIDEventFieldAmbientLightSensorRawChannel1): \ 1233 alsEvent->ch1 = value; \ 1234 break; \ 1235 case IOHIDEventFieldOffset(kIOHIDEventFieldAmbientLightSensorRawChannel2): \ 1236 alsEvent->ch2 = value; \ 1237 break; \ 1238 case IOHIDEventFieldOffset(kIOHIDEventFieldAmbientLightSensorRawChannel3): \ 1239 alsEvent->ch3 = value; \ 1240 break; \ 1241 case IOHIDEventFieldOffset(kIOHIDEventFieldAmbientLightDisplayBrightnessChanged): \ 1242 alsEvent->brightnessChanged = value; \ 1243 break; \ 1244 }; \ 1245 } \ 1246 break; \ 1247 case kIOHIDEventTypeProximity: \ 1248 { \ 1249 IOHIDProximityEventData * proxEvent = (IOHIDProximityEventData *)eventData;\ 1250 switch ( fieldOffset ) { \ 1251 case IOHIDEventFieldOffset(kIOHIDEventFieldProximityDetectionMask): \ 1252 proxEvent->detectionMask = value; \ 1253 break; \ 1254 case IOHIDEventFieldOffset(kIOHIDEventFieldProximityLevel): \ 1255 proxEvent->level = value; \ 1256 break; \ 1257 }; \ 1258 } \ 1259 break; \ 1260 case kIOHIDEventTypeKeyboard: \ 1261 { \ 1262 IOHIDKeyboardEventData * keyEvent = (IOHIDKeyboardEventData *)eventData;\ 1263 switch ( fieldOffset ) { \ 1264 case IOHIDEventFieldOffset(kIOHIDEventFieldKeyboardUsagePage): \ 1265 keyEvent->usagePage = value; \ 1266 break; \ 1267 case IOHIDEventFieldOffset(kIOHIDEventFieldKeyboardUsage): \ 1268 keyEvent->usage = value; \ 1269 break; \ 1270 case IOHIDEventFieldOffset(kIOHIDEventFieldKeyboardDown): \ 1271 keyEvent->down = value; \ 1272 break; \ 1273 case IOHIDEventFieldOffset(kIOHIDEventFieldKeyboardRepeat): \ 1274 if ( value ) \ 1275 keyEvent->options |= kIOHIDEventOptionIsRepeat; \ 1276 else \ 1277 keyEvent->options &= ~kIOHIDEventOptionIsRepeat; \ 1278 break; \ 1279 }; \ 1280 } \ 1281 break; \ 1282 case kIOHIDEventTypeDigitizer: \ 1283 { \ 1284 IOHIDDigitizerEventData * digEvent = (IOHIDDigitizerEventData *)eventData; \ 1285 switch ( fieldOffset ) { \ 1286 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerX): \ 1287 digEvent->position.x = IOHIDEventValueFixed(value, isFixed); \ 1288 break; \ 1289 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerY): \ 1290 digEvent->position.y = IOHIDEventValueFixed(value, isFixed); \ 1291 break; \ 1292 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerZ): \ 1293 digEvent->position.z = IOHIDEventValueFixed(value, isFixed); \ 1294 break; \ 1295 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerButtonMask): \ 1296 digEvent->buttonMask = value; \ 1297 break; \ 1298 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerType): \ 1299 digEvent->transducerType = value; \ 1300 break; \ 1301 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerIndex): \ 1302 digEvent->transducerIndex = value; \ 1303 break; \ 1304 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerIdentity): \ 1305 digEvent->identity = value; \ 1306 break; \ 1307 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerEventMask): \ 1308 digEvent->eventMask = value; \ 1309 break; \ 1310 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerChildEventMask): \ 1311 digEvent->childEventMask = value; \ 1312 break; \ 1313 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerRange): \ 1314 if ( value ) \ 1315 digEvent->options |= kIOHIDTransducerRange; \ 1316 else \ 1317 digEvent->options &= ~kIOHIDTransducerRange; \ 1318 break; \ 1319 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerIsDisplayIntegrated): \ 1320 if ( value ) \ 1321 digEvent->options |= kIOHIDTransducerDisplayIntegrated; \ 1322 else \ 1323 digEvent->options &= kIOHIDTransducerDisplayIntegrated; \ 1324 break; \ 1325 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerTouch): \ 1326 if ( value ) \ 1327 digEvent->options |= kIOHIDTransducerTouch; \ 1328 else \ 1329 digEvent->options &= ~kIOHIDTransducerTouch; \ 1330 break; \ 1331 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerCollection): \ 1332 if ( value ) \ 1333 digEvent->options |= kIOHIDEventOptionIsCollection; \ 1334 else \ 1335 digEvent->options &= ~kIOHIDEventOptionIsCollection; \ 1336 break; \ 1337 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerPressure): \ 1338 digEvent->pressure = IOHIDEventValueFixed(value, isFixed); \ 1339 break; \ 1340 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerAuxiliaryPressure): \ 1341 digEvent->auxPressure = IOHIDEventValueFixed(value, isFixed); \ 1342 break; \ 1343 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerTwist): \ 1344 digEvent->twist = IOHIDEventValueFixed(value, isFixed); \ 1345 break; \ 1346 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerTiltX): \ 1347 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerTiltY): \ 1348 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerAltitude): \ 1349 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerAzimuth): \ 1350 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerQuality): \ 1351 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerDensity): \ 1352 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerIrregularity): \ 1353 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerMajorRadius): \ 1354 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerMinorRadius): \ 1355 switch ( digEvent->orientationType ) {\ 1356 case kIOHIDDigitizerOrientationTypeTilt:\ 1357 switch ( fieldOffset ) {\ 1358 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerTiltX): \ 1359 digEvent->orientation.tilt.x = IOHIDEventValueFixed(value, isFixed); \ 1360 break; \ 1361 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerTiltY): \ 1362 digEvent->orientation.tilt.y = IOHIDEventValueFixed(value, isFixed); \ 1363 break; \ 1364 }; \ 1365 break; \ 1366 case kIOHIDDigitizerOrientationTypePolar:\ 1367 switch ( fieldOffset ) {\ 1368 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerAltitude): \ 1369 digEvent->orientation.polar.altitude = IOHIDEventValueFixed(value, isFixed); \ 1370 break; \ 1371 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerAzimuth): \ 1372 digEvent->orientation.polar.azimuth = IOHIDEventValueFixed(value, isFixed); \ 1373 break; \ 1374 }; \ 1375 break; \ 1376 case kIOHIDDigitizerOrientationTypeQuality:\ 1377 switch ( fieldOffset ) {\ 1378 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerQuality): \ 1379 digEvent->orientation.quality.quality = IOHIDEventValueFixed(value, isFixed); \ 1380 break; \ 1381 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerDensity): \ 1382 digEvent->orientation.quality.density = IOHIDEventValueFixed(value, isFixed); \ 1383 break; \ 1384 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerIrregularity): \ 1385 digEvent->orientation.quality.irregularity = IOHIDEventValueFixed(value, isFixed); \ 1386 break; \ 1387 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerMajorRadius): \ 1388 digEvent->orientation.quality.majorRadius = IOHIDEventValueFixed(value, isFixed); \ 1389 break; \ 1390 case IOHIDEventFieldOffset(kIOHIDEventFieldDigitizerMinorRadius): \ 1391 digEvent->orientation.quality.minorRadius = IOHIDEventValueFixed(value, isFixed); \ 1392 break; \ 1393 }; \ 1394 break; \ 1395 }; \ 1396 break; \ 1397 }; \ 1398 } \ 1399 break; \ 1400 case kIOHIDEventTypeZoomToggle: \ 1401 { \ 1402 /* IOHIDZoomToggleEventData * zoom = (IOHIDZoomToggleEventData *)eventData; */\ 1403 switch ( fieldOffset ) { \ 1404 }; \ 1405 } \ 1406 break; \ 1407 case kIOHIDEventTypeSymbolicHotKey: \ 1408 { \ 1409 IOHIDSymbolicHotKeyEventData * symbolicEvent = (IOHIDSymbolicHotKeyEventData *)eventData; \ 1410 switch ( fieldOffset ) { \ 1411 case IOHIDEventFieldOffset(kIOHIDEventFieldSymbolicHotKeyValue): \ 1412 symbolicEvent->hotKey = value; \ 1413 break; \ 1414 case IOHIDEventFieldOffset(kIOHIDEventFieldSymbolicHotKeyIsCGSEvent): \ 1415 if ( value ) \ 1416 symbolicEvent->options |= kIOHIDSymbolicHotKeyOptionIsCGSHotKey; \ 1417 else \ 1418 symbolicEvent->options &= ~kIOHIDSymbolicHotKeyOptionIsCGSHotKey; \ 1419 break; \ 1420 }; \ 1421 } \ 1422 break; \ 1423 case kIOHIDEventTypePower: \ 1424 { \ 1425 IOHIDPowerEventData * pwrEvent = (IOHIDPowerEventData *)eventData; \ 1426 switch ( fieldOffset ) {\ 1427 case IOHIDEventFieldOffset(kIOHIDEventFieldPowerMeasurement): \ 1428 pwrEvent->measurement = IOHIDEventValueFixed(value, isFixed); \ 1429 break; \ 1430 case IOHIDEventFieldOffset(kIOHIDEventFieldPowerType): \ 1431 pwrEvent->powerType = value; \ 1432 break; \ 1433 case IOHIDEventFieldOffset(kIOHIDEventFieldPowerSubType): \ 1434 pwrEvent->powerSubType = value; \ 1435 break; \ 1436 }; \ 1437 } \ 1438 break; \ 1439 }; \ 1440} 1441 1442#define SET_EVENT_VALUE(event, field, value, options) \ 1443{ IOHIDEventType fieldEvType = IOHIDEventFieldEventType(field); \ 1444 uint32_t fieldOffset = IOHIDEventFieldOffset(field); \ 1445 IOHIDEventRef ev = (fieldEvType == kIOHIDEventTypeNULL) ? event : NULL; \ 1446 if ( ev || (ev = IOHIDEventGetEventWithOptions(event, fieldEvType, options)) ) {\ 1447 SET_EVENTDATA_VALUE(GET_EVENTDATA(ev),fieldEvType,fieldOffset,value, false);\ 1448 } \ 1449} 1450 1451#define SET_EVENT_VALUE_FIXED(event, field, value, options) \ 1452{ IOHIDEventType fieldEvType = IOHIDEventFieldEventType(field); \ 1453 uint32_t fieldOffset = IOHIDEventFieldOffset(field); \ 1454 IOHIDEventRef ev = (fieldEvType == kIOHIDEventTypeNULL) ? event : NULL; \ 1455 if ( ev || (ev = IOHIDEventGetEventWithOptions(event, fieldEvType, options)) ) {\ 1456 SET_EVENTDATA_VALUE(GET_EVENTDATA(ev),fieldEvType,fieldOffset,value, true);\ 1457 } \ 1458} 1459 1460#endif /* _IOKIT_HID_IOHIDEVENTDATA_H */ 1461