pub const BYTEDEF: u32 = 1;
pub const MICRODEF: u32 = 1;
pub const MISSING_DATA: i32 = -32768;
pub const MISSING: i32 = -32768;
pub const INaN: i32 = -32768;
pub const LEFT_EYE: u32 = 0;
pub const RIGHT_EYE: u32 = 1;
pub const LEFTEYEI: u32 = 0;
pub const RIGHTEYEI: u32 = 1;
pub const LEFT: u32 = 0;
pub const RIGHT: u32 = 1;
pub const BINOCULAR: u32 = 2;
pub const SAMPLE_LEFT: u32 = 32768;
pub const SAMPLE_RIGHT: u32 = 16384;
pub const SAMPLE_TIMESTAMP: u32 = 8192;
pub const SAMPLE_PUPILXY: u32 = 4096;
pub const SAMPLE_HREFXY: u32 = 2048;
pub const SAMPLE_GAZEXY: u32 = 1024;
pub const SAMPLE_GAZERES: u32 = 512;
pub const SAMPLE_PUPILSIZE: u32 = 256;
pub const SAMPLE_STATUS: u32 = 128;
pub const SAMPLE_INPUTS: u32 = 64;
pub const SAMPLE_BUTTONS: u32 = 32;
pub const SAMPLE_HEADPOS: u32 = 16;
pub const SAMPLE_TAGGED: u32 = 8;
pub const SAMPLE_UTAGGED: u32 = 4;
pub const SAMPLE_ADD_OFFSET: u32 = 2;
pub const FSAMPLEDEF: u32 = 1;
pub const DSAMPLEDEF: u32 = 1;
pub const FSAMPLERAWDEF: u32 = 1;
pub const FEVENTDEF: u32 = 1;
pub const DEVENTDEF: u32 = 1;
pub const SAMPLE_TYPE: u32 = 200;
pub const STARTPARSE: u32 = 1;
pub const ENDPARSE: u32 = 2;
pub const BREAKPARSE: u32 = 10;
pub const STARTBLINK: u32 = 3;
pub const ENDBLINK: u32 = 4;
pub const STARTSACC: u32 = 5;
pub const ENDSACC: u32 = 6;
pub const STARTFIX: u32 = 7;
pub const ENDFIX: u32 = 8;
pub const FIXUPDATE: u32 = 9;
pub const STARTSAMPLES: u32 = 15;
pub const ENDSAMPLES: u32 = 16;
pub const STARTEVENTS: u32 = 17;
pub const ENDEVENTS: u32 = 18;
pub const MESSAGEEVENT: u32 = 24;
pub const BUTTONEVENT: u32 = 25;
pub const INPUTEVENT: u32 = 28;
pub const LOST_DATA_EVENT: u32 = 63;
pub const ISAMPLE_BUFFER: u32 = 200;
pub const IEVENT_BUFFER: u32 = 66;
pub const IOEVENT_BUFFER: u32 = 8;
pub const IMESSAGE_BUFFER: u32 = 250;
pub const CONTROL_BUFFER: u32 = 36;
pub const ILINKDATA_BUFFER: u32 = 36;
pub const READ_ENDTIME: u32 = 64;
pub const READ_GRES: u32 = 512;
pub const READ_SIZE: u32 = 128;
pub const READ_VEL: u32 = 256;
pub const READ_STATUS: u32 = 8192;
pub const READ_BEG: u32 = 1;
pub const READ_END: u32 = 2;
pub const READ_AVG: u32 = 4;
pub const READ_PUPILXY: u32 = 1024;
pub const READ_HREFXY: u32 = 2048;
pub const READ_GAZEXY: u32 = 4096;
pub const READ_BEGPOS: u32 = 8;
pub const READ_ENDPOS: u32 = 16;
pub const READ_AVGPOS: u32 = 32;
pub const FRIGHTEYE_EVENTS: u32 = 32768;
pub const FLEFTEYE_EVENTS: u32 = 16384;
pub const LEFTEYE_EVENTS: u32 = 32768;
pub const RIGHTEYE_EVENTS: u32 = 16384;
pub const BLINK_EVENTS: u32 = 8192;
pub const FIXATION_EVENTS: u32 = 4096;
pub const FIXUPDATE_EVENTS: u32 = 2048;
pub const SACCADE_EVENTS: u32 = 1024;
pub const MESSAGE_EVENTS: u32 = 512;
pub const BUTTON_EVENTS: u32 = 64;
pub const INPUT_EVENTS: u32 = 32;
pub const EVENT_VELOCITY: u32 = 32768;
pub const EVENT_PUPILSIZE: u32 = 16384;
pub const EVENT_GAZERES: u32 = 8192;
pub const EVENT_STATUS: u32 = 4096;
pub const EVENT_GAZEXY: u32 = 1024;
pub const EVENT_HREFXY: u32 = 512;
pub const EVENT_PUPILXY: u32 = 256;
pub const FIX_AVG_ONLY: u32 = 8;
pub const START_TIME_ONLY: u32 = 4;
pub const PARSEDBY_GAZE: u32 = 192;
pub const PARSEDBY_HREF: u32 = 128;
pub const PARSEDBY_PUPIL: u32 = 64;
pub const ILINKDATAVERSION: u32 = 2;
pub const ELNAMESIZE: u32 = 40;
pub const ELREMBUFSIZE: u32 = 420;
pub const ELINKADDRSIZE: u32 = 16;
pub const PUPIL_DIA_FLAG: u32 = 1;
pub const HAVE_SAMPLES_FLAG: u32 = 2;
pub const HAVE_EVENTS_FLAG: u32 = 4;
pub const HAVE_LEFT_FLAG: u32 = 32768;
pub const HAVE_RIGHT_FLAG: u32 = 16384;
pub const DROPPED_SAMPLE: u32 = 32768;
pub const DROPPED_EVENT: u32 = 16384;
pub const DROPPED_CONTROL: u32 = 8192;
pub const DFILE_IS_OPEN: u32 = 128;
pub const DFILE_EVENTS_ON: u32 = 64;
pub const DFILE_SAMPLES_ON: u32 = 32;
pub const DLINK_EVENTS_ON: u32 = 8;
pub const DLINK_SAMPLES_ON: u32 = 4;
pub const DRECORD_ACTIVE: u32 = 1;
pub const COMMAND_FULL_WARN: u32 = 1;
pub const MESSAGE_FULL_WARN: u32 = 2;
pub const LINK_FULL_WARN: u32 = 4;
pub const FULL_WARN: u32 = 15;
pub const LINK_CONNECTED: u32 = 16;
pub const LINK_BROADCAST: u32 = 32;
pub const LINK_IS_TCPIP: u32 = 64;
pub const LED_TOP_WARNING: u32 = 128;
pub const LED_BOT_WARNING: u32 = 64;
pub const LED_LEFT_WARNING: u32 = 32;
pub const LED_RIGHT_WARNING: u32 = 16;
pub const HEAD_POSITION_WARNING: u32 = 240;
pub const LED_EXTRA_WARNING: u32 = 8;
pub const LED_MISSING_WARNING: u32 = 4;
pub const HEAD_VELOCITY_WARNING: u32 = 1;
pub const CALIBRATION_AREA_WARNING: u32 = 2;
pub const MATH_ERROR_WARNING: u32 = 8192;
pub const INTERP_SAMPLE_WARNING: u32 = 4096;
pub const INTERP_PUPIL_WARNING: u32 = 32768;
pub const CR_WARNING: u32 = 3840;
pub const CR_LEFT_WARNING: u32 = 1280;
pub const CR_RIGHT_WARNING: u32 = 2560;
pub const CR_LOST_WARNING: u32 = 768;
pub const CR_LOST_LEFT_WARNING: u32 = 256;
pub const CR_LOST_RIGHT_WARNING: u32 = 512;
pub const CR_RECOV_WARNING: u32 = 3072;
pub const CR_RECOV_LEFT_WARNING: u32 = 1024;
pub const CR_RECOV_RIGHT_WARNING: u32 = 2048;
pub const HPOS_TOP_WARNING: u32 = 128;
pub const HPOS_BOT_WARNING: u32 = 64;
pub const HPOS_LEFT_WARNING: u32 = 32;
pub const HPOS_RIGHT_WARNING: u32 = 16;
pub const HPOS_WARNING: u32 = 240;
pub const HPOS_ANGLE_WARNING: u32 = 8;
pub const HPOS_MISSING_WARNING: u32 = 4;
pub const HPOS_DISTANCE_WARNING: u32 = 1;
pub const TFLAG_MISSING: u32 = 16384;
pub const TFLAG_ANGLE: u32 = 8192;
pub const TFLAG_NEAREYE: u32 = 4096;
pub const TFLAG_CLOSE: u32 = 2048;
pub const TFLAG_FAR: u32 = 1024;
pub const TFLAG_T_TSIDE: u32 = 128;
pub const TFLAG_T_BSIDE: u32 = 64;
pub const TFLAG_T_LSIDE: u32 = 32;
pub const TFLAG_T_RSIDE: u32 = 16;
pub const TFLAG_E_TSIDE: u32 = 8;
pub const TFLAG_E_BSIDE: u32 = 4;
pub const TFLAG_E_LSIDE: u32 = 2;
pub const TFLAG_E_RSIDE: u32 = 1;
pub const OK_RESULT: u32 = 0;
pub const NO_REPLY: u32 = 1000;
pub const LINK_TERMINATED_RESULT: i32 = -100;
pub const ABORT_RESULT: u32 = 27;
pub const UNEXPECTED_EOL_RESULT: i32 = -1;
pub const SYNTAX_ERROR_RESULT: i32 = -2;
pub const BAD_VALUE_RESULT: i32 = -3;
pub const EXTRA_CHARACTERS_RESULT: i32 = -4;
pub const LINK_SEND_MAX: u32 = 244;
pub const LINK_INITIALIZE_FAILED: i32 = -200;
pub const CONNECT_TIMEOUT_FAILED: i32 = -201;
pub const WRONG_LINK_VERSION: i32 = -202;
pub const TRACKER_BUSY: i32 = -203;
pub const IN_DISCONNECT_MODE: u32 = 16384;
pub const IN_UNKNOWN_MODE: u32 = 0;
pub const IN_IDLE_MODE: u32 = 1;
pub const IN_SETUP_MODE: u32 = 2;
pub const IN_RECORD_MODE: u32 = 4;
pub const IN_TARGET_MODE: u32 = 8;
pub const IN_DRIFTCORR_MODE: u32 = 16;
pub const IN_IMAGE_MODE: u32 = 32;
pub const IN_USER_MENU: u32 = 64;
pub const IN_PLAYBACK_MODE: u32 = 256;
pub const EL_IDLE_MODE: u32 = 1;
pub const EL_IMAGE_MODE: u32 = 2;
pub const EL_SETUP_MENU_MODE: u32 = 3;
pub const EL_USER_MENU_1: u32 = 5;
pub const EL_USER_MENU_2: u32 = 6;
pub const EL_USER_MENU_3: u32 = 7;
pub const EL_OPTIONS_MENU_MODE: u32 = 8;
pub const EL_OUTPUT_MENU_MODE: u32 = 9;
pub const EL_DEMO_MENU_MODE: u32 = 10;
pub const EL_CALIBRATE_MODE: u32 = 11;
pub const EL_VALIDATE_MODE: u32 = 12;
pub const EL_DRIFT_CORR_MODE: u32 = 13;
pub const EL_RECORD_MODE: u32 = 14;
pub const SCENECAM_ALIGN_MODE: u32 = 15;
pub const SCENECAM_DEPTH_MODE: u32 = 16;
pub const RECORD_FILE_SAMPLES: u32 = 1;
pub const RECORD_FILE_EVENTS: u32 = 2;
pub const RECORD_LINK_SAMPLES: u32 = 4;
pub const RECORD_LINK_EVENTS: u32 = 8;
pub const ELIMAGE_2: u32 = 0;
pub const ELIMAGE_16: u32 = 1;
pub const ELIMAGE_16P: u32 = 2;
pub const ELIMAGE_256: u32 = 3;
pub const ELIMAGE_128HV: u32 = 4;
pub const ELIMAGE_128HVX: u32 = 5;
pub const KB_PRESS: u32 = 10;
pub const KB_RELEASE: i32 = -1;
pub const KB_REPEAT: u32 = 1;
pub const NUM_LOCK_ON: u32 = 32;
pub const CAPS_LOCK_ON: u32 = 64;
pub const ALT_KEY_DOWN: u32 = 8;
pub const CTRL_KEY_DOWN: u32 = 4;
pub const SHIFT_KEY_DOWN: u32 = 3;
pub const KB_BUTTON: u32 = 65280;
pub const F1_KEY: u32 = 15104;
pub const F2_KEY: u32 = 15360;
pub const F3_KEY: u32 = 15616;
pub const F4_KEY: u32 = 15872;
pub const F5_KEY: u32 = 16128;
pub const F6_KEY: u32 = 16384;
pub const F7_KEY: u32 = 16640;
pub const F8_KEY: u32 = 16896;
pub const F9_KEY: u32 = 17152;
pub const F10_KEY: u32 = 17408;
pub const PAGE_UP: u32 = 18688;
pub const PAGE_DOWN: u32 = 20736;
pub const CURS_UP: u32 = 18432;
pub const CURS_DOWN: u32 = 20480;
pub const CURS_LEFT: u32 = 19200;
pub const CURS_RIGHT: u32 = 19712;
pub const ESC_KEY: u32 = 27;
pub const ENTER_KEY: u32 = 13;
pub const FILE_XFER_ABORTED: i32 = -110;
pub const FILE_CANT_OPEN: i32 = -111;
pub const FILE_NO_REPLY: i32 = -112;
pub const FILE_BAD_DATA: i32 = -113;
pub const FILEDATA_SIZE_FLAG: u32 = 999;
pub const FILE_BLOCK_SIZE: u32 = 512;
pub const ABORT_BX: i32 = -32000;
pub const PAUSE_BX: i32 = -32001;
pub const DONE_BX: i32 = -32002;
pub const JUNK_KEY: u32 = 1;
pub const TERMINATE_KEY: u32 = 32767;
pub const DONE_TRIAL: u32 = 0;
pub const TRIAL_OK: u32 = 0;
pub const REPEAT_TRIAL: u32 = 1;
pub const SKIP_TRIAL: u32 = 2;
pub const ABORT_EXPT: u32 = 3;
pub const TRIAL_ERROR: i32 = -1;
pub const BX_AVERAGE: u32 = 0;
pub const BX_DARKEN: u32 = 1;
pub const BX_LIGHTEN: u32 = 2;
pub const BX_MAXCONTRAST: u32 = 4;
pub const BX_NODITHER: u32 = 8;
pub const BX_GRAYSCALE: u32 = 16;
pub const BX_TXFILE: u32 = 32;
pub const BX_DOTRANSFER: u32 = 256;
pub const SV_NOREPLACE: u32 = 1;
pub const SV_MAKEPATH: u32 = 2;
pub const BAD_FILENAME: i32 = -2222;
pub const BAD_ARGUMENT: i32 = -2223;
pub const KEYINPUT_EVENT: u32 = 1;
pub const MOUSE_INPUT_EVENT: u32 = 4;
pub const MOUSE_MOTION_INPUT_EVENT: u32 = 5;
pub const MOUSE_BUTTON_INPUT_EVENT: u32 = 6;
pub const ELKMOD_NONE: u32 = 0;
pub const ELKMOD_LSHIFT: u32 = 1;
pub const ELKMOD_RSHIFT: u32 = 2;
pub const ELKMOD_LCTRL: u32 = 64;
pub const ELKMOD_RCTRL: u32 = 128;
pub const ELKMOD_LALT: u32 = 256;
pub const ELKMOD_RALT: u32 = 512;
pub const ELKMOD_LMETA: u32 = 1024;
pub const ELKMOD_RMETA: u32 = 2048;
pub const ELKMOD_NUM: u32 = 4096;
pub const ELKMOD_CAPS: u32 = 8192;
pub const ELKMOD_MODE: u32 = 16384;
pub const ELKEY_DOWN: u32 = 1;
pub const ELKEY_UP: u32 = 0;
pub const FIVE_SAMPLE_MODEL: u32 = 1;
pub const NINE_SAMPLE_MODEL: u32 = 2;
pub const SEVENTEEN_SAMPLE_MODEL: u32 = 3;
pub const EL1000_TRACKER_MODEL: u32 = 4;
pub const CR_HAIR_COLOR: u32 = 1;
pub const PUPIL_HAIR_COLOR: u32 = 2;
pub const PUPIL_BOX_COLOR: u32 = 3;
pub const SEARCH_LIMIT_BOX_COLOR: u32 = 4;
pub const MOUSE_CURSOR_COLOR: u32 = 5;
pub type byte = ::std::os::raw::c_uchar;
pub type INT16 = ::std::os::raw::c_short;
pub type UINT16 = ::std::os::raw::c_ushort;
pub type INT32 = ::std::os::raw::c_int;
pub type UINT32 = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MICRO {
pub msec: INT32,
pub usec: INT16,
}
#[test]
fn bindgen_test_layout_MICRO() {
assert_eq!(
::std::mem::size_of::<MICRO>(),
8usize,
concat!("Size of: ", stringify!(MICRO))
);
assert_eq!(
::std::mem::align_of::<MICRO>(),
4usize,
concat!("Alignment of ", stringify!(MICRO))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<MICRO>())).msec as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MICRO),
"::",
stringify!(msec)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<MICRO>())).usec as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(MICRO),
"::",
stringify!(usec)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct ISAMPLE {
pub time: UINT32,
pub type_: INT16,
pub flags: UINT16,
pub px: [INT16; 2usize],
pub py: [INT16; 2usize],
pub hx: [INT16; 2usize],
pub hy: [INT16; 2usize],
pub pa: [UINT16; 2usize],
pub gx: [INT16; 2usize],
pub gy: [INT16; 2usize],
pub rx: INT16,
pub ry: INT16,
pub status: UINT16,
pub input: UINT16,
pub buttons: UINT16,
pub htype: INT16,
pub hdata: [INT16; 8usize],
}
#[test]
fn bindgen_test_layout_ISAMPLE() {
assert_eq!(
::std::mem::size_of::<ISAMPLE>(),
64usize,
concat!("Size of: ", stringify!(ISAMPLE))
);
assert_eq!(
::std::mem::align_of::<ISAMPLE>(),
4usize,
concat!("Alignment of ", stringify!(ISAMPLE))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ISAMPLE>())).time as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ISAMPLE),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ISAMPLE>())).type_ as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ISAMPLE),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ISAMPLE>())).flags as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(ISAMPLE),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ISAMPLE>())).px as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ISAMPLE),
"::",
stringify!(px)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ISAMPLE>())).py as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ISAMPLE),
"::",
stringify!(py)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ISAMPLE>())).hx as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ISAMPLE),
"::",
stringify!(hx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ISAMPLE>())).hy as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(ISAMPLE),
"::",
stringify!(hy)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ISAMPLE>())).pa as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(ISAMPLE),
"::",
stringify!(pa)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ISAMPLE>())).gx as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(ISAMPLE),
"::",
stringify!(gx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ISAMPLE>())).gy as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(ISAMPLE),
"::",
stringify!(gy)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ISAMPLE>())).rx as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(ISAMPLE),
"::",
stringify!(rx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ISAMPLE>())).ry as *const _ as usize },
38usize,
concat!(
"Offset of field: ",
stringify!(ISAMPLE),
"::",
stringify!(ry)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ISAMPLE>())).status as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(ISAMPLE),
"::",
stringify!(status)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ISAMPLE>())).input as *const _ as usize },
42usize,
concat!(
"Offset of field: ",
stringify!(ISAMPLE),
"::",
stringify!(input)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ISAMPLE>())).buttons as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(ISAMPLE),
"::",
stringify!(buttons)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ISAMPLE>())).htype as *const _ as usize },
46usize,
concat!(
"Offset of field: ",
stringify!(ISAMPLE),
"::",
stringify!(htype)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ISAMPLE>())).hdata as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(ISAMPLE),
"::",
stringify!(hdata)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FSAMPLE {
pub time: UINT32,
pub type_: INT16,
pub flags: UINT16,
pub px: [f32; 2usize],
pub py: [f32; 2usize],
pub hx: [f32; 2usize],
pub hy: [f32; 2usize],
pub pa: [f32; 2usize],
pub gx: [f32; 2usize],
pub gy: [f32; 2usize],
pub rx: f32,
pub ry: f32,
pub status: UINT16,
pub input: UINT16,
pub buttons: UINT16,
pub htype: INT16,
pub hdata: [INT16; 8usize],
}
#[test]
fn bindgen_test_layout_FSAMPLE() {
assert_eq!(
::std::mem::size_of::<FSAMPLE>(),
96usize,
concat!("Size of: ", stringify!(FSAMPLE))
);
assert_eq!(
::std::mem::align_of::<FSAMPLE>(),
4usize,
concat!("Alignment of ", stringify!(FSAMPLE))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FSAMPLE>())).time as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FSAMPLE),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FSAMPLE>())).type_ as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(FSAMPLE),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FSAMPLE>())).flags as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(FSAMPLE),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FSAMPLE>())).px as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(FSAMPLE),
"::",
stringify!(px)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FSAMPLE>())).py as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(FSAMPLE),
"::",
stringify!(py)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FSAMPLE>())).hx as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(FSAMPLE),
"::",
stringify!(hx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FSAMPLE>())).hy as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(FSAMPLE),
"::",
stringify!(hy)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FSAMPLE>())).pa as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(FSAMPLE),
"::",
stringify!(pa)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FSAMPLE>())).gx as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(FSAMPLE),
"::",
stringify!(gx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FSAMPLE>())).gy as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(FSAMPLE),
"::",
stringify!(gy)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FSAMPLE>())).rx as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(FSAMPLE),
"::",
stringify!(rx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FSAMPLE>())).ry as *const _ as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(FSAMPLE),
"::",
stringify!(ry)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FSAMPLE>())).status as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(FSAMPLE),
"::",
stringify!(status)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FSAMPLE>())).input as *const _ as usize },
74usize,
concat!(
"Offset of field: ",
stringify!(FSAMPLE),
"::",
stringify!(input)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FSAMPLE>())).buttons as *const _ as usize },
76usize,
concat!(
"Offset of field: ",
stringify!(FSAMPLE),
"::",
stringify!(buttons)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FSAMPLE>())).htype as *const _ as usize },
78usize,
concat!(
"Offset of field: ",
stringify!(FSAMPLE),
"::",
stringify!(htype)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FSAMPLE>())).hdata as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(FSAMPLE),
"::",
stringify!(hdata)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct DSAMPLE {
pub time: f64,
pub type_: INT16,
pub flags: UINT16,
pub px: [f32; 2usize],
pub py: [f32; 2usize],
pub hx: [f32; 2usize],
pub hy: [f32; 2usize],
pub pa: [f32; 2usize],
pub gx: [f32; 2usize],
pub gy: [f32; 2usize],
pub rx: f32,
pub ry: f32,
pub status: UINT16,
pub input: UINT16,
pub buttons: UINT16,
pub htype: INT16,
pub hdata: [INT16; 8usize],
}
#[test]
fn bindgen_test_layout_DSAMPLE() {
assert_eq!(
::std::mem::size_of::<DSAMPLE>(),
104usize,
concat!("Size of: ", stringify!(DSAMPLE))
);
assert_eq!(
::std::mem::align_of::<DSAMPLE>(),
8usize,
concat!("Alignment of ", stringify!(DSAMPLE))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DSAMPLE>())).time as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(DSAMPLE),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DSAMPLE>())).type_ as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(DSAMPLE),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DSAMPLE>())).flags as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(DSAMPLE),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DSAMPLE>())).px as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(DSAMPLE),
"::",
stringify!(px)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DSAMPLE>())).py as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(DSAMPLE),
"::",
stringify!(py)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DSAMPLE>())).hx as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(DSAMPLE),
"::",
stringify!(hx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DSAMPLE>())).hy as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(DSAMPLE),
"::",
stringify!(hy)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DSAMPLE>())).pa as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(DSAMPLE),
"::",
stringify!(pa)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DSAMPLE>())).gx as *const _ as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(DSAMPLE),
"::",
stringify!(gx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DSAMPLE>())).gy as *const _ as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(DSAMPLE),
"::",
stringify!(gy)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DSAMPLE>())).rx as *const _ as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(DSAMPLE),
"::",
stringify!(rx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DSAMPLE>())).ry as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(DSAMPLE),
"::",
stringify!(ry)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DSAMPLE>())).status as *const _ as usize },
76usize,
concat!(
"Offset of field: ",
stringify!(DSAMPLE),
"::",
stringify!(status)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DSAMPLE>())).input as *const _ as usize },
78usize,
concat!(
"Offset of field: ",
stringify!(DSAMPLE),
"::",
stringify!(input)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DSAMPLE>())).buttons as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(DSAMPLE),
"::",
stringify!(buttons)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DSAMPLE>())).htype as *const _ as usize },
82usize,
concat!(
"Offset of field: ",
stringify!(DSAMPLE),
"::",
stringify!(htype)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DSAMPLE>())).hdata as *const _ as usize },
84usize,
concat!(
"Offset of field: ",
stringify!(DSAMPLE),
"::",
stringify!(hdata)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FSAMPLE_RAW {
pub struct_size: UINT32,
pub raw_pupil: [f32; 2usize],
pub raw_cr: [f32; 2usize],
pub pupil_area: UINT32,
pub cr_area: UINT32,
pub pupil_dimension: [UINT32; 2usize],
pub cr_dimension: [UINT32; 2usize],
pub window_position: [UINT32; 2usize],
pub pupil_cr: [f32; 2usize],
pub cr_area2: UINT32,
pub raw_cr2: [f32; 2usize],
}
#[test]
fn bindgen_test_layout_FSAMPLE_RAW() {
assert_eq!(
::std::mem::size_of::<FSAMPLE_RAW>(),
72usize,
concat!("Size of: ", stringify!(FSAMPLE_RAW))
);
assert_eq!(
::std::mem::align_of::<FSAMPLE_RAW>(),
4usize,
concat!("Alignment of ", stringify!(FSAMPLE_RAW))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FSAMPLE_RAW>())).struct_size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FSAMPLE_RAW),
"::",
stringify!(struct_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FSAMPLE_RAW>())).raw_pupil as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(FSAMPLE_RAW),
"::",
stringify!(raw_pupil)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FSAMPLE_RAW>())).raw_cr as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(FSAMPLE_RAW),
"::",
stringify!(raw_cr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FSAMPLE_RAW>())).pupil_area as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(FSAMPLE_RAW),
"::",
stringify!(pupil_area)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FSAMPLE_RAW>())).cr_area as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(FSAMPLE_RAW),
"::",
stringify!(cr_area)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FSAMPLE_RAW>())).pupil_dimension as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(FSAMPLE_RAW),
"::",
stringify!(pupil_dimension)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FSAMPLE_RAW>())).cr_dimension as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(FSAMPLE_RAW),
"::",
stringify!(cr_dimension)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FSAMPLE_RAW>())).window_position as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(FSAMPLE_RAW),
"::",
stringify!(window_position)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FSAMPLE_RAW>())).pupil_cr as *const _ as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(FSAMPLE_RAW),
"::",
stringify!(pupil_cr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FSAMPLE_RAW>())).cr_area2 as *const _ as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(FSAMPLE_RAW),
"::",
stringify!(cr_area2)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FSAMPLE_RAW>())).raw_cr2 as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(FSAMPLE_RAW),
"::",
stringify!(raw_cr2)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct IEVENT {
pub time: UINT32,
pub type_: INT16,
pub read: UINT16,
pub eye: INT16,
pub sttime: UINT32,
pub entime: UINT32,
pub hstx: INT16,
pub hsty: INT16,
pub gstx: INT16,
pub gsty: INT16,
pub sta: UINT16,
pub henx: INT16,
pub heny: INT16,
pub genx: INT16,
pub geny: INT16,
pub ena: UINT16,
pub havx: INT16,
pub havy: INT16,
pub gavx: INT16,
pub gavy: INT16,
pub ava: UINT16,
pub avel: INT16,
pub pvel: INT16,
pub svel: INT16,
pub evel: INT16,
pub supd_x: INT16,
pub eupd_x: INT16,
pub supd_y: INT16,
pub eupd_y: INT16,
pub status: UINT16,
}
#[test]
fn bindgen_test_layout_IEVENT() {
assert_eq!(
::std::mem::size_of::<IEVENT>(),
68usize,
concat!("Size of: ", stringify!(IEVENT))
);
assert_eq!(
::std::mem::align_of::<IEVENT>(),
4usize,
concat!("Alignment of ", stringify!(IEVENT))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IEVENT>())).time as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(IEVENT),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IEVENT>())).type_ as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(IEVENT),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IEVENT>())).read as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(IEVENT),
"::",
stringify!(read)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IEVENT>())).eye as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(IEVENT),
"::",
stringify!(eye)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IEVENT>())).sttime as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(IEVENT),
"::",
stringify!(sttime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IEVENT>())).entime as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(IEVENT),
"::",
stringify!(entime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IEVENT>())).hstx as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(IEVENT),
"::",
stringify!(hstx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IEVENT>())).hsty as *const _ as usize },
22usize,
concat!(
"Offset of field: ",
stringify!(IEVENT),
"::",
stringify!(hsty)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IEVENT>())).gstx as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(IEVENT),
"::",
stringify!(gstx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IEVENT>())).gsty as *const _ as usize },
26usize,
concat!(
"Offset of field: ",
stringify!(IEVENT),
"::",
stringify!(gsty)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IEVENT>())).sta as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(IEVENT),
"::",
stringify!(sta)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IEVENT>())).henx as *const _ as usize },
30usize,
concat!(
"Offset of field: ",
stringify!(IEVENT),
"::",
stringify!(henx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IEVENT>())).heny as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(IEVENT),
"::",
stringify!(heny)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IEVENT>())).genx as *const _ as usize },
34usize,
concat!(
"Offset of field: ",
stringify!(IEVENT),
"::",
stringify!(genx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IEVENT>())).geny as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(IEVENT),
"::",
stringify!(geny)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IEVENT>())).ena as *const _ as usize },
38usize,
concat!(
"Offset of field: ",
stringify!(IEVENT),
"::",
stringify!(ena)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IEVENT>())).havx as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(IEVENT),
"::",
stringify!(havx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IEVENT>())).havy as *const _ as usize },
42usize,
concat!(
"Offset of field: ",
stringify!(IEVENT),
"::",
stringify!(havy)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IEVENT>())).gavx as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(IEVENT),
"::",
stringify!(gavx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IEVENT>())).gavy as *const _ as usize },
46usize,
concat!(
"Offset of field: ",
stringify!(IEVENT),
"::",
stringify!(gavy)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IEVENT>())).ava as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(IEVENT),
"::",
stringify!(ava)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IEVENT>())).avel as *const _ as usize },
50usize,
concat!(
"Offset of field: ",
stringify!(IEVENT),
"::",
stringify!(avel)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IEVENT>())).pvel as *const _ as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(IEVENT),
"::",
stringify!(pvel)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IEVENT>())).svel as *const _ as usize },
54usize,
concat!(
"Offset of field: ",
stringify!(IEVENT),
"::",
stringify!(svel)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IEVENT>())).evel as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(IEVENT),
"::",
stringify!(evel)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IEVENT>())).supd_x as *const _ as usize },
58usize,
concat!(
"Offset of field: ",
stringify!(IEVENT),
"::",
stringify!(supd_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IEVENT>())).eupd_x as *const _ as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(IEVENT),
"::",
stringify!(eupd_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IEVENT>())).supd_y as *const _ as usize },
62usize,
concat!(
"Offset of field: ",
stringify!(IEVENT),
"::",
stringify!(supd_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IEVENT>())).eupd_y as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(IEVENT),
"::",
stringify!(eupd_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IEVENT>())).status as *const _ as usize },
66usize,
concat!(
"Offset of field: ",
stringify!(IEVENT),
"::",
stringify!(status)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct FEVENT {
pub time: UINT32,
pub type_: INT16,
pub read: UINT16,
pub eye: INT16,
pub sttime: UINT32,
pub entime: UINT32,
pub hstx: f32,
pub hsty: f32,
pub gstx: f32,
pub gsty: f32,
pub sta: f32,
pub henx: f32,
pub heny: f32,
pub genx: f32,
pub geny: f32,
pub ena: f32,
pub havx: f32,
pub havy: f32,
pub gavx: f32,
pub gavy: f32,
pub ava: f32,
pub avel: f32,
pub pvel: f32,
pub svel: f32,
pub evel: f32,
pub supd_x: f32,
pub eupd_x: f32,
pub supd_y: f32,
pub eupd_y: f32,
pub status: UINT16,
}
#[test]
fn bindgen_test_layout_FEVENT() {
assert_eq!(
::std::mem::size_of::<FEVENT>(),
116usize,
concat!("Size of: ", stringify!(FEVENT))
);
assert_eq!(
::std::mem::align_of::<FEVENT>(),
4usize,
concat!("Alignment of ", stringify!(FEVENT))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FEVENT>())).time as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(FEVENT),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FEVENT>())).type_ as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(FEVENT),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FEVENT>())).read as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(FEVENT),
"::",
stringify!(read)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FEVENT>())).eye as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(FEVENT),
"::",
stringify!(eye)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FEVENT>())).sttime as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(FEVENT),
"::",
stringify!(sttime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FEVENT>())).entime as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(FEVENT),
"::",
stringify!(entime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FEVENT>())).hstx as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(FEVENT),
"::",
stringify!(hstx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FEVENT>())).hsty as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(FEVENT),
"::",
stringify!(hsty)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FEVENT>())).gstx as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(FEVENT),
"::",
stringify!(gstx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FEVENT>())).gsty as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(FEVENT),
"::",
stringify!(gsty)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FEVENT>())).sta as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(FEVENT),
"::",
stringify!(sta)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FEVENT>())).henx as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(FEVENT),
"::",
stringify!(henx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FEVENT>())).heny as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(FEVENT),
"::",
stringify!(heny)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FEVENT>())).genx as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(FEVENT),
"::",
stringify!(genx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FEVENT>())).geny as *const _ as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(FEVENT),
"::",
stringify!(geny)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FEVENT>())).ena as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(FEVENT),
"::",
stringify!(ena)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FEVENT>())).havx as *const _ as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(FEVENT),
"::",
stringify!(havx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FEVENT>())).havy as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(FEVENT),
"::",
stringify!(havy)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FEVENT>())).gavx as *const _ as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(FEVENT),
"::",
stringify!(gavx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FEVENT>())).gavy as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(FEVENT),
"::",
stringify!(gavy)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FEVENT>())).ava as *const _ as usize },
76usize,
concat!(
"Offset of field: ",
stringify!(FEVENT),
"::",
stringify!(ava)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FEVENT>())).avel as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(FEVENT),
"::",
stringify!(avel)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FEVENT>())).pvel as *const _ as usize },
84usize,
concat!(
"Offset of field: ",
stringify!(FEVENT),
"::",
stringify!(pvel)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FEVENT>())).svel as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(FEVENT),
"::",
stringify!(svel)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FEVENT>())).evel as *const _ as usize },
92usize,
concat!(
"Offset of field: ",
stringify!(FEVENT),
"::",
stringify!(evel)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FEVENT>())).supd_x as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(FEVENT),
"::",
stringify!(supd_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FEVENT>())).eupd_x as *const _ as usize },
100usize,
concat!(
"Offset of field: ",
stringify!(FEVENT),
"::",
stringify!(eupd_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FEVENT>())).supd_y as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(FEVENT),
"::",
stringify!(supd_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FEVENT>())).eupd_y as *const _ as usize },
108usize,
concat!(
"Offset of field: ",
stringify!(FEVENT),
"::",
stringify!(eupd_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<FEVENT>())).status as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(FEVENT),
"::",
stringify!(status)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct DEVENT {
pub time: f64,
pub type_: INT16,
pub read: UINT16,
pub eye: INT16,
pub sttime: f64,
pub entime: f64,
pub hstx: f32,
pub hsty: f32,
pub gstx: f32,
pub gsty: f32,
pub sta: f32,
pub henx: f32,
pub heny: f32,
pub genx: f32,
pub geny: f32,
pub ena: f32,
pub havx: f32,
pub havy: f32,
pub gavx: f32,
pub gavy: f32,
pub ava: f32,
pub avel: f32,
pub pvel: f32,
pub svel: f32,
pub evel: f32,
pub supd_x: f32,
pub eupd_x: f32,
pub supd_y: f32,
pub eupd_y: f32,
pub status: UINT16,
}
#[test]
fn bindgen_test_layout_DEVENT() {
assert_eq!(
::std::mem::size_of::<DEVENT>(),
128usize,
concat!("Size of: ", stringify!(DEVENT))
);
assert_eq!(
::std::mem::align_of::<DEVENT>(),
8usize,
concat!("Alignment of ", stringify!(DEVENT))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DEVENT>())).time as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(DEVENT),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DEVENT>())).type_ as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(DEVENT),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DEVENT>())).read as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(DEVENT),
"::",
stringify!(read)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DEVENT>())).eye as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(DEVENT),
"::",
stringify!(eye)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DEVENT>())).sttime as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(DEVENT),
"::",
stringify!(sttime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DEVENT>())).entime as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(DEVENT),
"::",
stringify!(entime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DEVENT>())).hstx as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(DEVENT),
"::",
stringify!(hstx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DEVENT>())).hsty as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(DEVENT),
"::",
stringify!(hsty)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DEVENT>())).gstx as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(DEVENT),
"::",
stringify!(gstx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DEVENT>())).gsty as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(DEVENT),
"::",
stringify!(gsty)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DEVENT>())).sta as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(DEVENT),
"::",
stringify!(sta)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DEVENT>())).henx as *const _ as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(DEVENT),
"::",
stringify!(henx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DEVENT>())).heny as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(DEVENT),
"::",
stringify!(heny)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DEVENT>())).genx as *const _ as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(DEVENT),
"::",
stringify!(genx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DEVENT>())).geny as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(DEVENT),
"::",
stringify!(geny)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DEVENT>())).ena as *const _ as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(DEVENT),
"::",
stringify!(ena)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DEVENT>())).havx as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(DEVENT),
"::",
stringify!(havx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DEVENT>())).havy as *const _ as usize },
76usize,
concat!(
"Offset of field: ",
stringify!(DEVENT),
"::",
stringify!(havy)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DEVENT>())).gavx as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(DEVENT),
"::",
stringify!(gavx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DEVENT>())).gavy as *const _ as usize },
84usize,
concat!(
"Offset of field: ",
stringify!(DEVENT),
"::",
stringify!(gavy)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DEVENT>())).ava as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(DEVENT),
"::",
stringify!(ava)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DEVENT>())).avel as *const _ as usize },
92usize,
concat!(
"Offset of field: ",
stringify!(DEVENT),
"::",
stringify!(avel)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DEVENT>())).pvel as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(DEVENT),
"::",
stringify!(pvel)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DEVENT>())).svel as *const _ as usize },
100usize,
concat!(
"Offset of field: ",
stringify!(DEVENT),
"::",
stringify!(svel)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DEVENT>())).evel as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(DEVENT),
"::",
stringify!(evel)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DEVENT>())).supd_x as *const _ as usize },
108usize,
concat!(
"Offset of field: ",
stringify!(DEVENT),
"::",
stringify!(supd_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DEVENT>())).eupd_x as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(DEVENT),
"::",
stringify!(eupd_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DEVENT>())).supd_y as *const _ as usize },
116usize,
concat!(
"Offset of field: ",
stringify!(DEVENT),
"::",
stringify!(supd_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DEVENT>())).eupd_y as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(DEVENT),
"::",
stringify!(eupd_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DEVENT>())).status as *const _ as usize },
124usize,
concat!(
"Offset of field: ",
stringify!(DEVENT),
"::",
stringify!(status)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct IMESSAGE {
pub time: UINT32,
pub type_: INT16,
pub length: UINT16,
pub text: [byte; 260usize],
}
#[test]
fn bindgen_test_layout_IMESSAGE() {
assert_eq!(
::std::mem::size_of::<IMESSAGE>(),
268usize,
concat!("Size of: ", stringify!(IMESSAGE))
);
assert_eq!(
::std::mem::align_of::<IMESSAGE>(),
4usize,
concat!("Alignment of ", stringify!(IMESSAGE))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IMESSAGE>())).time as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(IMESSAGE),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IMESSAGE>())).type_ as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(IMESSAGE),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IMESSAGE>())).length as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(IMESSAGE),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IMESSAGE>())).text as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(IMESSAGE),
"::",
stringify!(text)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct DMESSAGE {
pub time: f64,
pub type_: INT16,
pub length: UINT16,
pub text: [byte; 260usize],
}
#[test]
fn bindgen_test_layout_DMESSAGE() {
assert_eq!(
::std::mem::size_of::<DMESSAGE>(),
272usize,
concat!("Size of: ", stringify!(DMESSAGE))
);
assert_eq!(
::std::mem::align_of::<DMESSAGE>(),
8usize,
concat!("Alignment of ", stringify!(DMESSAGE))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DMESSAGE>())).time as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(DMESSAGE),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DMESSAGE>())).type_ as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(DMESSAGE),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DMESSAGE>())).length as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(DMESSAGE),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DMESSAGE>())).text as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(DMESSAGE),
"::",
stringify!(text)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct IOEVENT {
pub time: UINT32,
pub type_: INT16,
pub data: UINT16,
}
#[test]
fn bindgen_test_layout_IOEVENT() {
assert_eq!(
::std::mem::size_of::<IOEVENT>(),
8usize,
concat!("Size of: ", stringify!(IOEVENT))
);
assert_eq!(
::std::mem::align_of::<IOEVENT>(),
4usize,
concat!("Alignment of ", stringify!(IOEVENT))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IOEVENT>())).time as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(IOEVENT),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IOEVENT>())).type_ as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(IOEVENT),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IOEVENT>())).data as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(IOEVENT),
"::",
stringify!(data)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct DIOEVENT {
pub time: f64,
pub type_: INT16,
pub data: UINT16,
}
#[test]
fn bindgen_test_layout_DIOEVENT() {
assert_eq!(
::std::mem::size_of::<DIOEVENT>(),
16usize,
concat!("Size of: ", stringify!(DIOEVENT))
);
assert_eq!(
::std::mem::align_of::<DIOEVENT>(),
8usize,
concat!("Alignment of ", stringify!(DIOEVENT))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DIOEVENT>())).time as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(DIOEVENT),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DIOEVENT>())).type_ as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(DIOEVENT),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DIOEVENT>())).data as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(DIOEVENT),
"::",
stringify!(data)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union ALL_DATA {
pub ie: IEVENT,
pub im: IMESSAGE,
pub io: IOEVENT,
pub is: ISAMPLE,
_bindgen_union_align: [u32; 67usize],
}
#[test]
fn bindgen_test_layout_ALL_DATA() {
assert_eq!(
::std::mem::size_of::<ALL_DATA>(),
268usize,
concat!("Size of: ", stringify!(ALL_DATA))
);
assert_eq!(
::std::mem::align_of::<ALL_DATA>(),
4usize,
concat!("Alignment of ", stringify!(ALL_DATA))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ALL_DATA>())).ie as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ALL_DATA),
"::",
stringify!(ie)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ALL_DATA>())).im as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ALL_DATA),
"::",
stringify!(im)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ALL_DATA>())).io as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ALL_DATA),
"::",
stringify!(io)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ALL_DATA>())).is as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ALL_DATA),
"::",
stringify!(is)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union ALLF_DATA {
pub fe: FEVENT,
pub im: IMESSAGE,
pub io: IOEVENT,
pub fs: FSAMPLE,
_bindgen_union_align: [u32; 67usize],
}
#[test]
fn bindgen_test_layout_ALLF_DATA() {
assert_eq!(
::std::mem::size_of::<ALLF_DATA>(),
268usize,
concat!("Size of: ", stringify!(ALLF_DATA))
);
assert_eq!(
::std::mem::align_of::<ALLF_DATA>(),
4usize,
concat!("Alignment of ", stringify!(ALLF_DATA))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ALLF_DATA>())).fe as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ALLF_DATA),
"::",
stringify!(fe)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ALLF_DATA>())).im as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ALLF_DATA),
"::",
stringify!(im)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ALLF_DATA>())).io as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ALLF_DATA),
"::",
stringify!(io)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ALLF_DATA>())).fs as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ALLF_DATA),
"::",
stringify!(fs)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union ALLD_DATA {
pub fe: DEVENT,
pub im: DMESSAGE,
pub io: DIOEVENT,
pub fs: DSAMPLE,
_bindgen_union_align: [u64; 34usize],
}
#[test]
fn bindgen_test_layout_ALLD_DATA() {
assert_eq!(
::std::mem::size_of::<ALLD_DATA>(),
272usize,
concat!("Size of: ", stringify!(ALLD_DATA))
);
assert_eq!(
::std::mem::align_of::<ALLD_DATA>(),
8usize,
concat!("Alignment of ", stringify!(ALLD_DATA))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ALLD_DATA>())).fe as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ALLD_DATA),
"::",
stringify!(fe)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ALLD_DATA>())).im as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ALLD_DATA),
"::",
stringify!(im)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ALLD_DATA>())).io as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ALLD_DATA),
"::",
stringify!(io)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ALLD_DATA>())).fs as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ALLD_DATA),
"::",
stringify!(fs)
)
);
}
pub type ELINKADDR = [byte; 16usize];
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ELINKNODE {
pub addr: ELINKADDR,
pub name: [::std::os::raw::c_char; 40usize],
}
#[test]
fn bindgen_test_layout_ELINKNODE() {
assert_eq!(
::std::mem::size_of::<ELINKNODE>(),
56usize,
concat!("Size of: ", stringify!(ELINKNODE))
);
assert_eq!(
::std::mem::align_of::<ELINKNODE>(),
1usize,
concat!("Alignment of ", stringify!(ELINKNODE))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ELINKNODE>())).addr as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ELINKNODE),
"::",
stringify!(addr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ELINKNODE>())).name as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ELINKNODE),
"::",
stringify!(name)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct ILINKDATA {
pub time: UINT32,
pub version: UINT32,
pub samrate: UINT16,
pub samdiv: UINT16,
pub prescaler: UINT16,
pub vprescaler: UINT16,
pub pprescaler: UINT16,
pub hprescaler: UINT16,
pub sample_data: UINT16,
pub event_data: UINT16,
pub event_types: UINT16,
pub in_sample_block: byte,
pub in_event_block: byte,
pub have_left_eye: byte,
pub have_right_eye: byte,
pub last_data_gap_types: UINT16,
pub last_data_buffer_type: UINT16,
pub last_data_buffer_size: UINT16,
pub control_read: UINT16,
pub first_in_block: UINT16,
pub last_data_item_time: UINT32,
pub last_data_item_type: UINT16,
pub last_data_item_contents: UINT16,
pub last_data_item: ALL_DATA,
pub block_number: UINT32,
pub block_sample: UINT32,
pub block_event: UINT32,
pub last_resx: UINT16,
pub last_resy: UINT16,
pub last_pupil: [UINT16; 2usize],
pub last_status: UINT16,
pub queued_samples: UINT16,
pub queued_events: UINT16,
pub queue_size: UINT16,
pub queue_free: UINT16,
pub last_rcve_time: UINT32,
pub samples_on: byte,
pub events_on: byte,
pub packet_flags: UINT16,
pub link_flags: UINT16,
pub state_flags: UINT16,
pub link_dstatus: byte,
pub link_pendcmd: byte,
pub reserved: UINT16,
pub our_name: [::std::os::raw::c_char; 40usize],
pub our_address: ELINKADDR,
pub eye_name: [::std::os::raw::c_char; 40usize],
pub eye_address: ELINKADDR,
pub ebroadcast_address: ELINKADDR,
pub rbroadcast_address: ELINKADDR,
pub polling_remotes: UINT16,
pub poll_responses: UINT16,
pub nodes: [ELINKNODE; 4usize],
}
#[test]
fn bindgen_test_layout_ILINKDATA() {
assert_eq!(
::std::mem::size_of::<ILINKDATA>(),
736usize,
concat!("Size of: ", stringify!(ILINKDATA))
);
assert_eq!(
::std::mem::align_of::<ILINKDATA>(),
4usize,
concat!("Alignment of ", stringify!(ILINKDATA))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).time as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(time)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).version as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(version)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).samrate as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(samrate)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).samdiv as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(samdiv)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).prescaler as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(prescaler)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).vprescaler as *const _ as usize },
14usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(vprescaler)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).pprescaler as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(pprescaler)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).hprescaler as *const _ as usize },
18usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(hprescaler)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).sample_data as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(sample_data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).event_data as *const _ as usize },
22usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(event_data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).event_types as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(event_types)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).in_sample_block as *const _ as usize },
26usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(in_sample_block)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).in_event_block as *const _ as usize },
27usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(in_event_block)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).have_left_eye as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(have_left_eye)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).have_right_eye as *const _ as usize },
29usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(have_right_eye)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).last_data_gap_types as *const _ as usize },
30usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(last_data_gap_types)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).last_data_buffer_type as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(last_data_buffer_type)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).last_data_buffer_size as *const _ as usize },
34usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(last_data_buffer_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).control_read as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(control_read)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).first_in_block as *const _ as usize },
38usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(first_in_block)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).last_data_item_time as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(last_data_item_time)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).last_data_item_type as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(last_data_item_type)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<ILINKDATA>())).last_data_item_contents as *const _ as usize
},
46usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(last_data_item_contents)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).last_data_item as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(last_data_item)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).block_number as *const _ as usize },
316usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(block_number)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).block_sample as *const _ as usize },
320usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(block_sample)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).block_event as *const _ as usize },
324usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(block_event)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).last_resx as *const _ as usize },
328usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(last_resx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).last_resy as *const _ as usize },
330usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(last_resy)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).last_pupil as *const _ as usize },
332usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(last_pupil)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).last_status as *const _ as usize },
336usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(last_status)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).queued_samples as *const _ as usize },
338usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(queued_samples)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).queued_events as *const _ as usize },
340usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(queued_events)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).queue_size as *const _ as usize },
342usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(queue_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).queue_free as *const _ as usize },
344usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(queue_free)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).last_rcve_time as *const _ as usize },
348usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(last_rcve_time)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).samples_on as *const _ as usize },
352usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(samples_on)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).events_on as *const _ as usize },
353usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(events_on)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).packet_flags as *const _ as usize },
354usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(packet_flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).link_flags as *const _ as usize },
356usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(link_flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).state_flags as *const _ as usize },
358usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(state_flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).link_dstatus as *const _ as usize },
360usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(link_dstatus)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).link_pendcmd as *const _ as usize },
361usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(link_pendcmd)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).reserved as *const _ as usize },
362usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(reserved)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).our_name as *const _ as usize },
364usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(our_name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).our_address as *const _ as usize },
404usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(our_address)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).eye_name as *const _ as usize },
420usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(eye_name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).eye_address as *const _ as usize },
460usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(eye_address)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).ebroadcast_address as *const _ as usize },
476usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(ebroadcast_address)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).rbroadcast_address as *const _ as usize },
492usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(rbroadcast_address)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).polling_remotes as *const _ as usize },
508usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(polling_remotes)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).poll_responses as *const _ as usize },
510usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(poll_responses)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<ILINKDATA>())).nodes as *const _ as usize },
512usize,
concat!(
"Offset of field: ",
stringify!(ILINKDATA),
"::",
stringify!(nodes)
)
);
}
extern "C" {
pub fn open_eyelink_system(bufsize: UINT16, options: *mut ::std::os::raw::c_char) -> UINT16;
}
extern "C" {
pub fn eyelink_set_name(name: *mut ::std::os::raw::c_char);
}
extern "C" {
pub fn close_eyelink_system();
}
extern "C" {
pub fn current_time() -> UINT32;
}
extern "C" {
pub fn current_micro(m: *mut MICRO) -> UINT32;
}
extern "C" {
pub fn current_usec() -> UINT32;
}
extern "C" {
pub fn msec_delay(n: UINT32);
}
extern "C" {
pub fn current_double_usec() -> f64;
}
extern "C" {
pub static mut eye_broadcast_address: ELINKADDR;
}
extern "C" {
pub static mut rem_broadcast_address: ELINKADDR;
}
extern "C" {
pub static mut our_address: ELINKADDR;
}
extern "C" {
pub fn eyelink_open_node(node: *mut byte, busytest: INT16) -> INT16;
}
extern "C" {
pub fn eyelink_open() -> INT16;
}
extern "C" {
pub fn eyelink_broadcast_open() -> INT16;
}
extern "C" {
pub fn eyelink_dummy_open() -> INT16;
}
extern "C" {
pub fn eyelink_close(send_msg: INT16) -> INT16;
}
extern "C" {
pub fn eyelink_reset_clock(enable: INT16) -> INT16;
}
extern "C" {
pub fn eyelink_is_connected() -> INT16;
}
extern "C" {
pub fn eyelink_quiet_mode(mode: INT16) -> INT16;
}
extern "C" {
pub fn eyelink_poll_trackers() -> INT16;
}
extern "C" {
pub fn eyelink_poll_remotes() -> INT16;
}
extern "C" {
pub fn eyelink_poll_responses() -> INT16;
}
extern "C" {
pub fn eyelink_get_node(resp: INT16, data: *mut ::std::os::raw::c_void) -> INT16;
}
extern "C" {
pub fn eyelink_node_send(
node: *mut byte,
data: *mut ::std::os::raw::c_void,
dsize: UINT16,
) -> INT16;
}
extern "C" {
pub fn eyelink_node_receive(node: *mut byte, data: *mut ::std::os::raw::c_void) -> INT16;
}
extern "C" {
pub fn eyelink_send_command(text: *mut ::std::os::raw::c_char) -> INT16;
}
extern "C" {
pub fn eyelink_command_result() -> INT16;
}
extern "C" {
pub fn eyelink_timed_command(msec: UINT32, text: *mut ::std::os::raw::c_char) -> INT16;
}
extern "C" {
pub fn eyelink_last_message(buf: *mut ::std::os::raw::c_char) -> INT16;
}
extern "C" {
pub fn eyelink_send_message(msg: *mut ::std::os::raw::c_char) -> INT16;
}
extern "C" {
pub fn eyelink_node_send_message(node: *mut byte, msg: *mut ::std::os::raw::c_char) -> INT16;
}
extern "C" {
pub fn eyelink_send_message_ex(exectime: UINT32, msg: *mut ::std::os::raw::c_char) -> INT16;
}
extern "C" {
pub fn eyelink_node_send_message_ex(
exectime: UINT32,
node: *mut byte,
msg: *mut ::std::os::raw::c_char,
) -> INT16;
}
extern "C" {
pub fn eyelink_read_request(text: *mut ::std::os::raw::c_char) -> INT16;
}
extern "C" {
pub fn eyelink_read_reply(buf: *mut ::std::os::raw::c_char) -> INT16;
}
extern "C" {
pub fn eyelink_request_time() -> UINT32;
}
extern "C" {
pub fn eyelink_node_request_time(node: *mut byte) -> UINT32;
}
extern "C" {
pub fn eyelink_read_time() -> UINT32;
}
extern "C" {
pub fn eyelink_abort() -> INT16;
}
extern "C" {
pub fn eyelink_start_setup() -> INT16;
}
extern "C" {
pub fn eyelink_in_setup() -> INT16;
}
extern "C" {
pub fn eyelink_target_check(x: *mut INT16, y: *mut INT16) -> INT16;
}
extern "C" {
pub fn eyelink_target_checkf(x: *mut f32, y: *mut f32) -> INT16;
}
extern "C" {
pub fn eyelink_accept_trigger() -> INT16;
}
extern "C" {
pub fn eyelink_driftcorr_start(x: INT16, y: INT16) -> INT16;
}
extern "C" {
pub fn eyelink_driftcorr_startf(x: f32, y: f32) -> INT16;
}
extern "C" {
pub fn eyelink_cal_result() -> INT16;
}
extern "C" {
pub fn eyelink_apply_driftcorr() -> INT16;
}
extern "C" {
pub fn eyelink_cal_message(msg: *mut ::std::os::raw::c_char) -> INT16;
}
extern "C" {
pub fn eyelink_current_mode() -> INT16;
}
extern "C" {
pub fn eyelink_tracker_mode() -> INT16;
}
extern "C" {
pub fn eyelink_wait_for_mode_ready(maxwait: UINT32) -> INT16;
}
extern "C" {
pub fn eyelink_user_menu_selection() -> INT16;
}
extern "C" {
pub fn eyelink_position_prescaler() -> INT16;
}
extern "C" {
pub fn eyelink_reset_data(clear: INT16) -> INT16;
}
extern "C" {
pub fn eyelink_data_status() -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn eyelink_in_data_block(samples: INT16, events: INT16) -> INT16;
}
extern "C" {
pub fn eyelink_wait_for_block_start(maxwait: UINT32, samples: INT16, events: INT16) -> INT16;
}
extern "C" {
pub fn eyelink_get_next_data(buf: *mut ::std::os::raw::c_void) -> INT16;
}
extern "C" {
pub fn eyelink_get_last_data(buf: *mut ::std::os::raw::c_void) -> INT16;
}
extern "C" {
pub fn eyelink_newest_sample(buf: *mut ::std::os::raw::c_void) -> INT16;
}
extern "C" {
pub fn eyelink_get_float_data(buf: *mut ::std::os::raw::c_void) -> INT16;
}
extern "C" {
pub fn eyelink_get_double_data(buf: *mut ::std::os::raw::c_void) -> INT16;
}
extern "C" {
pub fn eyelink_newest_float_sample(buf: *mut ::std::os::raw::c_void) -> INT16;
}
extern "C" {
pub fn eyelink_newest_double_sample(buf: *mut ::std::os::raw::c_void) -> INT16;
}
extern "C" {
pub fn eyelink_eye_available() -> INT16;
}
extern "C" {
pub fn eyelink_sample_data_flags() -> UINT16;
}
extern "C" {
pub fn eyelink_event_data_flags() -> UINT16;
}
extern "C" {
pub fn eyelink_event_type_flags() -> UINT16;
}
extern "C" {
pub fn eyelink_data_count(samples: INT16, events: INT16) -> INT16;
}
extern "C" {
pub fn eyelink_wait_for_data(maxwait: UINT32, samples: INT16, events: INT16) -> INT16;
}
extern "C" {
pub fn eyelink_get_sample(sample: *mut ::std::os::raw::c_void) -> INT16;
}
extern "C" {
pub fn eyelink_data_switch(flags: UINT16) -> INT16;
}
extern "C" {
pub fn eyelink_data_start(flags: UINT16, lock: INT16) -> INT16;
}
extern "C" {
pub fn eyelink_data_stop() -> INT16;
}
extern "C" {
pub fn eyelink_playback_start() -> INT16;
}
extern "C" {
pub fn eyelink_playback_stop() -> INT16;
}
extern "C" {
pub fn eyelink_request_image(type_: INT16, xsize: INT16, ysize: INT16) -> INT16;
}
extern "C" {
pub fn eyelink_image_status() -> INT16;
}
extern "C" {
pub fn eyelink_abort_image();
}
extern "C" {
pub fn eyelink_image_data(xsize: *mut INT16, ysize: *mut INT16, type_: *mut INT16) -> INT16;
}
extern "C" {
pub fn eyelink_get_line(buf: *mut ::std::os::raw::c_void) -> INT16;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct IMAGE_PALDATA {
pub palette_id: byte,
pub ncolors: byte,
pub camera: byte,
pub threshold: byte,
pub flags: UINT16,
pub image_number: UINT16,
pub extra: [byte; 10usize],
pub rfirst_color: byte,
pub rfirst_brite: byte,
pub rlast_color: byte,
pub rlast_brite: byte,
pub nspecial: INT16,
pub spcolors: [IMAGE_PALDATA__bindgen_ty_1; 6usize],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct IMAGE_PALDATA__bindgen_ty_1 {
pub index: byte,
pub r: byte,
pub g: byte,
pub b: byte,
}
#[test]
fn bindgen_test_layout_IMAGE_PALDATA__bindgen_ty_1() {
assert_eq!(
::std::mem::size_of::<IMAGE_PALDATA__bindgen_ty_1>(),
4usize,
concat!("Size of: ", stringify!(IMAGE_PALDATA__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<IMAGE_PALDATA__bindgen_ty_1>(),
1usize,
concat!("Alignment of ", stringify!(IMAGE_PALDATA__bindgen_ty_1))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<IMAGE_PALDATA__bindgen_ty_1>())).index as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(IMAGE_PALDATA__bindgen_ty_1),
"::",
stringify!(index)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IMAGE_PALDATA__bindgen_ty_1>())).r as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(IMAGE_PALDATA__bindgen_ty_1),
"::",
stringify!(r)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IMAGE_PALDATA__bindgen_ty_1>())).g as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(IMAGE_PALDATA__bindgen_ty_1),
"::",
stringify!(g)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IMAGE_PALDATA__bindgen_ty_1>())).b as *const _ as usize },
3usize,
concat!(
"Offset of field: ",
stringify!(IMAGE_PALDATA__bindgen_ty_1),
"::",
stringify!(b)
)
);
}
#[test]
fn bindgen_test_layout_IMAGE_PALDATA() {
assert_eq!(
::std::mem::size_of::<IMAGE_PALDATA>(),
48usize,
concat!("Size of: ", stringify!(IMAGE_PALDATA))
);
assert_eq!(
::std::mem::align_of::<IMAGE_PALDATA>(),
2usize,
concat!("Alignment of ", stringify!(IMAGE_PALDATA))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IMAGE_PALDATA>())).palette_id as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(IMAGE_PALDATA),
"::",
stringify!(palette_id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IMAGE_PALDATA>())).ncolors as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(IMAGE_PALDATA),
"::",
stringify!(ncolors)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IMAGE_PALDATA>())).camera as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(IMAGE_PALDATA),
"::",
stringify!(camera)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IMAGE_PALDATA>())).threshold as *const _ as usize },
3usize,
concat!(
"Offset of field: ",
stringify!(IMAGE_PALDATA),
"::",
stringify!(threshold)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IMAGE_PALDATA>())).flags as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(IMAGE_PALDATA),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IMAGE_PALDATA>())).image_number as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(IMAGE_PALDATA),
"::",
stringify!(image_number)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IMAGE_PALDATA>())).extra as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(IMAGE_PALDATA),
"::",
stringify!(extra)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IMAGE_PALDATA>())).rfirst_color as *const _ as usize },
18usize,
concat!(
"Offset of field: ",
stringify!(IMAGE_PALDATA),
"::",
stringify!(rfirst_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IMAGE_PALDATA>())).rfirst_brite as *const _ as usize },
19usize,
concat!(
"Offset of field: ",
stringify!(IMAGE_PALDATA),
"::",
stringify!(rfirst_brite)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IMAGE_PALDATA>())).rlast_color as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(IMAGE_PALDATA),
"::",
stringify!(rlast_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IMAGE_PALDATA>())).rlast_brite as *const _ as usize },
21usize,
concat!(
"Offset of field: ",
stringify!(IMAGE_PALDATA),
"::",
stringify!(rlast_brite)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IMAGE_PALDATA>())).nspecial as *const _ as usize },
22usize,
concat!(
"Offset of field: ",
stringify!(IMAGE_PALDATA),
"::",
stringify!(nspecial)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<IMAGE_PALDATA>())).spcolors as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(IMAGE_PALDATA),
"::",
stringify!(spcolors)
)
);
}
extern "C" {
pub fn eyelink_get_palette(pal: *mut ::std::os::raw::c_void) -> INT16;
}
extern "C" {
pub fn eyelink_read_keybutton(
mods: *mut INT16,
state: *mut INT16,
kcode: *mut UINT16,
time: *mut UINT32,
) -> UINT16;
}
extern "C" {
pub fn eyelink_send_keybutton(code: UINT16, mods: UINT16, state: INT16) -> INT16;
}
extern "C" {
pub fn eyelink_button_states() -> UINT16;
}
extern "C" {
pub fn eyelink_last_button_states(time: *mut UINT32) -> UINT16;
}
extern "C" {
pub fn eyelink_last_button_press(time: *mut UINT32) -> UINT16;
}
extern "C" {
pub fn eyelink_flush_keybuttons(enable_buttons: INT16) -> INT16;
}
extern "C" {
pub fn eyelink_request_file_read(src: *mut ::std::os::raw::c_char) -> INT16;
}
extern "C" {
pub fn eyelink_get_file_block(buf: *mut ::std::os::raw::c_void, offset: *mut INT32) -> INT16;
}
extern "C" {
pub fn eyelink_request_file_block(offset: UINT32) -> INT16;
}
extern "C" {
pub fn eyelink_end_file_transfer() -> INT16;
}
extern "C" {
pub fn eyelink_get_tracker_version(c: *mut ::std::os::raw::c_char) -> INT16;
}
extern "C" {
pub fn eyelink2_mode_data(
sample_rate: *mut INT16,
crmode: *mut INT16,
file_filter: *mut INT16,
link_filter: *mut INT16,
) -> INT16;
}
extern "C" {
pub fn eyelink_mode_data(
sample_rate: *mut INT16,
crmode: *mut INT16,
file_filter: *mut INT16,
link_filter: *mut INT16,
) -> INT16;
}
extern "C" {
pub fn eyelink_bitmap_packet(
data: *mut ::std::os::raw::c_void,
size: UINT16,
seq: UINT16,
) -> INT16;
}
extern "C" {
pub fn eyelink_bitmap_ack_count() -> INT16;
}
extern "C" {
pub fn eyelink_set_tracker_node(node: *mut byte);
}
extern "C" {
pub fn eyelink_tracker_double_usec() -> f64;
}
extern "C" {
pub fn eyelink_tracker_msec() -> UINT32;
}
extern "C" {
pub fn eyelink_double_usec_offset() -> f64;
}
extern "C" {
pub fn eyelink_msec_offset() -> UINT32;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct DISPLAYINFO {
pub left: INT32,
pub top: INT32,
pub right: INT32,
pub bottom: INT32,
pub width: INT32,
pub height: INT32,
pub bits: INT32,
pub palsize: INT32,
pub palrsvd: INT32,
pub pages: INT32,
pub refresh: f32,
pub winnt: INT32,
}
#[test]
fn bindgen_test_layout_DISPLAYINFO() {
assert_eq!(
::std::mem::size_of::<DISPLAYINFO>(),
48usize,
concat!("Size of: ", stringify!(DISPLAYINFO))
);
assert_eq!(
::std::mem::align_of::<DISPLAYINFO>(),
4usize,
concat!("Alignment of ", stringify!(DISPLAYINFO))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DISPLAYINFO>())).left as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(DISPLAYINFO),
"::",
stringify!(left)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DISPLAYINFO>())).top as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(DISPLAYINFO),
"::",
stringify!(top)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DISPLAYINFO>())).right as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(DISPLAYINFO),
"::",
stringify!(right)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DISPLAYINFO>())).bottom as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(DISPLAYINFO),
"::",
stringify!(bottom)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DISPLAYINFO>())).width as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(DISPLAYINFO),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DISPLAYINFO>())).height as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(DISPLAYINFO),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DISPLAYINFO>())).bits as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(DISPLAYINFO),
"::",
stringify!(bits)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DISPLAYINFO>())).palsize as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(DISPLAYINFO),
"::",
stringify!(palsize)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DISPLAYINFO>())).palrsvd as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(DISPLAYINFO),
"::",
stringify!(palrsvd)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DISPLAYINFO>())).pages as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(DISPLAYINFO),
"::",
stringify!(pages)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DISPLAYINFO>())).refresh as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(DISPLAYINFO),
"::",
stringify!(refresh)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<DISPLAYINFO>())).winnt as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(DISPLAYINFO),
"::",
stringify!(winnt)
)
);
}
extern "C" {
pub fn open_eyelink_connection(mode: INT16) -> INT16;
}
extern "C" {
pub fn close_eyelink_connection();
}
extern "C" {
pub fn set_eyelink_address(addr: *mut ::std::os::raw::c_char) -> INT16;
}
extern "C" {
pub fn set_application_priority(priority: INT32) -> INT32;
}
extern "C" {
pub fn message_pump() -> INT16;
}
extern "C" {
pub fn key_message_pump() -> INT16;
}
extern "C" {
pub fn pump_delay(delay: UINT32);
}
extern "C" {
pub fn flush_getkey_queue();
}
extern "C" {
pub fn read_getkey_queue() -> UINT16;
}
extern "C" {
pub fn echo_key() -> UINT16;
}
extern "C" {
pub fn getkey() -> UINT16;
}
extern "C" {
pub fn getkey_with_mod(unicode: *mut UINT16) -> UINT32;
}
extern "C" {
pub fn eyecmd_printf(fmt: *const ::std::os::raw::c_char, ...) -> INT16;
}
extern "C" {
pub fn eyemsg_printf(fmt: *const ::std::os::raw::c_char, ...) -> INT16;
}
extern "C" {
pub fn eyemsg_printf_ex(exectime: UINT32, fmt: *const ::std::os::raw::c_char, ...) -> INT16;
}
extern "C" {
pub fn start_recording(
file_samples: INT16,
file_events: INT16,
link_samples: INT16,
link_events: INT16,
) -> INT16;
}
extern "C" {
pub fn check_recording() -> INT16;
}
extern "C" {
pub fn stop_recording();
}
extern "C" {
pub fn set_offline_mode();
}
extern "C" {
pub fn check_record_exit() -> INT16;
}
extern "C" {
pub fn exit_calibration();
}
extern "C" {
pub fn do_tracker_setup() -> INT16;
}
extern "C" {
pub fn do_drift_correct(x: INT16, y: INT16, draw: INT16, allow_setup: INT16) -> INT16;
}
extern "C" {
pub fn do_drift_correctf(x: f32, y: f32, draw: INT16, allow_setup: INT16) -> INT16;
}
extern "C" {
pub fn target_mode_display() -> INT16;
}
extern "C" {
pub fn image_mode_display() -> INT16;
}
extern "C" {
pub fn alert_printf(fmt: *mut ::std::os::raw::c_char, ...);
}
extern "C" {
pub fn receive_data_file(
src: *mut ::std::os::raw::c_char,
dest: *mut ::std::os::raw::c_char,
dest_is_path: INT16,
) -> INT32;
}
extern "C" {
pub fn receive_data_file_feedback(
src: *mut ::std::os::raw::c_char,
dest: *mut ::std::os::raw::c_char,
dest_is_path: INT16,
progress: ::std::option::Option<
unsafe extern "C" fn(size: ::std::os::raw::c_uint, received: ::std::os::raw::c_uint),
>,
) -> INT32;
}
extern "C" {
pub fn receive_data_file_feedback_v2(
src: *mut ::std::os::raw::c_char,
dest: *mut ::std::os::raw::c_char,
dest_is_path: INT16,
progress: ::std::option::Option<
unsafe extern "C" fn(size: ::std::os::raw::c_uint, received: ::std::os::raw::c_uint),
>,
) -> INT32;
}
extern "C" {
pub fn send_data_file_feedback(
src: *mut ::std::os::raw::c_char,
dest: *mut ::std::os::raw::c_char,
dest_is_path: INT16,
progress: ::std::option::Option<
unsafe extern "C" fn(size: ::std::os::raw::c_uint, received: ::std::os::raw::c_uint),
>,
) -> INT32;
}
extern "C" {
pub fn open_data_file(name: *mut ::std::os::raw::c_char) -> INT16;
}
extern "C" {
pub fn close_data_file() -> INT16;
}
extern "C" {
pub fn escape_pressed() -> INT16;
}
extern "C" {
pub fn break_pressed() -> INT16;
}
extern "C" {
pub fn terminal_break(assert: INT16);
}
extern "C" {
pub fn application_terminated() -> INT16;
}
extern "C" {
pub fn begin_realtime_mode(delay: UINT32);
}
extern "C" {
pub fn end_realtime_mode();
}
extern "C" {
pub fn set_high_priority();
}
extern "C" {
pub fn set_normal_priority();
}
extern "C" {
pub fn in_realtime_mode() -> INT32;
}
extern "C" {
pub fn eyelink_enable_extended_realtime();
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct EYECOLOR {
pub r: byte,
pub g: byte,
pub b: byte,
pub unused: byte,
}
#[test]
fn bindgen_test_layout_EYECOLOR() {
assert_eq!(
::std::mem::size_of::<EYECOLOR>(),
4usize,
concat!("Size of: ", stringify!(EYECOLOR))
);
assert_eq!(
::std::mem::align_of::<EYECOLOR>(),
1usize,
concat!("Alignment of ", stringify!(EYECOLOR))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<EYECOLOR>())).r as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(EYECOLOR),
"::",
stringify!(r)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<EYECOLOR>())).g as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(EYECOLOR),
"::",
stringify!(g)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<EYECOLOR>())).b as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(EYECOLOR),
"::",
stringify!(b)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<EYECOLOR>())).unused as *const _ as usize },
3usize,
concat!(
"Offset of field: ",
stringify!(EYECOLOR),
"::",
stringify!(unused)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct EYEPALETTE {
pub ncolors: ::std::os::raw::c_int,
pub colors: *mut EYECOLOR,
}
#[test]
fn bindgen_test_layout_EYEPALETTE() {
assert_eq!(
::std::mem::size_of::<EYEPALETTE>(),
16usize,
concat!("Size of: ", stringify!(EYEPALETTE))
);
assert_eq!(
::std::mem::align_of::<EYEPALETTE>(),
8usize,
concat!("Alignment of ", stringify!(EYEPALETTE))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<EYEPALETTE>())).ncolors as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(EYEPALETTE),
"::",
stringify!(ncolors)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<EYEPALETTE>())).colors as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(EYEPALETTE),
"::",
stringify!(colors)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct EYEPIXELFORMAT {
pub colorkey: byte,
pub Rmask: INT32,
pub Gmask: INT32,
pub Bmask: INT32,
pub Amask: INT32,
pub palette: *mut EYEPALETTE,
}
#[test]
fn bindgen_test_layout_EYEPIXELFORMAT() {
assert_eq!(
::std::mem::size_of::<EYEPIXELFORMAT>(),
32usize,
concat!("Size of: ", stringify!(EYEPIXELFORMAT))
);
assert_eq!(
::std::mem::align_of::<EYEPIXELFORMAT>(),
8usize,
concat!("Alignment of ", stringify!(EYEPIXELFORMAT))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<EYEPIXELFORMAT>())).colorkey as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(EYEPIXELFORMAT),
"::",
stringify!(colorkey)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<EYEPIXELFORMAT>())).Rmask as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(EYEPIXELFORMAT),
"::",
stringify!(Rmask)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<EYEPIXELFORMAT>())).Gmask as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(EYEPIXELFORMAT),
"::",
stringify!(Gmask)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<EYEPIXELFORMAT>())).Bmask as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(EYEPIXELFORMAT),
"::",
stringify!(Bmask)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<EYEPIXELFORMAT>())).Amask as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(EYEPIXELFORMAT),
"::",
stringify!(Amask)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<EYEPIXELFORMAT>())).palette as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(EYEPIXELFORMAT),
"::",
stringify!(palette)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct EYEBITMAP {
pub w: INT32,
pub h: INT32,
pub pitch: INT32,
pub depth: INT32,
pub pixels: *mut ::std::os::raw::c_void,
pub format: *mut EYEPIXELFORMAT,
}
#[test]
fn bindgen_test_layout_EYEBITMAP() {
assert_eq!(
::std::mem::size_of::<EYEBITMAP>(),
32usize,
concat!("Size of: ", stringify!(EYEBITMAP))
);
assert_eq!(
::std::mem::align_of::<EYEBITMAP>(),
8usize,
concat!("Alignment of ", stringify!(EYEBITMAP))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<EYEBITMAP>())).w as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(EYEBITMAP),
"::",
stringify!(w)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<EYEBITMAP>())).h as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(EYEBITMAP),
"::",
stringify!(h)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<EYEBITMAP>())).pitch as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(EYEBITMAP),
"::",
stringify!(pitch)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<EYEBITMAP>())).depth as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(EYEBITMAP),
"::",
stringify!(depth)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<EYEBITMAP>())).pixels as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(EYEBITMAP),
"::",
stringify!(pixels)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<EYEBITMAP>())).format as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(EYEBITMAP),
"::",
stringify!(format)
)
);
}
pub const IMAGETYPE_JPEG: IMAGETYPE = 0;
pub const IMAGETYPE_PNG: IMAGETYPE = 1;
pub const IMAGETYPE_GIF: IMAGETYPE = 2;
pub const IMAGETYPE_BMP: IMAGETYPE = 3;
pub const IMAGETYPE_XPM: IMAGETYPE = 4;
pub type IMAGETYPE = u32;
extern "C" {
pub fn eyelink_get_error(
id: ::std::os::raw::c_int,
function_name: *mut ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn splice_fname(
fname: *mut ::std::os::raw::c_char,
path: *mut ::std::os::raw::c_char,
ffname: *mut ::std::os::raw::c_char,
);
}
extern "C" {
pub fn check_filename_characters(name: *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn file_exists(path: *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn create_path(
path: *mut ::std::os::raw::c_char,
create: INT16,
is_dir: INT16,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn el_bitmap_save_and_backdrop(
hbm: *mut EYEBITMAP,
xs: INT16,
ys: INT16,
width: INT16,
height: INT16,
fname: *mut ::std::os::raw::c_char,
path: *mut ::std::os::raw::c_char,
sv_options: INT16,
xd: INT16,
yd: INT16,
xferoptions: UINT16,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn el_bitmap_to_backdrop(
hbm: *mut EYEBITMAP,
xs: INT16,
ys: INT16,
width: INT16,
height: INT16,
xd: INT16,
yd: INT16,
xferoptions: UINT16,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn el_bitmap_save(
hbm: *mut EYEBITMAP,
xs: INT16,
ys: INT16,
width: INT16,
height: INT16,
fname: *mut ::std::os::raw::c_char,
path: *mut ::std::os::raw::c_char,
sv_options: INT16,
) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct KeyInput {
pub type_: byte,
pub state: byte,
pub key: UINT16,
pub modifier: UINT16,
pub unicode: UINT16,
}
#[test]
fn bindgen_test_layout_KeyInput() {
assert_eq!(
::std::mem::size_of::<KeyInput>(),
8usize,
concat!("Size of: ", stringify!(KeyInput))
);
assert_eq!(
::std::mem::align_of::<KeyInput>(),
2usize,
concat!("Alignment of ", stringify!(KeyInput))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<KeyInput>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(KeyInput),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<KeyInput>())).state as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(KeyInput),
"::",
stringify!(state)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<KeyInput>())).key as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(KeyInput),
"::",
stringify!(key)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<KeyInput>())).modifier as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(KeyInput),
"::",
stringify!(modifier)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<KeyInput>())).unicode as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(KeyInput),
"::",
stringify!(unicode)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MouseMotionEvent {
pub type_: byte,
pub which: byte,
pub state: byte,
pub x: UINT16,
pub y: UINT16,
pub xrel: UINT16,
pub yrel: UINT16,
}
#[test]
fn bindgen_test_layout_MouseMotionEvent() {
assert_eq!(
::std::mem::size_of::<MouseMotionEvent>(),
12usize,
concat!("Size of: ", stringify!(MouseMotionEvent))
);
assert_eq!(
::std::mem::align_of::<MouseMotionEvent>(),
2usize,
concat!("Alignment of ", stringify!(MouseMotionEvent))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<MouseMotionEvent>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MouseMotionEvent),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<MouseMotionEvent>())).which as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(MouseMotionEvent),
"::",
stringify!(which)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<MouseMotionEvent>())).state as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(MouseMotionEvent),
"::",
stringify!(state)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<MouseMotionEvent>())).x as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(MouseMotionEvent),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<MouseMotionEvent>())).y as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(MouseMotionEvent),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<MouseMotionEvent>())).xrel as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(MouseMotionEvent),
"::",
stringify!(xrel)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<MouseMotionEvent>())).yrel as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(MouseMotionEvent),
"::",
stringify!(yrel)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct MouseButtonEvent {
pub type_: byte,
pub which: byte,
pub button: byte,
pub state: byte,
pub x: UINT16,
pub y: UINT16,
}
#[test]
fn bindgen_test_layout_MouseButtonEvent() {
assert_eq!(
::std::mem::size_of::<MouseButtonEvent>(),
8usize,
concat!("Size of: ", stringify!(MouseButtonEvent))
);
assert_eq!(
::std::mem::align_of::<MouseButtonEvent>(),
2usize,
concat!("Alignment of ", stringify!(MouseButtonEvent))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<MouseButtonEvent>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(MouseButtonEvent),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<MouseButtonEvent>())).which as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(MouseButtonEvent),
"::",
stringify!(which)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<MouseButtonEvent>())).button as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(MouseButtonEvent),
"::",
stringify!(button)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<MouseButtonEvent>())).state as *const _ as usize },
3usize,
concat!(
"Offset of field: ",
stringify!(MouseButtonEvent),
"::",
stringify!(state)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<MouseButtonEvent>())).x as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(MouseButtonEvent),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<MouseButtonEvent>())).y as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(MouseButtonEvent),
"::",
stringify!(y)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union InputEvent {
pub type_: byte,
pub key: KeyInput,
pub motion: MouseMotionEvent,
pub button: MouseButtonEvent,
_bindgen_union_align: [u16; 6usize],
}
#[test]
fn bindgen_test_layout_InputEvent() {
assert_eq!(
::std::mem::size_of::<InputEvent>(),
12usize,
concat!("Size of: ", stringify!(InputEvent))
);
assert_eq!(
::std::mem::align_of::<InputEvent>(),
2usize,
concat!("Alignment of ", stringify!(InputEvent))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<InputEvent>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(InputEvent),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<InputEvent>())).key as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(InputEvent),
"::",
stringify!(key)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<InputEvent>())).motion as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(InputEvent),
"::",
stringify!(motion)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<InputEvent>())).button as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(InputEvent),
"::",
stringify!(button)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct HOOKFCNS {
pub setup_cal_display_hook: ::std::option::Option<unsafe extern "C" fn() -> INT16>,
pub exit_cal_display_hook: ::std::option::Option<unsafe extern "C" fn()>,
pub record_abort_hide_hook: ::std::option::Option<unsafe extern "C" fn()>,
pub setup_image_display_hook:
::std::option::Option<unsafe extern "C" fn(width: INT16, height: INT16) -> INT16>,
pub image_title_hook: ::std::option::Option<
unsafe extern "C" fn(threshold: INT16, cam_name: *mut ::std::os::raw::c_char),
>,
pub draw_image_line_hook: ::std::option::Option<
unsafe extern "C" fn(width: INT16, line: INT16, totlines: INT16, pixels: *mut byte),
>,
pub set_image_palette_hook: ::std::option::Option<
unsafe extern "C" fn(ncolors: INT16, r: *mut byte, g: *mut byte, b: *mut byte),
>,
pub exit_image_display_hook: ::std::option::Option<unsafe extern "C" fn()>,
pub clear_cal_display_hook: ::std::option::Option<unsafe extern "C" fn()>,
pub erase_cal_target_hook: ::std::option::Option<unsafe extern "C" fn()>,
pub draw_cal_target_hook: ::std::option::Option<unsafe extern "C" fn(x: INT16, y: INT16)>,
pub cal_target_beep_hook: ::std::option::Option<unsafe extern "C" fn()>,
pub cal_done_beep_hook: ::std::option::Option<unsafe extern "C" fn(error: INT16)>,
pub dc_done_beep_hook: ::std::option::Option<unsafe extern "C" fn(error: INT16)>,
pub dc_target_beep_hook: ::std::option::Option<unsafe extern "C" fn()>,
pub get_input_key_hook: ::std::option::Option<
unsafe extern "C" fn(event: *mut InputEvent) -> ::std::os::raw::c_short,
>,
pub alert_printf_hook:
::std::option::Option<unsafe extern "C" fn(arg1: *const ::std::os::raw::c_char)>,
}
#[test]
fn bindgen_test_layout_HOOKFCNS() {
assert_eq!(
::std::mem::size_of::<HOOKFCNS>(),
136usize,
concat!("Size of: ", stringify!(HOOKFCNS))
);
assert_eq!(
::std::mem::align_of::<HOOKFCNS>(),
8usize,
concat!("Alignment of ", stringify!(HOOKFCNS))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<HOOKFCNS>())).setup_cal_display_hook as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(HOOKFCNS),
"::",
stringify!(setup_cal_display_hook)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<HOOKFCNS>())).exit_cal_display_hook as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(HOOKFCNS),
"::",
stringify!(exit_cal_display_hook)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<HOOKFCNS>())).record_abort_hide_hook as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(HOOKFCNS),
"::",
stringify!(record_abort_hide_hook)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<HOOKFCNS>())).setup_image_display_hook as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(HOOKFCNS),
"::",
stringify!(setup_image_display_hook)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<HOOKFCNS>())).image_title_hook as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(HOOKFCNS),
"::",
stringify!(image_title_hook)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<HOOKFCNS>())).draw_image_line_hook as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(HOOKFCNS),
"::",
stringify!(draw_image_line_hook)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<HOOKFCNS>())).set_image_palette_hook as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(HOOKFCNS),
"::",
stringify!(set_image_palette_hook)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<HOOKFCNS>())).exit_image_display_hook as *const _ as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(HOOKFCNS),
"::",
stringify!(exit_image_display_hook)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<HOOKFCNS>())).clear_cal_display_hook as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(HOOKFCNS),
"::",
stringify!(clear_cal_display_hook)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<HOOKFCNS>())).erase_cal_target_hook as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(HOOKFCNS),
"::",
stringify!(erase_cal_target_hook)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<HOOKFCNS>())).draw_cal_target_hook as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(HOOKFCNS),
"::",
stringify!(draw_cal_target_hook)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<HOOKFCNS>())).cal_target_beep_hook as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(HOOKFCNS),
"::",
stringify!(cal_target_beep_hook)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<HOOKFCNS>())).cal_done_beep_hook as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(HOOKFCNS),
"::",
stringify!(cal_done_beep_hook)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<HOOKFCNS>())).dc_done_beep_hook as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(HOOKFCNS),
"::",
stringify!(dc_done_beep_hook)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<HOOKFCNS>())).dc_target_beep_hook as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(HOOKFCNS),
"::",
stringify!(dc_target_beep_hook)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<HOOKFCNS>())).get_input_key_hook as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(HOOKFCNS),
"::",
stringify!(get_input_key_hook)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<HOOKFCNS>())).alert_printf_hook as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(HOOKFCNS),
"::",
stringify!(alert_printf_hook)
)
);
}
pub const _EL_CAL_BEEP_EL_DC_DONE_ERR_BEEP: _EL_CAL_BEEP = -2;
pub const _EL_CAL_BEEP_EL_CAL_DONE_ERR_BEEP: _EL_CAL_BEEP = -1;
pub const _EL_CAL_BEEP_EL_CAL_DONE_GOOD_BEEP: _EL_CAL_BEEP = 0;
pub const _EL_CAL_BEEP_EL_CAL_TARG_BEEP: _EL_CAL_BEEP = 1;
pub const _EL_CAL_BEEP_EL_DC_DONE_GOOD_BEEP: _EL_CAL_BEEP = 2;
pub const _EL_CAL_BEEP_EL_DC_TARG_BEEP: _EL_CAL_BEEP = 3;
pub type _EL_CAL_BEEP = i32;
pub use self::_EL_CAL_BEEP as EL_CAL_BEEP;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct HOOKFCNS2 {
pub major: ::std::os::raw::c_int,
pub minor: ::std::os::raw::c_int,
pub userData: *mut ::std::os::raw::c_void,
pub setup_cal_display_hook:
::std::option::Option<unsafe extern "C" fn(userData: *mut ::std::os::raw::c_void) -> INT16>,
pub exit_cal_display_hook:
::std::option::Option<unsafe extern "C" fn(userData: *mut ::std::os::raw::c_void) -> INT16>,
pub setup_image_display_hook: ::std::option::Option<
unsafe extern "C" fn(
userData: *mut ::std::os::raw::c_void,
width: INT16,
height: INT16,
) -> INT16,
>,
pub image_title_hook: ::std::option::Option<
unsafe extern "C" fn(
userData: *mut ::std::os::raw::c_void,
title: *mut ::std::os::raw::c_char,
) -> INT16,
>,
pub draw_image: ::std::option::Option<
unsafe extern "C" fn(
userData: *mut ::std::os::raw::c_void,
width: INT16,
height: INT16,
pixels: *mut byte,
) -> INT16,
>,
pub exit_image_display_hook:
::std::option::Option<unsafe extern "C" fn(userData: *mut ::std::os::raw::c_void) -> INT16>,
pub clear_cal_display_hook:
::std::option::Option<unsafe extern "C" fn(userData: *mut ::std::os::raw::c_void) -> INT16>,
pub erase_cal_target_hook:
::std::option::Option<unsafe extern "C" fn(userData: *mut ::std::os::raw::c_void) -> INT16>,
pub draw_cal_target_hook: ::std::option::Option<
unsafe extern "C" fn(userData: *mut ::std::os::raw::c_void, x: f32, y: f32) -> INT16,
>,
pub play_target_beep_hook: ::std::option::Option<
unsafe extern "C" fn(
userData: *mut ::std::os::raw::c_void,
beep_type: EL_CAL_BEEP,
) -> INT16,
>,
pub get_input_key_hook: ::std::option::Option<
unsafe extern "C" fn(
userData: *mut ::std::os::raw::c_void,
event: *mut InputEvent,
) -> INT16,
>,
pub alert_printf_hook: ::std::option::Option<
unsafe extern "C" fn(
userData: *mut ::std::os::raw::c_void,
msg: *const ::std::os::raw::c_char,
) -> INT16,
>,
pub reserved1: ::std::os::raw::c_int,
pub reserved2: ::std::os::raw::c_int,
pub reserved3: ::std::os::raw::c_int,
pub reserved4: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_HOOKFCNS2() {
assert_eq!(
::std::mem::size_of::<HOOKFCNS2>(),
128usize,
concat!("Size of: ", stringify!(HOOKFCNS2))
);
assert_eq!(
::std::mem::align_of::<HOOKFCNS2>(),
8usize,
concat!("Alignment of ", stringify!(HOOKFCNS2))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<HOOKFCNS2>())).major as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(HOOKFCNS2),
"::",
stringify!(major)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<HOOKFCNS2>())).minor as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(HOOKFCNS2),
"::",
stringify!(minor)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<HOOKFCNS2>())).userData as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(HOOKFCNS2),
"::",
stringify!(userData)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<HOOKFCNS2>())).setup_cal_display_hook as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(HOOKFCNS2),
"::",
stringify!(setup_cal_display_hook)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<HOOKFCNS2>())).exit_cal_display_hook as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(HOOKFCNS2),
"::",
stringify!(exit_cal_display_hook)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<HOOKFCNS2>())).setup_image_display_hook as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(HOOKFCNS2),
"::",
stringify!(setup_image_display_hook)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<HOOKFCNS2>())).image_title_hook as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(HOOKFCNS2),
"::",
stringify!(image_title_hook)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<HOOKFCNS2>())).draw_image as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(HOOKFCNS2),
"::",
stringify!(draw_image)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<HOOKFCNS2>())).exit_image_display_hook as *const _ as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(HOOKFCNS2),
"::",
stringify!(exit_image_display_hook)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<HOOKFCNS2>())).clear_cal_display_hook as *const _ as usize
},
64usize,
concat!(
"Offset of field: ",
stringify!(HOOKFCNS2),
"::",
stringify!(clear_cal_display_hook)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<HOOKFCNS2>())).erase_cal_target_hook as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(HOOKFCNS2),
"::",
stringify!(erase_cal_target_hook)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<HOOKFCNS2>())).draw_cal_target_hook as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(HOOKFCNS2),
"::",
stringify!(draw_cal_target_hook)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<HOOKFCNS2>())).play_target_beep_hook as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(HOOKFCNS2),
"::",
stringify!(play_target_beep_hook)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<HOOKFCNS2>())).get_input_key_hook as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(HOOKFCNS2),
"::",
stringify!(get_input_key_hook)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<HOOKFCNS2>())).alert_printf_hook as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(HOOKFCNS2),
"::",
stringify!(alert_printf_hook)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<HOOKFCNS2>())).reserved1 as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(HOOKFCNS2),
"::",
stringify!(reserved1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<HOOKFCNS2>())).reserved2 as *const _ as usize },
116usize,
concat!(
"Offset of field: ",
stringify!(HOOKFCNS2),
"::",
stringify!(reserved2)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<HOOKFCNS2>())).reserved3 as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(HOOKFCNS2),
"::",
stringify!(reserved3)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<HOOKFCNS2>())).reserved4 as *const _ as usize },
124usize,
concat!(
"Offset of field: ",
stringify!(HOOKFCNS2),
"::",
stringify!(reserved4)
)
);
}
extern "C" {
pub fn setup_graphic_hook_functions(hooks: *mut HOOKFCNS);
}
extern "C" {
pub fn get_all_hook_functions() -> *mut HOOKFCNS;
}
extern "C" {
pub fn setup_graphic_hook_functions_V2(hooks: *mut HOOKFCNS2) -> INT16;
}
extern "C" {
pub fn get_all_hook_functions_V2() -> *mut HOOKFCNS2;
}
extern "C" {
pub fn set_write_image_hook(
hookfn: ::std::option::Option<
unsafe extern "C" fn(
outfilename: *mut ::std::os::raw::c_char,
format: ::std::os::raw::c_int,
bitmap: *mut EYEBITMAP,
) -> ::std::os::raw::c_int,
>,
options: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn eyelink_peep_input_event(
event: *mut InputEvent,
mask: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn eyelink_get_input_event(
event: *mut InputEvent,
mask: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn eyelink_peep_last_input_event(
event: *mut InputEvent,
mask: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn eyelink_flush_input_event();
}
extern "C" {
pub fn eyelink_initialize_mapping(left: f32, top: f32, right: f32, bottom: f32) -> INT32;
}
extern "C" {
pub fn eyelink_href_to_gaze(xp: *mut f32, yp: *mut f32, sample: *mut FSAMPLE) -> INT32;
}
extern "C" {
pub fn eyelink_gaze_to_href(xp: *mut f32, yp: *mut f32, sample: *mut FSAMPLE) -> INT32;
}
extern "C" {
pub fn eyelink_href_angle(x1: f32, y1: f32, x2: f32, y2: f32) -> f32;
}
extern "C" {
pub fn eyelink_href_resolution(x: f32, y: f32, xres: *mut f32, yres: *mut f32);
}
extern "C" {
pub fn get_image_xhair_data(
x: *mut INT16,
y: *mut INT16,
xhairs_on: *mut INT16,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn eyelink_get_extra_raw_values(
s: *mut FSAMPLE,
rv: *mut FSAMPLE_RAW,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn eyelink_get_extra_raw_values_v2(
s: *mut FSAMPLE,
eye: ::std::os::raw::c_int,
rv: *mut FSAMPLE_RAW,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn eyelink_calculate_velocity_x_y(
slen: ::std::os::raw::c_int,
xvel: *mut f32,
yvel: *mut f32,
vel_sample: *mut FSAMPLE,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn eyelink_calculate_velocity(
slen: ::std::os::raw::c_int,
vel: *mut f32,
vel_sample: *mut FSAMPLE,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn eyelink_calculate_overallvelocity_and_acceleration(
slen: ::std::os::raw::c_int,
vel: *mut f32,
acc: *mut f32,
vel_sample: *mut FSAMPLE,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn timemsg_printf(t: UINT32, fmt: *mut ::std::os::raw::c_char, ...) -> INT16;
}
extern "C" {
pub fn open_message_file(fname: *mut ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn close_message_file();
}
pub type CrossHairInfo = _CrossHairInfo;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _CrossHairInfo {
pub majorVersion: ::std::os::raw::c_short,
pub minorVersion: ::std::os::raw::c_short,
pub w: ::std::os::raw::c_int,
pub h: ::std::os::raw::c_int,
pub privatedata: *mut ::std::os::raw::c_void,
pub userdata: *mut ::std::os::raw::c_void,
pub drawLine: ::std::option::Option<
unsafe extern "C" fn(
dt: *mut CrossHairInfo,
x1: ::std::os::raw::c_int,
y1: ::std::os::raw::c_int,
x2: ::std::os::raw::c_int,
y2: ::std::os::raw::c_int,
colorindex: ::std::os::raw::c_int,
),
>,
pub drawLozenge: ::std::option::Option<
unsafe extern "C" fn(
dt: *mut CrossHairInfo,
x: ::std::os::raw::c_int,
y: ::std::os::raw::c_int,
w: ::std::os::raw::c_int,
h: ::std::os::raw::c_int,
colorindex: ::std::os::raw::c_int,
),
>,
pub getMouseState: ::std::option::Option<
unsafe extern "C" fn(
dt: *mut CrossHairInfo,
x: *mut ::std::os::raw::c_int,
y: *mut ::std::os::raw::c_int,
state: *mut ::std::os::raw::c_int,
),
>,
pub reserved1: ::std::os::raw::c_int,
pub reserved2: ::std::os::raw::c_int,
pub reserved3: ::std::os::raw::c_int,
pub reserved4: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout__CrossHairInfo() {
assert_eq!(
::std::mem::size_of::<_CrossHairInfo>(),
72usize,
concat!("Size of: ", stringify!(_CrossHairInfo))
);
assert_eq!(
::std::mem::align_of::<_CrossHairInfo>(),
8usize,
concat!("Alignment of ", stringify!(_CrossHairInfo))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_CrossHairInfo>())).majorVersion as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_CrossHairInfo),
"::",
stringify!(majorVersion)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_CrossHairInfo>())).minorVersion as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(_CrossHairInfo),
"::",
stringify!(minorVersion)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_CrossHairInfo>())).w as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(_CrossHairInfo),
"::",
stringify!(w)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_CrossHairInfo>())).h as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_CrossHairInfo),
"::",
stringify!(h)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_CrossHairInfo>())).privatedata as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_CrossHairInfo),
"::",
stringify!(privatedata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_CrossHairInfo>())).userdata as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_CrossHairInfo),
"::",
stringify!(userdata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_CrossHairInfo>())).drawLine as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_CrossHairInfo),
"::",
stringify!(drawLine)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_CrossHairInfo>())).drawLozenge as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_CrossHairInfo),
"::",
stringify!(drawLozenge)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_CrossHairInfo>())).getMouseState as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_CrossHairInfo),
"::",
stringify!(getMouseState)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_CrossHairInfo>())).reserved1 as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_CrossHairInfo),
"::",
stringify!(reserved1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_CrossHairInfo>())).reserved2 as *const _ as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(_CrossHairInfo),
"::",
stringify!(reserved2)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_CrossHairInfo>())).reserved3 as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_CrossHairInfo),
"::",
stringify!(reserved3)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_CrossHairInfo>())).reserved4 as *const _ as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(_CrossHairInfo),
"::",
stringify!(reserved4)
)
);
}
extern "C" {
pub fn eyelink_draw_cross_hair(chi: *mut CrossHairInfo) -> INT32;
}
extern "C" {
pub fn eyelink_dll_version(c: *mut ::std::os::raw::c_char);
}