f85c50657b
- This updates the bindings generator, the low-level bindings as
well as the higher-level bindings and the examples to work
with a newer master of cimplot that links to implot 0.7.
- Several things are not done properly yet:
- Contexts can be created and as long as they are not dropped
things work out (shown in the examples). However, this should
be done more imgui-rs like, where operations that require a context
make that explicit by requiring a context reference to be passed.
- The README has not been updated yet to all the new features that
were added.
10630 lines
310 KiB
Rust
Generated
10630 lines
310 KiB
Rust
Generated
/* automatically generated by rust-bindgen */
|
|
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
|
|
pub struct __BindgenBitfieldUnit<Storage, Align> {
|
|
storage: Storage,
|
|
align: [Align; 0],
|
|
}
|
|
impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align> {
|
|
#[inline]
|
|
pub const fn new(storage: Storage) -> Self {
|
|
Self { storage, align: [] }
|
|
}
|
|
}
|
|
impl<Storage, Align> __BindgenBitfieldUnit<Storage, Align>
|
|
where
|
|
Storage: AsRef<[u8]> + AsMut<[u8]>,
|
|
{
|
|
#[inline]
|
|
pub fn get_bit(&self, index: usize) -> bool {
|
|
debug_assert!(index / 8 < self.storage.as_ref().len());
|
|
let byte_index = index / 8;
|
|
let byte = self.storage.as_ref()[byte_index];
|
|
let bit_index = if cfg!(target_endian = "big") {
|
|
7 - (index % 8)
|
|
} else {
|
|
index % 8
|
|
};
|
|
let mask = 1 << bit_index;
|
|
byte & mask == mask
|
|
}
|
|
#[inline]
|
|
pub fn set_bit(&mut self, index: usize, val: bool) {
|
|
debug_assert!(index / 8 < self.storage.as_ref().len());
|
|
let byte_index = index / 8;
|
|
let byte = &mut self.storage.as_mut()[byte_index];
|
|
let bit_index = if cfg!(target_endian = "big") {
|
|
7 - (index % 8)
|
|
} else {
|
|
index % 8
|
|
};
|
|
let mask = 1 << bit_index;
|
|
if val {
|
|
*byte |= mask;
|
|
} else {
|
|
*byte &= !mask;
|
|
}
|
|
}
|
|
#[inline]
|
|
pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
|
|
debug_assert!(bit_width <= 64);
|
|
debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
|
|
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
|
|
let mut val = 0;
|
|
for i in 0..(bit_width as usize) {
|
|
if self.get_bit(i + bit_offset) {
|
|
let index = if cfg!(target_endian = "big") {
|
|
bit_width as usize - 1 - i
|
|
} else {
|
|
i
|
|
};
|
|
val |= 1 << index;
|
|
}
|
|
}
|
|
val
|
|
}
|
|
#[inline]
|
|
pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
|
|
debug_assert!(bit_width <= 64);
|
|
debug_assert!(bit_offset / 8 < self.storage.as_ref().len());
|
|
debug_assert!((bit_offset + (bit_width as usize)) / 8 <= self.storage.as_ref().len());
|
|
for i in 0..(bit_width as usize) {
|
|
let mask = 1 << i;
|
|
let val_bit_is_set = val & mask == mask;
|
|
let index = if cfg!(target_endian = "big") {
|
|
bit_width as usize - 1 - i
|
|
} else {
|
|
i
|
|
};
|
|
self.set_bit(index + bit_offset, val_bit_is_set);
|
|
}
|
|
}
|
|
}
|
|
pub const _STDIO_H: u32 = 1;
|
|
pub const _FEATURES_H: u32 = 1;
|
|
pub const _DEFAULT_SOURCE: u32 = 1;
|
|
pub const __GLIBC_USE_ISOC2X: u32 = 0;
|
|
pub const __USE_ISOC11: u32 = 1;
|
|
pub const __USE_ISOC99: u32 = 1;
|
|
pub const __USE_ISOC95: u32 = 1;
|
|
pub const __USE_POSIX_IMPLICITLY: u32 = 1;
|
|
pub const _POSIX_SOURCE: u32 = 1;
|
|
pub const _POSIX_C_SOURCE: u32 = 200809;
|
|
pub const __USE_POSIX: u32 = 1;
|
|
pub const __USE_POSIX2: u32 = 1;
|
|
pub const __USE_POSIX199309: u32 = 1;
|
|
pub const __USE_POSIX199506: u32 = 1;
|
|
pub const __USE_XOPEN2K: u32 = 1;
|
|
pub const __USE_XOPEN2K8: u32 = 1;
|
|
pub const _ATFILE_SOURCE: u32 = 1;
|
|
pub const __USE_MISC: u32 = 1;
|
|
pub const __USE_ATFILE: u32 = 1;
|
|
pub const __USE_FORTIFY_LEVEL: u32 = 0;
|
|
pub const __GLIBC_USE_DEPRECATED_GETS: u32 = 0;
|
|
pub const __GLIBC_USE_DEPRECATED_SCANF: u32 = 0;
|
|
pub const _STDC_PREDEF_H: u32 = 1;
|
|
pub const __STDC_IEC_559__: u32 = 1;
|
|
pub const __STDC_IEC_559_COMPLEX__: u32 = 1;
|
|
pub const __STDC_ISO_10646__: u32 = 201706;
|
|
pub const __GNU_LIBRARY__: u32 = 6;
|
|
pub const __GLIBC__: u32 = 2;
|
|
pub const __GLIBC_MINOR__: u32 = 31;
|
|
pub const _SYS_CDEFS_H: u32 = 1;
|
|
pub const __glibc_c99_flexarr_available: u32 = 1;
|
|
pub const __WORDSIZE: u32 = 64;
|
|
pub const __WORDSIZE_TIME64_COMPAT32: u32 = 1;
|
|
pub const __SYSCALL_WORDSIZE: u32 = 64;
|
|
pub const __LONG_DOUBLE_USES_FLOAT128: u32 = 0;
|
|
pub const __HAVE_GENERIC_SELECTION: u32 = 1;
|
|
pub const __GLIBC_USE_LIB_EXT2: u32 = 0;
|
|
pub const __GLIBC_USE_IEC_60559_BFP_EXT: u32 = 0;
|
|
pub const __GLIBC_USE_IEC_60559_BFP_EXT_C2X: u32 = 0;
|
|
pub const __GLIBC_USE_IEC_60559_FUNCS_EXT: u32 = 0;
|
|
pub const __GLIBC_USE_IEC_60559_FUNCS_EXT_C2X: u32 = 0;
|
|
pub const __GLIBC_USE_IEC_60559_TYPES_EXT: u32 = 0;
|
|
pub const __GNUC_VA_LIST: u32 = 1;
|
|
pub const _BITS_TYPES_H: u32 = 1;
|
|
pub const __TIMESIZE: u32 = 64;
|
|
pub const _BITS_TYPESIZES_H: u32 = 1;
|
|
pub const __OFF_T_MATCHES_OFF64_T: u32 = 1;
|
|
pub const __INO_T_MATCHES_INO64_T: u32 = 1;
|
|
pub const __RLIM_T_MATCHES_RLIM64_T: u32 = 1;
|
|
pub const __STATFS_MATCHES_STATFS64: u32 = 1;
|
|
pub const __FD_SETSIZE: u32 = 1024;
|
|
pub const _BITS_TIME64_H: u32 = 1;
|
|
pub const _____fpos_t_defined: u32 = 1;
|
|
pub const ____mbstate_t_defined: u32 = 1;
|
|
pub const _____fpos64_t_defined: u32 = 1;
|
|
pub const ____FILE_defined: u32 = 1;
|
|
pub const __FILE_defined: u32 = 1;
|
|
pub const __struct_FILE_defined: u32 = 1;
|
|
pub const _IO_EOF_SEEN: u32 = 16;
|
|
pub const _IO_ERR_SEEN: u32 = 32;
|
|
pub const _IO_USER_LOCK: u32 = 32768;
|
|
pub const _IOFBF: u32 = 0;
|
|
pub const _IOLBF: u32 = 1;
|
|
pub const _IONBF: u32 = 2;
|
|
pub const BUFSIZ: u32 = 8192;
|
|
pub const EOF: i32 = -1;
|
|
pub const SEEK_SET: u32 = 0;
|
|
pub const SEEK_CUR: u32 = 1;
|
|
pub const SEEK_END: u32 = 2;
|
|
pub const P_tmpdir: &'static [u8; 5usize] = b"/tmp\0";
|
|
pub const _BITS_STDIO_LIM_H: u32 = 1;
|
|
pub const L_tmpnam: u32 = 20;
|
|
pub const TMP_MAX: u32 = 238328;
|
|
pub const FILENAME_MAX: u32 = 4096;
|
|
pub const L_ctermid: u32 = 9;
|
|
pub const FOPEN_MAX: u32 = 16;
|
|
pub const _STDINT_H: u32 = 1;
|
|
pub const _BITS_WCHAR_H: u32 = 1;
|
|
pub const _BITS_STDINT_INTN_H: u32 = 1;
|
|
pub const _BITS_STDINT_UINTN_H: u32 = 1;
|
|
pub const INT8_MIN: i32 = -128;
|
|
pub const INT16_MIN: i32 = -32768;
|
|
pub const INT32_MIN: i32 = -2147483648;
|
|
pub const INT8_MAX: u32 = 127;
|
|
pub const INT16_MAX: u32 = 32767;
|
|
pub const INT32_MAX: u32 = 2147483647;
|
|
pub const UINT8_MAX: u32 = 255;
|
|
pub const UINT16_MAX: u32 = 65535;
|
|
pub const UINT32_MAX: u32 = 4294967295;
|
|
pub const INT_LEAST8_MIN: i32 = -128;
|
|
pub const INT_LEAST16_MIN: i32 = -32768;
|
|
pub const INT_LEAST32_MIN: i32 = -2147483648;
|
|
pub const INT_LEAST8_MAX: u32 = 127;
|
|
pub const INT_LEAST16_MAX: u32 = 32767;
|
|
pub const INT_LEAST32_MAX: u32 = 2147483647;
|
|
pub const UINT_LEAST8_MAX: u32 = 255;
|
|
pub const UINT_LEAST16_MAX: u32 = 65535;
|
|
pub const UINT_LEAST32_MAX: u32 = 4294967295;
|
|
pub const INT_FAST8_MIN: i32 = -128;
|
|
pub const INT_FAST16_MIN: i64 = -9223372036854775808;
|
|
pub const INT_FAST32_MIN: i64 = -9223372036854775808;
|
|
pub const INT_FAST8_MAX: u32 = 127;
|
|
pub const INT_FAST16_MAX: u64 = 9223372036854775807;
|
|
pub const INT_FAST32_MAX: u64 = 9223372036854775807;
|
|
pub const UINT_FAST8_MAX: u32 = 255;
|
|
pub const UINT_FAST16_MAX: i32 = -1;
|
|
pub const UINT_FAST32_MAX: i32 = -1;
|
|
pub const INTPTR_MIN: i64 = -9223372036854775808;
|
|
pub const INTPTR_MAX: u64 = 9223372036854775807;
|
|
pub const UINTPTR_MAX: i32 = -1;
|
|
pub const PTRDIFF_MIN: i64 = -9223372036854775808;
|
|
pub const PTRDIFF_MAX: u64 = 9223372036854775807;
|
|
pub const SIG_ATOMIC_MIN: i32 = -2147483648;
|
|
pub const SIG_ATOMIC_MAX: u32 = 2147483647;
|
|
pub const SIZE_MAX: i32 = -1;
|
|
pub const WINT_MIN: u32 = 0;
|
|
pub const WINT_MAX: u32 = 4294967295;
|
|
pub const true_: u32 = 1;
|
|
pub const false_: u32 = 0;
|
|
pub const __bool_true_false_are_defined: u32 = 1;
|
|
pub type size_t = ::std::os::raw::c_ulong;
|
|
pub type va_list = __builtin_va_list;
|
|
pub type __gnuc_va_list = __builtin_va_list;
|
|
pub type __u_char = ::std::os::raw::c_uchar;
|
|
pub type __u_short = ::std::os::raw::c_ushort;
|
|
pub type __u_int = ::std::os::raw::c_uint;
|
|
pub type __u_long = ::std::os::raw::c_ulong;
|
|
pub type __int8_t = ::std::os::raw::c_schar;
|
|
pub type __uint8_t = ::std::os::raw::c_uchar;
|
|
pub type __int16_t = ::std::os::raw::c_short;
|
|
pub type __uint16_t = ::std::os::raw::c_ushort;
|
|
pub type __int32_t = ::std::os::raw::c_int;
|
|
pub type __uint32_t = ::std::os::raw::c_uint;
|
|
pub type __int64_t = ::std::os::raw::c_long;
|
|
pub type __uint64_t = ::std::os::raw::c_ulong;
|
|
pub type __int_least8_t = __int8_t;
|
|
pub type __uint_least8_t = __uint8_t;
|
|
pub type __int_least16_t = __int16_t;
|
|
pub type __uint_least16_t = __uint16_t;
|
|
pub type __int_least32_t = __int32_t;
|
|
pub type __uint_least32_t = __uint32_t;
|
|
pub type __int_least64_t = __int64_t;
|
|
pub type __uint_least64_t = __uint64_t;
|
|
pub type __quad_t = ::std::os::raw::c_long;
|
|
pub type __u_quad_t = ::std::os::raw::c_ulong;
|
|
pub type __intmax_t = ::std::os::raw::c_long;
|
|
pub type __uintmax_t = ::std::os::raw::c_ulong;
|
|
pub type __dev_t = ::std::os::raw::c_ulong;
|
|
pub type __uid_t = ::std::os::raw::c_uint;
|
|
pub type __gid_t = ::std::os::raw::c_uint;
|
|
pub type __ino_t = ::std::os::raw::c_ulong;
|
|
pub type __ino64_t = ::std::os::raw::c_ulong;
|
|
pub type __mode_t = ::std::os::raw::c_uint;
|
|
pub type __nlink_t = ::std::os::raw::c_ulong;
|
|
pub type __off_t = ::std::os::raw::c_long;
|
|
pub type __off64_t = ::std::os::raw::c_long;
|
|
pub type __pid_t = ::std::os::raw::c_int;
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct __fsid_t {
|
|
pub __val: [::std::os::raw::c_int; 2usize],
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout___fsid_t() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<__fsid_t>(),
|
|
8usize,
|
|
concat!("Size of: ", stringify!(__fsid_t))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<__fsid_t>(),
|
|
4usize,
|
|
concat!("Alignment of ", stringify!(__fsid_t))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<__fsid_t>())).__val as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(__fsid_t),
|
|
"::",
|
|
stringify!(__val)
|
|
)
|
|
);
|
|
}
|
|
pub type __clock_t = ::std::os::raw::c_long;
|
|
pub type __rlim_t = ::std::os::raw::c_ulong;
|
|
pub type __rlim64_t = ::std::os::raw::c_ulong;
|
|
pub type __id_t = ::std::os::raw::c_uint;
|
|
pub type __time_t = ::std::os::raw::c_long;
|
|
pub type __useconds_t = ::std::os::raw::c_uint;
|
|
pub type __suseconds_t = ::std::os::raw::c_long;
|
|
pub type __daddr_t = ::std::os::raw::c_int;
|
|
pub type __key_t = ::std::os::raw::c_int;
|
|
pub type __clockid_t = ::std::os::raw::c_int;
|
|
pub type __timer_t = *mut ::std::os::raw::c_void;
|
|
pub type __blksize_t = ::std::os::raw::c_long;
|
|
pub type __blkcnt_t = ::std::os::raw::c_long;
|
|
pub type __blkcnt64_t = ::std::os::raw::c_long;
|
|
pub type __fsblkcnt_t = ::std::os::raw::c_ulong;
|
|
pub type __fsblkcnt64_t = ::std::os::raw::c_ulong;
|
|
pub type __fsfilcnt_t = ::std::os::raw::c_ulong;
|
|
pub type __fsfilcnt64_t = ::std::os::raw::c_ulong;
|
|
pub type __fsword_t = ::std::os::raw::c_long;
|
|
pub type __ssize_t = ::std::os::raw::c_long;
|
|
pub type __syscall_slong_t = ::std::os::raw::c_long;
|
|
pub type __syscall_ulong_t = ::std::os::raw::c_ulong;
|
|
pub type __loff_t = __off64_t;
|
|
pub type __caddr_t = *mut ::std::os::raw::c_char;
|
|
pub type __intptr_t = ::std::os::raw::c_long;
|
|
pub type __socklen_t = ::std::os::raw::c_uint;
|
|
pub type __sig_atomic_t = ::std::os::raw::c_int;
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct __mbstate_t {
|
|
pub __count: ::std::os::raw::c_int,
|
|
pub __value: __mbstate_t__bindgen_ty_1,
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub union __mbstate_t__bindgen_ty_1 {
|
|
pub __wch: ::std::os::raw::c_uint,
|
|
pub __wchb: [::std::os::raw::c_char; 4usize],
|
|
_bindgen_union_align: u32,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout___mbstate_t__bindgen_ty_1() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<__mbstate_t__bindgen_ty_1>(),
|
|
4usize,
|
|
concat!("Size of: ", stringify!(__mbstate_t__bindgen_ty_1))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<__mbstate_t__bindgen_ty_1>(),
|
|
4usize,
|
|
concat!("Alignment of ", stringify!(__mbstate_t__bindgen_ty_1))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<__mbstate_t__bindgen_ty_1>())).__wch as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(__mbstate_t__bindgen_ty_1),
|
|
"::",
|
|
stringify!(__wch)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<__mbstate_t__bindgen_ty_1>())).__wchb as *const _ as usize
|
|
},
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(__mbstate_t__bindgen_ty_1),
|
|
"::",
|
|
stringify!(__wchb)
|
|
)
|
|
);
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout___mbstate_t() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<__mbstate_t>(),
|
|
8usize,
|
|
concat!("Size of: ", stringify!(__mbstate_t))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<__mbstate_t>(),
|
|
4usize,
|
|
concat!("Alignment of ", stringify!(__mbstate_t))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<__mbstate_t>())).__count as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(__mbstate_t),
|
|
"::",
|
|
stringify!(__count)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<__mbstate_t>())).__value as *const _ as usize },
|
|
4usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(__mbstate_t),
|
|
"::",
|
|
stringify!(__value)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct _G_fpos_t {
|
|
pub __pos: __off_t,
|
|
pub __state: __mbstate_t,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout__G_fpos_t() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<_G_fpos_t>(),
|
|
16usize,
|
|
concat!("Size of: ", stringify!(_G_fpos_t))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<_G_fpos_t>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(_G_fpos_t))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_G_fpos_t>())).__pos as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_G_fpos_t),
|
|
"::",
|
|
stringify!(__pos)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_G_fpos_t>())).__state as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_G_fpos_t),
|
|
"::",
|
|
stringify!(__state)
|
|
)
|
|
);
|
|
}
|
|
pub type __fpos_t = _G_fpos_t;
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct _G_fpos64_t {
|
|
pub __pos: __off64_t,
|
|
pub __state: __mbstate_t,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout__G_fpos64_t() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<_G_fpos64_t>(),
|
|
16usize,
|
|
concat!("Size of: ", stringify!(_G_fpos64_t))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<_G_fpos64_t>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(_G_fpos64_t))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_G_fpos64_t>())).__pos as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_G_fpos64_t),
|
|
"::",
|
|
stringify!(__pos)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_G_fpos64_t>())).__state as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_G_fpos64_t),
|
|
"::",
|
|
stringify!(__state)
|
|
)
|
|
);
|
|
}
|
|
pub type __fpos64_t = _G_fpos64_t;
|
|
pub type __FILE = _IO_FILE;
|
|
pub type FILE = _IO_FILE;
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct _IO_marker {
|
|
_unused: [u8; 0],
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct _IO_codecvt {
|
|
_unused: [u8; 0],
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct _IO_wide_data {
|
|
_unused: [u8; 0],
|
|
}
|
|
pub type _IO_lock_t = ::std::os::raw::c_void;
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct _IO_FILE {
|
|
pub _flags: ::std::os::raw::c_int,
|
|
pub _IO_read_ptr: *mut ::std::os::raw::c_char,
|
|
pub _IO_read_end: *mut ::std::os::raw::c_char,
|
|
pub _IO_read_base: *mut ::std::os::raw::c_char,
|
|
pub _IO_write_base: *mut ::std::os::raw::c_char,
|
|
pub _IO_write_ptr: *mut ::std::os::raw::c_char,
|
|
pub _IO_write_end: *mut ::std::os::raw::c_char,
|
|
pub _IO_buf_base: *mut ::std::os::raw::c_char,
|
|
pub _IO_buf_end: *mut ::std::os::raw::c_char,
|
|
pub _IO_save_base: *mut ::std::os::raw::c_char,
|
|
pub _IO_backup_base: *mut ::std::os::raw::c_char,
|
|
pub _IO_save_end: *mut ::std::os::raw::c_char,
|
|
pub _markers: *mut _IO_marker,
|
|
pub _chain: *mut _IO_FILE,
|
|
pub _fileno: ::std::os::raw::c_int,
|
|
pub _flags2: ::std::os::raw::c_int,
|
|
pub _old_offset: __off_t,
|
|
pub _cur_column: ::std::os::raw::c_ushort,
|
|
pub _vtable_offset: ::std::os::raw::c_schar,
|
|
pub _shortbuf: [::std::os::raw::c_char; 1usize],
|
|
pub _lock: *mut _IO_lock_t,
|
|
pub _offset: __off64_t,
|
|
pub _codecvt: *mut _IO_codecvt,
|
|
pub _wide_data: *mut _IO_wide_data,
|
|
pub _freeres_list: *mut _IO_FILE,
|
|
pub _freeres_buf: *mut ::std::os::raw::c_void,
|
|
pub __pad5: size_t,
|
|
pub _mode: ::std::os::raw::c_int,
|
|
pub _unused2: [::std::os::raw::c_char; 20usize],
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout__IO_FILE() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<_IO_FILE>(),
|
|
216usize,
|
|
concat!("Size of: ", stringify!(_IO_FILE))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<_IO_FILE>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(_IO_FILE))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._flags as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_flags)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_read_ptr as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_IO_read_ptr)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_read_end as *const _ as usize },
|
|
16usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_IO_read_end)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_read_base as *const _ as usize },
|
|
24usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_IO_read_base)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_write_base as *const _ as usize },
|
|
32usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_IO_write_base)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_write_ptr as *const _ as usize },
|
|
40usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_IO_write_ptr)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_write_end as *const _ as usize },
|
|
48usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_IO_write_end)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_buf_base as *const _ as usize },
|
|
56usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_IO_buf_base)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_buf_end as *const _ as usize },
|
|
64usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_IO_buf_end)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_save_base as *const _ as usize },
|
|
72usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_IO_save_base)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_backup_base as *const _ as usize },
|
|
80usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_IO_backup_base)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_save_end as *const _ as usize },
|
|
88usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_IO_save_end)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._markers as *const _ as usize },
|
|
96usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_markers)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._chain as *const _ as usize },
|
|
104usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_chain)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._fileno as *const _ as usize },
|
|
112usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_fileno)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._flags2 as *const _ as usize },
|
|
116usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_flags2)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._old_offset as *const _ as usize },
|
|
120usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_old_offset)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._cur_column as *const _ as usize },
|
|
128usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_cur_column)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._vtable_offset as *const _ as usize },
|
|
130usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_vtable_offset)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._shortbuf as *const _ as usize },
|
|
131usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_shortbuf)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._lock as *const _ as usize },
|
|
136usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_lock)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._offset as *const _ as usize },
|
|
144usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_offset)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._codecvt as *const _ as usize },
|
|
152usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_codecvt)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._wide_data as *const _ as usize },
|
|
160usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_wide_data)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._freeres_list as *const _ as usize },
|
|
168usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_freeres_list)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._freeres_buf as *const _ as usize },
|
|
176usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_freeres_buf)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>())).__pad5 as *const _ as usize },
|
|
184usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(__pad5)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._mode as *const _ as usize },
|
|
192usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_mode)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._unused2 as *const _ as usize },
|
|
196usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(_IO_FILE),
|
|
"::",
|
|
stringify!(_unused2)
|
|
)
|
|
);
|
|
}
|
|
pub type off_t = __off_t;
|
|
pub type ssize_t = __ssize_t;
|
|
pub type fpos_t = __fpos_t;
|
|
extern "C" {
|
|
pub static mut stdin: *mut FILE;
|
|
}
|
|
extern "C" {
|
|
pub static mut stdout: *mut FILE;
|
|
}
|
|
extern "C" {
|
|
pub static mut stderr: *mut FILE;
|
|
}
|
|
extern "C" {
|
|
pub fn remove(__filename: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn rename(
|
|
__old: *const ::std::os::raw::c_char,
|
|
__new: *const ::std::os::raw::c_char,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn renameat(
|
|
__oldfd: ::std::os::raw::c_int,
|
|
__old: *const ::std::os::raw::c_char,
|
|
__newfd: ::std::os::raw::c_int,
|
|
__new: *const ::std::os::raw::c_char,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn tmpfile() -> *mut FILE;
|
|
}
|
|
extern "C" {
|
|
pub fn tmpnam(__s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
|
|
}
|
|
extern "C" {
|
|
pub fn tmpnam_r(__s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
|
|
}
|
|
extern "C" {
|
|
pub fn tempnam(
|
|
__dir: *const ::std::os::raw::c_char,
|
|
__pfx: *const ::std::os::raw::c_char,
|
|
) -> *mut ::std::os::raw::c_char;
|
|
}
|
|
extern "C" {
|
|
pub fn fclose(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn fflush(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn fflush_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn fopen(
|
|
__filename: *const ::std::os::raw::c_char,
|
|
__modes: *const ::std::os::raw::c_char,
|
|
) -> *mut FILE;
|
|
}
|
|
extern "C" {
|
|
pub fn freopen(
|
|
__filename: *const ::std::os::raw::c_char,
|
|
__modes: *const ::std::os::raw::c_char,
|
|
__stream: *mut FILE,
|
|
) -> *mut FILE;
|
|
}
|
|
extern "C" {
|
|
pub fn fdopen(__fd: ::std::os::raw::c_int, __modes: *const ::std::os::raw::c_char)
|
|
-> *mut FILE;
|
|
}
|
|
extern "C" {
|
|
pub fn fmemopen(
|
|
__s: *mut ::std::os::raw::c_void,
|
|
__len: size_t,
|
|
__modes: *const ::std::os::raw::c_char,
|
|
) -> *mut FILE;
|
|
}
|
|
extern "C" {
|
|
pub fn open_memstream(
|
|
__bufloc: *mut *mut ::std::os::raw::c_char,
|
|
__sizeloc: *mut size_t,
|
|
) -> *mut FILE;
|
|
}
|
|
extern "C" {
|
|
pub fn setbuf(__stream: *mut FILE, __buf: *mut ::std::os::raw::c_char);
|
|
}
|
|
extern "C" {
|
|
pub fn setvbuf(
|
|
__stream: *mut FILE,
|
|
__buf: *mut ::std::os::raw::c_char,
|
|
__modes: ::std::os::raw::c_int,
|
|
__n: size_t,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn setbuffer(__stream: *mut FILE, __buf: *mut ::std::os::raw::c_char, __size: size_t);
|
|
}
|
|
extern "C" {
|
|
pub fn setlinebuf(__stream: *mut FILE);
|
|
}
|
|
extern "C" {
|
|
pub fn fprintf(
|
|
__stream: *mut FILE,
|
|
__format: *const ::std::os::raw::c_char,
|
|
...
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn printf(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn sprintf(
|
|
__s: *mut ::std::os::raw::c_char,
|
|
__format: *const ::std::os::raw::c_char,
|
|
...
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn vfprintf(
|
|
__s: *mut FILE,
|
|
__format: *const ::std::os::raw::c_char,
|
|
__arg: *mut __va_list_tag,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn vprintf(
|
|
__format: *const ::std::os::raw::c_char,
|
|
__arg: *mut __va_list_tag,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn vsprintf(
|
|
__s: *mut ::std::os::raw::c_char,
|
|
__format: *const ::std::os::raw::c_char,
|
|
__arg: *mut __va_list_tag,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn snprintf(
|
|
__s: *mut ::std::os::raw::c_char,
|
|
__maxlen: ::std::os::raw::c_ulong,
|
|
__format: *const ::std::os::raw::c_char,
|
|
...
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn vsnprintf(
|
|
__s: *mut ::std::os::raw::c_char,
|
|
__maxlen: ::std::os::raw::c_ulong,
|
|
__format: *const ::std::os::raw::c_char,
|
|
__arg: *mut __va_list_tag,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn vdprintf(
|
|
__fd: ::std::os::raw::c_int,
|
|
__fmt: *const ::std::os::raw::c_char,
|
|
__arg: *mut __va_list_tag,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn dprintf(
|
|
__fd: ::std::os::raw::c_int,
|
|
__fmt: *const ::std::os::raw::c_char,
|
|
...
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn fscanf(
|
|
__stream: *mut FILE,
|
|
__format: *const ::std::os::raw::c_char,
|
|
...
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn scanf(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn sscanf(
|
|
__s: *const ::std::os::raw::c_char,
|
|
__format: *const ::std::os::raw::c_char,
|
|
...
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
#[link_name = "\u{1}__isoc99_fscanf"]
|
|
pub fn fscanf1(
|
|
__stream: *mut FILE,
|
|
__format: *const ::std::os::raw::c_char,
|
|
...
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
#[link_name = "\u{1}__isoc99_scanf"]
|
|
pub fn scanf1(__format: *const ::std::os::raw::c_char, ...) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
#[link_name = "\u{1}__isoc99_sscanf"]
|
|
pub fn sscanf1(
|
|
__s: *const ::std::os::raw::c_char,
|
|
__format: *const ::std::os::raw::c_char,
|
|
...
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn vfscanf(
|
|
__s: *mut FILE,
|
|
__format: *const ::std::os::raw::c_char,
|
|
__arg: *mut __va_list_tag,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn vscanf(
|
|
__format: *const ::std::os::raw::c_char,
|
|
__arg: *mut __va_list_tag,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn vsscanf(
|
|
__s: *const ::std::os::raw::c_char,
|
|
__format: *const ::std::os::raw::c_char,
|
|
__arg: *mut __va_list_tag,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
#[link_name = "\u{1}__isoc99_vfscanf"]
|
|
pub fn vfscanf1(
|
|
__s: *mut FILE,
|
|
__format: *const ::std::os::raw::c_char,
|
|
__arg: *mut __va_list_tag,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
#[link_name = "\u{1}__isoc99_vscanf"]
|
|
pub fn vscanf1(
|
|
__format: *const ::std::os::raw::c_char,
|
|
__arg: *mut __va_list_tag,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
#[link_name = "\u{1}__isoc99_vsscanf"]
|
|
pub fn vsscanf1(
|
|
__s: *const ::std::os::raw::c_char,
|
|
__format: *const ::std::os::raw::c_char,
|
|
__arg: *mut __va_list_tag,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn fgetc(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn getc(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn getchar() -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn getc_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn getchar_unlocked() -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn fgetc_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn fputc(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn putc(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn putchar(__c: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn fputc_unlocked(__c: ::std::os::raw::c_int, __stream: *mut FILE)
|
|
-> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn putc_unlocked(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn putchar_unlocked(__c: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn getw(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn putw(__w: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn fgets(
|
|
__s: *mut ::std::os::raw::c_char,
|
|
__n: ::std::os::raw::c_int,
|
|
__stream: *mut FILE,
|
|
) -> *mut ::std::os::raw::c_char;
|
|
}
|
|
extern "C" {
|
|
pub fn __getdelim(
|
|
__lineptr: *mut *mut ::std::os::raw::c_char,
|
|
__n: *mut size_t,
|
|
__delimiter: ::std::os::raw::c_int,
|
|
__stream: *mut FILE,
|
|
) -> __ssize_t;
|
|
}
|
|
extern "C" {
|
|
pub fn getdelim(
|
|
__lineptr: *mut *mut ::std::os::raw::c_char,
|
|
__n: *mut size_t,
|
|
__delimiter: ::std::os::raw::c_int,
|
|
__stream: *mut FILE,
|
|
) -> __ssize_t;
|
|
}
|
|
extern "C" {
|
|
pub fn getline(
|
|
__lineptr: *mut *mut ::std::os::raw::c_char,
|
|
__n: *mut size_t,
|
|
__stream: *mut FILE,
|
|
) -> __ssize_t;
|
|
}
|
|
extern "C" {
|
|
pub fn fputs(__s: *const ::std::os::raw::c_char, __stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn puts(__s: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn ungetc(__c: ::std::os::raw::c_int, __stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn fread(
|
|
__ptr: *mut ::std::os::raw::c_void,
|
|
__size: ::std::os::raw::c_ulong,
|
|
__n: ::std::os::raw::c_ulong,
|
|
__stream: *mut FILE,
|
|
) -> ::std::os::raw::c_ulong;
|
|
}
|
|
extern "C" {
|
|
pub fn fwrite(
|
|
__ptr: *const ::std::os::raw::c_void,
|
|
__size: ::std::os::raw::c_ulong,
|
|
__n: ::std::os::raw::c_ulong,
|
|
__s: *mut FILE,
|
|
) -> ::std::os::raw::c_ulong;
|
|
}
|
|
extern "C" {
|
|
pub fn fread_unlocked(
|
|
__ptr: *mut ::std::os::raw::c_void,
|
|
__size: size_t,
|
|
__n: size_t,
|
|
__stream: *mut FILE,
|
|
) -> size_t;
|
|
}
|
|
extern "C" {
|
|
pub fn fwrite_unlocked(
|
|
__ptr: *const ::std::os::raw::c_void,
|
|
__size: size_t,
|
|
__n: size_t,
|
|
__stream: *mut FILE,
|
|
) -> size_t;
|
|
}
|
|
extern "C" {
|
|
pub fn fseek(
|
|
__stream: *mut FILE,
|
|
__off: ::std::os::raw::c_long,
|
|
__whence: ::std::os::raw::c_int,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn ftell(__stream: *mut FILE) -> ::std::os::raw::c_long;
|
|
}
|
|
extern "C" {
|
|
pub fn rewind(__stream: *mut FILE);
|
|
}
|
|
extern "C" {
|
|
pub fn fseeko(
|
|
__stream: *mut FILE,
|
|
__off: __off_t,
|
|
__whence: ::std::os::raw::c_int,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn ftello(__stream: *mut FILE) -> __off_t;
|
|
}
|
|
extern "C" {
|
|
pub fn fgetpos(__stream: *mut FILE, __pos: *mut fpos_t) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn fsetpos(__stream: *mut FILE, __pos: *const fpos_t) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn clearerr(__stream: *mut FILE);
|
|
}
|
|
extern "C" {
|
|
pub fn feof(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn ferror(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn clearerr_unlocked(__stream: *mut FILE);
|
|
}
|
|
extern "C" {
|
|
pub fn feof_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn ferror_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn perror(__s: *const ::std::os::raw::c_char);
|
|
}
|
|
extern "C" {
|
|
pub static mut sys_nerr: ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub static mut sys_errlist: [*const ::std::os::raw::c_char; 0usize];
|
|
}
|
|
extern "C" {
|
|
pub fn fileno(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn fileno_unlocked(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn popen(
|
|
__command: *const ::std::os::raw::c_char,
|
|
__modes: *const ::std::os::raw::c_char,
|
|
) -> *mut FILE;
|
|
}
|
|
extern "C" {
|
|
pub fn pclose(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn ctermid(__s: *mut ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
|
|
}
|
|
extern "C" {
|
|
pub fn flockfile(__stream: *mut FILE);
|
|
}
|
|
extern "C" {
|
|
pub fn ftrylockfile(__stream: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn funlockfile(__stream: *mut FILE);
|
|
}
|
|
extern "C" {
|
|
pub fn __uflow(arg1: *mut FILE) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn __overflow(arg1: *mut FILE, arg2: ::std::os::raw::c_int) -> ::std::os::raw::c_int;
|
|
}
|
|
pub type int_least8_t = __int_least8_t;
|
|
pub type int_least16_t = __int_least16_t;
|
|
pub type int_least32_t = __int_least32_t;
|
|
pub type int_least64_t = __int_least64_t;
|
|
pub type uint_least8_t = __uint_least8_t;
|
|
pub type uint_least16_t = __uint_least16_t;
|
|
pub type uint_least32_t = __uint_least32_t;
|
|
pub type uint_least64_t = __uint_least64_t;
|
|
pub type int_fast8_t = ::std::os::raw::c_schar;
|
|
pub type int_fast16_t = ::std::os::raw::c_long;
|
|
pub type int_fast32_t = ::std::os::raw::c_long;
|
|
pub type int_fast64_t = ::std::os::raw::c_long;
|
|
pub type uint_fast8_t = ::std::os::raw::c_uchar;
|
|
pub type uint_fast16_t = ::std::os::raw::c_ulong;
|
|
pub type uint_fast32_t = ::std::os::raw::c_ulong;
|
|
pub type uint_fast64_t = ::std::os::raw::c_ulong;
|
|
pub type intmax_t = __intmax_t;
|
|
pub type uintmax_t = __uintmax_t;
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImGuiContext {
|
|
_unused: [u8; 0],
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImDrawListSharedData {
|
|
_unused: [u8; 0],
|
|
}
|
|
pub type ImGuiCol = ::std::os::raw::c_int;
|
|
pub type ImGuiCond = ::std::os::raw::c_int;
|
|
pub type ImGuiDataType = ::std::os::raw::c_int;
|
|
pub type ImGuiDir = ::std::os::raw::c_int;
|
|
pub type ImGuiKey = ::std::os::raw::c_int;
|
|
pub type ImGuiNavInput = ::std::os::raw::c_int;
|
|
pub type ImGuiMouseButton = ::std::os::raw::c_int;
|
|
pub type ImGuiMouseCursor = ::std::os::raw::c_int;
|
|
pub type ImGuiStyleVar = ::std::os::raw::c_int;
|
|
pub type ImDrawCornerFlags = ::std::os::raw::c_int;
|
|
pub type ImDrawListFlags = ::std::os::raw::c_int;
|
|
pub type ImFontAtlasFlags = ::std::os::raw::c_int;
|
|
pub type ImGuiBackendFlags = ::std::os::raw::c_int;
|
|
pub type ImGuiColorEditFlags = ::std::os::raw::c_int;
|
|
pub type ImGuiConfigFlags = ::std::os::raw::c_int;
|
|
pub type ImGuiComboFlags = ::std::os::raw::c_int;
|
|
pub type ImGuiDragDropFlags = ::std::os::raw::c_int;
|
|
pub type ImGuiFocusedFlags = ::std::os::raw::c_int;
|
|
pub type ImGuiHoveredFlags = ::std::os::raw::c_int;
|
|
pub type ImGuiInputTextFlags = ::std::os::raw::c_int;
|
|
pub type ImGuiKeyModFlags = ::std::os::raw::c_int;
|
|
pub type ImGuiPopupFlags = ::std::os::raw::c_int;
|
|
pub type ImGuiSelectableFlags = ::std::os::raw::c_int;
|
|
pub type ImGuiTabBarFlags = ::std::os::raw::c_int;
|
|
pub type ImGuiTabItemFlags = ::std::os::raw::c_int;
|
|
pub type ImGuiTreeNodeFlags = ::std::os::raw::c_int;
|
|
pub type ImGuiWindowFlags = ::std::os::raw::c_int;
|
|
pub type ImTextureID = *mut ::std::os::raw::c_void;
|
|
pub type ImGuiID = ::std::os::raw::c_uint;
|
|
pub type ImGuiInputTextCallback = ::std::option::Option<
|
|
unsafe extern "C" fn(data: *mut ImGuiInputTextCallbackData) -> ::std::os::raw::c_int,
|
|
>;
|
|
pub type ImGuiSizeCallback =
|
|
::std::option::Option<unsafe extern "C" fn(data: *mut ImGuiSizeCallbackData)>;
|
|
pub type ImWchar16 = ::std::os::raw::c_ushort;
|
|
pub type ImWchar32 = ::std::os::raw::c_uint;
|
|
pub type ImWchar = ImWchar16;
|
|
pub type ImS8 = ::std::os::raw::c_schar;
|
|
pub type ImU8 = ::std::os::raw::c_uchar;
|
|
pub type ImS16 = ::std::os::raw::c_short;
|
|
pub type ImU16 = ::std::os::raw::c_ushort;
|
|
pub type ImS32 = ::std::os::raw::c_int;
|
|
pub type ImU32 = ::std::os::raw::c_uint;
|
|
pub type ImS64 = i64;
|
|
pub type ImU64 = u64;
|
|
pub type ImDrawCallback = ::std::option::Option<
|
|
unsafe extern "C" fn(parent_list: *const ImDrawList, cmd: *const ImDrawCmd),
|
|
>;
|
|
pub type ImDrawIdx = ::std::os::raw::c_ushort;
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImVector {
|
|
pub Size: ::std::os::raw::c_int,
|
|
pub Capacity: ::std::os::raw::c_int,
|
|
pub Data: *mut ::std::os::raw::c_void,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImVector() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImVector>(),
|
|
16usize,
|
|
concat!("Size of: ", stringify!(ImVector))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImVector>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImVector))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector>())).Size as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector),
|
|
"::",
|
|
stringify!(Size)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector>())).Capacity as *const _ as usize },
|
|
4usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector),
|
|
"::",
|
|
stringify!(Capacity)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector>())).Data as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector),
|
|
"::",
|
|
stringify!(Data)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImVector_float {
|
|
pub Size: ::std::os::raw::c_int,
|
|
pub Capacity: ::std::os::raw::c_int,
|
|
pub Data: *mut f32,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImVector_float() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImVector_float>(),
|
|
16usize,
|
|
concat!("Size of: ", stringify!(ImVector_float))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImVector_float>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImVector_float))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_float>())).Size as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_float),
|
|
"::",
|
|
stringify!(Size)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_float>())).Capacity as *const _ as usize },
|
|
4usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_float),
|
|
"::",
|
|
stringify!(Capacity)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_float>())).Data as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_float),
|
|
"::",
|
|
stringify!(Data)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImVector_ImWchar {
|
|
pub Size: ::std::os::raw::c_int,
|
|
pub Capacity: ::std::os::raw::c_int,
|
|
pub Data: *mut ImWchar,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImVector_ImWchar() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImVector_ImWchar>(),
|
|
16usize,
|
|
concat!("Size of: ", stringify!(ImVector_ImWchar))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImVector_ImWchar>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImVector_ImWchar))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImWchar>())).Size as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImWchar),
|
|
"::",
|
|
stringify!(Size)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImWchar>())).Capacity as *const _ as usize },
|
|
4usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImWchar),
|
|
"::",
|
|
stringify!(Capacity)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImWchar>())).Data as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImWchar),
|
|
"::",
|
|
stringify!(Data)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImVector_ImDrawVert {
|
|
pub Size: ::std::os::raw::c_int,
|
|
pub Capacity: ::std::os::raw::c_int,
|
|
pub Data: *mut ImDrawVert,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImVector_ImDrawVert() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImVector_ImDrawVert>(),
|
|
16usize,
|
|
concat!("Size of: ", stringify!(ImVector_ImDrawVert))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImVector_ImDrawVert>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImVector_ImDrawVert))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImDrawVert>())).Size as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImDrawVert),
|
|
"::",
|
|
stringify!(Size)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImDrawVert>())).Capacity as *const _ as usize },
|
|
4usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImDrawVert),
|
|
"::",
|
|
stringify!(Capacity)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImDrawVert>())).Data as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImDrawVert),
|
|
"::",
|
|
stringify!(Data)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImVector_ImFontGlyph {
|
|
pub Size: ::std::os::raw::c_int,
|
|
pub Capacity: ::std::os::raw::c_int,
|
|
pub Data: *mut ImFontGlyph,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImVector_ImFontGlyph() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImVector_ImFontGlyph>(),
|
|
16usize,
|
|
concat!("Size of: ", stringify!(ImVector_ImFontGlyph))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImVector_ImFontGlyph>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImVector_ImFontGlyph))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImFontGlyph>())).Size as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImFontGlyph),
|
|
"::",
|
|
stringify!(Size)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImFontGlyph>())).Capacity as *const _ as usize },
|
|
4usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImFontGlyph),
|
|
"::",
|
|
stringify!(Capacity)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImFontGlyph>())).Data as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImFontGlyph),
|
|
"::",
|
|
stringify!(Data)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImVector_ImGuiTextRange {
|
|
pub Size: ::std::os::raw::c_int,
|
|
pub Capacity: ::std::os::raw::c_int,
|
|
pub Data: *mut ImGuiTextRange,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImVector_ImGuiTextRange() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImVector_ImGuiTextRange>(),
|
|
16usize,
|
|
concat!("Size of: ", stringify!(ImVector_ImGuiTextRange))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImVector_ImGuiTextRange>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImVector_ImGuiTextRange))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImGuiTextRange>())).Size as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImGuiTextRange),
|
|
"::",
|
|
stringify!(Size)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<ImVector_ImGuiTextRange>())).Capacity as *const _ as usize
|
|
},
|
|
4usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImGuiTextRange),
|
|
"::",
|
|
stringify!(Capacity)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImGuiTextRange>())).Data as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImGuiTextRange),
|
|
"::",
|
|
stringify!(Data)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImVector_ImGuiStoragePair {
|
|
pub Size: ::std::os::raw::c_int,
|
|
pub Capacity: ::std::os::raw::c_int,
|
|
pub Data: *mut ImGuiStoragePair,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImVector_ImGuiStoragePair() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImVector_ImGuiStoragePair>(),
|
|
16usize,
|
|
concat!("Size of: ", stringify!(ImVector_ImGuiStoragePair))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImVector_ImGuiStoragePair>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImVector_ImGuiStoragePair))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImGuiStoragePair>())).Size as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImGuiStoragePair),
|
|
"::",
|
|
stringify!(Size)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<ImVector_ImGuiStoragePair>())).Capacity as *const _ as usize
|
|
},
|
|
4usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImGuiStoragePair),
|
|
"::",
|
|
stringify!(Capacity)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImGuiStoragePair>())).Data as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImGuiStoragePair),
|
|
"::",
|
|
stringify!(Data)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImVector_ImDrawChannel {
|
|
pub Size: ::std::os::raw::c_int,
|
|
pub Capacity: ::std::os::raw::c_int,
|
|
pub Data: *mut ImDrawChannel,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImVector_ImDrawChannel() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImVector_ImDrawChannel>(),
|
|
16usize,
|
|
concat!("Size of: ", stringify!(ImVector_ImDrawChannel))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImVector_ImDrawChannel>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImVector_ImDrawChannel))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImDrawChannel>())).Size as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImDrawChannel),
|
|
"::",
|
|
stringify!(Size)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImDrawChannel>())).Capacity as *const _ as usize },
|
|
4usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImDrawChannel),
|
|
"::",
|
|
stringify!(Capacity)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImDrawChannel>())).Data as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImDrawChannel),
|
|
"::",
|
|
stringify!(Data)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImVector_char {
|
|
pub Size: ::std::os::raw::c_int,
|
|
pub Capacity: ::std::os::raw::c_int,
|
|
pub Data: *mut ::std::os::raw::c_char,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImVector_char() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImVector_char>(),
|
|
16usize,
|
|
concat!("Size of: ", stringify!(ImVector_char))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImVector_char>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImVector_char))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_char>())).Size as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_char),
|
|
"::",
|
|
stringify!(Size)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_char>())).Capacity as *const _ as usize },
|
|
4usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_char),
|
|
"::",
|
|
stringify!(Capacity)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_char>())).Data as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_char),
|
|
"::",
|
|
stringify!(Data)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImVector_ImU32 {
|
|
pub Size: ::std::os::raw::c_int,
|
|
pub Capacity: ::std::os::raw::c_int,
|
|
pub Data: *mut ImU32,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImVector_ImU32() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImVector_ImU32>(),
|
|
16usize,
|
|
concat!("Size of: ", stringify!(ImVector_ImU32))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImVector_ImU32>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImVector_ImU32))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImU32>())).Size as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImU32),
|
|
"::",
|
|
stringify!(Size)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImU32>())).Capacity as *const _ as usize },
|
|
4usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImU32),
|
|
"::",
|
|
stringify!(Capacity)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImU32>())).Data as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImU32),
|
|
"::",
|
|
stringify!(Data)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImVector_ImFontAtlasCustomRect {
|
|
pub Size: ::std::os::raw::c_int,
|
|
pub Capacity: ::std::os::raw::c_int,
|
|
pub Data: *mut ImFontAtlasCustomRect,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImVector_ImFontAtlasCustomRect() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImVector_ImFontAtlasCustomRect>(),
|
|
16usize,
|
|
concat!("Size of: ", stringify!(ImVector_ImFontAtlasCustomRect))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImVector_ImFontAtlasCustomRect>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImVector_ImFontAtlasCustomRect))
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<ImVector_ImFontAtlasCustomRect>())).Size as *const _ as usize
|
|
},
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImFontAtlasCustomRect),
|
|
"::",
|
|
stringify!(Size)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<ImVector_ImFontAtlasCustomRect>())).Capacity as *const _ as usize
|
|
},
|
|
4usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImFontAtlasCustomRect),
|
|
"::",
|
|
stringify!(Capacity)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<ImVector_ImFontAtlasCustomRect>())).Data as *const _ as usize
|
|
},
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImFontAtlasCustomRect),
|
|
"::",
|
|
stringify!(Data)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImVector_ImTextureID {
|
|
pub Size: ::std::os::raw::c_int,
|
|
pub Capacity: ::std::os::raw::c_int,
|
|
pub Data: *mut ImTextureID,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImVector_ImTextureID() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImVector_ImTextureID>(),
|
|
16usize,
|
|
concat!("Size of: ", stringify!(ImVector_ImTextureID))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImVector_ImTextureID>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImVector_ImTextureID))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImTextureID>())).Size as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImTextureID),
|
|
"::",
|
|
stringify!(Size)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImTextureID>())).Capacity as *const _ as usize },
|
|
4usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImTextureID),
|
|
"::",
|
|
stringify!(Capacity)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImTextureID>())).Data as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImTextureID),
|
|
"::",
|
|
stringify!(Data)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImVector_ImFontConfig {
|
|
pub Size: ::std::os::raw::c_int,
|
|
pub Capacity: ::std::os::raw::c_int,
|
|
pub Data: *mut ImFontConfig,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImVector_ImFontConfig() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImVector_ImFontConfig>(),
|
|
16usize,
|
|
concat!("Size of: ", stringify!(ImVector_ImFontConfig))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImVector_ImFontConfig>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImVector_ImFontConfig))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImFontConfig>())).Size as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImFontConfig),
|
|
"::",
|
|
stringify!(Size)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImFontConfig>())).Capacity as *const _ as usize },
|
|
4usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImFontConfig),
|
|
"::",
|
|
stringify!(Capacity)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImFontConfig>())).Data as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImFontConfig),
|
|
"::",
|
|
stringify!(Data)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImVector_ImFontPtr {
|
|
pub Size: ::std::os::raw::c_int,
|
|
pub Capacity: ::std::os::raw::c_int,
|
|
pub Data: *mut *mut ImFont,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImVector_ImFontPtr() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImVector_ImFontPtr>(),
|
|
16usize,
|
|
concat!("Size of: ", stringify!(ImVector_ImFontPtr))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImVector_ImFontPtr>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImVector_ImFontPtr))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImFontPtr>())).Size as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImFontPtr),
|
|
"::",
|
|
stringify!(Size)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImFontPtr>())).Capacity as *const _ as usize },
|
|
4usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImFontPtr),
|
|
"::",
|
|
stringify!(Capacity)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImFontPtr>())).Data as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImFontPtr),
|
|
"::",
|
|
stringify!(Data)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImVector_ImDrawCmd {
|
|
pub Size: ::std::os::raw::c_int,
|
|
pub Capacity: ::std::os::raw::c_int,
|
|
pub Data: *mut ImDrawCmd,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImVector_ImDrawCmd() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImVector_ImDrawCmd>(),
|
|
16usize,
|
|
concat!("Size of: ", stringify!(ImVector_ImDrawCmd))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImVector_ImDrawCmd>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImVector_ImDrawCmd))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImDrawCmd>())).Size as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImDrawCmd),
|
|
"::",
|
|
stringify!(Size)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImDrawCmd>())).Capacity as *const _ as usize },
|
|
4usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImDrawCmd),
|
|
"::",
|
|
stringify!(Capacity)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImDrawCmd>())).Data as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImDrawCmd),
|
|
"::",
|
|
stringify!(Data)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImVector_ImVec4 {
|
|
pub Size: ::std::os::raw::c_int,
|
|
pub Capacity: ::std::os::raw::c_int,
|
|
pub Data: *mut ImVec4,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImVector_ImVec4() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImVector_ImVec4>(),
|
|
16usize,
|
|
concat!("Size of: ", stringify!(ImVector_ImVec4))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImVector_ImVec4>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImVector_ImVec4))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImVec4>())).Size as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImVec4),
|
|
"::",
|
|
stringify!(Size)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImVec4>())).Capacity as *const _ as usize },
|
|
4usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImVec4),
|
|
"::",
|
|
stringify!(Capacity)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImVec4>())).Data as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImVec4),
|
|
"::",
|
|
stringify!(Data)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImVector_ImDrawIdx {
|
|
pub Size: ::std::os::raw::c_int,
|
|
pub Capacity: ::std::os::raw::c_int,
|
|
pub Data: *mut ImDrawIdx,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImVector_ImDrawIdx() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImVector_ImDrawIdx>(),
|
|
16usize,
|
|
concat!("Size of: ", stringify!(ImVector_ImDrawIdx))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImVector_ImDrawIdx>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImVector_ImDrawIdx))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImDrawIdx>())).Size as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImDrawIdx),
|
|
"::",
|
|
stringify!(Size)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImDrawIdx>())).Capacity as *const _ as usize },
|
|
4usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImDrawIdx),
|
|
"::",
|
|
stringify!(Capacity)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImDrawIdx>())).Data as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImDrawIdx),
|
|
"::",
|
|
stringify!(Data)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImVector_ImVec2 {
|
|
pub Size: ::std::os::raw::c_int,
|
|
pub Capacity: ::std::os::raw::c_int,
|
|
pub Data: *mut ImVec2,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImVector_ImVec2() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImVector_ImVec2>(),
|
|
16usize,
|
|
concat!("Size of: ", stringify!(ImVector_ImVec2))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImVector_ImVec2>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImVector_ImVec2))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImVec2>())).Size as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImVec2),
|
|
"::",
|
|
stringify!(Size)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImVec2>())).Capacity as *const _ as usize },
|
|
4usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImVec2),
|
|
"::",
|
|
stringify!(Capacity)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVector_ImVec2>())).Data as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImVector_ImVec2),
|
|
"::",
|
|
stringify!(Data)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImVec2 {
|
|
pub x: f32,
|
|
pub y: f32,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImVec2() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImVec2>(),
|
|
8usize,
|
|
concat!("Size of: ", stringify!(ImVec2))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImVec2>(),
|
|
4usize,
|
|
concat!("Alignment of ", stringify!(ImVec2))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVec2>())).x as *const _ as usize },
|
|
0usize,
|
|
concat!("Offset of field: ", stringify!(ImVec2), "::", stringify!(x))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVec2>())).y as *const _ as usize },
|
|
4usize,
|
|
concat!("Offset of field: ", stringify!(ImVec2), "::", stringify!(y))
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImVec4 {
|
|
pub x: f32,
|
|
pub y: f32,
|
|
pub z: f32,
|
|
pub w: f32,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImVec4() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImVec4>(),
|
|
16usize,
|
|
concat!("Size of: ", stringify!(ImVec4))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImVec4>(),
|
|
4usize,
|
|
concat!("Alignment of ", stringify!(ImVec4))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVec4>())).x as *const _ as usize },
|
|
0usize,
|
|
concat!("Offset of field: ", stringify!(ImVec4), "::", stringify!(x))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVec4>())).y as *const _ as usize },
|
|
4usize,
|
|
concat!("Offset of field: ", stringify!(ImVec4), "::", stringify!(y))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVec4>())).z as *const _ as usize },
|
|
8usize,
|
|
concat!("Offset of field: ", stringify!(ImVec4), "::", stringify!(z))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImVec4>())).w as *const _ as usize },
|
|
12usize,
|
|
concat!("Offset of field: ", stringify!(ImVec4), "::", stringify!(w))
|
|
);
|
|
}
|
|
pub const ImGuiWindowFlags__ImGuiWindowFlags_None: ImGuiWindowFlags_ = 0;
|
|
pub const ImGuiWindowFlags__ImGuiWindowFlags_NoTitleBar: ImGuiWindowFlags_ = 1;
|
|
pub const ImGuiWindowFlags__ImGuiWindowFlags_NoResize: ImGuiWindowFlags_ = 2;
|
|
pub const ImGuiWindowFlags__ImGuiWindowFlags_NoMove: ImGuiWindowFlags_ = 4;
|
|
pub const ImGuiWindowFlags__ImGuiWindowFlags_NoScrollbar: ImGuiWindowFlags_ = 8;
|
|
pub const ImGuiWindowFlags__ImGuiWindowFlags_NoScrollWithMouse: ImGuiWindowFlags_ = 16;
|
|
pub const ImGuiWindowFlags__ImGuiWindowFlags_NoCollapse: ImGuiWindowFlags_ = 32;
|
|
pub const ImGuiWindowFlags__ImGuiWindowFlags_AlwaysAutoResize: ImGuiWindowFlags_ = 64;
|
|
pub const ImGuiWindowFlags__ImGuiWindowFlags_NoBackground: ImGuiWindowFlags_ = 128;
|
|
pub const ImGuiWindowFlags__ImGuiWindowFlags_NoSavedSettings: ImGuiWindowFlags_ = 256;
|
|
pub const ImGuiWindowFlags__ImGuiWindowFlags_NoMouseInputs: ImGuiWindowFlags_ = 512;
|
|
pub const ImGuiWindowFlags__ImGuiWindowFlags_MenuBar: ImGuiWindowFlags_ = 1024;
|
|
pub const ImGuiWindowFlags__ImGuiWindowFlags_HorizontalScrollbar: ImGuiWindowFlags_ = 2048;
|
|
pub const ImGuiWindowFlags__ImGuiWindowFlags_NoFocusOnAppearing: ImGuiWindowFlags_ = 4096;
|
|
pub const ImGuiWindowFlags__ImGuiWindowFlags_NoBringToFrontOnFocus: ImGuiWindowFlags_ = 8192;
|
|
pub const ImGuiWindowFlags__ImGuiWindowFlags_AlwaysVerticalScrollbar: ImGuiWindowFlags_ = 16384;
|
|
pub const ImGuiWindowFlags__ImGuiWindowFlags_AlwaysHorizontalScrollbar: ImGuiWindowFlags_ = 32768;
|
|
pub const ImGuiWindowFlags__ImGuiWindowFlags_AlwaysUseWindowPadding: ImGuiWindowFlags_ = 65536;
|
|
pub const ImGuiWindowFlags__ImGuiWindowFlags_NoNavInputs: ImGuiWindowFlags_ = 262144;
|
|
pub const ImGuiWindowFlags__ImGuiWindowFlags_NoNavFocus: ImGuiWindowFlags_ = 524288;
|
|
pub const ImGuiWindowFlags__ImGuiWindowFlags_UnsavedDocument: ImGuiWindowFlags_ = 1048576;
|
|
pub const ImGuiWindowFlags__ImGuiWindowFlags_NoNav: ImGuiWindowFlags_ = 786432;
|
|
pub const ImGuiWindowFlags__ImGuiWindowFlags_NoDecoration: ImGuiWindowFlags_ = 43;
|
|
pub const ImGuiWindowFlags__ImGuiWindowFlags_NoInputs: ImGuiWindowFlags_ = 786944;
|
|
pub const ImGuiWindowFlags__ImGuiWindowFlags_NavFlattened: ImGuiWindowFlags_ = 8388608;
|
|
pub const ImGuiWindowFlags__ImGuiWindowFlags_ChildWindow: ImGuiWindowFlags_ = 16777216;
|
|
pub const ImGuiWindowFlags__ImGuiWindowFlags_Tooltip: ImGuiWindowFlags_ = 33554432;
|
|
pub const ImGuiWindowFlags__ImGuiWindowFlags_Popup: ImGuiWindowFlags_ = 67108864;
|
|
pub const ImGuiWindowFlags__ImGuiWindowFlags_Modal: ImGuiWindowFlags_ = 134217728;
|
|
pub const ImGuiWindowFlags__ImGuiWindowFlags_ChildMenu: ImGuiWindowFlags_ = 268435456;
|
|
pub type ImGuiWindowFlags_ = u32;
|
|
pub const ImGuiInputTextFlags__ImGuiInputTextFlags_None: ImGuiInputTextFlags_ = 0;
|
|
pub const ImGuiInputTextFlags__ImGuiInputTextFlags_CharsDecimal: ImGuiInputTextFlags_ = 1;
|
|
pub const ImGuiInputTextFlags__ImGuiInputTextFlags_CharsHexadecimal: ImGuiInputTextFlags_ = 2;
|
|
pub const ImGuiInputTextFlags__ImGuiInputTextFlags_CharsUppercase: ImGuiInputTextFlags_ = 4;
|
|
pub const ImGuiInputTextFlags__ImGuiInputTextFlags_CharsNoBlank: ImGuiInputTextFlags_ = 8;
|
|
pub const ImGuiInputTextFlags__ImGuiInputTextFlags_AutoSelectAll: ImGuiInputTextFlags_ = 16;
|
|
pub const ImGuiInputTextFlags__ImGuiInputTextFlags_EnterReturnsTrue: ImGuiInputTextFlags_ = 32;
|
|
pub const ImGuiInputTextFlags__ImGuiInputTextFlags_CallbackCompletion: ImGuiInputTextFlags_ = 64;
|
|
pub const ImGuiInputTextFlags__ImGuiInputTextFlags_CallbackHistory: ImGuiInputTextFlags_ = 128;
|
|
pub const ImGuiInputTextFlags__ImGuiInputTextFlags_CallbackAlways: ImGuiInputTextFlags_ = 256;
|
|
pub const ImGuiInputTextFlags__ImGuiInputTextFlags_CallbackCharFilter: ImGuiInputTextFlags_ = 512;
|
|
pub const ImGuiInputTextFlags__ImGuiInputTextFlags_AllowTabInput: ImGuiInputTextFlags_ = 1024;
|
|
pub const ImGuiInputTextFlags__ImGuiInputTextFlags_CtrlEnterForNewLine: ImGuiInputTextFlags_ = 2048;
|
|
pub const ImGuiInputTextFlags__ImGuiInputTextFlags_NoHorizontalScroll: ImGuiInputTextFlags_ = 4096;
|
|
pub const ImGuiInputTextFlags__ImGuiInputTextFlags_AlwaysInsertMode: ImGuiInputTextFlags_ = 8192;
|
|
pub const ImGuiInputTextFlags__ImGuiInputTextFlags_ReadOnly: ImGuiInputTextFlags_ = 16384;
|
|
pub const ImGuiInputTextFlags__ImGuiInputTextFlags_Password: ImGuiInputTextFlags_ = 32768;
|
|
pub const ImGuiInputTextFlags__ImGuiInputTextFlags_NoUndoRedo: ImGuiInputTextFlags_ = 65536;
|
|
pub const ImGuiInputTextFlags__ImGuiInputTextFlags_CharsScientific: ImGuiInputTextFlags_ = 131072;
|
|
pub const ImGuiInputTextFlags__ImGuiInputTextFlags_CallbackResize: ImGuiInputTextFlags_ = 262144;
|
|
pub const ImGuiInputTextFlags__ImGuiInputTextFlags_Multiline: ImGuiInputTextFlags_ = 1048576;
|
|
pub const ImGuiInputTextFlags__ImGuiInputTextFlags_NoMarkEdited: ImGuiInputTextFlags_ = 2097152;
|
|
pub type ImGuiInputTextFlags_ = u32;
|
|
pub const ImGuiTreeNodeFlags__ImGuiTreeNodeFlags_None: ImGuiTreeNodeFlags_ = 0;
|
|
pub const ImGuiTreeNodeFlags__ImGuiTreeNodeFlags_Selected: ImGuiTreeNodeFlags_ = 1;
|
|
pub const ImGuiTreeNodeFlags__ImGuiTreeNodeFlags_Framed: ImGuiTreeNodeFlags_ = 2;
|
|
pub const ImGuiTreeNodeFlags__ImGuiTreeNodeFlags_AllowItemOverlap: ImGuiTreeNodeFlags_ = 4;
|
|
pub const ImGuiTreeNodeFlags__ImGuiTreeNodeFlags_NoTreePushOnOpen: ImGuiTreeNodeFlags_ = 8;
|
|
pub const ImGuiTreeNodeFlags__ImGuiTreeNodeFlags_NoAutoOpenOnLog: ImGuiTreeNodeFlags_ = 16;
|
|
pub const ImGuiTreeNodeFlags__ImGuiTreeNodeFlags_DefaultOpen: ImGuiTreeNodeFlags_ = 32;
|
|
pub const ImGuiTreeNodeFlags__ImGuiTreeNodeFlags_OpenOnDoubleClick: ImGuiTreeNodeFlags_ = 64;
|
|
pub const ImGuiTreeNodeFlags__ImGuiTreeNodeFlags_OpenOnArrow: ImGuiTreeNodeFlags_ = 128;
|
|
pub const ImGuiTreeNodeFlags__ImGuiTreeNodeFlags_Leaf: ImGuiTreeNodeFlags_ = 256;
|
|
pub const ImGuiTreeNodeFlags__ImGuiTreeNodeFlags_Bullet: ImGuiTreeNodeFlags_ = 512;
|
|
pub const ImGuiTreeNodeFlags__ImGuiTreeNodeFlags_FramePadding: ImGuiTreeNodeFlags_ = 1024;
|
|
pub const ImGuiTreeNodeFlags__ImGuiTreeNodeFlags_SpanAvailWidth: ImGuiTreeNodeFlags_ = 2048;
|
|
pub const ImGuiTreeNodeFlags__ImGuiTreeNodeFlags_SpanFullWidth: ImGuiTreeNodeFlags_ = 4096;
|
|
pub const ImGuiTreeNodeFlags__ImGuiTreeNodeFlags_NavLeftJumpsBackHere: ImGuiTreeNodeFlags_ = 8192;
|
|
pub const ImGuiTreeNodeFlags__ImGuiTreeNodeFlags_CollapsingHeader: ImGuiTreeNodeFlags_ = 26;
|
|
pub type ImGuiTreeNodeFlags_ = u32;
|
|
pub const ImGuiPopupFlags__ImGuiPopupFlags_None: ImGuiPopupFlags_ = 0;
|
|
pub const ImGuiPopupFlags__ImGuiPopupFlags_MouseButtonLeft: ImGuiPopupFlags_ = 0;
|
|
pub const ImGuiPopupFlags__ImGuiPopupFlags_MouseButtonRight: ImGuiPopupFlags_ = 1;
|
|
pub const ImGuiPopupFlags__ImGuiPopupFlags_MouseButtonMiddle: ImGuiPopupFlags_ = 2;
|
|
pub const ImGuiPopupFlags__ImGuiPopupFlags_MouseButtonMask_: ImGuiPopupFlags_ = 31;
|
|
pub const ImGuiPopupFlags__ImGuiPopupFlags_MouseButtonDefault_: ImGuiPopupFlags_ = 1;
|
|
pub const ImGuiPopupFlags__ImGuiPopupFlags_NoOpenOverExistingPopup: ImGuiPopupFlags_ = 32;
|
|
pub const ImGuiPopupFlags__ImGuiPopupFlags_NoOpenOverItems: ImGuiPopupFlags_ = 64;
|
|
pub const ImGuiPopupFlags__ImGuiPopupFlags_AnyPopupId: ImGuiPopupFlags_ = 128;
|
|
pub const ImGuiPopupFlags__ImGuiPopupFlags_AnyPopupLevel: ImGuiPopupFlags_ = 256;
|
|
pub const ImGuiPopupFlags__ImGuiPopupFlags_AnyPopup: ImGuiPopupFlags_ = 384;
|
|
pub type ImGuiPopupFlags_ = u32;
|
|
pub const ImGuiSelectableFlags__ImGuiSelectableFlags_None: ImGuiSelectableFlags_ = 0;
|
|
pub const ImGuiSelectableFlags__ImGuiSelectableFlags_DontClosePopups: ImGuiSelectableFlags_ = 1;
|
|
pub const ImGuiSelectableFlags__ImGuiSelectableFlags_SpanAllColumns: ImGuiSelectableFlags_ = 2;
|
|
pub const ImGuiSelectableFlags__ImGuiSelectableFlags_AllowDoubleClick: ImGuiSelectableFlags_ = 4;
|
|
pub const ImGuiSelectableFlags__ImGuiSelectableFlags_Disabled: ImGuiSelectableFlags_ = 8;
|
|
pub const ImGuiSelectableFlags__ImGuiSelectableFlags_AllowItemOverlap: ImGuiSelectableFlags_ = 16;
|
|
pub type ImGuiSelectableFlags_ = u32;
|
|
pub const ImGuiComboFlags__ImGuiComboFlags_None: ImGuiComboFlags_ = 0;
|
|
pub const ImGuiComboFlags__ImGuiComboFlags_PopupAlignLeft: ImGuiComboFlags_ = 1;
|
|
pub const ImGuiComboFlags__ImGuiComboFlags_HeightSmall: ImGuiComboFlags_ = 2;
|
|
pub const ImGuiComboFlags__ImGuiComboFlags_HeightRegular: ImGuiComboFlags_ = 4;
|
|
pub const ImGuiComboFlags__ImGuiComboFlags_HeightLarge: ImGuiComboFlags_ = 8;
|
|
pub const ImGuiComboFlags__ImGuiComboFlags_HeightLargest: ImGuiComboFlags_ = 16;
|
|
pub const ImGuiComboFlags__ImGuiComboFlags_NoArrowButton: ImGuiComboFlags_ = 32;
|
|
pub const ImGuiComboFlags__ImGuiComboFlags_NoPreview: ImGuiComboFlags_ = 64;
|
|
pub const ImGuiComboFlags__ImGuiComboFlags_HeightMask_: ImGuiComboFlags_ = 30;
|
|
pub type ImGuiComboFlags_ = u32;
|
|
pub const ImGuiTabBarFlags__ImGuiTabBarFlags_None: ImGuiTabBarFlags_ = 0;
|
|
pub const ImGuiTabBarFlags__ImGuiTabBarFlags_Reorderable: ImGuiTabBarFlags_ = 1;
|
|
pub const ImGuiTabBarFlags__ImGuiTabBarFlags_AutoSelectNewTabs: ImGuiTabBarFlags_ = 2;
|
|
pub const ImGuiTabBarFlags__ImGuiTabBarFlags_TabListPopupButton: ImGuiTabBarFlags_ = 4;
|
|
pub const ImGuiTabBarFlags__ImGuiTabBarFlags_NoCloseWithMiddleMouseButton: ImGuiTabBarFlags_ = 8;
|
|
pub const ImGuiTabBarFlags__ImGuiTabBarFlags_NoTabListScrollingButtons: ImGuiTabBarFlags_ = 16;
|
|
pub const ImGuiTabBarFlags__ImGuiTabBarFlags_NoTooltip: ImGuiTabBarFlags_ = 32;
|
|
pub const ImGuiTabBarFlags__ImGuiTabBarFlags_FittingPolicyResizeDown: ImGuiTabBarFlags_ = 64;
|
|
pub const ImGuiTabBarFlags__ImGuiTabBarFlags_FittingPolicyScroll: ImGuiTabBarFlags_ = 128;
|
|
pub const ImGuiTabBarFlags__ImGuiTabBarFlags_FittingPolicyMask_: ImGuiTabBarFlags_ = 192;
|
|
pub const ImGuiTabBarFlags__ImGuiTabBarFlags_FittingPolicyDefault_: ImGuiTabBarFlags_ = 64;
|
|
pub type ImGuiTabBarFlags_ = u32;
|
|
pub const ImGuiTabItemFlags__ImGuiTabItemFlags_None: ImGuiTabItemFlags_ = 0;
|
|
pub const ImGuiTabItemFlags__ImGuiTabItemFlags_UnsavedDocument: ImGuiTabItemFlags_ = 1;
|
|
pub const ImGuiTabItemFlags__ImGuiTabItemFlags_SetSelected: ImGuiTabItemFlags_ = 2;
|
|
pub const ImGuiTabItemFlags__ImGuiTabItemFlags_NoCloseWithMiddleMouseButton: ImGuiTabItemFlags_ = 4;
|
|
pub const ImGuiTabItemFlags__ImGuiTabItemFlags_NoPushId: ImGuiTabItemFlags_ = 8;
|
|
pub const ImGuiTabItemFlags__ImGuiTabItemFlags_NoTooltip: ImGuiTabItemFlags_ = 16;
|
|
pub type ImGuiTabItemFlags_ = u32;
|
|
pub const ImGuiFocusedFlags__ImGuiFocusedFlags_None: ImGuiFocusedFlags_ = 0;
|
|
pub const ImGuiFocusedFlags__ImGuiFocusedFlags_ChildWindows: ImGuiFocusedFlags_ = 1;
|
|
pub const ImGuiFocusedFlags__ImGuiFocusedFlags_RootWindow: ImGuiFocusedFlags_ = 2;
|
|
pub const ImGuiFocusedFlags__ImGuiFocusedFlags_AnyWindow: ImGuiFocusedFlags_ = 4;
|
|
pub const ImGuiFocusedFlags__ImGuiFocusedFlags_RootAndChildWindows: ImGuiFocusedFlags_ = 3;
|
|
pub type ImGuiFocusedFlags_ = u32;
|
|
pub const ImGuiHoveredFlags__ImGuiHoveredFlags_None: ImGuiHoveredFlags_ = 0;
|
|
pub const ImGuiHoveredFlags__ImGuiHoveredFlags_ChildWindows: ImGuiHoveredFlags_ = 1;
|
|
pub const ImGuiHoveredFlags__ImGuiHoveredFlags_RootWindow: ImGuiHoveredFlags_ = 2;
|
|
pub const ImGuiHoveredFlags__ImGuiHoveredFlags_AnyWindow: ImGuiHoveredFlags_ = 4;
|
|
pub const ImGuiHoveredFlags__ImGuiHoveredFlags_AllowWhenBlockedByPopup: ImGuiHoveredFlags_ = 8;
|
|
pub const ImGuiHoveredFlags__ImGuiHoveredFlags_AllowWhenBlockedByActiveItem: ImGuiHoveredFlags_ =
|
|
32;
|
|
pub const ImGuiHoveredFlags__ImGuiHoveredFlags_AllowWhenOverlapped: ImGuiHoveredFlags_ = 64;
|
|
pub const ImGuiHoveredFlags__ImGuiHoveredFlags_AllowWhenDisabled: ImGuiHoveredFlags_ = 128;
|
|
pub const ImGuiHoveredFlags__ImGuiHoveredFlags_RectOnly: ImGuiHoveredFlags_ = 104;
|
|
pub const ImGuiHoveredFlags__ImGuiHoveredFlags_RootAndChildWindows: ImGuiHoveredFlags_ = 3;
|
|
pub type ImGuiHoveredFlags_ = u32;
|
|
pub const ImGuiDragDropFlags__ImGuiDragDropFlags_None: ImGuiDragDropFlags_ = 0;
|
|
pub const ImGuiDragDropFlags__ImGuiDragDropFlags_SourceNoPreviewTooltip: ImGuiDragDropFlags_ = 1;
|
|
pub const ImGuiDragDropFlags__ImGuiDragDropFlags_SourceNoDisableHover: ImGuiDragDropFlags_ = 2;
|
|
pub const ImGuiDragDropFlags__ImGuiDragDropFlags_SourceNoHoldToOpenOthers: ImGuiDragDropFlags_ = 4;
|
|
pub const ImGuiDragDropFlags__ImGuiDragDropFlags_SourceAllowNullID: ImGuiDragDropFlags_ = 8;
|
|
pub const ImGuiDragDropFlags__ImGuiDragDropFlags_SourceExtern: ImGuiDragDropFlags_ = 16;
|
|
pub const ImGuiDragDropFlags__ImGuiDragDropFlags_SourceAutoExpirePayload: ImGuiDragDropFlags_ = 32;
|
|
pub const ImGuiDragDropFlags__ImGuiDragDropFlags_AcceptBeforeDelivery: ImGuiDragDropFlags_ = 1024;
|
|
pub const ImGuiDragDropFlags__ImGuiDragDropFlags_AcceptNoDrawDefaultRect: ImGuiDragDropFlags_ =
|
|
2048;
|
|
pub const ImGuiDragDropFlags__ImGuiDragDropFlags_AcceptNoPreviewTooltip: ImGuiDragDropFlags_ = 4096;
|
|
pub const ImGuiDragDropFlags__ImGuiDragDropFlags_AcceptPeekOnly: ImGuiDragDropFlags_ = 3072;
|
|
pub type ImGuiDragDropFlags_ = u32;
|
|
pub const ImGuiDataType__ImGuiDataType_S8: ImGuiDataType_ = 0;
|
|
pub const ImGuiDataType__ImGuiDataType_U8: ImGuiDataType_ = 1;
|
|
pub const ImGuiDataType__ImGuiDataType_S16: ImGuiDataType_ = 2;
|
|
pub const ImGuiDataType__ImGuiDataType_U16: ImGuiDataType_ = 3;
|
|
pub const ImGuiDataType__ImGuiDataType_S32: ImGuiDataType_ = 4;
|
|
pub const ImGuiDataType__ImGuiDataType_U32: ImGuiDataType_ = 5;
|
|
pub const ImGuiDataType__ImGuiDataType_S64: ImGuiDataType_ = 6;
|
|
pub const ImGuiDataType__ImGuiDataType_U64: ImGuiDataType_ = 7;
|
|
pub const ImGuiDataType__ImGuiDataType_Float: ImGuiDataType_ = 8;
|
|
pub const ImGuiDataType__ImGuiDataType_Double: ImGuiDataType_ = 9;
|
|
pub const ImGuiDataType__ImGuiDataType_COUNT: ImGuiDataType_ = 10;
|
|
pub type ImGuiDataType_ = u32;
|
|
pub const ImGuiDir__ImGuiDir_None: ImGuiDir_ = -1;
|
|
pub const ImGuiDir__ImGuiDir_Left: ImGuiDir_ = 0;
|
|
pub const ImGuiDir__ImGuiDir_Right: ImGuiDir_ = 1;
|
|
pub const ImGuiDir__ImGuiDir_Up: ImGuiDir_ = 2;
|
|
pub const ImGuiDir__ImGuiDir_Down: ImGuiDir_ = 3;
|
|
pub const ImGuiDir__ImGuiDir_COUNT: ImGuiDir_ = 4;
|
|
pub type ImGuiDir_ = i32;
|
|
pub const ImGuiKey__ImGuiKey_Tab: ImGuiKey_ = 0;
|
|
pub const ImGuiKey__ImGuiKey_LeftArrow: ImGuiKey_ = 1;
|
|
pub const ImGuiKey__ImGuiKey_RightArrow: ImGuiKey_ = 2;
|
|
pub const ImGuiKey__ImGuiKey_UpArrow: ImGuiKey_ = 3;
|
|
pub const ImGuiKey__ImGuiKey_DownArrow: ImGuiKey_ = 4;
|
|
pub const ImGuiKey__ImGuiKey_PageUp: ImGuiKey_ = 5;
|
|
pub const ImGuiKey__ImGuiKey_PageDown: ImGuiKey_ = 6;
|
|
pub const ImGuiKey__ImGuiKey_Home: ImGuiKey_ = 7;
|
|
pub const ImGuiKey__ImGuiKey_End: ImGuiKey_ = 8;
|
|
pub const ImGuiKey__ImGuiKey_Insert: ImGuiKey_ = 9;
|
|
pub const ImGuiKey__ImGuiKey_Delete: ImGuiKey_ = 10;
|
|
pub const ImGuiKey__ImGuiKey_Backspace: ImGuiKey_ = 11;
|
|
pub const ImGuiKey__ImGuiKey_Space: ImGuiKey_ = 12;
|
|
pub const ImGuiKey__ImGuiKey_Enter: ImGuiKey_ = 13;
|
|
pub const ImGuiKey__ImGuiKey_Escape: ImGuiKey_ = 14;
|
|
pub const ImGuiKey__ImGuiKey_KeyPadEnter: ImGuiKey_ = 15;
|
|
pub const ImGuiKey__ImGuiKey_A: ImGuiKey_ = 16;
|
|
pub const ImGuiKey__ImGuiKey_C: ImGuiKey_ = 17;
|
|
pub const ImGuiKey__ImGuiKey_V: ImGuiKey_ = 18;
|
|
pub const ImGuiKey__ImGuiKey_X: ImGuiKey_ = 19;
|
|
pub const ImGuiKey__ImGuiKey_Y: ImGuiKey_ = 20;
|
|
pub const ImGuiKey__ImGuiKey_Z: ImGuiKey_ = 21;
|
|
pub const ImGuiKey__ImGuiKey_COUNT: ImGuiKey_ = 22;
|
|
pub type ImGuiKey_ = u32;
|
|
pub const ImGuiKeyModFlags__ImGuiKeyModFlags_None: ImGuiKeyModFlags_ = 0;
|
|
pub const ImGuiKeyModFlags__ImGuiKeyModFlags_Ctrl: ImGuiKeyModFlags_ = 1;
|
|
pub const ImGuiKeyModFlags__ImGuiKeyModFlags_Shift: ImGuiKeyModFlags_ = 2;
|
|
pub const ImGuiKeyModFlags__ImGuiKeyModFlags_Alt: ImGuiKeyModFlags_ = 4;
|
|
pub const ImGuiKeyModFlags__ImGuiKeyModFlags_Super: ImGuiKeyModFlags_ = 8;
|
|
pub type ImGuiKeyModFlags_ = u32;
|
|
pub const ImGuiNavInput__ImGuiNavInput_Activate: ImGuiNavInput_ = 0;
|
|
pub const ImGuiNavInput__ImGuiNavInput_Cancel: ImGuiNavInput_ = 1;
|
|
pub const ImGuiNavInput__ImGuiNavInput_Input: ImGuiNavInput_ = 2;
|
|
pub const ImGuiNavInput__ImGuiNavInput_Menu: ImGuiNavInput_ = 3;
|
|
pub const ImGuiNavInput__ImGuiNavInput_DpadLeft: ImGuiNavInput_ = 4;
|
|
pub const ImGuiNavInput__ImGuiNavInput_DpadRight: ImGuiNavInput_ = 5;
|
|
pub const ImGuiNavInput__ImGuiNavInput_DpadUp: ImGuiNavInput_ = 6;
|
|
pub const ImGuiNavInput__ImGuiNavInput_DpadDown: ImGuiNavInput_ = 7;
|
|
pub const ImGuiNavInput__ImGuiNavInput_LStickLeft: ImGuiNavInput_ = 8;
|
|
pub const ImGuiNavInput__ImGuiNavInput_LStickRight: ImGuiNavInput_ = 9;
|
|
pub const ImGuiNavInput__ImGuiNavInput_LStickUp: ImGuiNavInput_ = 10;
|
|
pub const ImGuiNavInput__ImGuiNavInput_LStickDown: ImGuiNavInput_ = 11;
|
|
pub const ImGuiNavInput__ImGuiNavInput_FocusPrev: ImGuiNavInput_ = 12;
|
|
pub const ImGuiNavInput__ImGuiNavInput_FocusNext: ImGuiNavInput_ = 13;
|
|
pub const ImGuiNavInput__ImGuiNavInput_TweakSlow: ImGuiNavInput_ = 14;
|
|
pub const ImGuiNavInput__ImGuiNavInput_TweakFast: ImGuiNavInput_ = 15;
|
|
pub const ImGuiNavInput__ImGuiNavInput_KeyMenu_: ImGuiNavInput_ = 16;
|
|
pub const ImGuiNavInput__ImGuiNavInput_KeyLeft_: ImGuiNavInput_ = 17;
|
|
pub const ImGuiNavInput__ImGuiNavInput_KeyRight_: ImGuiNavInput_ = 18;
|
|
pub const ImGuiNavInput__ImGuiNavInput_KeyUp_: ImGuiNavInput_ = 19;
|
|
pub const ImGuiNavInput__ImGuiNavInput_KeyDown_: ImGuiNavInput_ = 20;
|
|
pub const ImGuiNavInput__ImGuiNavInput_COUNT: ImGuiNavInput_ = 21;
|
|
pub const ImGuiNavInput__ImGuiNavInput_InternalStart_: ImGuiNavInput_ = 16;
|
|
pub type ImGuiNavInput_ = u32;
|
|
pub const ImGuiConfigFlags__ImGuiConfigFlags_None: ImGuiConfigFlags_ = 0;
|
|
pub const ImGuiConfigFlags__ImGuiConfigFlags_NavEnableKeyboard: ImGuiConfigFlags_ = 1;
|
|
pub const ImGuiConfigFlags__ImGuiConfigFlags_NavEnableGamepad: ImGuiConfigFlags_ = 2;
|
|
pub const ImGuiConfigFlags__ImGuiConfigFlags_NavEnableSetMousePos: ImGuiConfigFlags_ = 4;
|
|
pub const ImGuiConfigFlags__ImGuiConfigFlags_NavNoCaptureKeyboard: ImGuiConfigFlags_ = 8;
|
|
pub const ImGuiConfigFlags__ImGuiConfigFlags_NoMouse: ImGuiConfigFlags_ = 16;
|
|
pub const ImGuiConfigFlags__ImGuiConfigFlags_NoMouseCursorChange: ImGuiConfigFlags_ = 32;
|
|
pub const ImGuiConfigFlags__ImGuiConfigFlags_IsSRGB: ImGuiConfigFlags_ = 1048576;
|
|
pub const ImGuiConfigFlags__ImGuiConfigFlags_IsTouchScreen: ImGuiConfigFlags_ = 2097152;
|
|
pub type ImGuiConfigFlags_ = u32;
|
|
pub const ImGuiBackendFlags__ImGuiBackendFlags_None: ImGuiBackendFlags_ = 0;
|
|
pub const ImGuiBackendFlags__ImGuiBackendFlags_HasGamepad: ImGuiBackendFlags_ = 1;
|
|
pub const ImGuiBackendFlags__ImGuiBackendFlags_HasMouseCursors: ImGuiBackendFlags_ = 2;
|
|
pub const ImGuiBackendFlags__ImGuiBackendFlags_HasSetMousePos: ImGuiBackendFlags_ = 4;
|
|
pub const ImGuiBackendFlags__ImGuiBackendFlags_RendererHasVtxOffset: ImGuiBackendFlags_ = 8;
|
|
pub type ImGuiBackendFlags_ = u32;
|
|
pub const ImGuiCol__ImGuiCol_Text: ImGuiCol_ = 0;
|
|
pub const ImGuiCol__ImGuiCol_TextDisabled: ImGuiCol_ = 1;
|
|
pub const ImGuiCol__ImGuiCol_WindowBg: ImGuiCol_ = 2;
|
|
pub const ImGuiCol__ImGuiCol_ChildBg: ImGuiCol_ = 3;
|
|
pub const ImGuiCol__ImGuiCol_PopupBg: ImGuiCol_ = 4;
|
|
pub const ImGuiCol__ImGuiCol_Border: ImGuiCol_ = 5;
|
|
pub const ImGuiCol__ImGuiCol_BorderShadow: ImGuiCol_ = 6;
|
|
pub const ImGuiCol__ImGuiCol_FrameBg: ImGuiCol_ = 7;
|
|
pub const ImGuiCol__ImGuiCol_FrameBgHovered: ImGuiCol_ = 8;
|
|
pub const ImGuiCol__ImGuiCol_FrameBgActive: ImGuiCol_ = 9;
|
|
pub const ImGuiCol__ImGuiCol_TitleBg: ImGuiCol_ = 10;
|
|
pub const ImGuiCol__ImGuiCol_TitleBgActive: ImGuiCol_ = 11;
|
|
pub const ImGuiCol__ImGuiCol_TitleBgCollapsed: ImGuiCol_ = 12;
|
|
pub const ImGuiCol__ImGuiCol_MenuBarBg: ImGuiCol_ = 13;
|
|
pub const ImGuiCol__ImGuiCol_ScrollbarBg: ImGuiCol_ = 14;
|
|
pub const ImGuiCol__ImGuiCol_ScrollbarGrab: ImGuiCol_ = 15;
|
|
pub const ImGuiCol__ImGuiCol_ScrollbarGrabHovered: ImGuiCol_ = 16;
|
|
pub const ImGuiCol__ImGuiCol_ScrollbarGrabActive: ImGuiCol_ = 17;
|
|
pub const ImGuiCol__ImGuiCol_CheckMark: ImGuiCol_ = 18;
|
|
pub const ImGuiCol__ImGuiCol_SliderGrab: ImGuiCol_ = 19;
|
|
pub const ImGuiCol__ImGuiCol_SliderGrabActive: ImGuiCol_ = 20;
|
|
pub const ImGuiCol__ImGuiCol_Button: ImGuiCol_ = 21;
|
|
pub const ImGuiCol__ImGuiCol_ButtonHovered: ImGuiCol_ = 22;
|
|
pub const ImGuiCol__ImGuiCol_ButtonActive: ImGuiCol_ = 23;
|
|
pub const ImGuiCol__ImGuiCol_Header: ImGuiCol_ = 24;
|
|
pub const ImGuiCol__ImGuiCol_HeaderHovered: ImGuiCol_ = 25;
|
|
pub const ImGuiCol__ImGuiCol_HeaderActive: ImGuiCol_ = 26;
|
|
pub const ImGuiCol__ImGuiCol_Separator: ImGuiCol_ = 27;
|
|
pub const ImGuiCol__ImGuiCol_SeparatorHovered: ImGuiCol_ = 28;
|
|
pub const ImGuiCol__ImGuiCol_SeparatorActive: ImGuiCol_ = 29;
|
|
pub const ImGuiCol__ImGuiCol_ResizeGrip: ImGuiCol_ = 30;
|
|
pub const ImGuiCol__ImGuiCol_ResizeGripHovered: ImGuiCol_ = 31;
|
|
pub const ImGuiCol__ImGuiCol_ResizeGripActive: ImGuiCol_ = 32;
|
|
pub const ImGuiCol__ImGuiCol_Tab: ImGuiCol_ = 33;
|
|
pub const ImGuiCol__ImGuiCol_TabHovered: ImGuiCol_ = 34;
|
|
pub const ImGuiCol__ImGuiCol_TabActive: ImGuiCol_ = 35;
|
|
pub const ImGuiCol__ImGuiCol_TabUnfocused: ImGuiCol_ = 36;
|
|
pub const ImGuiCol__ImGuiCol_TabUnfocusedActive: ImGuiCol_ = 37;
|
|
pub const ImGuiCol__ImGuiCol_PlotLines: ImGuiCol_ = 38;
|
|
pub const ImGuiCol__ImGuiCol_PlotLinesHovered: ImGuiCol_ = 39;
|
|
pub const ImGuiCol__ImGuiCol_PlotHistogram: ImGuiCol_ = 40;
|
|
pub const ImGuiCol__ImGuiCol_PlotHistogramHovered: ImGuiCol_ = 41;
|
|
pub const ImGuiCol__ImGuiCol_TextSelectedBg: ImGuiCol_ = 42;
|
|
pub const ImGuiCol__ImGuiCol_DragDropTarget: ImGuiCol_ = 43;
|
|
pub const ImGuiCol__ImGuiCol_NavHighlight: ImGuiCol_ = 44;
|
|
pub const ImGuiCol__ImGuiCol_NavWindowingHighlight: ImGuiCol_ = 45;
|
|
pub const ImGuiCol__ImGuiCol_NavWindowingDimBg: ImGuiCol_ = 46;
|
|
pub const ImGuiCol__ImGuiCol_ModalWindowDimBg: ImGuiCol_ = 47;
|
|
pub const ImGuiCol__ImGuiCol_COUNT: ImGuiCol_ = 48;
|
|
pub type ImGuiCol_ = u32;
|
|
pub const ImGuiStyleVar__ImGuiStyleVar_Alpha: ImGuiStyleVar_ = 0;
|
|
pub const ImGuiStyleVar__ImGuiStyleVar_WindowPadding: ImGuiStyleVar_ = 1;
|
|
pub const ImGuiStyleVar__ImGuiStyleVar_WindowRounding: ImGuiStyleVar_ = 2;
|
|
pub const ImGuiStyleVar__ImGuiStyleVar_WindowBorderSize: ImGuiStyleVar_ = 3;
|
|
pub const ImGuiStyleVar__ImGuiStyleVar_WindowMinSize: ImGuiStyleVar_ = 4;
|
|
pub const ImGuiStyleVar__ImGuiStyleVar_WindowTitleAlign: ImGuiStyleVar_ = 5;
|
|
pub const ImGuiStyleVar__ImGuiStyleVar_ChildRounding: ImGuiStyleVar_ = 6;
|
|
pub const ImGuiStyleVar__ImGuiStyleVar_ChildBorderSize: ImGuiStyleVar_ = 7;
|
|
pub const ImGuiStyleVar__ImGuiStyleVar_PopupRounding: ImGuiStyleVar_ = 8;
|
|
pub const ImGuiStyleVar__ImGuiStyleVar_PopupBorderSize: ImGuiStyleVar_ = 9;
|
|
pub const ImGuiStyleVar__ImGuiStyleVar_FramePadding: ImGuiStyleVar_ = 10;
|
|
pub const ImGuiStyleVar__ImGuiStyleVar_FrameRounding: ImGuiStyleVar_ = 11;
|
|
pub const ImGuiStyleVar__ImGuiStyleVar_FrameBorderSize: ImGuiStyleVar_ = 12;
|
|
pub const ImGuiStyleVar__ImGuiStyleVar_ItemSpacing: ImGuiStyleVar_ = 13;
|
|
pub const ImGuiStyleVar__ImGuiStyleVar_ItemInnerSpacing: ImGuiStyleVar_ = 14;
|
|
pub const ImGuiStyleVar__ImGuiStyleVar_IndentSpacing: ImGuiStyleVar_ = 15;
|
|
pub const ImGuiStyleVar__ImGuiStyleVar_ScrollbarSize: ImGuiStyleVar_ = 16;
|
|
pub const ImGuiStyleVar__ImGuiStyleVar_ScrollbarRounding: ImGuiStyleVar_ = 17;
|
|
pub const ImGuiStyleVar__ImGuiStyleVar_GrabMinSize: ImGuiStyleVar_ = 18;
|
|
pub const ImGuiStyleVar__ImGuiStyleVar_GrabRounding: ImGuiStyleVar_ = 19;
|
|
pub const ImGuiStyleVar__ImGuiStyleVar_TabRounding: ImGuiStyleVar_ = 20;
|
|
pub const ImGuiStyleVar__ImGuiStyleVar_ButtonTextAlign: ImGuiStyleVar_ = 21;
|
|
pub const ImGuiStyleVar__ImGuiStyleVar_SelectableTextAlign: ImGuiStyleVar_ = 22;
|
|
pub const ImGuiStyleVar__ImGuiStyleVar_COUNT: ImGuiStyleVar_ = 23;
|
|
pub type ImGuiStyleVar_ = u32;
|
|
pub const ImGuiColorEditFlags__ImGuiColorEditFlags_None: ImGuiColorEditFlags_ = 0;
|
|
pub const ImGuiColorEditFlags__ImGuiColorEditFlags_NoAlpha: ImGuiColorEditFlags_ = 2;
|
|
pub const ImGuiColorEditFlags__ImGuiColorEditFlags_NoPicker: ImGuiColorEditFlags_ = 4;
|
|
pub const ImGuiColorEditFlags__ImGuiColorEditFlags_NoOptions: ImGuiColorEditFlags_ = 8;
|
|
pub const ImGuiColorEditFlags__ImGuiColorEditFlags_NoSmallPreview: ImGuiColorEditFlags_ = 16;
|
|
pub const ImGuiColorEditFlags__ImGuiColorEditFlags_NoInputs: ImGuiColorEditFlags_ = 32;
|
|
pub const ImGuiColorEditFlags__ImGuiColorEditFlags_NoTooltip: ImGuiColorEditFlags_ = 64;
|
|
pub const ImGuiColorEditFlags__ImGuiColorEditFlags_NoLabel: ImGuiColorEditFlags_ = 128;
|
|
pub const ImGuiColorEditFlags__ImGuiColorEditFlags_NoSidePreview: ImGuiColorEditFlags_ = 256;
|
|
pub const ImGuiColorEditFlags__ImGuiColorEditFlags_NoDragDrop: ImGuiColorEditFlags_ = 512;
|
|
pub const ImGuiColorEditFlags__ImGuiColorEditFlags_NoBorder: ImGuiColorEditFlags_ = 1024;
|
|
pub const ImGuiColorEditFlags__ImGuiColorEditFlags_AlphaBar: ImGuiColorEditFlags_ = 65536;
|
|
pub const ImGuiColorEditFlags__ImGuiColorEditFlags_AlphaPreview: ImGuiColorEditFlags_ = 131072;
|
|
pub const ImGuiColorEditFlags__ImGuiColorEditFlags_AlphaPreviewHalf: ImGuiColorEditFlags_ = 262144;
|
|
pub const ImGuiColorEditFlags__ImGuiColorEditFlags_HDR: ImGuiColorEditFlags_ = 524288;
|
|
pub const ImGuiColorEditFlags__ImGuiColorEditFlags_DisplayRGB: ImGuiColorEditFlags_ = 1048576;
|
|
pub const ImGuiColorEditFlags__ImGuiColorEditFlags_DisplayHSV: ImGuiColorEditFlags_ = 2097152;
|
|
pub const ImGuiColorEditFlags__ImGuiColorEditFlags_DisplayHex: ImGuiColorEditFlags_ = 4194304;
|
|
pub const ImGuiColorEditFlags__ImGuiColorEditFlags_Uint8: ImGuiColorEditFlags_ = 8388608;
|
|
pub const ImGuiColorEditFlags__ImGuiColorEditFlags_Float: ImGuiColorEditFlags_ = 16777216;
|
|
pub const ImGuiColorEditFlags__ImGuiColorEditFlags_PickerHueBar: ImGuiColorEditFlags_ = 33554432;
|
|
pub const ImGuiColorEditFlags__ImGuiColorEditFlags_PickerHueWheel: ImGuiColorEditFlags_ = 67108864;
|
|
pub const ImGuiColorEditFlags__ImGuiColorEditFlags_InputRGB: ImGuiColorEditFlags_ = 134217728;
|
|
pub const ImGuiColorEditFlags__ImGuiColorEditFlags_InputHSV: ImGuiColorEditFlags_ = 268435456;
|
|
pub const ImGuiColorEditFlags__ImGuiColorEditFlags__OptionsDefault: ImGuiColorEditFlags_ =
|
|
177209344;
|
|
pub const ImGuiColorEditFlags__ImGuiColorEditFlags__DisplayMask: ImGuiColorEditFlags_ = 7340032;
|
|
pub const ImGuiColorEditFlags__ImGuiColorEditFlags__DataTypeMask: ImGuiColorEditFlags_ = 25165824;
|
|
pub const ImGuiColorEditFlags__ImGuiColorEditFlags__PickerMask: ImGuiColorEditFlags_ = 100663296;
|
|
pub const ImGuiColorEditFlags__ImGuiColorEditFlags__InputMask: ImGuiColorEditFlags_ = 402653184;
|
|
pub type ImGuiColorEditFlags_ = u32;
|
|
pub const ImGuiMouseButton__ImGuiMouseButton_Left: ImGuiMouseButton_ = 0;
|
|
pub const ImGuiMouseButton__ImGuiMouseButton_Right: ImGuiMouseButton_ = 1;
|
|
pub const ImGuiMouseButton__ImGuiMouseButton_Middle: ImGuiMouseButton_ = 2;
|
|
pub const ImGuiMouseButton__ImGuiMouseButton_COUNT: ImGuiMouseButton_ = 5;
|
|
pub type ImGuiMouseButton_ = u32;
|
|
pub const ImGuiMouseCursor__ImGuiMouseCursor_None: ImGuiMouseCursor_ = -1;
|
|
pub const ImGuiMouseCursor__ImGuiMouseCursor_Arrow: ImGuiMouseCursor_ = 0;
|
|
pub const ImGuiMouseCursor__ImGuiMouseCursor_TextInput: ImGuiMouseCursor_ = 1;
|
|
pub const ImGuiMouseCursor__ImGuiMouseCursor_ResizeAll: ImGuiMouseCursor_ = 2;
|
|
pub const ImGuiMouseCursor__ImGuiMouseCursor_ResizeNS: ImGuiMouseCursor_ = 3;
|
|
pub const ImGuiMouseCursor__ImGuiMouseCursor_ResizeEW: ImGuiMouseCursor_ = 4;
|
|
pub const ImGuiMouseCursor__ImGuiMouseCursor_ResizeNESW: ImGuiMouseCursor_ = 5;
|
|
pub const ImGuiMouseCursor__ImGuiMouseCursor_ResizeNWSE: ImGuiMouseCursor_ = 6;
|
|
pub const ImGuiMouseCursor__ImGuiMouseCursor_Hand: ImGuiMouseCursor_ = 7;
|
|
pub const ImGuiMouseCursor__ImGuiMouseCursor_NotAllowed: ImGuiMouseCursor_ = 8;
|
|
pub const ImGuiMouseCursor__ImGuiMouseCursor_COUNT: ImGuiMouseCursor_ = 9;
|
|
pub type ImGuiMouseCursor_ = i32;
|
|
pub const ImGuiCond__ImGuiCond_None: ImGuiCond_ = 0;
|
|
pub const ImGuiCond__ImGuiCond_Always: ImGuiCond_ = 1;
|
|
pub const ImGuiCond__ImGuiCond_Once: ImGuiCond_ = 2;
|
|
pub const ImGuiCond__ImGuiCond_FirstUseEver: ImGuiCond_ = 4;
|
|
pub const ImGuiCond__ImGuiCond_Appearing: ImGuiCond_ = 8;
|
|
pub type ImGuiCond_ = u32;
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct ImGuiStyle {
|
|
pub Alpha: f32,
|
|
pub WindowPadding: ImVec2,
|
|
pub WindowRounding: f32,
|
|
pub WindowBorderSize: f32,
|
|
pub WindowMinSize: ImVec2,
|
|
pub WindowTitleAlign: ImVec2,
|
|
pub WindowMenuButtonPosition: ImGuiDir,
|
|
pub ChildRounding: f32,
|
|
pub ChildBorderSize: f32,
|
|
pub PopupRounding: f32,
|
|
pub PopupBorderSize: f32,
|
|
pub FramePadding: ImVec2,
|
|
pub FrameRounding: f32,
|
|
pub FrameBorderSize: f32,
|
|
pub ItemSpacing: ImVec2,
|
|
pub ItemInnerSpacing: ImVec2,
|
|
pub TouchExtraPadding: ImVec2,
|
|
pub IndentSpacing: f32,
|
|
pub ColumnsMinSpacing: f32,
|
|
pub ScrollbarSize: f32,
|
|
pub ScrollbarRounding: f32,
|
|
pub GrabMinSize: f32,
|
|
pub GrabRounding: f32,
|
|
pub TabRounding: f32,
|
|
pub TabBorderSize: f32,
|
|
pub TabMinWidthForUnselectedCloseButton: f32,
|
|
pub ColorButtonPosition: ImGuiDir,
|
|
pub ButtonTextAlign: ImVec2,
|
|
pub SelectableTextAlign: ImVec2,
|
|
pub DisplayWindowPadding: ImVec2,
|
|
pub DisplaySafeAreaPadding: ImVec2,
|
|
pub MouseCursorScale: f32,
|
|
pub AntiAliasedLines: bool,
|
|
pub AntiAliasedFill: bool,
|
|
pub CurveTessellationTol: f32,
|
|
pub CircleSegmentMaxError: f32,
|
|
pub Colors: [ImVec4; 48usize],
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImGuiStyle() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImGuiStyle>(),
|
|
952usize,
|
|
concat!("Size of: ", stringify!(ImGuiStyle))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImGuiStyle>(),
|
|
4usize,
|
|
concat!("Alignment of ", stringify!(ImGuiStyle))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiStyle>())).Alpha as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStyle),
|
|
"::",
|
|
stringify!(Alpha)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiStyle>())).WindowPadding as *const _ as usize },
|
|
4usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStyle),
|
|
"::",
|
|
stringify!(WindowPadding)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiStyle>())).WindowRounding as *const _ as usize },
|
|
12usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStyle),
|
|
"::",
|
|
stringify!(WindowRounding)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiStyle>())).WindowBorderSize as *const _ as usize },
|
|
16usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStyle),
|
|
"::",
|
|
stringify!(WindowBorderSize)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiStyle>())).WindowMinSize as *const _ as usize },
|
|
20usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStyle),
|
|
"::",
|
|
stringify!(WindowMinSize)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiStyle>())).WindowTitleAlign as *const _ as usize },
|
|
28usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStyle),
|
|
"::",
|
|
stringify!(WindowTitleAlign)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<ImGuiStyle>())).WindowMenuButtonPosition as *const _ as usize
|
|
},
|
|
36usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStyle),
|
|
"::",
|
|
stringify!(WindowMenuButtonPosition)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiStyle>())).ChildRounding as *const _ as usize },
|
|
40usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStyle),
|
|
"::",
|
|
stringify!(ChildRounding)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiStyle>())).ChildBorderSize as *const _ as usize },
|
|
44usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStyle),
|
|
"::",
|
|
stringify!(ChildBorderSize)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiStyle>())).PopupRounding as *const _ as usize },
|
|
48usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStyle),
|
|
"::",
|
|
stringify!(PopupRounding)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiStyle>())).PopupBorderSize as *const _ as usize },
|
|
52usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStyle),
|
|
"::",
|
|
stringify!(PopupBorderSize)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiStyle>())).FramePadding as *const _ as usize },
|
|
56usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStyle),
|
|
"::",
|
|
stringify!(FramePadding)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiStyle>())).FrameRounding as *const _ as usize },
|
|
64usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStyle),
|
|
"::",
|
|
stringify!(FrameRounding)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiStyle>())).FrameBorderSize as *const _ as usize },
|
|
68usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStyle),
|
|
"::",
|
|
stringify!(FrameBorderSize)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiStyle>())).ItemSpacing as *const _ as usize },
|
|
72usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStyle),
|
|
"::",
|
|
stringify!(ItemSpacing)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiStyle>())).ItemInnerSpacing as *const _ as usize },
|
|
80usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStyle),
|
|
"::",
|
|
stringify!(ItemInnerSpacing)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiStyle>())).TouchExtraPadding as *const _ as usize },
|
|
88usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStyle),
|
|
"::",
|
|
stringify!(TouchExtraPadding)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiStyle>())).IndentSpacing as *const _ as usize },
|
|
96usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStyle),
|
|
"::",
|
|
stringify!(IndentSpacing)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiStyle>())).ColumnsMinSpacing as *const _ as usize },
|
|
100usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStyle),
|
|
"::",
|
|
stringify!(ColumnsMinSpacing)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiStyle>())).ScrollbarSize as *const _ as usize },
|
|
104usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStyle),
|
|
"::",
|
|
stringify!(ScrollbarSize)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiStyle>())).ScrollbarRounding as *const _ as usize },
|
|
108usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStyle),
|
|
"::",
|
|
stringify!(ScrollbarRounding)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiStyle>())).GrabMinSize as *const _ as usize },
|
|
112usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStyle),
|
|
"::",
|
|
stringify!(GrabMinSize)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiStyle>())).GrabRounding as *const _ as usize },
|
|
116usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStyle),
|
|
"::",
|
|
stringify!(GrabRounding)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiStyle>())).TabRounding as *const _ as usize },
|
|
120usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStyle),
|
|
"::",
|
|
stringify!(TabRounding)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiStyle>())).TabBorderSize as *const _ as usize },
|
|
124usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStyle),
|
|
"::",
|
|
stringify!(TabBorderSize)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<ImGuiStyle>())).TabMinWidthForUnselectedCloseButton as *const _
|
|
as usize
|
|
},
|
|
128usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStyle),
|
|
"::",
|
|
stringify!(TabMinWidthForUnselectedCloseButton)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiStyle>())).ColorButtonPosition as *const _ as usize },
|
|
132usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStyle),
|
|
"::",
|
|
stringify!(ColorButtonPosition)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiStyle>())).ButtonTextAlign as *const _ as usize },
|
|
136usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStyle),
|
|
"::",
|
|
stringify!(ButtonTextAlign)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiStyle>())).SelectableTextAlign as *const _ as usize },
|
|
144usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStyle),
|
|
"::",
|
|
stringify!(SelectableTextAlign)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiStyle>())).DisplayWindowPadding as *const _ as usize },
|
|
152usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStyle),
|
|
"::",
|
|
stringify!(DisplayWindowPadding)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<ImGuiStyle>())).DisplaySafeAreaPadding as *const _ as usize
|
|
},
|
|
160usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStyle),
|
|
"::",
|
|
stringify!(DisplaySafeAreaPadding)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiStyle>())).MouseCursorScale as *const _ as usize },
|
|
168usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStyle),
|
|
"::",
|
|
stringify!(MouseCursorScale)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiStyle>())).AntiAliasedLines as *const _ as usize },
|
|
172usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStyle),
|
|
"::",
|
|
stringify!(AntiAliasedLines)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiStyle>())).AntiAliasedFill as *const _ as usize },
|
|
173usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStyle),
|
|
"::",
|
|
stringify!(AntiAliasedFill)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiStyle>())).CurveTessellationTol as *const _ as usize },
|
|
176usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStyle),
|
|
"::",
|
|
stringify!(CurveTessellationTol)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<ImGuiStyle>())).CircleSegmentMaxError as *const _ as usize
|
|
},
|
|
180usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStyle),
|
|
"::",
|
|
stringify!(CircleSegmentMaxError)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiStyle>())).Colors as *const _ as usize },
|
|
184usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStyle),
|
|
"::",
|
|
stringify!(Colors)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct ImGuiIO {
|
|
pub ConfigFlags: ImGuiConfigFlags,
|
|
pub BackendFlags: ImGuiBackendFlags,
|
|
pub DisplaySize: ImVec2,
|
|
pub DeltaTime: f32,
|
|
pub IniSavingRate: f32,
|
|
pub IniFilename: *const ::std::os::raw::c_char,
|
|
pub LogFilename: *const ::std::os::raw::c_char,
|
|
pub MouseDoubleClickTime: f32,
|
|
pub MouseDoubleClickMaxDist: f32,
|
|
pub MouseDragThreshold: f32,
|
|
pub KeyMap: [::std::os::raw::c_int; 22usize],
|
|
pub KeyRepeatDelay: f32,
|
|
pub KeyRepeatRate: f32,
|
|
pub UserData: *mut ::std::os::raw::c_void,
|
|
pub Fonts: *mut ImFontAtlas,
|
|
pub FontGlobalScale: f32,
|
|
pub FontAllowUserScaling: bool,
|
|
pub FontDefault: *mut ImFont,
|
|
pub DisplayFramebufferScale: ImVec2,
|
|
pub MouseDrawCursor: bool,
|
|
pub ConfigMacOSXBehaviors: bool,
|
|
pub ConfigInputTextCursorBlink: bool,
|
|
pub ConfigWindowsResizeFromEdges: bool,
|
|
pub ConfigWindowsMoveFromTitleBarOnly: bool,
|
|
pub ConfigWindowsMemoryCompactTimer: f32,
|
|
pub BackendPlatformName: *const ::std::os::raw::c_char,
|
|
pub BackendRendererName: *const ::std::os::raw::c_char,
|
|
pub BackendPlatformUserData: *mut ::std::os::raw::c_void,
|
|
pub BackendRendererUserData: *mut ::std::os::raw::c_void,
|
|
pub BackendLanguageUserData: *mut ::std::os::raw::c_void,
|
|
pub GetClipboardTextFn: ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
user_data: *mut ::std::os::raw::c_void,
|
|
) -> *const ::std::os::raw::c_char,
|
|
>,
|
|
pub SetClipboardTextFn: ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
user_data: *mut ::std::os::raw::c_void,
|
|
text: *const ::std::os::raw::c_char,
|
|
),
|
|
>,
|
|
pub ClipboardUserData: *mut ::std::os::raw::c_void,
|
|
pub ImeSetInputScreenPosFn: ::std::option::Option<
|
|
unsafe extern "C" fn(x: ::std::os::raw::c_int, y: ::std::os::raw::c_int),
|
|
>,
|
|
pub ImeWindowHandle: *mut ::std::os::raw::c_void,
|
|
pub RenderDrawListsFnUnused: *mut ::std::os::raw::c_void,
|
|
pub MousePos: ImVec2,
|
|
pub MouseDown: [bool; 5usize],
|
|
pub MouseWheel: f32,
|
|
pub MouseWheelH: f32,
|
|
pub KeyCtrl: bool,
|
|
pub KeyShift: bool,
|
|
pub KeyAlt: bool,
|
|
pub KeySuper: bool,
|
|
pub KeysDown: [bool; 512usize],
|
|
pub NavInputs: [f32; 21usize],
|
|
pub WantCaptureMouse: bool,
|
|
pub WantCaptureKeyboard: bool,
|
|
pub WantTextInput: bool,
|
|
pub WantSetMousePos: bool,
|
|
pub WantSaveIniSettings: bool,
|
|
pub NavActive: bool,
|
|
pub NavVisible: bool,
|
|
pub Framerate: f32,
|
|
pub MetricsRenderVertices: ::std::os::raw::c_int,
|
|
pub MetricsRenderIndices: ::std::os::raw::c_int,
|
|
pub MetricsRenderWindows: ::std::os::raw::c_int,
|
|
pub MetricsActiveWindows: ::std::os::raw::c_int,
|
|
pub MetricsActiveAllocations: ::std::os::raw::c_int,
|
|
pub MouseDelta: ImVec2,
|
|
pub KeyMods: ImGuiKeyModFlags,
|
|
pub MousePosPrev: ImVec2,
|
|
pub MouseClickedPos: [ImVec2; 5usize],
|
|
pub MouseClickedTime: [f64; 5usize],
|
|
pub MouseClicked: [bool; 5usize],
|
|
pub MouseDoubleClicked: [bool; 5usize],
|
|
pub MouseReleased: [bool; 5usize],
|
|
pub MouseDownOwned: [bool; 5usize],
|
|
pub MouseDownWasDoubleClick: [bool; 5usize],
|
|
pub MouseDownDuration: [f32; 5usize],
|
|
pub MouseDownDurationPrev: [f32; 5usize],
|
|
pub MouseDragMaxDistanceAbs: [ImVec2; 5usize],
|
|
pub MouseDragMaxDistanceSqr: [f32; 5usize],
|
|
pub KeysDownDuration: [f32; 512usize],
|
|
pub KeysDownDurationPrev: [f32; 512usize],
|
|
pub NavInputsDownDuration: [f32; 21usize],
|
|
pub NavInputsDownDurationPrev: [f32; 21usize],
|
|
pub PenPressure: f32,
|
|
pub InputQueueSurrogate: ImWchar16,
|
|
pub InputQueueCharacters: ImVector_ImWchar,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImGuiIO() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImGuiIO>(),
|
|
5472usize,
|
|
concat!("Size of: ", stringify!(ImGuiIO))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImGuiIO>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImGuiIO))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).ConfigFlags as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(ConfigFlags)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).BackendFlags as *const _ as usize },
|
|
4usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(BackendFlags)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).DisplaySize as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(DisplaySize)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).DeltaTime as *const _ as usize },
|
|
16usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(DeltaTime)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).IniSavingRate as *const _ as usize },
|
|
20usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(IniSavingRate)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).IniFilename as *const _ as usize },
|
|
24usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(IniFilename)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).LogFilename as *const _ as usize },
|
|
32usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(LogFilename)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).MouseDoubleClickTime as *const _ as usize },
|
|
40usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(MouseDoubleClickTime)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).MouseDoubleClickMaxDist as *const _ as usize },
|
|
44usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(MouseDoubleClickMaxDist)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).MouseDragThreshold as *const _ as usize },
|
|
48usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(MouseDragThreshold)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).KeyMap as *const _ as usize },
|
|
52usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(KeyMap)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).KeyRepeatDelay as *const _ as usize },
|
|
140usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(KeyRepeatDelay)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).KeyRepeatRate as *const _ as usize },
|
|
144usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(KeyRepeatRate)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).UserData as *const _ as usize },
|
|
152usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(UserData)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).Fonts as *const _ as usize },
|
|
160usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(Fonts)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).FontGlobalScale as *const _ as usize },
|
|
168usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(FontGlobalScale)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).FontAllowUserScaling as *const _ as usize },
|
|
172usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(FontAllowUserScaling)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).FontDefault as *const _ as usize },
|
|
176usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(FontDefault)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).DisplayFramebufferScale as *const _ as usize },
|
|
184usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(DisplayFramebufferScale)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).MouseDrawCursor as *const _ as usize },
|
|
192usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(MouseDrawCursor)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).ConfigMacOSXBehaviors as *const _ as usize },
|
|
193usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(ConfigMacOSXBehaviors)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<ImGuiIO>())).ConfigInputTextCursorBlink as *const _ as usize
|
|
},
|
|
194usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(ConfigInputTextCursorBlink)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<ImGuiIO>())).ConfigWindowsResizeFromEdges as *const _ as usize
|
|
},
|
|
195usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(ConfigWindowsResizeFromEdges)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<ImGuiIO>())).ConfigWindowsMoveFromTitleBarOnly as *const _
|
|
as usize
|
|
},
|
|
196usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(ConfigWindowsMoveFromTitleBarOnly)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<ImGuiIO>())).ConfigWindowsMemoryCompactTimer as *const _ as usize
|
|
},
|
|
200usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(ConfigWindowsMemoryCompactTimer)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).BackendPlatformName as *const _ as usize },
|
|
208usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(BackendPlatformName)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).BackendRendererName as *const _ as usize },
|
|
216usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(BackendRendererName)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).BackendPlatformUserData as *const _ as usize },
|
|
224usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(BackendPlatformUserData)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).BackendRendererUserData as *const _ as usize },
|
|
232usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(BackendRendererUserData)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).BackendLanguageUserData as *const _ as usize },
|
|
240usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(BackendLanguageUserData)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).GetClipboardTextFn as *const _ as usize },
|
|
248usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(GetClipboardTextFn)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).SetClipboardTextFn as *const _ as usize },
|
|
256usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(SetClipboardTextFn)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).ClipboardUserData as *const _ as usize },
|
|
264usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(ClipboardUserData)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).ImeSetInputScreenPosFn as *const _ as usize },
|
|
272usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(ImeSetInputScreenPosFn)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).ImeWindowHandle as *const _ as usize },
|
|
280usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(ImeWindowHandle)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).RenderDrawListsFnUnused as *const _ as usize },
|
|
288usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(RenderDrawListsFnUnused)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).MousePos as *const _ as usize },
|
|
296usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(MousePos)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).MouseDown as *const _ as usize },
|
|
304usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(MouseDown)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).MouseWheel as *const _ as usize },
|
|
312usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(MouseWheel)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).MouseWheelH as *const _ as usize },
|
|
316usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(MouseWheelH)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).KeyCtrl as *const _ as usize },
|
|
320usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(KeyCtrl)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).KeyShift as *const _ as usize },
|
|
321usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(KeyShift)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).KeyAlt as *const _ as usize },
|
|
322usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(KeyAlt)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).KeySuper as *const _ as usize },
|
|
323usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(KeySuper)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).KeysDown as *const _ as usize },
|
|
324usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(KeysDown)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).NavInputs as *const _ as usize },
|
|
836usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(NavInputs)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).WantCaptureMouse as *const _ as usize },
|
|
920usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(WantCaptureMouse)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).WantCaptureKeyboard as *const _ as usize },
|
|
921usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(WantCaptureKeyboard)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).WantTextInput as *const _ as usize },
|
|
922usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(WantTextInput)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).WantSetMousePos as *const _ as usize },
|
|
923usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(WantSetMousePos)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).WantSaveIniSettings as *const _ as usize },
|
|
924usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(WantSaveIniSettings)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).NavActive as *const _ as usize },
|
|
925usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(NavActive)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).NavVisible as *const _ as usize },
|
|
926usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(NavVisible)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).Framerate as *const _ as usize },
|
|
928usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(Framerate)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).MetricsRenderVertices as *const _ as usize },
|
|
932usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(MetricsRenderVertices)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).MetricsRenderIndices as *const _ as usize },
|
|
936usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(MetricsRenderIndices)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).MetricsRenderWindows as *const _ as usize },
|
|
940usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(MetricsRenderWindows)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).MetricsActiveWindows as *const _ as usize },
|
|
944usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(MetricsActiveWindows)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<ImGuiIO>())).MetricsActiveAllocations as *const _ as usize
|
|
},
|
|
948usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(MetricsActiveAllocations)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).MouseDelta as *const _ as usize },
|
|
952usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(MouseDelta)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).KeyMods as *const _ as usize },
|
|
960usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(KeyMods)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).MousePosPrev as *const _ as usize },
|
|
964usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(MousePosPrev)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).MouseClickedPos as *const _ as usize },
|
|
972usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(MouseClickedPos)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).MouseClickedTime as *const _ as usize },
|
|
1016usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(MouseClickedTime)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).MouseClicked as *const _ as usize },
|
|
1056usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(MouseClicked)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).MouseDoubleClicked as *const _ as usize },
|
|
1061usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(MouseDoubleClicked)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).MouseReleased as *const _ as usize },
|
|
1066usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(MouseReleased)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).MouseDownOwned as *const _ as usize },
|
|
1071usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(MouseDownOwned)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).MouseDownWasDoubleClick as *const _ as usize },
|
|
1076usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(MouseDownWasDoubleClick)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).MouseDownDuration as *const _ as usize },
|
|
1084usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(MouseDownDuration)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).MouseDownDurationPrev as *const _ as usize },
|
|
1104usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(MouseDownDurationPrev)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).MouseDragMaxDistanceAbs as *const _ as usize },
|
|
1124usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(MouseDragMaxDistanceAbs)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).MouseDragMaxDistanceSqr as *const _ as usize },
|
|
1164usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(MouseDragMaxDistanceSqr)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).KeysDownDuration as *const _ as usize },
|
|
1184usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(KeysDownDuration)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).KeysDownDurationPrev as *const _ as usize },
|
|
3232usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(KeysDownDurationPrev)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).NavInputsDownDuration as *const _ as usize },
|
|
5280usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(NavInputsDownDuration)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<ImGuiIO>())).NavInputsDownDurationPrev as *const _ as usize
|
|
},
|
|
5364usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(NavInputsDownDurationPrev)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).PenPressure as *const _ as usize },
|
|
5448usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(PenPressure)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).InputQueueSurrogate as *const _ as usize },
|
|
5452usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(InputQueueSurrogate)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiIO>())).InputQueueCharacters as *const _ as usize },
|
|
5456usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiIO),
|
|
"::",
|
|
stringify!(InputQueueCharacters)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImGuiInputTextCallbackData {
|
|
pub EventFlag: ImGuiInputTextFlags,
|
|
pub Flags: ImGuiInputTextFlags,
|
|
pub UserData: *mut ::std::os::raw::c_void,
|
|
pub EventChar: ImWchar,
|
|
pub EventKey: ImGuiKey,
|
|
pub Buf: *mut ::std::os::raw::c_char,
|
|
pub BufTextLen: ::std::os::raw::c_int,
|
|
pub BufSize: ::std::os::raw::c_int,
|
|
pub BufDirty: bool,
|
|
pub CursorPos: ::std::os::raw::c_int,
|
|
pub SelectionStart: ::std::os::raw::c_int,
|
|
pub SelectionEnd: ::std::os::raw::c_int,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImGuiInputTextCallbackData() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImGuiInputTextCallbackData>(),
|
|
56usize,
|
|
concat!("Size of: ", stringify!(ImGuiInputTextCallbackData))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImGuiInputTextCallbackData>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImGuiInputTextCallbackData))
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<ImGuiInputTextCallbackData>())).EventFlag as *const _ as usize
|
|
},
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiInputTextCallbackData),
|
|
"::",
|
|
stringify!(EventFlag)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<ImGuiInputTextCallbackData>())).Flags as *const _ as usize
|
|
},
|
|
4usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiInputTextCallbackData),
|
|
"::",
|
|
stringify!(Flags)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<ImGuiInputTextCallbackData>())).UserData as *const _ as usize
|
|
},
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiInputTextCallbackData),
|
|
"::",
|
|
stringify!(UserData)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<ImGuiInputTextCallbackData>())).EventChar as *const _ as usize
|
|
},
|
|
16usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiInputTextCallbackData),
|
|
"::",
|
|
stringify!(EventChar)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<ImGuiInputTextCallbackData>())).EventKey as *const _ as usize
|
|
},
|
|
20usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiInputTextCallbackData),
|
|
"::",
|
|
stringify!(EventKey)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiInputTextCallbackData>())).Buf as *const _ as usize },
|
|
24usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiInputTextCallbackData),
|
|
"::",
|
|
stringify!(Buf)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<ImGuiInputTextCallbackData>())).BufTextLen as *const _ as usize
|
|
},
|
|
32usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiInputTextCallbackData),
|
|
"::",
|
|
stringify!(BufTextLen)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<ImGuiInputTextCallbackData>())).BufSize as *const _ as usize
|
|
},
|
|
36usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiInputTextCallbackData),
|
|
"::",
|
|
stringify!(BufSize)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<ImGuiInputTextCallbackData>())).BufDirty as *const _ as usize
|
|
},
|
|
40usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiInputTextCallbackData),
|
|
"::",
|
|
stringify!(BufDirty)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<ImGuiInputTextCallbackData>())).CursorPos as *const _ as usize
|
|
},
|
|
44usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiInputTextCallbackData),
|
|
"::",
|
|
stringify!(CursorPos)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<ImGuiInputTextCallbackData>())).SelectionStart as *const _
|
|
as usize
|
|
},
|
|
48usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiInputTextCallbackData),
|
|
"::",
|
|
stringify!(SelectionStart)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<ImGuiInputTextCallbackData>())).SelectionEnd as *const _ as usize
|
|
},
|
|
52usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiInputTextCallbackData),
|
|
"::",
|
|
stringify!(SelectionEnd)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImGuiSizeCallbackData {
|
|
pub UserData: *mut ::std::os::raw::c_void,
|
|
pub Pos: ImVec2,
|
|
pub CurrentSize: ImVec2,
|
|
pub DesiredSize: ImVec2,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImGuiSizeCallbackData() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImGuiSizeCallbackData>(),
|
|
32usize,
|
|
concat!("Size of: ", stringify!(ImGuiSizeCallbackData))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImGuiSizeCallbackData>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImGuiSizeCallbackData))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiSizeCallbackData>())).UserData as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiSizeCallbackData),
|
|
"::",
|
|
stringify!(UserData)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiSizeCallbackData>())).Pos as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiSizeCallbackData),
|
|
"::",
|
|
stringify!(Pos)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<ImGuiSizeCallbackData>())).CurrentSize as *const _ as usize
|
|
},
|
|
16usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiSizeCallbackData),
|
|
"::",
|
|
stringify!(CurrentSize)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<ImGuiSizeCallbackData>())).DesiredSize as *const _ as usize
|
|
},
|
|
24usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiSizeCallbackData),
|
|
"::",
|
|
stringify!(DesiredSize)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct ImGuiPayload {
|
|
pub Data: *mut ::std::os::raw::c_void,
|
|
pub DataSize: ::std::os::raw::c_int,
|
|
pub SourceId: ImGuiID,
|
|
pub SourceParentId: ImGuiID,
|
|
pub DataFrameCount: ::std::os::raw::c_int,
|
|
pub DataType: [::std::os::raw::c_char; 33usize],
|
|
pub Preview: bool,
|
|
pub Delivery: bool,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImGuiPayload() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImGuiPayload>(),
|
|
64usize,
|
|
concat!("Size of: ", stringify!(ImGuiPayload))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImGuiPayload>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImGuiPayload))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiPayload>())).Data as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiPayload),
|
|
"::",
|
|
stringify!(Data)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiPayload>())).DataSize as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiPayload),
|
|
"::",
|
|
stringify!(DataSize)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiPayload>())).SourceId as *const _ as usize },
|
|
12usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiPayload),
|
|
"::",
|
|
stringify!(SourceId)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiPayload>())).SourceParentId as *const _ as usize },
|
|
16usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiPayload),
|
|
"::",
|
|
stringify!(SourceParentId)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiPayload>())).DataFrameCount as *const _ as usize },
|
|
20usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiPayload),
|
|
"::",
|
|
stringify!(DataFrameCount)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiPayload>())).DataType as *const _ as usize },
|
|
24usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiPayload),
|
|
"::",
|
|
stringify!(DataType)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiPayload>())).Preview as *const _ as usize },
|
|
57usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiPayload),
|
|
"::",
|
|
stringify!(Preview)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiPayload>())).Delivery as *const _ as usize },
|
|
58usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiPayload),
|
|
"::",
|
|
stringify!(Delivery)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImGuiOnceUponAFrame {
|
|
pub RefFrame: ::std::os::raw::c_int,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImGuiOnceUponAFrame() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImGuiOnceUponAFrame>(),
|
|
4usize,
|
|
concat!("Size of: ", stringify!(ImGuiOnceUponAFrame))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImGuiOnceUponAFrame>(),
|
|
4usize,
|
|
concat!("Alignment of ", stringify!(ImGuiOnceUponAFrame))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiOnceUponAFrame>())).RefFrame as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiOnceUponAFrame),
|
|
"::",
|
|
stringify!(RefFrame)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct ImGuiTextFilter {
|
|
pub InputBuf: [::std::os::raw::c_char; 256usize],
|
|
pub Filters: ImVector_ImGuiTextRange,
|
|
pub CountGrep: ::std::os::raw::c_int,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImGuiTextFilter() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImGuiTextFilter>(),
|
|
280usize,
|
|
concat!("Size of: ", stringify!(ImGuiTextFilter))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImGuiTextFilter>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImGuiTextFilter))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiTextFilter>())).InputBuf as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiTextFilter),
|
|
"::",
|
|
stringify!(InputBuf)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiTextFilter>())).Filters as *const _ as usize },
|
|
256usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiTextFilter),
|
|
"::",
|
|
stringify!(Filters)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiTextFilter>())).CountGrep as *const _ as usize },
|
|
272usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiTextFilter),
|
|
"::",
|
|
stringify!(CountGrep)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImGuiTextBuffer {
|
|
pub Buf: ImVector_char,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImGuiTextBuffer() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImGuiTextBuffer>(),
|
|
16usize,
|
|
concat!("Size of: ", stringify!(ImGuiTextBuffer))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImGuiTextBuffer>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImGuiTextBuffer))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiTextBuffer>())).Buf as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiTextBuffer),
|
|
"::",
|
|
stringify!(Buf)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImGuiStorage {
|
|
pub Data: ImVector_ImGuiStoragePair,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImGuiStorage() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImGuiStorage>(),
|
|
16usize,
|
|
concat!("Size of: ", stringify!(ImGuiStorage))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImGuiStorage>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImGuiStorage))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiStorage>())).Data as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStorage),
|
|
"::",
|
|
stringify!(Data)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImGuiListClipper {
|
|
pub DisplayStart: ::std::os::raw::c_int,
|
|
pub DisplayEnd: ::std::os::raw::c_int,
|
|
pub ItemsCount: ::std::os::raw::c_int,
|
|
pub StepNo: ::std::os::raw::c_int,
|
|
pub ItemsHeight: f32,
|
|
pub StartPosY: f32,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImGuiListClipper() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImGuiListClipper>(),
|
|
24usize,
|
|
concat!("Size of: ", stringify!(ImGuiListClipper))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImGuiListClipper>(),
|
|
4usize,
|
|
concat!("Alignment of ", stringify!(ImGuiListClipper))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiListClipper>())).DisplayStart as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiListClipper),
|
|
"::",
|
|
stringify!(DisplayStart)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiListClipper>())).DisplayEnd as *const _ as usize },
|
|
4usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiListClipper),
|
|
"::",
|
|
stringify!(DisplayEnd)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiListClipper>())).ItemsCount as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiListClipper),
|
|
"::",
|
|
stringify!(ItemsCount)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiListClipper>())).StepNo as *const _ as usize },
|
|
12usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiListClipper),
|
|
"::",
|
|
stringify!(StepNo)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiListClipper>())).ItemsHeight as *const _ as usize },
|
|
16usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiListClipper),
|
|
"::",
|
|
stringify!(ItemsHeight)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiListClipper>())).StartPosY as *const _ as usize },
|
|
20usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiListClipper),
|
|
"::",
|
|
stringify!(StartPosY)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImColor {
|
|
pub Value: ImVec4,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImColor() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImColor>(),
|
|
16usize,
|
|
concat!("Size of: ", stringify!(ImColor))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImColor>(),
|
|
4usize,
|
|
concat!("Alignment of ", stringify!(ImColor))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImColor>())).Value as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImColor),
|
|
"::",
|
|
stringify!(Value)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImDrawCmd {
|
|
pub ClipRect: ImVec4,
|
|
pub TextureId: ImTextureID,
|
|
pub VtxOffset: ::std::os::raw::c_uint,
|
|
pub IdxOffset: ::std::os::raw::c_uint,
|
|
pub ElemCount: ::std::os::raw::c_uint,
|
|
pub UserCallback: ImDrawCallback,
|
|
pub UserCallbackData: *mut ::std::os::raw::c_void,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImDrawCmd() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImDrawCmd>(),
|
|
56usize,
|
|
concat!("Size of: ", stringify!(ImDrawCmd))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImDrawCmd>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImDrawCmd))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImDrawCmd>())).ClipRect as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImDrawCmd),
|
|
"::",
|
|
stringify!(ClipRect)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImDrawCmd>())).TextureId as *const _ as usize },
|
|
16usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImDrawCmd),
|
|
"::",
|
|
stringify!(TextureId)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImDrawCmd>())).VtxOffset as *const _ as usize },
|
|
24usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImDrawCmd),
|
|
"::",
|
|
stringify!(VtxOffset)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImDrawCmd>())).IdxOffset as *const _ as usize },
|
|
28usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImDrawCmd),
|
|
"::",
|
|
stringify!(IdxOffset)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImDrawCmd>())).ElemCount as *const _ as usize },
|
|
32usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImDrawCmd),
|
|
"::",
|
|
stringify!(ElemCount)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImDrawCmd>())).UserCallback as *const _ as usize },
|
|
40usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImDrawCmd),
|
|
"::",
|
|
stringify!(UserCallback)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImDrawCmd>())).UserCallbackData as *const _ as usize },
|
|
48usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImDrawCmd),
|
|
"::",
|
|
stringify!(UserCallbackData)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImDrawVert {
|
|
pub pos: ImVec2,
|
|
pub uv: ImVec2,
|
|
pub col: ImU32,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImDrawVert() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImDrawVert>(),
|
|
20usize,
|
|
concat!("Size of: ", stringify!(ImDrawVert))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImDrawVert>(),
|
|
4usize,
|
|
concat!("Alignment of ", stringify!(ImDrawVert))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImDrawVert>())).pos as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImDrawVert),
|
|
"::",
|
|
stringify!(pos)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImDrawVert>())).uv as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImDrawVert),
|
|
"::",
|
|
stringify!(uv)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImDrawVert>())).col as *const _ as usize },
|
|
16usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImDrawVert),
|
|
"::",
|
|
stringify!(col)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImDrawChannel {
|
|
pub _CmdBuffer: ImVector_ImDrawCmd,
|
|
pub _IdxBuffer: ImVector_ImDrawIdx,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImDrawChannel() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImDrawChannel>(),
|
|
32usize,
|
|
concat!("Size of: ", stringify!(ImDrawChannel))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImDrawChannel>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImDrawChannel))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImDrawChannel>()))._CmdBuffer as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImDrawChannel),
|
|
"::",
|
|
stringify!(_CmdBuffer)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImDrawChannel>()))._IdxBuffer as *const _ as usize },
|
|
16usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImDrawChannel),
|
|
"::",
|
|
stringify!(_IdxBuffer)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImDrawListSplitter {
|
|
pub _Current: ::std::os::raw::c_int,
|
|
pub _Count: ::std::os::raw::c_int,
|
|
pub _Channels: ImVector_ImDrawChannel,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImDrawListSplitter() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImDrawListSplitter>(),
|
|
24usize,
|
|
concat!("Size of: ", stringify!(ImDrawListSplitter))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImDrawListSplitter>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImDrawListSplitter))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImDrawListSplitter>()))._Current as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImDrawListSplitter),
|
|
"::",
|
|
stringify!(_Current)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImDrawListSplitter>()))._Count as *const _ as usize },
|
|
4usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImDrawListSplitter),
|
|
"::",
|
|
stringify!(_Count)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImDrawListSplitter>()))._Channels as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImDrawListSplitter),
|
|
"::",
|
|
stringify!(_Channels)
|
|
)
|
|
);
|
|
}
|
|
pub const ImDrawCornerFlags__ImDrawCornerFlags_None: ImDrawCornerFlags_ = 0;
|
|
pub const ImDrawCornerFlags__ImDrawCornerFlags_TopLeft: ImDrawCornerFlags_ = 1;
|
|
pub const ImDrawCornerFlags__ImDrawCornerFlags_TopRight: ImDrawCornerFlags_ = 2;
|
|
pub const ImDrawCornerFlags__ImDrawCornerFlags_BotLeft: ImDrawCornerFlags_ = 4;
|
|
pub const ImDrawCornerFlags__ImDrawCornerFlags_BotRight: ImDrawCornerFlags_ = 8;
|
|
pub const ImDrawCornerFlags__ImDrawCornerFlags_Top: ImDrawCornerFlags_ = 3;
|
|
pub const ImDrawCornerFlags__ImDrawCornerFlags_Bot: ImDrawCornerFlags_ = 12;
|
|
pub const ImDrawCornerFlags__ImDrawCornerFlags_Left: ImDrawCornerFlags_ = 5;
|
|
pub const ImDrawCornerFlags__ImDrawCornerFlags_Right: ImDrawCornerFlags_ = 10;
|
|
pub const ImDrawCornerFlags__ImDrawCornerFlags_All: ImDrawCornerFlags_ = 15;
|
|
pub type ImDrawCornerFlags_ = u32;
|
|
pub const ImDrawListFlags__ImDrawListFlags_None: ImDrawListFlags_ = 0;
|
|
pub const ImDrawListFlags__ImDrawListFlags_AntiAliasedLines: ImDrawListFlags_ = 1;
|
|
pub const ImDrawListFlags__ImDrawListFlags_AntiAliasedFill: ImDrawListFlags_ = 2;
|
|
pub const ImDrawListFlags__ImDrawListFlags_AllowVtxOffset: ImDrawListFlags_ = 4;
|
|
pub type ImDrawListFlags_ = u32;
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImDrawList {
|
|
pub CmdBuffer: ImVector_ImDrawCmd,
|
|
pub IdxBuffer: ImVector_ImDrawIdx,
|
|
pub VtxBuffer: ImVector_ImDrawVert,
|
|
pub Flags: ImDrawListFlags,
|
|
pub _Data: *const ImDrawListSharedData,
|
|
pub _OwnerName: *const ::std::os::raw::c_char,
|
|
pub _VtxCurrentIdx: ::std::os::raw::c_uint,
|
|
pub _VtxWritePtr: *mut ImDrawVert,
|
|
pub _IdxWritePtr: *mut ImDrawIdx,
|
|
pub _ClipRectStack: ImVector_ImVec4,
|
|
pub _TextureIdStack: ImVector_ImTextureID,
|
|
pub _Path: ImVector_ImVec2,
|
|
pub _CmdHeader: ImDrawCmd,
|
|
pub _Splitter: ImDrawListSplitter,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImDrawList() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImDrawList>(),
|
|
224usize,
|
|
concat!("Size of: ", stringify!(ImDrawList))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImDrawList>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImDrawList))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImDrawList>())).CmdBuffer as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImDrawList),
|
|
"::",
|
|
stringify!(CmdBuffer)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImDrawList>())).IdxBuffer as *const _ as usize },
|
|
16usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImDrawList),
|
|
"::",
|
|
stringify!(IdxBuffer)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImDrawList>())).VtxBuffer as *const _ as usize },
|
|
32usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImDrawList),
|
|
"::",
|
|
stringify!(VtxBuffer)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImDrawList>())).Flags as *const _ as usize },
|
|
48usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImDrawList),
|
|
"::",
|
|
stringify!(Flags)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImDrawList>()))._Data as *const _ as usize },
|
|
56usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImDrawList),
|
|
"::",
|
|
stringify!(_Data)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImDrawList>()))._OwnerName as *const _ as usize },
|
|
64usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImDrawList),
|
|
"::",
|
|
stringify!(_OwnerName)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImDrawList>()))._VtxCurrentIdx as *const _ as usize },
|
|
72usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImDrawList),
|
|
"::",
|
|
stringify!(_VtxCurrentIdx)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImDrawList>()))._VtxWritePtr as *const _ as usize },
|
|
80usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImDrawList),
|
|
"::",
|
|
stringify!(_VtxWritePtr)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImDrawList>()))._IdxWritePtr as *const _ as usize },
|
|
88usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImDrawList),
|
|
"::",
|
|
stringify!(_IdxWritePtr)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImDrawList>()))._ClipRectStack as *const _ as usize },
|
|
96usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImDrawList),
|
|
"::",
|
|
stringify!(_ClipRectStack)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImDrawList>()))._TextureIdStack as *const _ as usize },
|
|
112usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImDrawList),
|
|
"::",
|
|
stringify!(_TextureIdStack)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImDrawList>()))._Path as *const _ as usize },
|
|
128usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImDrawList),
|
|
"::",
|
|
stringify!(_Path)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImDrawList>()))._CmdHeader as *const _ as usize },
|
|
144usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImDrawList),
|
|
"::",
|
|
stringify!(_CmdHeader)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImDrawList>()))._Splitter as *const _ as usize },
|
|
200usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImDrawList),
|
|
"::",
|
|
stringify!(_Splitter)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImDrawData {
|
|
pub Valid: bool,
|
|
pub CmdLists: *mut *mut ImDrawList,
|
|
pub CmdListsCount: ::std::os::raw::c_int,
|
|
pub TotalIdxCount: ::std::os::raw::c_int,
|
|
pub TotalVtxCount: ::std::os::raw::c_int,
|
|
pub DisplayPos: ImVec2,
|
|
pub DisplaySize: ImVec2,
|
|
pub FramebufferScale: ImVec2,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImDrawData() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImDrawData>(),
|
|
56usize,
|
|
concat!("Size of: ", stringify!(ImDrawData))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImDrawData>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImDrawData))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImDrawData>())).Valid as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImDrawData),
|
|
"::",
|
|
stringify!(Valid)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImDrawData>())).CmdLists as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImDrawData),
|
|
"::",
|
|
stringify!(CmdLists)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImDrawData>())).CmdListsCount as *const _ as usize },
|
|
16usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImDrawData),
|
|
"::",
|
|
stringify!(CmdListsCount)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImDrawData>())).TotalIdxCount as *const _ as usize },
|
|
20usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImDrawData),
|
|
"::",
|
|
stringify!(TotalIdxCount)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImDrawData>())).TotalVtxCount as *const _ as usize },
|
|
24usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImDrawData),
|
|
"::",
|
|
stringify!(TotalVtxCount)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImDrawData>())).DisplayPos as *const _ as usize },
|
|
28usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImDrawData),
|
|
"::",
|
|
stringify!(DisplayPos)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImDrawData>())).DisplaySize as *const _ as usize },
|
|
36usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImDrawData),
|
|
"::",
|
|
stringify!(DisplaySize)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImDrawData>())).FramebufferScale as *const _ as usize },
|
|
44usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImDrawData),
|
|
"::",
|
|
stringify!(FramebufferScale)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct ImFontConfig {
|
|
pub FontData: *mut ::std::os::raw::c_void,
|
|
pub FontDataSize: ::std::os::raw::c_int,
|
|
pub FontDataOwnedByAtlas: bool,
|
|
pub FontNo: ::std::os::raw::c_int,
|
|
pub SizePixels: f32,
|
|
pub OversampleH: ::std::os::raw::c_int,
|
|
pub OversampleV: ::std::os::raw::c_int,
|
|
pub PixelSnapH: bool,
|
|
pub GlyphExtraSpacing: ImVec2,
|
|
pub GlyphOffset: ImVec2,
|
|
pub GlyphRanges: *const ImWchar,
|
|
pub GlyphMinAdvanceX: f32,
|
|
pub GlyphMaxAdvanceX: f32,
|
|
pub MergeMode: bool,
|
|
pub RasterizerFlags: ::std::os::raw::c_uint,
|
|
pub RasterizerMultiply: f32,
|
|
pub EllipsisChar: ImWchar,
|
|
pub Name: [::std::os::raw::c_char; 40usize],
|
|
pub DstFont: *mut ImFont,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImFontConfig() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImFontConfig>(),
|
|
136usize,
|
|
concat!("Size of: ", stringify!(ImFontConfig))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImFontConfig>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImFontConfig))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontConfig>())).FontData as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontConfig),
|
|
"::",
|
|
stringify!(FontData)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontConfig>())).FontDataSize as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontConfig),
|
|
"::",
|
|
stringify!(FontDataSize)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<ImFontConfig>())).FontDataOwnedByAtlas as *const _ as usize
|
|
},
|
|
12usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontConfig),
|
|
"::",
|
|
stringify!(FontDataOwnedByAtlas)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontConfig>())).FontNo as *const _ as usize },
|
|
16usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontConfig),
|
|
"::",
|
|
stringify!(FontNo)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontConfig>())).SizePixels as *const _ as usize },
|
|
20usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontConfig),
|
|
"::",
|
|
stringify!(SizePixels)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontConfig>())).OversampleH as *const _ as usize },
|
|
24usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontConfig),
|
|
"::",
|
|
stringify!(OversampleH)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontConfig>())).OversampleV as *const _ as usize },
|
|
28usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontConfig),
|
|
"::",
|
|
stringify!(OversampleV)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontConfig>())).PixelSnapH as *const _ as usize },
|
|
32usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontConfig),
|
|
"::",
|
|
stringify!(PixelSnapH)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontConfig>())).GlyphExtraSpacing as *const _ as usize },
|
|
36usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontConfig),
|
|
"::",
|
|
stringify!(GlyphExtraSpacing)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontConfig>())).GlyphOffset as *const _ as usize },
|
|
44usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontConfig),
|
|
"::",
|
|
stringify!(GlyphOffset)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontConfig>())).GlyphRanges as *const _ as usize },
|
|
56usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontConfig),
|
|
"::",
|
|
stringify!(GlyphRanges)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontConfig>())).GlyphMinAdvanceX as *const _ as usize },
|
|
64usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontConfig),
|
|
"::",
|
|
stringify!(GlyphMinAdvanceX)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontConfig>())).GlyphMaxAdvanceX as *const _ as usize },
|
|
68usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontConfig),
|
|
"::",
|
|
stringify!(GlyphMaxAdvanceX)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontConfig>())).MergeMode as *const _ as usize },
|
|
72usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontConfig),
|
|
"::",
|
|
stringify!(MergeMode)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontConfig>())).RasterizerFlags as *const _ as usize },
|
|
76usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontConfig),
|
|
"::",
|
|
stringify!(RasterizerFlags)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontConfig>())).RasterizerMultiply as *const _ as usize },
|
|
80usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontConfig),
|
|
"::",
|
|
stringify!(RasterizerMultiply)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontConfig>())).EllipsisChar as *const _ as usize },
|
|
84usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontConfig),
|
|
"::",
|
|
stringify!(EllipsisChar)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontConfig>())).Name as *const _ as usize },
|
|
86usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontConfig),
|
|
"::",
|
|
stringify!(Name)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontConfig>())).DstFont as *const _ as usize },
|
|
128usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontConfig),
|
|
"::",
|
|
stringify!(DstFont)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImFontGlyph {
|
|
pub _bitfield_1: __BindgenBitfieldUnit<[u8; 4usize], u32>,
|
|
pub AdvanceX: f32,
|
|
pub X0: f32,
|
|
pub Y0: f32,
|
|
pub X1: f32,
|
|
pub Y1: f32,
|
|
pub U0: f32,
|
|
pub V0: f32,
|
|
pub U1: f32,
|
|
pub V1: f32,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImFontGlyph() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImFontGlyph>(),
|
|
40usize,
|
|
concat!("Size of: ", stringify!(ImFontGlyph))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImFontGlyph>(),
|
|
4usize,
|
|
concat!("Alignment of ", stringify!(ImFontGlyph))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontGlyph>())).AdvanceX as *const _ as usize },
|
|
4usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontGlyph),
|
|
"::",
|
|
stringify!(AdvanceX)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontGlyph>())).X0 as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontGlyph),
|
|
"::",
|
|
stringify!(X0)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontGlyph>())).Y0 as *const _ as usize },
|
|
12usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontGlyph),
|
|
"::",
|
|
stringify!(Y0)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontGlyph>())).X1 as *const _ as usize },
|
|
16usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontGlyph),
|
|
"::",
|
|
stringify!(X1)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontGlyph>())).Y1 as *const _ as usize },
|
|
20usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontGlyph),
|
|
"::",
|
|
stringify!(Y1)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontGlyph>())).U0 as *const _ as usize },
|
|
24usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontGlyph),
|
|
"::",
|
|
stringify!(U0)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontGlyph>())).V0 as *const _ as usize },
|
|
28usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontGlyph),
|
|
"::",
|
|
stringify!(V0)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontGlyph>())).U1 as *const _ as usize },
|
|
32usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontGlyph),
|
|
"::",
|
|
stringify!(U1)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontGlyph>())).V1 as *const _ as usize },
|
|
36usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontGlyph),
|
|
"::",
|
|
stringify!(V1)
|
|
)
|
|
);
|
|
}
|
|
impl ImFontGlyph {
|
|
#[inline]
|
|
pub fn Codepoint(&self) -> ::std::os::raw::c_uint {
|
|
unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 31u8) as u32) }
|
|
}
|
|
#[inline]
|
|
pub fn set_Codepoint(&mut self, val: ::std::os::raw::c_uint) {
|
|
unsafe {
|
|
let val: u32 = ::std::mem::transmute(val);
|
|
self._bitfield_1.set(0usize, 31u8, val as u64)
|
|
}
|
|
}
|
|
#[inline]
|
|
pub fn Visible(&self) -> ::std::os::raw::c_uint {
|
|
unsafe { ::std::mem::transmute(self._bitfield_1.get(31usize, 1u8) as u32) }
|
|
}
|
|
#[inline]
|
|
pub fn set_Visible(&mut self, val: ::std::os::raw::c_uint) {
|
|
unsafe {
|
|
let val: u32 = ::std::mem::transmute(val);
|
|
self._bitfield_1.set(31usize, 1u8, val as u64)
|
|
}
|
|
}
|
|
#[inline]
|
|
pub fn new_bitfield_1(
|
|
Codepoint: ::std::os::raw::c_uint,
|
|
Visible: ::std::os::raw::c_uint,
|
|
) -> __BindgenBitfieldUnit<[u8; 4usize], u32> {
|
|
let mut __bindgen_bitfield_unit: __BindgenBitfieldUnit<[u8; 4usize], u32> =
|
|
Default::default();
|
|
__bindgen_bitfield_unit.set(0usize, 31u8, {
|
|
let Codepoint: u32 = unsafe { ::std::mem::transmute(Codepoint) };
|
|
Codepoint as u64
|
|
});
|
|
__bindgen_bitfield_unit.set(31usize, 1u8, {
|
|
let Visible: u32 = unsafe { ::std::mem::transmute(Visible) };
|
|
Visible as u64
|
|
});
|
|
__bindgen_bitfield_unit
|
|
}
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImFontGlyphRangesBuilder {
|
|
pub UsedChars: ImVector_ImU32,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImFontGlyphRangesBuilder() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImFontGlyphRangesBuilder>(),
|
|
16usize,
|
|
concat!("Size of: ", stringify!(ImFontGlyphRangesBuilder))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImFontGlyphRangesBuilder>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImFontGlyphRangesBuilder))
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<ImFontGlyphRangesBuilder>())).UsedChars as *const _ as usize
|
|
},
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontGlyphRangesBuilder),
|
|
"::",
|
|
stringify!(UsedChars)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImFontAtlasCustomRect {
|
|
pub Width: ::std::os::raw::c_ushort,
|
|
pub Height: ::std::os::raw::c_ushort,
|
|
pub X: ::std::os::raw::c_ushort,
|
|
pub Y: ::std::os::raw::c_ushort,
|
|
pub GlyphID: ::std::os::raw::c_uint,
|
|
pub GlyphAdvanceX: f32,
|
|
pub GlyphOffset: ImVec2,
|
|
pub Font: *mut ImFont,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImFontAtlasCustomRect() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImFontAtlasCustomRect>(),
|
|
32usize,
|
|
concat!("Size of: ", stringify!(ImFontAtlasCustomRect))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImFontAtlasCustomRect>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImFontAtlasCustomRect))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontAtlasCustomRect>())).Width as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontAtlasCustomRect),
|
|
"::",
|
|
stringify!(Width)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontAtlasCustomRect>())).Height as *const _ as usize },
|
|
2usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontAtlasCustomRect),
|
|
"::",
|
|
stringify!(Height)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontAtlasCustomRect>())).X as *const _ as usize },
|
|
4usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontAtlasCustomRect),
|
|
"::",
|
|
stringify!(X)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontAtlasCustomRect>())).Y as *const _ as usize },
|
|
6usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontAtlasCustomRect),
|
|
"::",
|
|
stringify!(Y)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontAtlasCustomRect>())).GlyphID as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontAtlasCustomRect),
|
|
"::",
|
|
stringify!(GlyphID)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<ImFontAtlasCustomRect>())).GlyphAdvanceX as *const _ as usize
|
|
},
|
|
12usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontAtlasCustomRect),
|
|
"::",
|
|
stringify!(GlyphAdvanceX)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<ImFontAtlasCustomRect>())).GlyphOffset as *const _ as usize
|
|
},
|
|
16usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontAtlasCustomRect),
|
|
"::",
|
|
stringify!(GlyphOffset)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontAtlasCustomRect>())).Font as *const _ as usize },
|
|
24usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontAtlasCustomRect),
|
|
"::",
|
|
stringify!(Font)
|
|
)
|
|
);
|
|
}
|
|
pub const ImFontAtlasFlags__ImFontAtlasFlags_None: ImFontAtlasFlags_ = 0;
|
|
pub const ImFontAtlasFlags__ImFontAtlasFlags_NoPowerOfTwoHeight: ImFontAtlasFlags_ = 1;
|
|
pub const ImFontAtlasFlags__ImFontAtlasFlags_NoMouseCursors: ImFontAtlasFlags_ = 2;
|
|
pub type ImFontAtlasFlags_ = u32;
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImFontAtlas {
|
|
pub Locked: bool,
|
|
pub Flags: ImFontAtlasFlags,
|
|
pub TexID: ImTextureID,
|
|
pub TexDesiredWidth: ::std::os::raw::c_int,
|
|
pub TexGlyphPadding: ::std::os::raw::c_int,
|
|
pub TexPixelsAlpha8: *mut ::std::os::raw::c_uchar,
|
|
pub TexPixelsRGBA32: *mut ::std::os::raw::c_uint,
|
|
pub TexWidth: ::std::os::raw::c_int,
|
|
pub TexHeight: ::std::os::raw::c_int,
|
|
pub TexUvScale: ImVec2,
|
|
pub TexUvWhitePixel: ImVec2,
|
|
pub Fonts: ImVector_ImFontPtr,
|
|
pub CustomRects: ImVector_ImFontAtlasCustomRect,
|
|
pub ConfigData: ImVector_ImFontConfig,
|
|
pub CustomRectIds: [::std::os::raw::c_int; 1usize],
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImFontAtlas() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImFontAtlas>(),
|
|
120usize,
|
|
concat!("Size of: ", stringify!(ImFontAtlas))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImFontAtlas>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImFontAtlas))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontAtlas>())).Locked as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontAtlas),
|
|
"::",
|
|
stringify!(Locked)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontAtlas>())).Flags as *const _ as usize },
|
|
4usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontAtlas),
|
|
"::",
|
|
stringify!(Flags)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontAtlas>())).TexID as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontAtlas),
|
|
"::",
|
|
stringify!(TexID)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontAtlas>())).TexDesiredWidth as *const _ as usize },
|
|
16usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontAtlas),
|
|
"::",
|
|
stringify!(TexDesiredWidth)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontAtlas>())).TexGlyphPadding as *const _ as usize },
|
|
20usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontAtlas),
|
|
"::",
|
|
stringify!(TexGlyphPadding)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontAtlas>())).TexPixelsAlpha8 as *const _ as usize },
|
|
24usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontAtlas),
|
|
"::",
|
|
stringify!(TexPixelsAlpha8)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontAtlas>())).TexPixelsRGBA32 as *const _ as usize },
|
|
32usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontAtlas),
|
|
"::",
|
|
stringify!(TexPixelsRGBA32)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontAtlas>())).TexWidth as *const _ as usize },
|
|
40usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontAtlas),
|
|
"::",
|
|
stringify!(TexWidth)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontAtlas>())).TexHeight as *const _ as usize },
|
|
44usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontAtlas),
|
|
"::",
|
|
stringify!(TexHeight)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontAtlas>())).TexUvScale as *const _ as usize },
|
|
48usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontAtlas),
|
|
"::",
|
|
stringify!(TexUvScale)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontAtlas>())).TexUvWhitePixel as *const _ as usize },
|
|
56usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontAtlas),
|
|
"::",
|
|
stringify!(TexUvWhitePixel)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontAtlas>())).Fonts as *const _ as usize },
|
|
64usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontAtlas),
|
|
"::",
|
|
stringify!(Fonts)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontAtlas>())).CustomRects as *const _ as usize },
|
|
80usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontAtlas),
|
|
"::",
|
|
stringify!(CustomRects)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontAtlas>())).ConfigData as *const _ as usize },
|
|
96usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontAtlas),
|
|
"::",
|
|
stringify!(ConfigData)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFontAtlas>())).CustomRectIds as *const _ as usize },
|
|
112usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFontAtlas),
|
|
"::",
|
|
stringify!(CustomRectIds)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImFont {
|
|
pub IndexAdvanceX: ImVector_float,
|
|
pub FallbackAdvanceX: f32,
|
|
pub FontSize: f32,
|
|
pub IndexLookup: ImVector_ImWchar,
|
|
pub Glyphs: ImVector_ImFontGlyph,
|
|
pub FallbackGlyph: *const ImFontGlyph,
|
|
pub DisplayOffset: ImVec2,
|
|
pub ContainerAtlas: *mut ImFontAtlas,
|
|
pub ConfigData: *const ImFontConfig,
|
|
pub ConfigDataCount: ::std::os::raw::c_short,
|
|
pub FallbackChar: ImWchar,
|
|
pub EllipsisChar: ImWchar,
|
|
pub DirtyLookupTables: bool,
|
|
pub Scale: f32,
|
|
pub Ascent: f32,
|
|
pub Descent: f32,
|
|
pub MetricsTotalSurface: ::std::os::raw::c_int,
|
|
pub Used4kPagesMap: [ImU8; 2usize],
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImFont() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImFont>(),
|
|
120usize,
|
|
concat!("Size of: ", stringify!(ImFont))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImFont>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImFont))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFont>())).IndexAdvanceX as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFont),
|
|
"::",
|
|
stringify!(IndexAdvanceX)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFont>())).FallbackAdvanceX as *const _ as usize },
|
|
16usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFont),
|
|
"::",
|
|
stringify!(FallbackAdvanceX)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFont>())).FontSize as *const _ as usize },
|
|
20usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFont),
|
|
"::",
|
|
stringify!(FontSize)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFont>())).IndexLookup as *const _ as usize },
|
|
24usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFont),
|
|
"::",
|
|
stringify!(IndexLookup)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFont>())).Glyphs as *const _ as usize },
|
|
40usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFont),
|
|
"::",
|
|
stringify!(Glyphs)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFont>())).FallbackGlyph as *const _ as usize },
|
|
56usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFont),
|
|
"::",
|
|
stringify!(FallbackGlyph)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFont>())).DisplayOffset as *const _ as usize },
|
|
64usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFont),
|
|
"::",
|
|
stringify!(DisplayOffset)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFont>())).ContainerAtlas as *const _ as usize },
|
|
72usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFont),
|
|
"::",
|
|
stringify!(ContainerAtlas)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFont>())).ConfigData as *const _ as usize },
|
|
80usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFont),
|
|
"::",
|
|
stringify!(ConfigData)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFont>())).ConfigDataCount as *const _ as usize },
|
|
88usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFont),
|
|
"::",
|
|
stringify!(ConfigDataCount)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFont>())).FallbackChar as *const _ as usize },
|
|
90usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFont),
|
|
"::",
|
|
stringify!(FallbackChar)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFont>())).EllipsisChar as *const _ as usize },
|
|
92usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFont),
|
|
"::",
|
|
stringify!(EllipsisChar)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFont>())).DirtyLookupTables as *const _ as usize },
|
|
94usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFont),
|
|
"::",
|
|
stringify!(DirtyLookupTables)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFont>())).Scale as *const _ as usize },
|
|
96usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFont),
|
|
"::",
|
|
stringify!(Scale)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFont>())).Ascent as *const _ as usize },
|
|
100usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFont),
|
|
"::",
|
|
stringify!(Ascent)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFont>())).Descent as *const _ as usize },
|
|
104usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFont),
|
|
"::",
|
|
stringify!(Descent)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFont>())).MetricsTotalSurface as *const _ as usize },
|
|
108usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFont),
|
|
"::",
|
|
stringify!(MetricsTotalSurface)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImFont>())).Used4kPagesMap as *const _ as usize },
|
|
112usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImFont),
|
|
"::",
|
|
stringify!(Used4kPagesMap)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImGuiTextRange {
|
|
pub b: *const ::std::os::raw::c_char,
|
|
pub e: *const ::std::os::raw::c_char,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImGuiTextRange() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImGuiTextRange>(),
|
|
16usize,
|
|
concat!("Size of: ", stringify!(ImGuiTextRange))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImGuiTextRange>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImGuiTextRange))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiTextRange>())).b as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiTextRange),
|
|
"::",
|
|
stringify!(b)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiTextRange>())).e as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiTextRange),
|
|
"::",
|
|
stringify!(e)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub struct ImGuiStoragePair {
|
|
pub key: ImGuiID,
|
|
pub __bindgen_anon_1: ImGuiStoragePair__bindgen_ty_1,
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Copy, Clone)]
|
|
pub union ImGuiStoragePair__bindgen_ty_1 {
|
|
pub val_i: ::std::os::raw::c_int,
|
|
pub val_f: f32,
|
|
pub val_p: *mut ::std::os::raw::c_void,
|
|
_bindgen_union_align: u64,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImGuiStoragePair__bindgen_ty_1() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImGuiStoragePair__bindgen_ty_1>(),
|
|
8usize,
|
|
concat!("Size of: ", stringify!(ImGuiStoragePair__bindgen_ty_1))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImGuiStoragePair__bindgen_ty_1>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImGuiStoragePair__bindgen_ty_1))
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<ImGuiStoragePair__bindgen_ty_1>())).val_i as *const _ as usize
|
|
},
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStoragePair__bindgen_ty_1),
|
|
"::",
|
|
stringify!(val_i)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<ImGuiStoragePair__bindgen_ty_1>())).val_f as *const _ as usize
|
|
},
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStoragePair__bindgen_ty_1),
|
|
"::",
|
|
stringify!(val_f)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<ImGuiStoragePair__bindgen_ty_1>())).val_p as *const _ as usize
|
|
},
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStoragePair__bindgen_ty_1),
|
|
"::",
|
|
stringify!(val_p)
|
|
)
|
|
);
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImGuiStoragePair() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImGuiStoragePair>(),
|
|
16usize,
|
|
concat!("Size of: ", stringify!(ImGuiStoragePair))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImGuiStoragePair>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImGuiStoragePair))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImGuiStoragePair>())).key as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImGuiStoragePair),
|
|
"::",
|
|
stringify!(key)
|
|
)
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImVec2_ImVec2Nil() -> *mut ImVec2;
|
|
}
|
|
extern "C" {
|
|
pub fn ImVec2_destroy(self_: *mut ImVec2);
|
|
}
|
|
extern "C" {
|
|
pub fn ImVec2_ImVec2Float(_x: f32, _y: f32) -> *mut ImVec2;
|
|
}
|
|
extern "C" {
|
|
pub fn ImVec4_ImVec4Nil() -> *mut ImVec4;
|
|
}
|
|
extern "C" {
|
|
pub fn ImVec4_destroy(self_: *mut ImVec4);
|
|
}
|
|
extern "C" {
|
|
pub fn ImVec4_ImVec4Float(_x: f32, _y: f32, _z: f32, _w: f32) -> *mut ImVec4;
|
|
}
|
|
extern "C" {
|
|
pub fn igCreateContext(shared_font_atlas: *mut ImFontAtlas) -> *mut ImGuiContext;
|
|
}
|
|
extern "C" {
|
|
pub fn igDestroyContext(ctx: *mut ImGuiContext);
|
|
}
|
|
extern "C" {
|
|
pub fn igGetCurrentContext() -> *mut ImGuiContext;
|
|
}
|
|
extern "C" {
|
|
pub fn igSetCurrentContext(ctx: *mut ImGuiContext);
|
|
}
|
|
extern "C" {
|
|
pub fn igGetIO() -> *mut ImGuiIO;
|
|
}
|
|
extern "C" {
|
|
pub fn igGetStyle() -> *mut ImGuiStyle;
|
|
}
|
|
extern "C" {
|
|
pub fn igNewFrame();
|
|
}
|
|
extern "C" {
|
|
pub fn igEndFrame();
|
|
}
|
|
extern "C" {
|
|
pub fn igRender();
|
|
}
|
|
extern "C" {
|
|
pub fn igGetDrawData() -> *mut ImDrawData;
|
|
}
|
|
extern "C" {
|
|
pub fn igShowDemoWindow(p_open: *mut bool);
|
|
}
|
|
extern "C" {
|
|
pub fn igShowAboutWindow(p_open: *mut bool);
|
|
}
|
|
extern "C" {
|
|
pub fn igShowMetricsWindow(p_open: *mut bool);
|
|
}
|
|
extern "C" {
|
|
pub fn igShowStyleEditor(ref_: *mut ImGuiStyle);
|
|
}
|
|
extern "C" {
|
|
pub fn igShowStyleSelector(label: *const ::std::os::raw::c_char) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igShowFontSelector(label: *const ::std::os::raw::c_char);
|
|
}
|
|
extern "C" {
|
|
pub fn igShowUserGuide();
|
|
}
|
|
extern "C" {
|
|
pub fn igGetVersion() -> *const ::std::os::raw::c_char;
|
|
}
|
|
extern "C" {
|
|
pub fn igStyleColorsDark(dst: *mut ImGuiStyle);
|
|
}
|
|
extern "C" {
|
|
pub fn igStyleColorsClassic(dst: *mut ImGuiStyle);
|
|
}
|
|
extern "C" {
|
|
pub fn igStyleColorsLight(dst: *mut ImGuiStyle);
|
|
}
|
|
extern "C" {
|
|
pub fn igBegin(
|
|
name: *const ::std::os::raw::c_char,
|
|
p_open: *mut bool,
|
|
flags: ImGuiWindowFlags,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igEnd();
|
|
}
|
|
extern "C" {
|
|
pub fn igBeginChildStr(
|
|
str_id: *const ::std::os::raw::c_char,
|
|
size: ImVec2,
|
|
border: bool,
|
|
flags: ImGuiWindowFlags,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igBeginChildID(id: ImGuiID, size: ImVec2, border: bool, flags: ImGuiWindowFlags)
|
|
-> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igEndChild();
|
|
}
|
|
extern "C" {
|
|
pub fn igIsWindowAppearing() -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igIsWindowCollapsed() -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igIsWindowFocused(flags: ImGuiFocusedFlags) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igIsWindowHovered(flags: ImGuiHoveredFlags) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igGetWindowDrawList() -> *mut ImDrawList;
|
|
}
|
|
extern "C" {
|
|
pub fn igGetWindowPos(pOut: *mut ImVec2);
|
|
}
|
|
extern "C" {
|
|
pub fn igGetWindowSize(pOut: *mut ImVec2);
|
|
}
|
|
extern "C" {
|
|
pub fn igGetWindowWidth() -> f32;
|
|
}
|
|
extern "C" {
|
|
pub fn igGetWindowHeight() -> f32;
|
|
}
|
|
extern "C" {
|
|
pub fn igSetNextWindowPos(pos: ImVec2, cond: ImGuiCond, pivot: ImVec2);
|
|
}
|
|
extern "C" {
|
|
pub fn igSetNextWindowSize(size: ImVec2, cond: ImGuiCond);
|
|
}
|
|
extern "C" {
|
|
pub fn igSetNextWindowSizeConstraints(
|
|
size_min: ImVec2,
|
|
size_max: ImVec2,
|
|
custom_callback: ImGuiSizeCallback,
|
|
custom_callback_data: *mut ::std::os::raw::c_void,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn igSetNextWindowContentSize(size: ImVec2);
|
|
}
|
|
extern "C" {
|
|
pub fn igSetNextWindowCollapsed(collapsed: bool, cond: ImGuiCond);
|
|
}
|
|
extern "C" {
|
|
pub fn igSetNextWindowFocus();
|
|
}
|
|
extern "C" {
|
|
pub fn igSetNextWindowBgAlpha(alpha: f32);
|
|
}
|
|
extern "C" {
|
|
pub fn igSetWindowPosVec2(pos: ImVec2, cond: ImGuiCond);
|
|
}
|
|
extern "C" {
|
|
pub fn igSetWindowSizeVec2(size: ImVec2, cond: ImGuiCond);
|
|
}
|
|
extern "C" {
|
|
pub fn igSetWindowCollapsedBool(collapsed: bool, cond: ImGuiCond);
|
|
}
|
|
extern "C" {
|
|
pub fn igSetWindowFocusNil();
|
|
}
|
|
extern "C" {
|
|
pub fn igSetWindowFontScale(scale: f32);
|
|
}
|
|
extern "C" {
|
|
pub fn igSetWindowPosStr(name: *const ::std::os::raw::c_char, pos: ImVec2, cond: ImGuiCond);
|
|
}
|
|
extern "C" {
|
|
pub fn igSetWindowSizeStr(name: *const ::std::os::raw::c_char, size: ImVec2, cond: ImGuiCond);
|
|
}
|
|
extern "C" {
|
|
pub fn igSetWindowCollapsedStr(
|
|
name: *const ::std::os::raw::c_char,
|
|
collapsed: bool,
|
|
cond: ImGuiCond,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn igSetWindowFocusStr(name: *const ::std::os::raw::c_char);
|
|
}
|
|
extern "C" {
|
|
pub fn igGetContentRegionMax(pOut: *mut ImVec2);
|
|
}
|
|
extern "C" {
|
|
pub fn igGetContentRegionAvail(pOut: *mut ImVec2);
|
|
}
|
|
extern "C" {
|
|
pub fn igGetWindowContentRegionMin(pOut: *mut ImVec2);
|
|
}
|
|
extern "C" {
|
|
pub fn igGetWindowContentRegionMax(pOut: *mut ImVec2);
|
|
}
|
|
extern "C" {
|
|
pub fn igGetWindowContentRegionWidth() -> f32;
|
|
}
|
|
extern "C" {
|
|
pub fn igGetScrollX() -> f32;
|
|
}
|
|
extern "C" {
|
|
pub fn igGetScrollY() -> f32;
|
|
}
|
|
extern "C" {
|
|
pub fn igGetScrollMaxX() -> f32;
|
|
}
|
|
extern "C" {
|
|
pub fn igGetScrollMaxY() -> f32;
|
|
}
|
|
extern "C" {
|
|
pub fn igSetScrollX(scroll_x: f32);
|
|
}
|
|
extern "C" {
|
|
pub fn igSetScrollY(scroll_y: f32);
|
|
}
|
|
extern "C" {
|
|
pub fn igSetScrollHereX(center_x_ratio: f32);
|
|
}
|
|
extern "C" {
|
|
pub fn igSetScrollHereY(center_y_ratio: f32);
|
|
}
|
|
extern "C" {
|
|
pub fn igSetScrollFromPosX(local_x: f32, center_x_ratio: f32);
|
|
}
|
|
extern "C" {
|
|
pub fn igSetScrollFromPosY(local_y: f32, center_y_ratio: f32);
|
|
}
|
|
extern "C" {
|
|
pub fn igPushFont(font: *mut ImFont);
|
|
}
|
|
extern "C" {
|
|
pub fn igPopFont();
|
|
}
|
|
extern "C" {
|
|
pub fn igPushStyleColorU32(idx: ImGuiCol, col: ImU32);
|
|
}
|
|
extern "C" {
|
|
pub fn igPushStyleColorVec4(idx: ImGuiCol, col: ImVec4);
|
|
}
|
|
extern "C" {
|
|
pub fn igPopStyleColor(count: ::std::os::raw::c_int);
|
|
}
|
|
extern "C" {
|
|
pub fn igPushStyleVarFloat(idx: ImGuiStyleVar, val: f32);
|
|
}
|
|
extern "C" {
|
|
pub fn igPushStyleVarVec2(idx: ImGuiStyleVar, val: ImVec2);
|
|
}
|
|
extern "C" {
|
|
pub fn igPopStyleVar(count: ::std::os::raw::c_int);
|
|
}
|
|
extern "C" {
|
|
pub fn igGetStyleColorVec4(idx: ImGuiCol) -> *const ImVec4;
|
|
}
|
|
extern "C" {
|
|
pub fn igGetFont() -> *mut ImFont;
|
|
}
|
|
extern "C" {
|
|
pub fn igGetFontSize() -> f32;
|
|
}
|
|
extern "C" {
|
|
pub fn igGetFontTexUvWhitePixel(pOut: *mut ImVec2);
|
|
}
|
|
extern "C" {
|
|
pub fn igGetColorU32Col(idx: ImGuiCol, alpha_mul: f32) -> ImU32;
|
|
}
|
|
extern "C" {
|
|
pub fn igGetColorU32Vec4(col: ImVec4) -> ImU32;
|
|
}
|
|
extern "C" {
|
|
pub fn igGetColorU32U32(col: ImU32) -> ImU32;
|
|
}
|
|
extern "C" {
|
|
pub fn igPushItemWidth(item_width: f32);
|
|
}
|
|
extern "C" {
|
|
pub fn igPopItemWidth();
|
|
}
|
|
extern "C" {
|
|
pub fn igSetNextItemWidth(item_width: f32);
|
|
}
|
|
extern "C" {
|
|
pub fn igCalcItemWidth() -> f32;
|
|
}
|
|
extern "C" {
|
|
pub fn igPushTextWrapPos(wrap_local_pos_x: f32);
|
|
}
|
|
extern "C" {
|
|
pub fn igPopTextWrapPos();
|
|
}
|
|
extern "C" {
|
|
pub fn igPushAllowKeyboardFocus(allow_keyboard_focus: bool);
|
|
}
|
|
extern "C" {
|
|
pub fn igPopAllowKeyboardFocus();
|
|
}
|
|
extern "C" {
|
|
pub fn igPushButtonRepeat(repeat: bool);
|
|
}
|
|
extern "C" {
|
|
pub fn igPopButtonRepeat();
|
|
}
|
|
extern "C" {
|
|
pub fn igSeparator();
|
|
}
|
|
extern "C" {
|
|
pub fn igSameLine(offset_from_start_x: f32, spacing: f32);
|
|
}
|
|
extern "C" {
|
|
pub fn igNewLine();
|
|
}
|
|
extern "C" {
|
|
pub fn igSpacing();
|
|
}
|
|
extern "C" {
|
|
pub fn igDummy(size: ImVec2);
|
|
}
|
|
extern "C" {
|
|
pub fn igIndent(indent_w: f32);
|
|
}
|
|
extern "C" {
|
|
pub fn igUnindent(indent_w: f32);
|
|
}
|
|
extern "C" {
|
|
pub fn igBeginGroup();
|
|
}
|
|
extern "C" {
|
|
pub fn igEndGroup();
|
|
}
|
|
extern "C" {
|
|
pub fn igGetCursorPos(pOut: *mut ImVec2);
|
|
}
|
|
extern "C" {
|
|
pub fn igGetCursorPosX() -> f32;
|
|
}
|
|
extern "C" {
|
|
pub fn igGetCursorPosY() -> f32;
|
|
}
|
|
extern "C" {
|
|
pub fn igSetCursorPos(local_pos: ImVec2);
|
|
}
|
|
extern "C" {
|
|
pub fn igSetCursorPosX(local_x: f32);
|
|
}
|
|
extern "C" {
|
|
pub fn igSetCursorPosY(local_y: f32);
|
|
}
|
|
extern "C" {
|
|
pub fn igGetCursorStartPos(pOut: *mut ImVec2);
|
|
}
|
|
extern "C" {
|
|
pub fn igGetCursorScreenPos(pOut: *mut ImVec2);
|
|
}
|
|
extern "C" {
|
|
pub fn igSetCursorScreenPos(pos: ImVec2);
|
|
}
|
|
extern "C" {
|
|
pub fn igAlignTextToFramePadding();
|
|
}
|
|
extern "C" {
|
|
pub fn igGetTextLineHeight() -> f32;
|
|
}
|
|
extern "C" {
|
|
pub fn igGetTextLineHeightWithSpacing() -> f32;
|
|
}
|
|
extern "C" {
|
|
pub fn igGetFrameHeight() -> f32;
|
|
}
|
|
extern "C" {
|
|
pub fn igGetFrameHeightWithSpacing() -> f32;
|
|
}
|
|
extern "C" {
|
|
pub fn igPushIDStr(str_id: *const ::std::os::raw::c_char);
|
|
}
|
|
extern "C" {
|
|
pub fn igPushIDStrStr(
|
|
str_id_begin: *const ::std::os::raw::c_char,
|
|
str_id_end: *const ::std::os::raw::c_char,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn igPushIDPtr(ptr_id: *const ::std::os::raw::c_void);
|
|
}
|
|
extern "C" {
|
|
pub fn igPushIDInt(int_id: ::std::os::raw::c_int);
|
|
}
|
|
extern "C" {
|
|
pub fn igPopID();
|
|
}
|
|
extern "C" {
|
|
pub fn igGetIDStr(str_id: *const ::std::os::raw::c_char) -> ImGuiID;
|
|
}
|
|
extern "C" {
|
|
pub fn igGetIDStrStr(
|
|
str_id_begin: *const ::std::os::raw::c_char,
|
|
str_id_end: *const ::std::os::raw::c_char,
|
|
) -> ImGuiID;
|
|
}
|
|
extern "C" {
|
|
pub fn igGetIDPtr(ptr_id: *const ::std::os::raw::c_void) -> ImGuiID;
|
|
}
|
|
extern "C" {
|
|
pub fn igTextUnformatted(
|
|
text: *const ::std::os::raw::c_char,
|
|
text_end: *const ::std::os::raw::c_char,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn igText(fmt: *const ::std::os::raw::c_char, ...);
|
|
}
|
|
extern "C" {
|
|
pub fn igTextV(fmt: *const ::std::os::raw::c_char, args: *mut __va_list_tag);
|
|
}
|
|
extern "C" {
|
|
pub fn igTextColored(col: ImVec4, fmt: *const ::std::os::raw::c_char, ...);
|
|
}
|
|
extern "C" {
|
|
pub fn igTextColoredV(
|
|
col: ImVec4,
|
|
fmt: *const ::std::os::raw::c_char,
|
|
args: *mut __va_list_tag,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn igTextDisabled(fmt: *const ::std::os::raw::c_char, ...);
|
|
}
|
|
extern "C" {
|
|
pub fn igTextDisabledV(fmt: *const ::std::os::raw::c_char, args: *mut __va_list_tag);
|
|
}
|
|
extern "C" {
|
|
pub fn igTextWrapped(fmt: *const ::std::os::raw::c_char, ...);
|
|
}
|
|
extern "C" {
|
|
pub fn igTextWrappedV(fmt: *const ::std::os::raw::c_char, args: *mut __va_list_tag);
|
|
}
|
|
extern "C" {
|
|
pub fn igLabelText(
|
|
label: *const ::std::os::raw::c_char,
|
|
fmt: *const ::std::os::raw::c_char,
|
|
...
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn igLabelTextV(
|
|
label: *const ::std::os::raw::c_char,
|
|
fmt: *const ::std::os::raw::c_char,
|
|
args: *mut __va_list_tag,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn igBulletText(fmt: *const ::std::os::raw::c_char, ...);
|
|
}
|
|
extern "C" {
|
|
pub fn igBulletTextV(fmt: *const ::std::os::raw::c_char, args: *mut __va_list_tag);
|
|
}
|
|
extern "C" {
|
|
pub fn igButton(label: *const ::std::os::raw::c_char, size: ImVec2) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igSmallButton(label: *const ::std::os::raw::c_char) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igInvisibleButton(str_id: *const ::std::os::raw::c_char, size: ImVec2) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igArrowButton(str_id: *const ::std::os::raw::c_char, dir: ImGuiDir) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igImage(
|
|
user_texture_id: ImTextureID,
|
|
size: ImVec2,
|
|
uv0: ImVec2,
|
|
uv1: ImVec2,
|
|
tint_col: ImVec4,
|
|
border_col: ImVec4,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn igImageButton(
|
|
user_texture_id: ImTextureID,
|
|
size: ImVec2,
|
|
uv0: ImVec2,
|
|
uv1: ImVec2,
|
|
frame_padding: ::std::os::raw::c_int,
|
|
bg_col: ImVec4,
|
|
tint_col: ImVec4,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igCheckbox(label: *const ::std::os::raw::c_char, v: *mut bool) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igCheckboxFlags(
|
|
label: *const ::std::os::raw::c_char,
|
|
flags: *mut ::std::os::raw::c_uint,
|
|
flags_value: ::std::os::raw::c_uint,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igRadioButtonBool(label: *const ::std::os::raw::c_char, active: bool) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igRadioButtonIntPtr(
|
|
label: *const ::std::os::raw::c_char,
|
|
v: *mut ::std::os::raw::c_int,
|
|
v_button: ::std::os::raw::c_int,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igProgressBar(fraction: f32, size_arg: ImVec2, overlay: *const ::std::os::raw::c_char);
|
|
}
|
|
extern "C" {
|
|
pub fn igBullet();
|
|
}
|
|
extern "C" {
|
|
pub fn igBeginCombo(
|
|
label: *const ::std::os::raw::c_char,
|
|
preview_value: *const ::std::os::raw::c_char,
|
|
flags: ImGuiComboFlags,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igEndCombo();
|
|
}
|
|
extern "C" {
|
|
pub fn igComboStr_arr(
|
|
label: *const ::std::os::raw::c_char,
|
|
current_item: *mut ::std::os::raw::c_int,
|
|
items: *const *const ::std::os::raw::c_char,
|
|
items_count: ::std::os::raw::c_int,
|
|
popup_max_height_in_items: ::std::os::raw::c_int,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igComboStr(
|
|
label: *const ::std::os::raw::c_char,
|
|
current_item: *mut ::std::os::raw::c_int,
|
|
items_separated_by_zeros: *const ::std::os::raw::c_char,
|
|
popup_max_height_in_items: ::std::os::raw::c_int,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igComboFnBoolPtr(
|
|
label: *const ::std::os::raw::c_char,
|
|
current_item: *mut ::std::os::raw::c_int,
|
|
items_getter: ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
data: *mut ::std::os::raw::c_void,
|
|
idx: ::std::os::raw::c_int,
|
|
out_text: *mut *const ::std::os::raw::c_char,
|
|
) -> bool,
|
|
>,
|
|
data: *mut ::std::os::raw::c_void,
|
|
items_count: ::std::os::raw::c_int,
|
|
popup_max_height_in_items: ::std::os::raw::c_int,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igDragFloat(
|
|
label: *const ::std::os::raw::c_char,
|
|
v: *mut f32,
|
|
v_speed: f32,
|
|
v_min: f32,
|
|
v_max: f32,
|
|
format: *const ::std::os::raw::c_char,
|
|
power: f32,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igDragFloat2(
|
|
label: *const ::std::os::raw::c_char,
|
|
v: *mut f32,
|
|
v_speed: f32,
|
|
v_min: f32,
|
|
v_max: f32,
|
|
format: *const ::std::os::raw::c_char,
|
|
power: f32,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igDragFloat3(
|
|
label: *const ::std::os::raw::c_char,
|
|
v: *mut f32,
|
|
v_speed: f32,
|
|
v_min: f32,
|
|
v_max: f32,
|
|
format: *const ::std::os::raw::c_char,
|
|
power: f32,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igDragFloat4(
|
|
label: *const ::std::os::raw::c_char,
|
|
v: *mut f32,
|
|
v_speed: f32,
|
|
v_min: f32,
|
|
v_max: f32,
|
|
format: *const ::std::os::raw::c_char,
|
|
power: f32,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igDragFloatRange2(
|
|
label: *const ::std::os::raw::c_char,
|
|
v_current_min: *mut f32,
|
|
v_current_max: *mut f32,
|
|
v_speed: f32,
|
|
v_min: f32,
|
|
v_max: f32,
|
|
format: *const ::std::os::raw::c_char,
|
|
format_max: *const ::std::os::raw::c_char,
|
|
power: f32,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igDragInt(
|
|
label: *const ::std::os::raw::c_char,
|
|
v: *mut ::std::os::raw::c_int,
|
|
v_speed: f32,
|
|
v_min: ::std::os::raw::c_int,
|
|
v_max: ::std::os::raw::c_int,
|
|
format: *const ::std::os::raw::c_char,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igDragInt2(
|
|
label: *const ::std::os::raw::c_char,
|
|
v: *mut ::std::os::raw::c_int,
|
|
v_speed: f32,
|
|
v_min: ::std::os::raw::c_int,
|
|
v_max: ::std::os::raw::c_int,
|
|
format: *const ::std::os::raw::c_char,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igDragInt3(
|
|
label: *const ::std::os::raw::c_char,
|
|
v: *mut ::std::os::raw::c_int,
|
|
v_speed: f32,
|
|
v_min: ::std::os::raw::c_int,
|
|
v_max: ::std::os::raw::c_int,
|
|
format: *const ::std::os::raw::c_char,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igDragInt4(
|
|
label: *const ::std::os::raw::c_char,
|
|
v: *mut ::std::os::raw::c_int,
|
|
v_speed: f32,
|
|
v_min: ::std::os::raw::c_int,
|
|
v_max: ::std::os::raw::c_int,
|
|
format: *const ::std::os::raw::c_char,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igDragIntRange2(
|
|
label: *const ::std::os::raw::c_char,
|
|
v_current_min: *mut ::std::os::raw::c_int,
|
|
v_current_max: *mut ::std::os::raw::c_int,
|
|
v_speed: f32,
|
|
v_min: ::std::os::raw::c_int,
|
|
v_max: ::std::os::raw::c_int,
|
|
format: *const ::std::os::raw::c_char,
|
|
format_max: *const ::std::os::raw::c_char,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igDragScalar(
|
|
label: *const ::std::os::raw::c_char,
|
|
data_type: ImGuiDataType,
|
|
p_data: *mut ::std::os::raw::c_void,
|
|
v_speed: f32,
|
|
p_min: *const ::std::os::raw::c_void,
|
|
p_max: *const ::std::os::raw::c_void,
|
|
format: *const ::std::os::raw::c_char,
|
|
power: f32,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igDragScalarN(
|
|
label: *const ::std::os::raw::c_char,
|
|
data_type: ImGuiDataType,
|
|
p_data: *mut ::std::os::raw::c_void,
|
|
components: ::std::os::raw::c_int,
|
|
v_speed: f32,
|
|
p_min: *const ::std::os::raw::c_void,
|
|
p_max: *const ::std::os::raw::c_void,
|
|
format: *const ::std::os::raw::c_char,
|
|
power: f32,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igSliderFloat(
|
|
label: *const ::std::os::raw::c_char,
|
|
v: *mut f32,
|
|
v_min: f32,
|
|
v_max: f32,
|
|
format: *const ::std::os::raw::c_char,
|
|
power: f32,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igSliderFloat2(
|
|
label: *const ::std::os::raw::c_char,
|
|
v: *mut f32,
|
|
v_min: f32,
|
|
v_max: f32,
|
|
format: *const ::std::os::raw::c_char,
|
|
power: f32,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igSliderFloat3(
|
|
label: *const ::std::os::raw::c_char,
|
|
v: *mut f32,
|
|
v_min: f32,
|
|
v_max: f32,
|
|
format: *const ::std::os::raw::c_char,
|
|
power: f32,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igSliderFloat4(
|
|
label: *const ::std::os::raw::c_char,
|
|
v: *mut f32,
|
|
v_min: f32,
|
|
v_max: f32,
|
|
format: *const ::std::os::raw::c_char,
|
|
power: f32,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igSliderAngle(
|
|
label: *const ::std::os::raw::c_char,
|
|
v_rad: *mut f32,
|
|
v_degrees_min: f32,
|
|
v_degrees_max: f32,
|
|
format: *const ::std::os::raw::c_char,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igSliderInt(
|
|
label: *const ::std::os::raw::c_char,
|
|
v: *mut ::std::os::raw::c_int,
|
|
v_min: ::std::os::raw::c_int,
|
|
v_max: ::std::os::raw::c_int,
|
|
format: *const ::std::os::raw::c_char,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igSliderInt2(
|
|
label: *const ::std::os::raw::c_char,
|
|
v: *mut ::std::os::raw::c_int,
|
|
v_min: ::std::os::raw::c_int,
|
|
v_max: ::std::os::raw::c_int,
|
|
format: *const ::std::os::raw::c_char,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igSliderInt3(
|
|
label: *const ::std::os::raw::c_char,
|
|
v: *mut ::std::os::raw::c_int,
|
|
v_min: ::std::os::raw::c_int,
|
|
v_max: ::std::os::raw::c_int,
|
|
format: *const ::std::os::raw::c_char,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igSliderInt4(
|
|
label: *const ::std::os::raw::c_char,
|
|
v: *mut ::std::os::raw::c_int,
|
|
v_min: ::std::os::raw::c_int,
|
|
v_max: ::std::os::raw::c_int,
|
|
format: *const ::std::os::raw::c_char,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igSliderScalar(
|
|
label: *const ::std::os::raw::c_char,
|
|
data_type: ImGuiDataType,
|
|
p_data: *mut ::std::os::raw::c_void,
|
|
p_min: *const ::std::os::raw::c_void,
|
|
p_max: *const ::std::os::raw::c_void,
|
|
format: *const ::std::os::raw::c_char,
|
|
power: f32,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igSliderScalarN(
|
|
label: *const ::std::os::raw::c_char,
|
|
data_type: ImGuiDataType,
|
|
p_data: *mut ::std::os::raw::c_void,
|
|
components: ::std::os::raw::c_int,
|
|
p_min: *const ::std::os::raw::c_void,
|
|
p_max: *const ::std::os::raw::c_void,
|
|
format: *const ::std::os::raw::c_char,
|
|
power: f32,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igVSliderFloat(
|
|
label: *const ::std::os::raw::c_char,
|
|
size: ImVec2,
|
|
v: *mut f32,
|
|
v_min: f32,
|
|
v_max: f32,
|
|
format: *const ::std::os::raw::c_char,
|
|
power: f32,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igVSliderInt(
|
|
label: *const ::std::os::raw::c_char,
|
|
size: ImVec2,
|
|
v: *mut ::std::os::raw::c_int,
|
|
v_min: ::std::os::raw::c_int,
|
|
v_max: ::std::os::raw::c_int,
|
|
format: *const ::std::os::raw::c_char,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igVSliderScalar(
|
|
label: *const ::std::os::raw::c_char,
|
|
size: ImVec2,
|
|
data_type: ImGuiDataType,
|
|
p_data: *mut ::std::os::raw::c_void,
|
|
p_min: *const ::std::os::raw::c_void,
|
|
p_max: *const ::std::os::raw::c_void,
|
|
format: *const ::std::os::raw::c_char,
|
|
power: f32,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igInputText(
|
|
label: *const ::std::os::raw::c_char,
|
|
buf: *mut ::std::os::raw::c_char,
|
|
buf_size: size_t,
|
|
flags: ImGuiInputTextFlags,
|
|
callback: ImGuiInputTextCallback,
|
|
user_data: *mut ::std::os::raw::c_void,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igInputTextMultiline(
|
|
label: *const ::std::os::raw::c_char,
|
|
buf: *mut ::std::os::raw::c_char,
|
|
buf_size: size_t,
|
|
size: ImVec2,
|
|
flags: ImGuiInputTextFlags,
|
|
callback: ImGuiInputTextCallback,
|
|
user_data: *mut ::std::os::raw::c_void,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igInputTextWithHint(
|
|
label: *const ::std::os::raw::c_char,
|
|
hint: *const ::std::os::raw::c_char,
|
|
buf: *mut ::std::os::raw::c_char,
|
|
buf_size: size_t,
|
|
flags: ImGuiInputTextFlags,
|
|
callback: ImGuiInputTextCallback,
|
|
user_data: *mut ::std::os::raw::c_void,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igInputFloat(
|
|
label: *const ::std::os::raw::c_char,
|
|
v: *mut f32,
|
|
step: f32,
|
|
step_fast: f32,
|
|
format: *const ::std::os::raw::c_char,
|
|
flags: ImGuiInputTextFlags,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igInputFloat2(
|
|
label: *const ::std::os::raw::c_char,
|
|
v: *mut f32,
|
|
format: *const ::std::os::raw::c_char,
|
|
flags: ImGuiInputTextFlags,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igInputFloat3(
|
|
label: *const ::std::os::raw::c_char,
|
|
v: *mut f32,
|
|
format: *const ::std::os::raw::c_char,
|
|
flags: ImGuiInputTextFlags,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igInputFloat4(
|
|
label: *const ::std::os::raw::c_char,
|
|
v: *mut f32,
|
|
format: *const ::std::os::raw::c_char,
|
|
flags: ImGuiInputTextFlags,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igInputInt(
|
|
label: *const ::std::os::raw::c_char,
|
|
v: *mut ::std::os::raw::c_int,
|
|
step: ::std::os::raw::c_int,
|
|
step_fast: ::std::os::raw::c_int,
|
|
flags: ImGuiInputTextFlags,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igInputInt2(
|
|
label: *const ::std::os::raw::c_char,
|
|
v: *mut ::std::os::raw::c_int,
|
|
flags: ImGuiInputTextFlags,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igInputInt3(
|
|
label: *const ::std::os::raw::c_char,
|
|
v: *mut ::std::os::raw::c_int,
|
|
flags: ImGuiInputTextFlags,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igInputInt4(
|
|
label: *const ::std::os::raw::c_char,
|
|
v: *mut ::std::os::raw::c_int,
|
|
flags: ImGuiInputTextFlags,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igInputDouble(
|
|
label: *const ::std::os::raw::c_char,
|
|
v: *mut f64,
|
|
step: f64,
|
|
step_fast: f64,
|
|
format: *const ::std::os::raw::c_char,
|
|
flags: ImGuiInputTextFlags,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igInputScalar(
|
|
label: *const ::std::os::raw::c_char,
|
|
data_type: ImGuiDataType,
|
|
p_data: *mut ::std::os::raw::c_void,
|
|
p_step: *const ::std::os::raw::c_void,
|
|
p_step_fast: *const ::std::os::raw::c_void,
|
|
format: *const ::std::os::raw::c_char,
|
|
flags: ImGuiInputTextFlags,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igInputScalarN(
|
|
label: *const ::std::os::raw::c_char,
|
|
data_type: ImGuiDataType,
|
|
p_data: *mut ::std::os::raw::c_void,
|
|
components: ::std::os::raw::c_int,
|
|
p_step: *const ::std::os::raw::c_void,
|
|
p_step_fast: *const ::std::os::raw::c_void,
|
|
format: *const ::std::os::raw::c_char,
|
|
flags: ImGuiInputTextFlags,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igColorEdit3(
|
|
label: *const ::std::os::raw::c_char,
|
|
col: *mut f32,
|
|
flags: ImGuiColorEditFlags,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igColorEdit4(
|
|
label: *const ::std::os::raw::c_char,
|
|
col: *mut f32,
|
|
flags: ImGuiColorEditFlags,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igColorPicker3(
|
|
label: *const ::std::os::raw::c_char,
|
|
col: *mut f32,
|
|
flags: ImGuiColorEditFlags,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igColorPicker4(
|
|
label: *const ::std::os::raw::c_char,
|
|
col: *mut f32,
|
|
flags: ImGuiColorEditFlags,
|
|
ref_col: *const f32,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igColorButton(
|
|
desc_id: *const ::std::os::raw::c_char,
|
|
col: ImVec4,
|
|
flags: ImGuiColorEditFlags,
|
|
size: ImVec2,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igSetColorEditOptions(flags: ImGuiColorEditFlags);
|
|
}
|
|
extern "C" {
|
|
pub fn igTreeNodeStr(label: *const ::std::os::raw::c_char) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igTreeNodeStrStr(
|
|
str_id: *const ::std::os::raw::c_char,
|
|
fmt: *const ::std::os::raw::c_char,
|
|
...
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igTreeNodePtr(
|
|
ptr_id: *const ::std::os::raw::c_void,
|
|
fmt: *const ::std::os::raw::c_char,
|
|
...
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igTreeNodeVStr(
|
|
str_id: *const ::std::os::raw::c_char,
|
|
fmt: *const ::std::os::raw::c_char,
|
|
args: *mut __va_list_tag,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igTreeNodeVPtr(
|
|
ptr_id: *const ::std::os::raw::c_void,
|
|
fmt: *const ::std::os::raw::c_char,
|
|
args: *mut __va_list_tag,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igTreeNodeExStr(label: *const ::std::os::raw::c_char, flags: ImGuiTreeNodeFlags)
|
|
-> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igTreeNodeExStrStr(
|
|
str_id: *const ::std::os::raw::c_char,
|
|
flags: ImGuiTreeNodeFlags,
|
|
fmt: *const ::std::os::raw::c_char,
|
|
...
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igTreeNodeExPtr(
|
|
ptr_id: *const ::std::os::raw::c_void,
|
|
flags: ImGuiTreeNodeFlags,
|
|
fmt: *const ::std::os::raw::c_char,
|
|
...
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igTreeNodeExVStr(
|
|
str_id: *const ::std::os::raw::c_char,
|
|
flags: ImGuiTreeNodeFlags,
|
|
fmt: *const ::std::os::raw::c_char,
|
|
args: *mut __va_list_tag,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igTreeNodeExVPtr(
|
|
ptr_id: *const ::std::os::raw::c_void,
|
|
flags: ImGuiTreeNodeFlags,
|
|
fmt: *const ::std::os::raw::c_char,
|
|
args: *mut __va_list_tag,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igTreePushStr(str_id: *const ::std::os::raw::c_char);
|
|
}
|
|
extern "C" {
|
|
pub fn igTreePushPtr(ptr_id: *const ::std::os::raw::c_void);
|
|
}
|
|
extern "C" {
|
|
pub fn igTreePop();
|
|
}
|
|
extern "C" {
|
|
pub fn igGetTreeNodeToLabelSpacing() -> f32;
|
|
}
|
|
extern "C" {
|
|
pub fn igCollapsingHeaderTreeNodeFlags(
|
|
label: *const ::std::os::raw::c_char,
|
|
flags: ImGuiTreeNodeFlags,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igCollapsingHeaderBoolPtr(
|
|
label: *const ::std::os::raw::c_char,
|
|
p_open: *mut bool,
|
|
flags: ImGuiTreeNodeFlags,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igSetNextItemOpen(is_open: bool, cond: ImGuiCond);
|
|
}
|
|
extern "C" {
|
|
pub fn igSelectableBool(
|
|
label: *const ::std::os::raw::c_char,
|
|
selected: bool,
|
|
flags: ImGuiSelectableFlags,
|
|
size: ImVec2,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igSelectableBoolPtr(
|
|
label: *const ::std::os::raw::c_char,
|
|
p_selected: *mut bool,
|
|
flags: ImGuiSelectableFlags,
|
|
size: ImVec2,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igListBoxStr_arr(
|
|
label: *const ::std::os::raw::c_char,
|
|
current_item: *mut ::std::os::raw::c_int,
|
|
items: *const *const ::std::os::raw::c_char,
|
|
items_count: ::std::os::raw::c_int,
|
|
height_in_items: ::std::os::raw::c_int,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igListBoxFnBoolPtr(
|
|
label: *const ::std::os::raw::c_char,
|
|
current_item: *mut ::std::os::raw::c_int,
|
|
items_getter: ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
data: *mut ::std::os::raw::c_void,
|
|
idx: ::std::os::raw::c_int,
|
|
out_text: *mut *const ::std::os::raw::c_char,
|
|
) -> bool,
|
|
>,
|
|
data: *mut ::std::os::raw::c_void,
|
|
items_count: ::std::os::raw::c_int,
|
|
height_in_items: ::std::os::raw::c_int,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igListBoxHeaderVec2(label: *const ::std::os::raw::c_char, size: ImVec2) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igListBoxHeaderInt(
|
|
label: *const ::std::os::raw::c_char,
|
|
items_count: ::std::os::raw::c_int,
|
|
height_in_items: ::std::os::raw::c_int,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igListBoxFooter();
|
|
}
|
|
extern "C" {
|
|
pub fn igPlotLinesFloatPtr(
|
|
label: *const ::std::os::raw::c_char,
|
|
values: *const f32,
|
|
values_count: ::std::os::raw::c_int,
|
|
values_offset: ::std::os::raw::c_int,
|
|
overlay_text: *const ::std::os::raw::c_char,
|
|
scale_min: f32,
|
|
scale_max: f32,
|
|
graph_size: ImVec2,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn igPlotLinesFnFloatPtr(
|
|
label: *const ::std::os::raw::c_char,
|
|
values_getter: ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
data: *mut ::std::os::raw::c_void,
|
|
idx: ::std::os::raw::c_int,
|
|
) -> f32,
|
|
>,
|
|
data: *mut ::std::os::raw::c_void,
|
|
values_count: ::std::os::raw::c_int,
|
|
values_offset: ::std::os::raw::c_int,
|
|
overlay_text: *const ::std::os::raw::c_char,
|
|
scale_min: f32,
|
|
scale_max: f32,
|
|
graph_size: ImVec2,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn igPlotHistogramFloatPtr(
|
|
label: *const ::std::os::raw::c_char,
|
|
values: *const f32,
|
|
values_count: ::std::os::raw::c_int,
|
|
values_offset: ::std::os::raw::c_int,
|
|
overlay_text: *const ::std::os::raw::c_char,
|
|
scale_min: f32,
|
|
scale_max: f32,
|
|
graph_size: ImVec2,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn igPlotHistogramFnFloatPtr(
|
|
label: *const ::std::os::raw::c_char,
|
|
values_getter: ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
data: *mut ::std::os::raw::c_void,
|
|
idx: ::std::os::raw::c_int,
|
|
) -> f32,
|
|
>,
|
|
data: *mut ::std::os::raw::c_void,
|
|
values_count: ::std::os::raw::c_int,
|
|
values_offset: ::std::os::raw::c_int,
|
|
overlay_text: *const ::std::os::raw::c_char,
|
|
scale_min: f32,
|
|
scale_max: f32,
|
|
graph_size: ImVec2,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn igValueBool(prefix: *const ::std::os::raw::c_char, b: bool);
|
|
}
|
|
extern "C" {
|
|
pub fn igValueInt(prefix: *const ::std::os::raw::c_char, v: ::std::os::raw::c_int);
|
|
}
|
|
extern "C" {
|
|
pub fn igValueUint(prefix: *const ::std::os::raw::c_char, v: ::std::os::raw::c_uint);
|
|
}
|
|
extern "C" {
|
|
pub fn igValueFloat(
|
|
prefix: *const ::std::os::raw::c_char,
|
|
v: f32,
|
|
float_format: *const ::std::os::raw::c_char,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn igBeginMenuBar() -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igEndMenuBar();
|
|
}
|
|
extern "C" {
|
|
pub fn igBeginMainMenuBar() -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igEndMainMenuBar();
|
|
}
|
|
extern "C" {
|
|
pub fn igBeginMenu(label: *const ::std::os::raw::c_char, enabled: bool) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igEndMenu();
|
|
}
|
|
extern "C" {
|
|
pub fn igMenuItemBool(
|
|
label: *const ::std::os::raw::c_char,
|
|
shortcut: *const ::std::os::raw::c_char,
|
|
selected: bool,
|
|
enabled: bool,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igMenuItemBoolPtr(
|
|
label: *const ::std::os::raw::c_char,
|
|
shortcut: *const ::std::os::raw::c_char,
|
|
p_selected: *mut bool,
|
|
enabled: bool,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igBeginTooltip();
|
|
}
|
|
extern "C" {
|
|
pub fn igEndTooltip();
|
|
}
|
|
extern "C" {
|
|
pub fn igSetTooltip(fmt: *const ::std::os::raw::c_char, ...);
|
|
}
|
|
extern "C" {
|
|
pub fn igSetTooltipV(fmt: *const ::std::os::raw::c_char, args: *mut __va_list_tag);
|
|
}
|
|
extern "C" {
|
|
pub fn igBeginPopup(str_id: *const ::std::os::raw::c_char, flags: ImGuiWindowFlags) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igBeginPopupModal(
|
|
name: *const ::std::os::raw::c_char,
|
|
p_open: *mut bool,
|
|
flags: ImGuiWindowFlags,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igEndPopup();
|
|
}
|
|
extern "C" {
|
|
pub fn igOpenPopup(str_id: *const ::std::os::raw::c_char, popup_flags: ImGuiPopupFlags);
|
|
}
|
|
extern "C" {
|
|
pub fn igOpenPopupContextItem(
|
|
str_id: *const ::std::os::raw::c_char,
|
|
popup_flags: ImGuiPopupFlags,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igCloseCurrentPopup();
|
|
}
|
|
extern "C" {
|
|
pub fn igBeginPopupContextItem(
|
|
str_id: *const ::std::os::raw::c_char,
|
|
popup_flags: ImGuiPopupFlags,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igBeginPopupContextWindow(
|
|
str_id: *const ::std::os::raw::c_char,
|
|
popup_flags: ImGuiPopupFlags,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igBeginPopupContextVoid(
|
|
str_id: *const ::std::os::raw::c_char,
|
|
popup_flags: ImGuiPopupFlags,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igIsPopupOpen(str_id: *const ::std::os::raw::c_char, flags: ImGuiPopupFlags) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igColumns(count: ::std::os::raw::c_int, id: *const ::std::os::raw::c_char, border: bool);
|
|
}
|
|
extern "C" {
|
|
pub fn igNextColumn();
|
|
}
|
|
extern "C" {
|
|
pub fn igGetColumnIndex() -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn igGetColumnWidth(column_index: ::std::os::raw::c_int) -> f32;
|
|
}
|
|
extern "C" {
|
|
pub fn igSetColumnWidth(column_index: ::std::os::raw::c_int, width: f32);
|
|
}
|
|
extern "C" {
|
|
pub fn igGetColumnOffset(column_index: ::std::os::raw::c_int) -> f32;
|
|
}
|
|
extern "C" {
|
|
pub fn igSetColumnOffset(column_index: ::std::os::raw::c_int, offset_x: f32);
|
|
}
|
|
extern "C" {
|
|
pub fn igGetColumnsCount() -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn igBeginTabBar(str_id: *const ::std::os::raw::c_char, flags: ImGuiTabBarFlags) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igEndTabBar();
|
|
}
|
|
extern "C" {
|
|
pub fn igBeginTabItem(
|
|
label: *const ::std::os::raw::c_char,
|
|
p_open: *mut bool,
|
|
flags: ImGuiTabItemFlags,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igEndTabItem();
|
|
}
|
|
extern "C" {
|
|
pub fn igSetTabItemClosed(tab_or_docked_window_label: *const ::std::os::raw::c_char);
|
|
}
|
|
extern "C" {
|
|
pub fn igLogToTTY(auto_open_depth: ::std::os::raw::c_int);
|
|
}
|
|
extern "C" {
|
|
pub fn igLogToFile(
|
|
auto_open_depth: ::std::os::raw::c_int,
|
|
filename: *const ::std::os::raw::c_char,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn igLogToClipboard(auto_open_depth: ::std::os::raw::c_int);
|
|
}
|
|
extern "C" {
|
|
pub fn igLogFinish();
|
|
}
|
|
extern "C" {
|
|
pub fn igLogButtons();
|
|
}
|
|
extern "C" {
|
|
pub fn igBeginDragDropSource(flags: ImGuiDragDropFlags) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igSetDragDropPayload(
|
|
type_: *const ::std::os::raw::c_char,
|
|
data: *const ::std::os::raw::c_void,
|
|
sz: size_t,
|
|
cond: ImGuiCond,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igEndDragDropSource();
|
|
}
|
|
extern "C" {
|
|
pub fn igBeginDragDropTarget() -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igAcceptDragDropPayload(
|
|
type_: *const ::std::os::raw::c_char,
|
|
flags: ImGuiDragDropFlags,
|
|
) -> *const ImGuiPayload;
|
|
}
|
|
extern "C" {
|
|
pub fn igEndDragDropTarget();
|
|
}
|
|
extern "C" {
|
|
pub fn igGetDragDropPayload() -> *const ImGuiPayload;
|
|
}
|
|
extern "C" {
|
|
pub fn igPushClipRect(
|
|
clip_rect_min: ImVec2,
|
|
clip_rect_max: ImVec2,
|
|
intersect_with_current_clip_rect: bool,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn igPopClipRect();
|
|
}
|
|
extern "C" {
|
|
pub fn igSetItemDefaultFocus();
|
|
}
|
|
extern "C" {
|
|
pub fn igSetKeyboardFocusHere(offset: ::std::os::raw::c_int);
|
|
}
|
|
extern "C" {
|
|
pub fn igIsItemHovered(flags: ImGuiHoveredFlags) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igIsItemActive() -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igIsItemFocused() -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igIsItemClicked(mouse_button: ImGuiMouseButton) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igIsItemVisible() -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igIsItemEdited() -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igIsItemActivated() -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igIsItemDeactivated() -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igIsItemDeactivatedAfterEdit() -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igIsItemToggledOpen() -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igIsAnyItemHovered() -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igIsAnyItemActive() -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igIsAnyItemFocused() -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igGetItemRectMin(pOut: *mut ImVec2);
|
|
}
|
|
extern "C" {
|
|
pub fn igGetItemRectMax(pOut: *mut ImVec2);
|
|
}
|
|
extern "C" {
|
|
pub fn igGetItemRectSize(pOut: *mut ImVec2);
|
|
}
|
|
extern "C" {
|
|
pub fn igSetItemAllowOverlap();
|
|
}
|
|
extern "C" {
|
|
pub fn igIsRectVisibleNil(size: ImVec2) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igIsRectVisibleVec2(rect_min: ImVec2, rect_max: ImVec2) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igGetTime() -> f64;
|
|
}
|
|
extern "C" {
|
|
pub fn igGetFrameCount() -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn igGetBackgroundDrawList() -> *mut ImDrawList;
|
|
}
|
|
extern "C" {
|
|
pub fn igGetForegroundDrawList() -> *mut ImDrawList;
|
|
}
|
|
extern "C" {
|
|
pub fn igGetDrawListSharedData() -> *mut ImDrawListSharedData;
|
|
}
|
|
extern "C" {
|
|
pub fn igGetStyleColorName(idx: ImGuiCol) -> *const ::std::os::raw::c_char;
|
|
}
|
|
extern "C" {
|
|
pub fn igSetStateStorage(storage: *mut ImGuiStorage);
|
|
}
|
|
extern "C" {
|
|
pub fn igGetStateStorage() -> *mut ImGuiStorage;
|
|
}
|
|
extern "C" {
|
|
pub fn igCalcListClipping(
|
|
items_count: ::std::os::raw::c_int,
|
|
items_height: f32,
|
|
out_items_display_start: *mut ::std::os::raw::c_int,
|
|
out_items_display_end: *mut ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn igBeginChildFrame(id: ImGuiID, size: ImVec2, flags: ImGuiWindowFlags) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igEndChildFrame();
|
|
}
|
|
extern "C" {
|
|
pub fn igCalcTextSize(
|
|
pOut: *mut ImVec2,
|
|
text: *const ::std::os::raw::c_char,
|
|
text_end: *const ::std::os::raw::c_char,
|
|
hide_text_after_double_hash: bool,
|
|
wrap_width: f32,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn igColorConvertU32ToFloat4(pOut: *mut ImVec4, in_: ImU32);
|
|
}
|
|
extern "C" {
|
|
pub fn igColorConvertFloat4ToU32(in_: ImVec4) -> ImU32;
|
|
}
|
|
extern "C" {
|
|
pub fn igColorConvertRGBtoHSV(
|
|
r: f32,
|
|
g: f32,
|
|
b: f32,
|
|
out_h: *mut f32,
|
|
out_s: *mut f32,
|
|
out_v: *mut f32,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn igColorConvertHSVtoRGB(
|
|
h: f32,
|
|
s: f32,
|
|
v: f32,
|
|
out_r: *mut f32,
|
|
out_g: *mut f32,
|
|
out_b: *mut f32,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn igGetKeyIndex(imgui_key: ImGuiKey) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn igIsKeyDown(user_key_index: ::std::os::raw::c_int) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igIsKeyPressed(user_key_index: ::std::os::raw::c_int, repeat: bool) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igIsKeyReleased(user_key_index: ::std::os::raw::c_int) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igGetKeyPressedAmount(
|
|
key_index: ::std::os::raw::c_int,
|
|
repeat_delay: f32,
|
|
rate: f32,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn igCaptureKeyboardFromApp(want_capture_keyboard_value: bool);
|
|
}
|
|
extern "C" {
|
|
pub fn igIsMouseDown(button: ImGuiMouseButton) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igIsMouseClicked(button: ImGuiMouseButton, repeat: bool) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igIsMouseReleased(button: ImGuiMouseButton) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igIsMouseDoubleClicked(button: ImGuiMouseButton) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igIsMouseHoveringRect(r_min: ImVec2, r_max: ImVec2, clip: bool) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igIsMousePosValid(mouse_pos: *const ImVec2) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igIsAnyMouseDown() -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igGetMousePos(pOut: *mut ImVec2);
|
|
}
|
|
extern "C" {
|
|
pub fn igGetMousePosOnOpeningCurrentPopup(pOut: *mut ImVec2);
|
|
}
|
|
extern "C" {
|
|
pub fn igIsMouseDragging(button: ImGuiMouseButton, lock_threshold: f32) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igGetMouseDragDelta(pOut: *mut ImVec2, button: ImGuiMouseButton, lock_threshold: f32);
|
|
}
|
|
extern "C" {
|
|
pub fn igResetMouseDragDelta(button: ImGuiMouseButton);
|
|
}
|
|
extern "C" {
|
|
pub fn igGetMouseCursor() -> ImGuiMouseCursor;
|
|
}
|
|
extern "C" {
|
|
pub fn igSetMouseCursor(cursor_type: ImGuiMouseCursor);
|
|
}
|
|
extern "C" {
|
|
pub fn igCaptureMouseFromApp(want_capture_mouse_value: bool);
|
|
}
|
|
extern "C" {
|
|
pub fn igGetClipboardText() -> *const ::std::os::raw::c_char;
|
|
}
|
|
extern "C" {
|
|
pub fn igSetClipboardText(text: *const ::std::os::raw::c_char);
|
|
}
|
|
extern "C" {
|
|
pub fn igLoadIniSettingsFromDisk(ini_filename: *const ::std::os::raw::c_char);
|
|
}
|
|
extern "C" {
|
|
pub fn igLoadIniSettingsFromMemory(ini_data: *const ::std::os::raw::c_char, ini_size: size_t);
|
|
}
|
|
extern "C" {
|
|
pub fn igSaveIniSettingsToDisk(ini_filename: *const ::std::os::raw::c_char);
|
|
}
|
|
extern "C" {
|
|
pub fn igSaveIniSettingsToMemory(out_ini_size: *mut size_t) -> *const ::std::os::raw::c_char;
|
|
}
|
|
extern "C" {
|
|
pub fn igDebugCheckVersionAndDataLayout(
|
|
version_str: *const ::std::os::raw::c_char,
|
|
sz_io: size_t,
|
|
sz_style: size_t,
|
|
sz_vec2: size_t,
|
|
sz_vec4: size_t,
|
|
sz_drawvert: size_t,
|
|
sz_drawidx: size_t,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn igSetAllocatorFunctions(
|
|
alloc_func: ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
sz: size_t,
|
|
user_data: *mut ::std::os::raw::c_void,
|
|
) -> *mut ::std::os::raw::c_void,
|
|
>,
|
|
free_func: ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
ptr: *mut ::std::os::raw::c_void,
|
|
user_data: *mut ::std::os::raw::c_void,
|
|
),
|
|
>,
|
|
user_data: *mut ::std::os::raw::c_void,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn igMemAlloc(size: size_t) -> *mut ::std::os::raw::c_void;
|
|
}
|
|
extern "C" {
|
|
pub fn igMemFree(ptr: *mut ::std::os::raw::c_void);
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiStyle_ImGuiStyle() -> *mut ImGuiStyle;
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiStyle_destroy(self_: *mut ImGuiStyle);
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiStyle_ScaleAllSizes(self_: *mut ImGuiStyle, scale_factor: f32);
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiIO_AddInputCharacter(self_: *mut ImGuiIO, c: ::std::os::raw::c_uint);
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiIO_AddInputCharacterUTF16(self_: *mut ImGuiIO, c: ImWchar16);
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiIO_AddInputCharactersUTF8(self_: *mut ImGuiIO, str: *const ::std::os::raw::c_char);
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiIO_ClearInputCharacters(self_: *mut ImGuiIO);
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiIO_ImGuiIO() -> *mut ImGuiIO;
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiIO_destroy(self_: *mut ImGuiIO);
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiInputTextCallbackData_ImGuiInputTextCallbackData() -> *mut ImGuiInputTextCallbackData;
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiInputTextCallbackData_destroy(self_: *mut ImGuiInputTextCallbackData);
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiInputTextCallbackData_DeleteChars(
|
|
self_: *mut ImGuiInputTextCallbackData,
|
|
pos: ::std::os::raw::c_int,
|
|
bytes_count: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiInputTextCallbackData_InsertChars(
|
|
self_: *mut ImGuiInputTextCallbackData,
|
|
pos: ::std::os::raw::c_int,
|
|
text: *const ::std::os::raw::c_char,
|
|
text_end: *const ::std::os::raw::c_char,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiInputTextCallbackData_HasSelection(self_: *mut ImGuiInputTextCallbackData) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiPayload_ImGuiPayload() -> *mut ImGuiPayload;
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiPayload_destroy(self_: *mut ImGuiPayload);
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiPayload_Clear(self_: *mut ImGuiPayload);
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiPayload_IsDataType(
|
|
self_: *mut ImGuiPayload,
|
|
type_: *const ::std::os::raw::c_char,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiPayload_IsPreview(self_: *mut ImGuiPayload) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiPayload_IsDelivery(self_: *mut ImGuiPayload) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiOnceUponAFrame_ImGuiOnceUponAFrame() -> *mut ImGuiOnceUponAFrame;
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiOnceUponAFrame_destroy(self_: *mut ImGuiOnceUponAFrame);
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiTextFilter_ImGuiTextFilter(
|
|
default_filter: *const ::std::os::raw::c_char,
|
|
) -> *mut ImGuiTextFilter;
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiTextFilter_destroy(self_: *mut ImGuiTextFilter);
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiTextFilter_Draw(
|
|
self_: *mut ImGuiTextFilter,
|
|
label: *const ::std::os::raw::c_char,
|
|
width: f32,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiTextFilter_PassFilter(
|
|
self_: *mut ImGuiTextFilter,
|
|
text: *const ::std::os::raw::c_char,
|
|
text_end: *const ::std::os::raw::c_char,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiTextFilter_Build(self_: *mut ImGuiTextFilter);
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiTextFilter_Clear(self_: *mut ImGuiTextFilter);
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiTextFilter_IsActive(self_: *mut ImGuiTextFilter) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiTextRange_ImGuiTextRangeNil() -> *mut ImGuiTextRange;
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiTextRange_destroy(self_: *mut ImGuiTextRange);
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiTextRange_ImGuiTextRangeStr(
|
|
_b: *const ::std::os::raw::c_char,
|
|
_e: *const ::std::os::raw::c_char,
|
|
) -> *mut ImGuiTextRange;
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiTextRange_empty(self_: *mut ImGuiTextRange) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiTextRange_split(
|
|
self_: *mut ImGuiTextRange,
|
|
separator: ::std::os::raw::c_char,
|
|
out: *mut ImVector_ImGuiTextRange,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiTextBuffer_ImGuiTextBuffer() -> *mut ImGuiTextBuffer;
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiTextBuffer_destroy(self_: *mut ImGuiTextBuffer);
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiTextBuffer_begin(self_: *mut ImGuiTextBuffer) -> *const ::std::os::raw::c_char;
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiTextBuffer_end(self_: *mut ImGuiTextBuffer) -> *const ::std::os::raw::c_char;
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiTextBuffer_size(self_: *mut ImGuiTextBuffer) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiTextBuffer_empty(self_: *mut ImGuiTextBuffer) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiTextBuffer_clear(self_: *mut ImGuiTextBuffer);
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiTextBuffer_reserve(self_: *mut ImGuiTextBuffer, capacity: ::std::os::raw::c_int);
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiTextBuffer_c_str(self_: *mut ImGuiTextBuffer) -> *const ::std::os::raw::c_char;
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiTextBuffer_append(
|
|
self_: *mut ImGuiTextBuffer,
|
|
str: *const ::std::os::raw::c_char,
|
|
str_end: *const ::std::os::raw::c_char,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiTextBuffer_appendfv(
|
|
self_: *mut ImGuiTextBuffer,
|
|
fmt: *const ::std::os::raw::c_char,
|
|
args: *mut __va_list_tag,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiStoragePair_ImGuiStoragePairInt(
|
|
_key: ImGuiID,
|
|
_val_i: ::std::os::raw::c_int,
|
|
) -> *mut ImGuiStoragePair;
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiStoragePair_destroy(self_: *mut ImGuiStoragePair);
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiStoragePair_ImGuiStoragePairFloat(
|
|
_key: ImGuiID,
|
|
_val_f: f32,
|
|
) -> *mut ImGuiStoragePair;
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiStoragePair_ImGuiStoragePairPtr(
|
|
_key: ImGuiID,
|
|
_val_p: *mut ::std::os::raw::c_void,
|
|
) -> *mut ImGuiStoragePair;
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiStorage_Clear(self_: *mut ImGuiStorage);
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiStorage_GetInt(
|
|
self_: *mut ImGuiStorage,
|
|
key: ImGuiID,
|
|
default_val: ::std::os::raw::c_int,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiStorage_SetInt(self_: *mut ImGuiStorage, key: ImGuiID, val: ::std::os::raw::c_int);
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiStorage_GetBool(self_: *mut ImGuiStorage, key: ImGuiID, default_val: bool) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiStorage_SetBool(self_: *mut ImGuiStorage, key: ImGuiID, val: bool);
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiStorage_GetFloat(self_: *mut ImGuiStorage, key: ImGuiID, default_val: f32) -> f32;
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiStorage_SetFloat(self_: *mut ImGuiStorage, key: ImGuiID, val: f32);
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiStorage_GetVoidPtr(
|
|
self_: *mut ImGuiStorage,
|
|
key: ImGuiID,
|
|
) -> *mut ::std::os::raw::c_void;
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiStorage_SetVoidPtr(
|
|
self_: *mut ImGuiStorage,
|
|
key: ImGuiID,
|
|
val: *mut ::std::os::raw::c_void,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiStorage_GetIntRef(
|
|
self_: *mut ImGuiStorage,
|
|
key: ImGuiID,
|
|
default_val: ::std::os::raw::c_int,
|
|
) -> *mut ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiStorage_GetBoolRef(
|
|
self_: *mut ImGuiStorage,
|
|
key: ImGuiID,
|
|
default_val: bool,
|
|
) -> *mut bool;
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiStorage_GetFloatRef(
|
|
self_: *mut ImGuiStorage,
|
|
key: ImGuiID,
|
|
default_val: f32,
|
|
) -> *mut f32;
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiStorage_GetVoidPtrRef(
|
|
self_: *mut ImGuiStorage,
|
|
key: ImGuiID,
|
|
default_val: *mut ::std::os::raw::c_void,
|
|
) -> *mut *mut ::std::os::raw::c_void;
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiStorage_SetAllInt(self_: *mut ImGuiStorage, val: ::std::os::raw::c_int);
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiStorage_BuildSortByKey(self_: *mut ImGuiStorage);
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiListClipper_ImGuiListClipper(
|
|
items_count: ::std::os::raw::c_int,
|
|
items_height: f32,
|
|
) -> *mut ImGuiListClipper;
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiListClipper_destroy(self_: *mut ImGuiListClipper);
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiListClipper_Step(self_: *mut ImGuiListClipper) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiListClipper_Begin(
|
|
self_: *mut ImGuiListClipper,
|
|
items_count: ::std::os::raw::c_int,
|
|
items_height: f32,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiListClipper_End(self_: *mut ImGuiListClipper);
|
|
}
|
|
extern "C" {
|
|
pub fn ImColor_ImColorNil() -> *mut ImColor;
|
|
}
|
|
extern "C" {
|
|
pub fn ImColor_destroy(self_: *mut ImColor);
|
|
}
|
|
extern "C" {
|
|
pub fn ImColor_ImColorInt(
|
|
r: ::std::os::raw::c_int,
|
|
g: ::std::os::raw::c_int,
|
|
b: ::std::os::raw::c_int,
|
|
a: ::std::os::raw::c_int,
|
|
) -> *mut ImColor;
|
|
}
|
|
extern "C" {
|
|
pub fn ImColor_ImColorU32(rgba: ImU32) -> *mut ImColor;
|
|
}
|
|
extern "C" {
|
|
pub fn ImColor_ImColorFloat(r: f32, g: f32, b: f32, a: f32) -> *mut ImColor;
|
|
}
|
|
extern "C" {
|
|
pub fn ImColor_ImColorVec4(col: ImVec4) -> *mut ImColor;
|
|
}
|
|
extern "C" {
|
|
pub fn ImColor_SetHSV(self_: *mut ImColor, h: f32, s: f32, v: f32, a: f32);
|
|
}
|
|
extern "C" {
|
|
pub fn ImColor_HSV(pOut: *mut ImColor, self_: *mut ImColor, h: f32, s: f32, v: f32, a: f32);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawCmd_ImDrawCmd() -> *mut ImDrawCmd;
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawCmd_destroy(self_: *mut ImDrawCmd);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawListSplitter_ImDrawListSplitter() -> *mut ImDrawListSplitter;
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawListSplitter_destroy(self_: *mut ImDrawListSplitter);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawListSplitter_Clear(self_: *mut ImDrawListSplitter);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawListSplitter_ClearFreeMemory(self_: *mut ImDrawListSplitter);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawListSplitter_Split(
|
|
self_: *mut ImDrawListSplitter,
|
|
draw_list: *mut ImDrawList,
|
|
count: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawListSplitter_Merge(self_: *mut ImDrawListSplitter, draw_list: *mut ImDrawList);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawListSplitter_SetCurrentChannel(
|
|
self_: *mut ImDrawListSplitter,
|
|
draw_list: *mut ImDrawList,
|
|
channel_idx: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_ImDrawList(shared_data: *const ImDrawListSharedData) -> *mut ImDrawList;
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_destroy(self_: *mut ImDrawList);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_PushClipRect(
|
|
self_: *mut ImDrawList,
|
|
clip_rect_min: ImVec2,
|
|
clip_rect_max: ImVec2,
|
|
intersect_with_current_clip_rect: bool,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_PushClipRectFullScreen(self_: *mut ImDrawList);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_PopClipRect(self_: *mut ImDrawList);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_PushTextureID(self_: *mut ImDrawList, texture_id: ImTextureID);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_PopTextureID(self_: *mut ImDrawList);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_GetClipRectMin(pOut: *mut ImVec2, self_: *mut ImDrawList);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_GetClipRectMax(pOut: *mut ImVec2, self_: *mut ImDrawList);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_AddLine(
|
|
self_: *mut ImDrawList,
|
|
p1: ImVec2,
|
|
p2: ImVec2,
|
|
col: ImU32,
|
|
thickness: f32,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_AddRect(
|
|
self_: *mut ImDrawList,
|
|
p_min: ImVec2,
|
|
p_max: ImVec2,
|
|
col: ImU32,
|
|
rounding: f32,
|
|
rounding_corners: ImDrawCornerFlags,
|
|
thickness: f32,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_AddRectFilled(
|
|
self_: *mut ImDrawList,
|
|
p_min: ImVec2,
|
|
p_max: ImVec2,
|
|
col: ImU32,
|
|
rounding: f32,
|
|
rounding_corners: ImDrawCornerFlags,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_AddRectFilledMultiColor(
|
|
self_: *mut ImDrawList,
|
|
p_min: ImVec2,
|
|
p_max: ImVec2,
|
|
col_upr_left: ImU32,
|
|
col_upr_right: ImU32,
|
|
col_bot_right: ImU32,
|
|
col_bot_left: ImU32,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_AddQuad(
|
|
self_: *mut ImDrawList,
|
|
p1: ImVec2,
|
|
p2: ImVec2,
|
|
p3: ImVec2,
|
|
p4: ImVec2,
|
|
col: ImU32,
|
|
thickness: f32,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_AddQuadFilled(
|
|
self_: *mut ImDrawList,
|
|
p1: ImVec2,
|
|
p2: ImVec2,
|
|
p3: ImVec2,
|
|
p4: ImVec2,
|
|
col: ImU32,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_AddTriangle(
|
|
self_: *mut ImDrawList,
|
|
p1: ImVec2,
|
|
p2: ImVec2,
|
|
p3: ImVec2,
|
|
col: ImU32,
|
|
thickness: f32,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_AddTriangleFilled(
|
|
self_: *mut ImDrawList,
|
|
p1: ImVec2,
|
|
p2: ImVec2,
|
|
p3: ImVec2,
|
|
col: ImU32,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_AddCircle(
|
|
self_: *mut ImDrawList,
|
|
center: ImVec2,
|
|
radius: f32,
|
|
col: ImU32,
|
|
num_segments: ::std::os::raw::c_int,
|
|
thickness: f32,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_AddCircleFilled(
|
|
self_: *mut ImDrawList,
|
|
center: ImVec2,
|
|
radius: f32,
|
|
col: ImU32,
|
|
num_segments: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_AddNgon(
|
|
self_: *mut ImDrawList,
|
|
center: ImVec2,
|
|
radius: f32,
|
|
col: ImU32,
|
|
num_segments: ::std::os::raw::c_int,
|
|
thickness: f32,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_AddNgonFilled(
|
|
self_: *mut ImDrawList,
|
|
center: ImVec2,
|
|
radius: f32,
|
|
col: ImU32,
|
|
num_segments: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_AddTextVec2(
|
|
self_: *mut ImDrawList,
|
|
pos: ImVec2,
|
|
col: ImU32,
|
|
text_begin: *const ::std::os::raw::c_char,
|
|
text_end: *const ::std::os::raw::c_char,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_AddTextFontPtr(
|
|
self_: *mut ImDrawList,
|
|
font: *const ImFont,
|
|
font_size: f32,
|
|
pos: ImVec2,
|
|
col: ImU32,
|
|
text_begin: *const ::std::os::raw::c_char,
|
|
text_end: *const ::std::os::raw::c_char,
|
|
wrap_width: f32,
|
|
cpu_fine_clip_rect: *const ImVec4,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_AddPolyline(
|
|
self_: *mut ImDrawList,
|
|
points: *const ImVec2,
|
|
num_points: ::std::os::raw::c_int,
|
|
col: ImU32,
|
|
closed: bool,
|
|
thickness: f32,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_AddConvexPolyFilled(
|
|
self_: *mut ImDrawList,
|
|
points: *const ImVec2,
|
|
num_points: ::std::os::raw::c_int,
|
|
col: ImU32,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_AddBezierCurve(
|
|
self_: *mut ImDrawList,
|
|
p1: ImVec2,
|
|
p2: ImVec2,
|
|
p3: ImVec2,
|
|
p4: ImVec2,
|
|
col: ImU32,
|
|
thickness: f32,
|
|
num_segments: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_AddImage(
|
|
self_: *mut ImDrawList,
|
|
user_texture_id: ImTextureID,
|
|
p_min: ImVec2,
|
|
p_max: ImVec2,
|
|
uv_min: ImVec2,
|
|
uv_max: ImVec2,
|
|
col: ImU32,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_AddImageQuad(
|
|
self_: *mut ImDrawList,
|
|
user_texture_id: ImTextureID,
|
|
p1: ImVec2,
|
|
p2: ImVec2,
|
|
p3: ImVec2,
|
|
p4: ImVec2,
|
|
uv1: ImVec2,
|
|
uv2: ImVec2,
|
|
uv3: ImVec2,
|
|
uv4: ImVec2,
|
|
col: ImU32,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_AddImageRounded(
|
|
self_: *mut ImDrawList,
|
|
user_texture_id: ImTextureID,
|
|
p_min: ImVec2,
|
|
p_max: ImVec2,
|
|
uv_min: ImVec2,
|
|
uv_max: ImVec2,
|
|
col: ImU32,
|
|
rounding: f32,
|
|
rounding_corners: ImDrawCornerFlags,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_PathClear(self_: *mut ImDrawList);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_PathLineTo(self_: *mut ImDrawList, pos: ImVec2);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_PathLineToMergeDuplicate(self_: *mut ImDrawList, pos: ImVec2);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_PathFillConvex(self_: *mut ImDrawList, col: ImU32);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_PathStroke(self_: *mut ImDrawList, col: ImU32, closed: bool, thickness: f32);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_PathArcTo(
|
|
self_: *mut ImDrawList,
|
|
center: ImVec2,
|
|
radius: f32,
|
|
a_min: f32,
|
|
a_max: f32,
|
|
num_segments: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_PathArcToFast(
|
|
self_: *mut ImDrawList,
|
|
center: ImVec2,
|
|
radius: f32,
|
|
a_min_of_12: ::std::os::raw::c_int,
|
|
a_max_of_12: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_PathBezierCurveTo(
|
|
self_: *mut ImDrawList,
|
|
p2: ImVec2,
|
|
p3: ImVec2,
|
|
p4: ImVec2,
|
|
num_segments: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_PathRect(
|
|
self_: *mut ImDrawList,
|
|
rect_min: ImVec2,
|
|
rect_max: ImVec2,
|
|
rounding: f32,
|
|
rounding_corners: ImDrawCornerFlags,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_AddCallback(
|
|
self_: *mut ImDrawList,
|
|
callback: ImDrawCallback,
|
|
callback_data: *mut ::std::os::raw::c_void,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_AddDrawCmd(self_: *mut ImDrawList);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_CloneOutput(self_: *mut ImDrawList) -> *mut ImDrawList;
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_ChannelsSplit(self_: *mut ImDrawList, count: ::std::os::raw::c_int);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_ChannelsMerge(self_: *mut ImDrawList);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_ChannelsSetCurrent(self_: *mut ImDrawList, n: ::std::os::raw::c_int);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_PrimReserve(
|
|
self_: *mut ImDrawList,
|
|
idx_count: ::std::os::raw::c_int,
|
|
vtx_count: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_PrimUnreserve(
|
|
self_: *mut ImDrawList,
|
|
idx_count: ::std::os::raw::c_int,
|
|
vtx_count: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_PrimRect(self_: *mut ImDrawList, a: ImVec2, b: ImVec2, col: ImU32);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_PrimRectUV(
|
|
self_: *mut ImDrawList,
|
|
a: ImVec2,
|
|
b: ImVec2,
|
|
uv_a: ImVec2,
|
|
uv_b: ImVec2,
|
|
col: ImU32,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_PrimQuadUV(
|
|
self_: *mut ImDrawList,
|
|
a: ImVec2,
|
|
b: ImVec2,
|
|
c: ImVec2,
|
|
d: ImVec2,
|
|
uv_a: ImVec2,
|
|
uv_b: ImVec2,
|
|
uv_c: ImVec2,
|
|
uv_d: ImVec2,
|
|
col: ImU32,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_PrimWriteVtx(self_: *mut ImDrawList, pos: ImVec2, uv: ImVec2, col: ImU32);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_PrimWriteIdx(self_: *mut ImDrawList, idx: ImDrawIdx);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList_PrimVtx(self_: *mut ImDrawList, pos: ImVec2, uv: ImVec2, col: ImU32);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList__ResetForNewFrame(self_: *mut ImDrawList);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList__ClearFreeMemory(self_: *mut ImDrawList);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList__PopUnusedDrawCmd(self_: *mut ImDrawList);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList__OnChangedClipRect(self_: *mut ImDrawList);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList__OnChangedTextureID(self_: *mut ImDrawList);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawList__OnChangedVtxOffset(self_: *mut ImDrawList);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawData_ImDrawData() -> *mut ImDrawData;
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawData_destroy(self_: *mut ImDrawData);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawData_Clear(self_: *mut ImDrawData);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawData_DeIndexAllBuffers(self_: *mut ImDrawData);
|
|
}
|
|
extern "C" {
|
|
pub fn ImDrawData_ScaleClipRects(self_: *mut ImDrawData, fb_scale: ImVec2);
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontConfig_ImFontConfig() -> *mut ImFontConfig;
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontConfig_destroy(self_: *mut ImFontConfig);
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontGlyphRangesBuilder_ImFontGlyphRangesBuilder() -> *mut ImFontGlyphRangesBuilder;
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontGlyphRangesBuilder_destroy(self_: *mut ImFontGlyphRangesBuilder);
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontGlyphRangesBuilder_Clear(self_: *mut ImFontGlyphRangesBuilder);
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontGlyphRangesBuilder_GetBit(self_: *mut ImFontGlyphRangesBuilder, n: size_t)
|
|
-> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontGlyphRangesBuilder_SetBit(self_: *mut ImFontGlyphRangesBuilder, n: size_t);
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontGlyphRangesBuilder_AddChar(self_: *mut ImFontGlyphRangesBuilder, c: ImWchar);
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontGlyphRangesBuilder_AddText(
|
|
self_: *mut ImFontGlyphRangesBuilder,
|
|
text: *const ::std::os::raw::c_char,
|
|
text_end: *const ::std::os::raw::c_char,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontGlyphRangesBuilder_AddRanges(
|
|
self_: *mut ImFontGlyphRangesBuilder,
|
|
ranges: *const ImWchar,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontGlyphRangesBuilder_BuildRanges(
|
|
self_: *mut ImFontGlyphRangesBuilder,
|
|
out_ranges: *mut ImVector_ImWchar,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontAtlasCustomRect_ImFontAtlasCustomRect() -> *mut ImFontAtlasCustomRect;
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontAtlasCustomRect_destroy(self_: *mut ImFontAtlasCustomRect);
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontAtlasCustomRect_IsPacked(self_: *mut ImFontAtlasCustomRect) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontAtlas_ImFontAtlas() -> *mut ImFontAtlas;
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontAtlas_destroy(self_: *mut ImFontAtlas);
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontAtlas_AddFont(
|
|
self_: *mut ImFontAtlas,
|
|
font_cfg: *const ImFontConfig,
|
|
) -> *mut ImFont;
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontAtlas_AddFontDefault(
|
|
self_: *mut ImFontAtlas,
|
|
font_cfg: *const ImFontConfig,
|
|
) -> *mut ImFont;
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontAtlas_AddFontFromFileTTF(
|
|
self_: *mut ImFontAtlas,
|
|
filename: *const ::std::os::raw::c_char,
|
|
size_pixels: f32,
|
|
font_cfg: *const ImFontConfig,
|
|
glyph_ranges: *const ImWchar,
|
|
) -> *mut ImFont;
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontAtlas_AddFontFromMemoryTTF(
|
|
self_: *mut ImFontAtlas,
|
|
font_data: *mut ::std::os::raw::c_void,
|
|
font_size: ::std::os::raw::c_int,
|
|
size_pixels: f32,
|
|
font_cfg: *const ImFontConfig,
|
|
glyph_ranges: *const ImWchar,
|
|
) -> *mut ImFont;
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontAtlas_AddFontFromMemoryCompressedTTF(
|
|
self_: *mut ImFontAtlas,
|
|
compressed_font_data: *const ::std::os::raw::c_void,
|
|
compressed_font_size: ::std::os::raw::c_int,
|
|
size_pixels: f32,
|
|
font_cfg: *const ImFontConfig,
|
|
glyph_ranges: *const ImWchar,
|
|
) -> *mut ImFont;
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontAtlas_AddFontFromMemoryCompressedBase85TTF(
|
|
self_: *mut ImFontAtlas,
|
|
compressed_font_data_base85: *const ::std::os::raw::c_char,
|
|
size_pixels: f32,
|
|
font_cfg: *const ImFontConfig,
|
|
glyph_ranges: *const ImWchar,
|
|
) -> *mut ImFont;
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontAtlas_ClearInputData(self_: *mut ImFontAtlas);
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontAtlas_ClearTexData(self_: *mut ImFontAtlas);
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontAtlas_ClearFonts(self_: *mut ImFontAtlas);
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontAtlas_Clear(self_: *mut ImFontAtlas);
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontAtlas_Build(self_: *mut ImFontAtlas) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontAtlas_GetTexDataAsAlpha8(
|
|
self_: *mut ImFontAtlas,
|
|
out_pixels: *mut *mut ::std::os::raw::c_uchar,
|
|
out_width: *mut ::std::os::raw::c_int,
|
|
out_height: *mut ::std::os::raw::c_int,
|
|
out_bytes_per_pixel: *mut ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontAtlas_GetTexDataAsRGBA32(
|
|
self_: *mut ImFontAtlas,
|
|
out_pixels: *mut *mut ::std::os::raw::c_uchar,
|
|
out_width: *mut ::std::os::raw::c_int,
|
|
out_height: *mut ::std::os::raw::c_int,
|
|
out_bytes_per_pixel: *mut ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontAtlas_IsBuilt(self_: *mut ImFontAtlas) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontAtlas_SetTexID(self_: *mut ImFontAtlas, id: ImTextureID);
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontAtlas_GetGlyphRangesDefault(self_: *mut ImFontAtlas) -> *const ImWchar;
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontAtlas_GetGlyphRangesKorean(self_: *mut ImFontAtlas) -> *const ImWchar;
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontAtlas_GetGlyphRangesJapanese(self_: *mut ImFontAtlas) -> *const ImWchar;
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontAtlas_GetGlyphRangesChineseFull(self_: *mut ImFontAtlas) -> *const ImWchar;
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontAtlas_GetGlyphRangesChineseSimplifiedCommon(
|
|
self_: *mut ImFontAtlas,
|
|
) -> *const ImWchar;
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontAtlas_GetGlyphRangesCyrillic(self_: *mut ImFontAtlas) -> *const ImWchar;
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontAtlas_GetGlyphRangesThai(self_: *mut ImFontAtlas) -> *const ImWchar;
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontAtlas_GetGlyphRangesVietnamese(self_: *mut ImFontAtlas) -> *const ImWchar;
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontAtlas_AddCustomRectRegular(
|
|
self_: *mut ImFontAtlas,
|
|
width: ::std::os::raw::c_int,
|
|
height: ::std::os::raw::c_int,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontAtlas_AddCustomRectFontGlyph(
|
|
self_: *mut ImFontAtlas,
|
|
font: *mut ImFont,
|
|
id: ImWchar,
|
|
width: ::std::os::raw::c_int,
|
|
height: ::std::os::raw::c_int,
|
|
advance_x: f32,
|
|
offset: ImVec2,
|
|
) -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontAtlas_GetCustomRectByIndex(
|
|
self_: *mut ImFontAtlas,
|
|
index: ::std::os::raw::c_int,
|
|
) -> *const ImFontAtlasCustomRect;
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontAtlas_CalcCustomRectUV(
|
|
self_: *mut ImFontAtlas,
|
|
rect: *const ImFontAtlasCustomRect,
|
|
out_uv_min: *mut ImVec2,
|
|
out_uv_max: *mut ImVec2,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImFontAtlas_GetMouseCursorTexData(
|
|
self_: *mut ImFontAtlas,
|
|
cursor: ImGuiMouseCursor,
|
|
out_offset: *mut ImVec2,
|
|
out_size: *mut ImVec2,
|
|
out_uv_border: *mut ImVec2,
|
|
out_uv_fill: *mut ImVec2,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn ImFont_ImFont() -> *mut ImFont;
|
|
}
|
|
extern "C" {
|
|
pub fn ImFont_destroy(self_: *mut ImFont);
|
|
}
|
|
extern "C" {
|
|
pub fn ImFont_FindGlyph(self_: *mut ImFont, c: ImWchar) -> *const ImFontGlyph;
|
|
}
|
|
extern "C" {
|
|
pub fn ImFont_FindGlyphNoFallback(self_: *mut ImFont, c: ImWchar) -> *const ImFontGlyph;
|
|
}
|
|
extern "C" {
|
|
pub fn ImFont_GetCharAdvance(self_: *mut ImFont, c: ImWchar) -> f32;
|
|
}
|
|
extern "C" {
|
|
pub fn ImFont_IsLoaded(self_: *mut ImFont) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn ImFont_GetDebugName(self_: *mut ImFont) -> *const ::std::os::raw::c_char;
|
|
}
|
|
extern "C" {
|
|
pub fn ImFont_CalcTextSizeA(
|
|
pOut: *mut ImVec2,
|
|
self_: *mut ImFont,
|
|
size: f32,
|
|
max_width: f32,
|
|
wrap_width: f32,
|
|
text_begin: *const ::std::os::raw::c_char,
|
|
text_end: *const ::std::os::raw::c_char,
|
|
remaining: *mut *const ::std::os::raw::c_char,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImFont_CalcWordWrapPositionA(
|
|
self_: *mut ImFont,
|
|
scale: f32,
|
|
text: *const ::std::os::raw::c_char,
|
|
text_end: *const ::std::os::raw::c_char,
|
|
wrap_width: f32,
|
|
) -> *const ::std::os::raw::c_char;
|
|
}
|
|
extern "C" {
|
|
pub fn ImFont_RenderChar(
|
|
self_: *mut ImFont,
|
|
draw_list: *mut ImDrawList,
|
|
size: f32,
|
|
pos: ImVec2,
|
|
col: ImU32,
|
|
c: ImWchar,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImFont_RenderText(
|
|
self_: *mut ImFont,
|
|
draw_list: *mut ImDrawList,
|
|
size: f32,
|
|
pos: ImVec2,
|
|
col: ImU32,
|
|
clip_rect: ImVec4,
|
|
text_begin: *const ::std::os::raw::c_char,
|
|
text_end: *const ::std::os::raw::c_char,
|
|
wrap_width: f32,
|
|
cpu_fine_clip: bool,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImFont_BuildLookupTable(self_: *mut ImFont);
|
|
}
|
|
extern "C" {
|
|
pub fn ImFont_ClearOutputData(self_: *mut ImFont);
|
|
}
|
|
extern "C" {
|
|
pub fn ImFont_GrowIndex(self_: *mut ImFont, new_size: ::std::os::raw::c_int);
|
|
}
|
|
extern "C" {
|
|
pub fn ImFont_AddGlyph(
|
|
self_: *mut ImFont,
|
|
c: ImWchar,
|
|
x0: f32,
|
|
y0: f32,
|
|
x1: f32,
|
|
y1: f32,
|
|
u0: f32,
|
|
v0: f32,
|
|
u1: f32,
|
|
v1: f32,
|
|
advance_x: f32,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImFont_AddRemapChar(self_: *mut ImFont, dst: ImWchar, src: ImWchar, overwrite_dst: bool);
|
|
}
|
|
extern "C" {
|
|
pub fn ImFont_SetGlyphVisible(self_: *mut ImFont, c: ImWchar, visible: bool);
|
|
}
|
|
extern "C" {
|
|
pub fn ImFont_SetFallbackChar(self_: *mut ImFont, c: ImWchar);
|
|
}
|
|
extern "C" {
|
|
pub fn ImFont_IsGlyphRangeUnused(
|
|
self_: *mut ImFont,
|
|
c_begin: ::std::os::raw::c_uint,
|
|
c_last: ::std::os::raw::c_uint,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
#[doc = "hand written functions"]
|
|
pub fn igLogText(fmt: *const ::std::os::raw::c_char, ...);
|
|
}
|
|
extern "C" {
|
|
pub fn ImGuiTextBuffer_appendf(
|
|
buffer: *mut ImGuiTextBuffer,
|
|
fmt: *const ::std::os::raw::c_char,
|
|
...
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn igGET_FLT_MAX() -> f32;
|
|
}
|
|
extern "C" {
|
|
pub fn ImVector_ImWchar_create() -> *mut ImVector_ImWchar;
|
|
}
|
|
extern "C" {
|
|
pub fn ImVector_ImWchar_destroy(self_: *mut ImVector_ImWchar);
|
|
}
|
|
extern "C" {
|
|
pub fn ImVector_ImWchar_Init(p: *mut ImVector_ImWchar);
|
|
}
|
|
extern "C" {
|
|
pub fn ImVector_ImWchar_UnInit(p: *mut ImVector_ImWchar);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImPlotContext {
|
|
_unused: [u8; 0],
|
|
}
|
|
pub type ImPlotFlags = ::std::os::raw::c_int;
|
|
pub type ImPlotAxisFlags = ::std::os::raw::c_int;
|
|
pub type ImPlotCol = ::std::os::raw::c_int;
|
|
pub type ImPlotStyleVar = ::std::os::raw::c_int;
|
|
pub type ImPlotMarker = ::std::os::raw::c_int;
|
|
pub type ImPlotColormap = ::std::os::raw::c_int;
|
|
pub const ImPlotFlags__ImPlotFlags_None: ImPlotFlags_ = 0;
|
|
pub const ImPlotFlags__ImPlotFlags_NoLegend: ImPlotFlags_ = 1;
|
|
pub const ImPlotFlags__ImPlotFlags_NoMenus: ImPlotFlags_ = 2;
|
|
pub const ImPlotFlags__ImPlotFlags_NoBoxSelect: ImPlotFlags_ = 4;
|
|
pub const ImPlotFlags__ImPlotFlags_NoMousePos: ImPlotFlags_ = 8;
|
|
pub const ImPlotFlags__ImPlotFlags_NoHighlight: ImPlotFlags_ = 16;
|
|
pub const ImPlotFlags__ImPlotFlags_NoChild: ImPlotFlags_ = 32;
|
|
pub const ImPlotFlags__ImPlotFlags_YAxis2: ImPlotFlags_ = 64;
|
|
pub const ImPlotFlags__ImPlotFlags_YAxis3: ImPlotFlags_ = 128;
|
|
pub const ImPlotFlags__ImPlotFlags_Query: ImPlotFlags_ = 256;
|
|
pub const ImPlotFlags__ImPlotFlags_Crosshairs: ImPlotFlags_ = 512;
|
|
pub const ImPlotFlags__ImPlotFlags_AntiAliased: ImPlotFlags_ = 1024;
|
|
pub const ImPlotFlags__ImPlotFlags_CanvasOnly: ImPlotFlags_ = 15;
|
|
pub type ImPlotFlags_ = u32;
|
|
pub const ImPlotAxisFlags__ImPlotAxisFlags_None: ImPlotAxisFlags_ = 0;
|
|
pub const ImPlotAxisFlags__ImPlotAxisFlags_NoGridLines: ImPlotAxisFlags_ = 1;
|
|
pub const ImPlotAxisFlags__ImPlotAxisFlags_NoTickMarks: ImPlotAxisFlags_ = 2;
|
|
pub const ImPlotAxisFlags__ImPlotAxisFlags_NoTickLabels: ImPlotAxisFlags_ = 4;
|
|
pub const ImPlotAxisFlags__ImPlotAxisFlags_LogScale: ImPlotAxisFlags_ = 8;
|
|
pub const ImPlotAxisFlags__ImPlotAxisFlags_Time: ImPlotAxisFlags_ = 16;
|
|
pub const ImPlotAxisFlags__ImPlotAxisFlags_Invert: ImPlotAxisFlags_ = 32;
|
|
pub const ImPlotAxisFlags__ImPlotAxisFlags_LockMin: ImPlotAxisFlags_ = 64;
|
|
pub const ImPlotAxisFlags__ImPlotAxisFlags_LockMax: ImPlotAxisFlags_ = 128;
|
|
pub const ImPlotAxisFlags__ImPlotAxisFlags_Lock: ImPlotAxisFlags_ = 192;
|
|
pub const ImPlotAxisFlags__ImPlotAxisFlags_NoDecorations: ImPlotAxisFlags_ = 7;
|
|
pub type ImPlotAxisFlags_ = u32;
|
|
pub const ImPlotCol__ImPlotCol_Line: ImPlotCol_ = 0;
|
|
pub const ImPlotCol__ImPlotCol_Fill: ImPlotCol_ = 1;
|
|
pub const ImPlotCol__ImPlotCol_MarkerOutline: ImPlotCol_ = 2;
|
|
pub const ImPlotCol__ImPlotCol_MarkerFill: ImPlotCol_ = 3;
|
|
pub const ImPlotCol__ImPlotCol_ErrorBar: ImPlotCol_ = 4;
|
|
pub const ImPlotCol__ImPlotCol_FrameBg: ImPlotCol_ = 5;
|
|
pub const ImPlotCol__ImPlotCol_PlotBg: ImPlotCol_ = 6;
|
|
pub const ImPlotCol__ImPlotCol_PlotBorder: ImPlotCol_ = 7;
|
|
pub const ImPlotCol__ImPlotCol_LegendBg: ImPlotCol_ = 8;
|
|
pub const ImPlotCol__ImPlotCol_LegendBorder: ImPlotCol_ = 9;
|
|
pub const ImPlotCol__ImPlotCol_LegendText: ImPlotCol_ = 10;
|
|
pub const ImPlotCol__ImPlotCol_TitleText: ImPlotCol_ = 11;
|
|
pub const ImPlotCol__ImPlotCol_InlayText: ImPlotCol_ = 12;
|
|
pub const ImPlotCol__ImPlotCol_XAxis: ImPlotCol_ = 13;
|
|
pub const ImPlotCol__ImPlotCol_XAxisGrid: ImPlotCol_ = 14;
|
|
pub const ImPlotCol__ImPlotCol_YAxis: ImPlotCol_ = 15;
|
|
pub const ImPlotCol__ImPlotCol_YAxisGrid: ImPlotCol_ = 16;
|
|
pub const ImPlotCol__ImPlotCol_YAxis2: ImPlotCol_ = 17;
|
|
pub const ImPlotCol__ImPlotCol_YAxisGrid2: ImPlotCol_ = 18;
|
|
pub const ImPlotCol__ImPlotCol_YAxis3: ImPlotCol_ = 19;
|
|
pub const ImPlotCol__ImPlotCol_YAxisGrid3: ImPlotCol_ = 20;
|
|
pub const ImPlotCol__ImPlotCol_Selection: ImPlotCol_ = 21;
|
|
pub const ImPlotCol__ImPlotCol_Query: ImPlotCol_ = 22;
|
|
pub const ImPlotCol__ImPlotCol_Crosshairs: ImPlotCol_ = 23;
|
|
pub const ImPlotCol__ImPlotCol_COUNT: ImPlotCol_ = 24;
|
|
pub type ImPlotCol_ = u32;
|
|
pub const ImPlotStyleVar__ImPlotStyleVar_LineWeight: ImPlotStyleVar_ = 0;
|
|
pub const ImPlotStyleVar__ImPlotStyleVar_Marker: ImPlotStyleVar_ = 1;
|
|
pub const ImPlotStyleVar__ImPlotStyleVar_MarkerSize: ImPlotStyleVar_ = 2;
|
|
pub const ImPlotStyleVar__ImPlotStyleVar_MarkerWeight: ImPlotStyleVar_ = 3;
|
|
pub const ImPlotStyleVar__ImPlotStyleVar_FillAlpha: ImPlotStyleVar_ = 4;
|
|
pub const ImPlotStyleVar__ImPlotStyleVar_ErrorBarSize: ImPlotStyleVar_ = 5;
|
|
pub const ImPlotStyleVar__ImPlotStyleVar_ErrorBarWeight: ImPlotStyleVar_ = 6;
|
|
pub const ImPlotStyleVar__ImPlotStyleVar_DigitalBitHeight: ImPlotStyleVar_ = 7;
|
|
pub const ImPlotStyleVar__ImPlotStyleVar_DigitalBitGap: ImPlotStyleVar_ = 8;
|
|
pub const ImPlotStyleVar__ImPlotStyleVar_PlotBorderSize: ImPlotStyleVar_ = 9;
|
|
pub const ImPlotStyleVar__ImPlotStyleVar_MinorAlpha: ImPlotStyleVar_ = 10;
|
|
pub const ImPlotStyleVar__ImPlotStyleVar_MajorTickLen: ImPlotStyleVar_ = 11;
|
|
pub const ImPlotStyleVar__ImPlotStyleVar_MinorTickLen: ImPlotStyleVar_ = 12;
|
|
pub const ImPlotStyleVar__ImPlotStyleVar_MajorTickSize: ImPlotStyleVar_ = 13;
|
|
pub const ImPlotStyleVar__ImPlotStyleVar_MinorTickSize: ImPlotStyleVar_ = 14;
|
|
pub const ImPlotStyleVar__ImPlotStyleVar_MajorGridSize: ImPlotStyleVar_ = 15;
|
|
pub const ImPlotStyleVar__ImPlotStyleVar_MinorGridSize: ImPlotStyleVar_ = 16;
|
|
pub const ImPlotStyleVar__ImPlotStyleVar_PlotPadding: ImPlotStyleVar_ = 17;
|
|
pub const ImPlotStyleVar__ImPlotStyleVar_LabelPadding: ImPlotStyleVar_ = 18;
|
|
pub const ImPlotStyleVar__ImPlotStyleVar_LegendPadding: ImPlotStyleVar_ = 19;
|
|
pub const ImPlotStyleVar__ImPlotStyleVar_InfoPadding: ImPlotStyleVar_ = 20;
|
|
pub const ImPlotStyleVar__ImPlotStyleVar_PlotMinSize: ImPlotStyleVar_ = 21;
|
|
pub const ImPlotStyleVar__ImPlotStyleVar_COUNT: ImPlotStyleVar_ = 22;
|
|
pub type ImPlotStyleVar_ = u32;
|
|
pub const ImPlotMarker__ImPlotMarker_None: ImPlotMarker_ = -1;
|
|
pub const ImPlotMarker__ImPlotMarker_Circle: ImPlotMarker_ = 0;
|
|
pub const ImPlotMarker__ImPlotMarker_Square: ImPlotMarker_ = 1;
|
|
pub const ImPlotMarker__ImPlotMarker_Diamond: ImPlotMarker_ = 2;
|
|
pub const ImPlotMarker__ImPlotMarker_Up: ImPlotMarker_ = 3;
|
|
pub const ImPlotMarker__ImPlotMarker_Down: ImPlotMarker_ = 4;
|
|
pub const ImPlotMarker__ImPlotMarker_Left: ImPlotMarker_ = 5;
|
|
pub const ImPlotMarker__ImPlotMarker_Right: ImPlotMarker_ = 6;
|
|
pub const ImPlotMarker__ImPlotMarker_Cross: ImPlotMarker_ = 7;
|
|
pub const ImPlotMarker__ImPlotMarker_Plus: ImPlotMarker_ = 8;
|
|
pub const ImPlotMarker__ImPlotMarker_Asterisk: ImPlotMarker_ = 9;
|
|
pub const ImPlotMarker__ImPlotMarker_COUNT: ImPlotMarker_ = 10;
|
|
pub type ImPlotMarker_ = i32;
|
|
pub const ImPlotColormap__ImPlotColormap_Default: ImPlotColormap_ = 0;
|
|
pub const ImPlotColormap__ImPlotColormap_Deep: ImPlotColormap_ = 1;
|
|
pub const ImPlotColormap__ImPlotColormap_Dark: ImPlotColormap_ = 2;
|
|
pub const ImPlotColormap__ImPlotColormap_Pastel: ImPlotColormap_ = 3;
|
|
pub const ImPlotColormap__ImPlotColormap_Paired: ImPlotColormap_ = 4;
|
|
pub const ImPlotColormap__ImPlotColormap_Viridis: ImPlotColormap_ = 5;
|
|
pub const ImPlotColormap__ImPlotColormap_Plasma: ImPlotColormap_ = 6;
|
|
pub const ImPlotColormap__ImPlotColormap_Hot: ImPlotColormap_ = 7;
|
|
pub const ImPlotColormap__ImPlotColormap_Cool: ImPlotColormap_ = 8;
|
|
pub const ImPlotColormap__ImPlotColormap_Pink: ImPlotColormap_ = 9;
|
|
pub const ImPlotColormap__ImPlotColormap_Jet: ImPlotColormap_ = 10;
|
|
pub const ImPlotColormap__ImPlotColormap_COUNT: ImPlotColormap_ = 11;
|
|
pub type ImPlotColormap_ = u32;
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImPlotPoint {
|
|
pub x: f64,
|
|
pub y: f64,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImPlotPoint() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImPlotPoint>(),
|
|
16usize,
|
|
concat!("Size of: ", stringify!(ImPlotPoint))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImPlotPoint>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImPlotPoint))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotPoint>())).x as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotPoint),
|
|
"::",
|
|
stringify!(x)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotPoint>())).y as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotPoint),
|
|
"::",
|
|
stringify!(y)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImPlotRange {
|
|
pub Min: f64,
|
|
pub Max: f64,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImPlotRange() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImPlotRange>(),
|
|
16usize,
|
|
concat!("Size of: ", stringify!(ImPlotRange))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImPlotRange>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImPlotRange))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotRange>())).Min as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotRange),
|
|
"::",
|
|
stringify!(Min)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotRange>())).Max as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotRange),
|
|
"::",
|
|
stringify!(Max)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImPlotLimits {
|
|
pub X: ImPlotRange,
|
|
pub Y: ImPlotRange,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImPlotLimits() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImPlotLimits>(),
|
|
32usize,
|
|
concat!("Size of: ", stringify!(ImPlotLimits))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImPlotLimits>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(ImPlotLimits))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotLimits>())).X as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotLimits),
|
|
"::",
|
|
stringify!(X)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotLimits>())).Y as *const _ as usize },
|
|
16usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotLimits),
|
|
"::",
|
|
stringify!(Y)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImPlotStyle {
|
|
pub LineWeight: f32,
|
|
pub Marker: ::std::os::raw::c_int,
|
|
pub MarkerSize: f32,
|
|
pub MarkerWeight: f32,
|
|
pub FillAlpha: f32,
|
|
pub ErrorBarSize: f32,
|
|
pub ErrorBarWeight: f32,
|
|
pub DigitalBitHeight: f32,
|
|
pub DigitalBitGap: f32,
|
|
pub PlotBorderSize: f32,
|
|
pub MinorAlpha: f32,
|
|
pub MajorTickLen: ImVec2,
|
|
pub MinorTickLen: ImVec2,
|
|
pub MajorTickSize: ImVec2,
|
|
pub MinorTickSize: ImVec2,
|
|
pub MajorGridSize: ImVec2,
|
|
pub MinorGridSize: ImVec2,
|
|
pub PlotPadding: ImVec2,
|
|
pub LabelPadding: ImVec2,
|
|
pub LegendPadding: ImVec2,
|
|
pub InfoPadding: ImVec2,
|
|
pub PlotMinSize: ImVec2,
|
|
pub Colors: [ImVec4; 24usize],
|
|
pub AntiAliasedLines: bool,
|
|
pub UseLocalTime: bool,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImPlotStyle() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImPlotStyle>(),
|
|
520usize,
|
|
concat!("Size of: ", stringify!(ImPlotStyle))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImPlotStyle>(),
|
|
4usize,
|
|
concat!("Alignment of ", stringify!(ImPlotStyle))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).LineWeight as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotStyle),
|
|
"::",
|
|
stringify!(LineWeight)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).Marker as *const _ as usize },
|
|
4usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotStyle),
|
|
"::",
|
|
stringify!(Marker)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).MarkerSize as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotStyle),
|
|
"::",
|
|
stringify!(MarkerSize)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).MarkerWeight as *const _ as usize },
|
|
12usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotStyle),
|
|
"::",
|
|
stringify!(MarkerWeight)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).FillAlpha as *const _ as usize },
|
|
16usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotStyle),
|
|
"::",
|
|
stringify!(FillAlpha)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).ErrorBarSize as *const _ as usize },
|
|
20usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotStyle),
|
|
"::",
|
|
stringify!(ErrorBarSize)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).ErrorBarWeight as *const _ as usize },
|
|
24usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotStyle),
|
|
"::",
|
|
stringify!(ErrorBarWeight)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).DigitalBitHeight as *const _ as usize },
|
|
28usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotStyle),
|
|
"::",
|
|
stringify!(DigitalBitHeight)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).DigitalBitGap as *const _ as usize },
|
|
32usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotStyle),
|
|
"::",
|
|
stringify!(DigitalBitGap)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).PlotBorderSize as *const _ as usize },
|
|
36usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotStyle),
|
|
"::",
|
|
stringify!(PlotBorderSize)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).MinorAlpha as *const _ as usize },
|
|
40usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotStyle),
|
|
"::",
|
|
stringify!(MinorAlpha)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).MajorTickLen as *const _ as usize },
|
|
44usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotStyle),
|
|
"::",
|
|
stringify!(MajorTickLen)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).MinorTickLen as *const _ as usize },
|
|
52usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotStyle),
|
|
"::",
|
|
stringify!(MinorTickLen)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).MajorTickSize as *const _ as usize },
|
|
60usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotStyle),
|
|
"::",
|
|
stringify!(MajorTickSize)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).MinorTickSize as *const _ as usize },
|
|
68usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotStyle),
|
|
"::",
|
|
stringify!(MinorTickSize)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).MajorGridSize as *const _ as usize },
|
|
76usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotStyle),
|
|
"::",
|
|
stringify!(MajorGridSize)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).MinorGridSize as *const _ as usize },
|
|
84usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotStyle),
|
|
"::",
|
|
stringify!(MinorGridSize)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).PlotPadding as *const _ as usize },
|
|
92usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotStyle),
|
|
"::",
|
|
stringify!(PlotPadding)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).LabelPadding as *const _ as usize },
|
|
100usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotStyle),
|
|
"::",
|
|
stringify!(LabelPadding)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).LegendPadding as *const _ as usize },
|
|
108usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotStyle),
|
|
"::",
|
|
stringify!(LegendPadding)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).InfoPadding as *const _ as usize },
|
|
116usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotStyle),
|
|
"::",
|
|
stringify!(InfoPadding)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).PlotMinSize as *const _ as usize },
|
|
124usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotStyle),
|
|
"::",
|
|
stringify!(PlotMinSize)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).Colors as *const _ as usize },
|
|
132usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotStyle),
|
|
"::",
|
|
stringify!(Colors)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).AntiAliasedLines as *const _ as usize },
|
|
516usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotStyle),
|
|
"::",
|
|
stringify!(AntiAliasedLines)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotStyle>())).UseLocalTime as *const _ as usize },
|
|
517usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotStyle),
|
|
"::",
|
|
stringify!(UseLocalTime)
|
|
)
|
|
);
|
|
}
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct ImPlotInputMap {
|
|
pub PanButton: ImGuiMouseButton,
|
|
pub PanMod: ImGuiKeyModFlags,
|
|
pub FitButton: ImGuiMouseButton,
|
|
pub ContextMenuButton: ImGuiMouseButton,
|
|
pub BoxSelectButton: ImGuiMouseButton,
|
|
pub BoxSelectMod: ImGuiKeyModFlags,
|
|
pub BoxSelectCancelButton: ImGuiMouseButton,
|
|
pub QueryButton: ImGuiMouseButton,
|
|
pub QueryMod: ImGuiKeyModFlags,
|
|
pub QueryToggleMod: ImGuiKeyModFlags,
|
|
pub HorizontalMod: ImGuiKeyModFlags,
|
|
pub VerticalMod: ImGuiKeyModFlags,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout_ImPlotInputMap() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<ImPlotInputMap>(),
|
|
48usize,
|
|
concat!("Size of: ", stringify!(ImPlotInputMap))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<ImPlotInputMap>(),
|
|
4usize,
|
|
concat!("Alignment of ", stringify!(ImPlotInputMap))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotInputMap>())).PanButton as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotInputMap),
|
|
"::",
|
|
stringify!(PanButton)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotInputMap>())).PanMod as *const _ as usize },
|
|
4usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotInputMap),
|
|
"::",
|
|
stringify!(PanMod)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotInputMap>())).FitButton as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotInputMap),
|
|
"::",
|
|
stringify!(FitButton)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<ImPlotInputMap>())).ContextMenuButton as *const _ as usize
|
|
},
|
|
12usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotInputMap),
|
|
"::",
|
|
stringify!(ContextMenuButton)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotInputMap>())).BoxSelectButton as *const _ as usize },
|
|
16usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotInputMap),
|
|
"::",
|
|
stringify!(BoxSelectButton)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotInputMap>())).BoxSelectMod as *const _ as usize },
|
|
20usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotInputMap),
|
|
"::",
|
|
stringify!(BoxSelectMod)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe {
|
|
&(*(::std::ptr::null::<ImPlotInputMap>())).BoxSelectCancelButton as *const _ as usize
|
|
},
|
|
24usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotInputMap),
|
|
"::",
|
|
stringify!(BoxSelectCancelButton)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotInputMap>())).QueryButton as *const _ as usize },
|
|
28usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotInputMap),
|
|
"::",
|
|
stringify!(QueryButton)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotInputMap>())).QueryMod as *const _ as usize },
|
|
32usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotInputMap),
|
|
"::",
|
|
stringify!(QueryMod)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotInputMap>())).QueryToggleMod as *const _ as usize },
|
|
36usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotInputMap),
|
|
"::",
|
|
stringify!(QueryToggleMod)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotInputMap>())).HorizontalMod as *const _ as usize },
|
|
40usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotInputMap),
|
|
"::",
|
|
stringify!(HorizontalMod)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<ImPlotInputMap>())).VerticalMod as *const _ as usize },
|
|
44usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(ImPlotInputMap),
|
|
"::",
|
|
stringify!(VerticalMod)
|
|
)
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlotPoint_ImPlotPointNil() -> *mut ImPlotPoint;
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlotPoint_destroy(self_: *mut ImPlotPoint);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlotPoint_ImPlotPointdouble(_x: f64, _y: f64) -> *mut ImPlotPoint;
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlotRange_ImPlotRangeNil() -> *mut ImPlotRange;
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlotRange_destroy(self_: *mut ImPlotRange);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlotRange_ImPlotRangedouble(_min: f64, _max: f64) -> *mut ImPlotRange;
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlotRange_Contains(self_: *mut ImPlotRange, value: f64) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlotRange_Size(self_: *mut ImPlotRange) -> f64;
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlotLimits_ContainsPlotPoInt(self_: *mut ImPlotLimits, p: ImPlotPoint) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlotLimits_Containsdouble(self_: *mut ImPlotLimits, x: f64, y: f64) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlotStyle_ImPlotStyle() -> *mut ImPlotStyle;
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlotStyle_destroy(self_: *mut ImPlotStyle);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlotInputMap_ImPlotInputMap() -> *mut ImPlotInputMap;
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlotInputMap_destroy(self_: *mut ImPlotInputMap);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_CreateContext() -> *mut ImPlotContext;
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_DestroyContext(ctx: *mut ImPlotContext);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_GetCurrentContext() -> *mut ImPlotContext;
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_SetCurrentContext(ctx: *mut ImPlotContext);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_BeginPlot(
|
|
title_id: *const ::std::os::raw::c_char,
|
|
x_label: *const ::std::os::raw::c_char,
|
|
y_label: *const ::std::os::raw::c_char,
|
|
size: ImVec2,
|
|
flags: ImPlotFlags,
|
|
x_flags: ImPlotAxisFlags,
|
|
y_flags: ImPlotAxisFlags,
|
|
y2_flags: ImPlotAxisFlags,
|
|
y3_flags: ImPlotAxisFlags,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_EndPlot();
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotLineFloatPtrInt(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
values: *const f32,
|
|
count: ::std::os::raw::c_int,
|
|
offset: ::std::os::raw::c_int,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotLinedoublePtrInt(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
values: *const f64,
|
|
count: ::std::os::raw::c_int,
|
|
offset: ::std::os::raw::c_int,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotLineFloatPtrFloatPtr(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
xs: *const f32,
|
|
ys: *const f32,
|
|
count: ::std::os::raw::c_int,
|
|
offset: ::std::os::raw::c_int,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotLinedoublePtrdoublePtr(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
xs: *const f64,
|
|
ys: *const f64,
|
|
count: ::std::os::raw::c_int,
|
|
offset: ::std::os::raw::c_int,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotLineVec2Ptr(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
data: *const ImVec2,
|
|
count: ::std::os::raw::c_int,
|
|
offset: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotLinePlotPoIntPtr(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
data: *const ImPlotPoint,
|
|
count: ::std::os::raw::c_int,
|
|
offset: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotLineFnPlotPoIntPtr(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
getter: ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
data: *mut ::std::os::raw::c_void,
|
|
idx: ::std::os::raw::c_int,
|
|
) -> ImPlotPoint,
|
|
>,
|
|
data: *mut ::std::os::raw::c_void,
|
|
count: ::std::os::raw::c_int,
|
|
offset: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotScatterFloatPtrInt(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
values: *const f32,
|
|
count: ::std::os::raw::c_int,
|
|
offset: ::std::os::raw::c_int,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotScatterdoublePtrInt(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
values: *const f64,
|
|
count: ::std::os::raw::c_int,
|
|
offset: ::std::os::raw::c_int,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotScatterFloatPtrFloatPtr(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
xs: *const f32,
|
|
ys: *const f32,
|
|
count: ::std::os::raw::c_int,
|
|
offset: ::std::os::raw::c_int,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotScatterdoublePtrdoublePtr(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
xs: *const f64,
|
|
ys: *const f64,
|
|
count: ::std::os::raw::c_int,
|
|
offset: ::std::os::raw::c_int,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotScatterVec2Ptr(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
data: *const ImVec2,
|
|
count: ::std::os::raw::c_int,
|
|
offset: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotScatterPlotPoIntPtr(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
data: *const ImPlotPoint,
|
|
count: ::std::os::raw::c_int,
|
|
offset: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotScatterFnPlotPoIntPtr(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
getter: ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
data: *mut ::std::os::raw::c_void,
|
|
idx: ::std::os::raw::c_int,
|
|
) -> ImPlotPoint,
|
|
>,
|
|
data: *mut ::std::os::raw::c_void,
|
|
count: ::std::os::raw::c_int,
|
|
offset: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotShadedFloatPtrIntFloat(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
values: *const f32,
|
|
count: ::std::os::raw::c_int,
|
|
y_ref: f32,
|
|
offset: ::std::os::raw::c_int,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotShadeddoublePtrIntdouble(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
values: *const f64,
|
|
count: ::std::os::raw::c_int,
|
|
y_ref: f64,
|
|
offset: ::std::os::raw::c_int,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotShadedFloatPtrFloatPtrIntFloat(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
xs: *const f32,
|
|
ys: *const f32,
|
|
count: ::std::os::raw::c_int,
|
|
y_ref: f32,
|
|
offset: ::std::os::raw::c_int,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotShadeddoublePtrdoublePtrIntdouble(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
xs: *const f64,
|
|
ys: *const f64,
|
|
count: ::std::os::raw::c_int,
|
|
y_ref: f64,
|
|
offset: ::std::os::raw::c_int,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotShadedFloatPtrFloatPtrFloatPtr(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
xs: *const f32,
|
|
ys1: *const f32,
|
|
ys2: *const f32,
|
|
count: ::std::os::raw::c_int,
|
|
offset: ::std::os::raw::c_int,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotShadeddoublePtrdoublePtrdoublePtr(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
xs: *const f64,
|
|
ys1: *const f64,
|
|
ys2: *const f64,
|
|
count: ::std::os::raw::c_int,
|
|
offset: ::std::os::raw::c_int,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotShadedFnPlotPoIntPtr(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
getter1: ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
data: *mut ::std::os::raw::c_void,
|
|
idx: ::std::os::raw::c_int,
|
|
) -> ImPlotPoint,
|
|
>,
|
|
data1: *mut ::std::os::raw::c_void,
|
|
getter2: ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
data: *mut ::std::os::raw::c_void,
|
|
idx: ::std::os::raw::c_int,
|
|
) -> ImPlotPoint,
|
|
>,
|
|
data2: *mut ::std::os::raw::c_void,
|
|
count: ::std::os::raw::c_int,
|
|
offset: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotBarsFloatPtrIntFloat(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
values: *const f32,
|
|
count: ::std::os::raw::c_int,
|
|
width: f32,
|
|
shift: f32,
|
|
offset: ::std::os::raw::c_int,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotBarsdoublePtrIntdouble(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
values: *const f64,
|
|
count: ::std::os::raw::c_int,
|
|
width: f64,
|
|
shift: f64,
|
|
offset: ::std::os::raw::c_int,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotBarsFloatPtrFloatPtr(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
xs: *const f32,
|
|
ys: *const f32,
|
|
count: ::std::os::raw::c_int,
|
|
width: f32,
|
|
offset: ::std::os::raw::c_int,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotBarsdoublePtrdoublePtr(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
xs: *const f64,
|
|
ys: *const f64,
|
|
count: ::std::os::raw::c_int,
|
|
width: f64,
|
|
offset: ::std::os::raw::c_int,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotBarsFnPlotPoIntPtr(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
getter: ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
data: *mut ::std::os::raw::c_void,
|
|
idx: ::std::os::raw::c_int,
|
|
) -> ImPlotPoint,
|
|
>,
|
|
data: *mut ::std::os::raw::c_void,
|
|
count: ::std::os::raw::c_int,
|
|
width: f64,
|
|
offset: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotBarsHFloatPtrIntFloat(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
values: *const f32,
|
|
count: ::std::os::raw::c_int,
|
|
height: f32,
|
|
shift: f32,
|
|
offset: ::std::os::raw::c_int,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotBarsHdoublePtrIntdouble(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
values: *const f64,
|
|
count: ::std::os::raw::c_int,
|
|
height: f64,
|
|
shift: f64,
|
|
offset: ::std::os::raw::c_int,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotBarsHFloatPtrFloatPtr(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
xs: *const f32,
|
|
ys: *const f32,
|
|
count: ::std::os::raw::c_int,
|
|
height: f32,
|
|
offset: ::std::os::raw::c_int,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotBarsHdoublePtrdoublePtr(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
xs: *const f64,
|
|
ys: *const f64,
|
|
count: ::std::os::raw::c_int,
|
|
height: f64,
|
|
offset: ::std::os::raw::c_int,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotBarsHFnPlotPoIntPtr(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
getter: ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
data: *mut ::std::os::raw::c_void,
|
|
idx: ::std::os::raw::c_int,
|
|
) -> ImPlotPoint,
|
|
>,
|
|
data: *mut ::std::os::raw::c_void,
|
|
count: ::std::os::raw::c_int,
|
|
height: f64,
|
|
offset: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotErrorBarsFloatPtrFloatPtrFloatPtrInt(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
xs: *const f32,
|
|
ys: *const f32,
|
|
err: *const f32,
|
|
count: ::std::os::raw::c_int,
|
|
offset: ::std::os::raw::c_int,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotErrorBarsdoublePtrdoublePtrdoublePtrInt(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
xs: *const f64,
|
|
ys: *const f64,
|
|
err: *const f64,
|
|
count: ::std::os::raw::c_int,
|
|
offset: ::std::os::raw::c_int,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotErrorBarsFloatPtrFloatPtrFloatPtrFloatPtr(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
xs: *const f32,
|
|
ys: *const f32,
|
|
neg: *const f32,
|
|
pos: *const f32,
|
|
count: ::std::os::raw::c_int,
|
|
offset: ::std::os::raw::c_int,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotErrorBarsdoublePtrdoublePtrdoublePtrdoublePtr(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
xs: *const f64,
|
|
ys: *const f64,
|
|
neg: *const f64,
|
|
pos: *const f64,
|
|
count: ::std::os::raw::c_int,
|
|
offset: ::std::os::raw::c_int,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotErrorBarsHFloatPtrFloatPtrFloatPtrInt(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
xs: *const f32,
|
|
ys: *const f32,
|
|
err: *const f32,
|
|
count: ::std::os::raw::c_int,
|
|
offset: ::std::os::raw::c_int,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotErrorBarsHdoublePtrdoublePtrdoublePtrInt(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
xs: *const f64,
|
|
ys: *const f64,
|
|
err: *const f64,
|
|
count: ::std::os::raw::c_int,
|
|
offset: ::std::os::raw::c_int,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotErrorBarsHFloatPtrFloatPtrFloatPtrFloatPtr(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
xs: *const f32,
|
|
ys: *const f32,
|
|
neg: *const f32,
|
|
pos: *const f32,
|
|
count: ::std::os::raw::c_int,
|
|
offset: ::std::os::raw::c_int,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotErrorBarsHdoublePtrdoublePtrdoublePtrdoublePtr(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
xs: *const f64,
|
|
ys: *const f64,
|
|
neg: *const f64,
|
|
pos: *const f64,
|
|
count: ::std::os::raw::c_int,
|
|
offset: ::std::os::raw::c_int,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotStemsFloatPtrIntFloat(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
values: *const f32,
|
|
count: ::std::os::raw::c_int,
|
|
y_ref: f32,
|
|
offset: ::std::os::raw::c_int,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotStemsdoublePtrIntdouble(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
values: *const f64,
|
|
count: ::std::os::raw::c_int,
|
|
y_ref: f64,
|
|
offset: ::std::os::raw::c_int,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotStemsFloatPtrFloatPtr(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
xs: *const f32,
|
|
ys: *const f32,
|
|
count: ::std::os::raw::c_int,
|
|
y_ref: f32,
|
|
offset: ::std::os::raw::c_int,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotStemsdoublePtrdoublePtr(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
xs: *const f64,
|
|
ys: *const f64,
|
|
count: ::std::os::raw::c_int,
|
|
y_ref: f64,
|
|
offset: ::std::os::raw::c_int,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotPieChartFloatPtr(
|
|
label_ids: *mut *const ::std::os::raw::c_char,
|
|
values: *const f32,
|
|
count: ::std::os::raw::c_int,
|
|
x: f32,
|
|
y: f32,
|
|
radius: f32,
|
|
normalize: bool,
|
|
label_fmt: *const ::std::os::raw::c_char,
|
|
angle0: f32,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotPieChartdoublePtr(
|
|
label_ids: *mut *const ::std::os::raw::c_char,
|
|
values: *const f64,
|
|
count: ::std::os::raw::c_int,
|
|
x: f64,
|
|
y: f64,
|
|
radius: f64,
|
|
normalize: bool,
|
|
label_fmt: *const ::std::os::raw::c_char,
|
|
angle0: f64,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotHeatmapFloatPtr(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
values: *const f32,
|
|
rows: ::std::os::raw::c_int,
|
|
cols: ::std::os::raw::c_int,
|
|
scale_min: f32,
|
|
scale_max: f32,
|
|
label_fmt: *const ::std::os::raw::c_char,
|
|
bounds_min: ImPlotPoint,
|
|
bounds_max: ImPlotPoint,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotHeatmapdoublePtr(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
values: *const f64,
|
|
rows: ::std::os::raw::c_int,
|
|
cols: ::std::os::raw::c_int,
|
|
scale_min: f64,
|
|
scale_max: f64,
|
|
label_fmt: *const ::std::os::raw::c_char,
|
|
bounds_min: ImPlotPoint,
|
|
bounds_max: ImPlotPoint,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotDigitalFloatPtr(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
xs: *const f32,
|
|
ys: *const f32,
|
|
count: ::std::os::raw::c_int,
|
|
offset: ::std::os::raw::c_int,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotDigitaldoublePtr(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
xs: *const f64,
|
|
ys: *const f64,
|
|
count: ::std::os::raw::c_int,
|
|
offset: ::std::os::raw::c_int,
|
|
stride: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotDigitalFnPlotPoIntPtr(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
getter: ::std::option::Option<
|
|
unsafe extern "C" fn(
|
|
data: *mut ::std::os::raw::c_void,
|
|
idx: ::std::os::raw::c_int,
|
|
) -> ImPlotPoint,
|
|
>,
|
|
data: *mut ::std::os::raw::c_void,
|
|
count: ::std::os::raw::c_int,
|
|
offset: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotTextFloat(
|
|
text: *const ::std::os::raw::c_char,
|
|
x: f32,
|
|
y: f32,
|
|
vertical: bool,
|
|
pixel_offset: ImVec2,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotTextdouble(
|
|
text: *const ::std::os::raw::c_char,
|
|
x: f64,
|
|
y: f64,
|
|
vertical: bool,
|
|
pixel_offset: ImVec2,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_SetNextPlotLimits(xmin: f64, xmax: f64, ymin: f64, ymax: f64, cond: ImGuiCond);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_SetNextPlotLimitsX(xmin: f64, xmax: f64, cond: ImGuiCond);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_SetNextPlotLimitsY(
|
|
ymin: f64,
|
|
ymax: f64,
|
|
cond: ImGuiCond,
|
|
y_axis: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_LinkNextPlotLimits(
|
|
xmin: *mut f64,
|
|
xmax: *mut f64,
|
|
ymin: *mut f64,
|
|
ymax: *mut f64,
|
|
ymin2: *mut f64,
|
|
ymax2: *mut f64,
|
|
ymin3: *mut f64,
|
|
ymax3: *mut f64,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_FitNextPlotAxes(x: bool, y: bool, y2: bool, y3: bool);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_SetNextPlotTicksXdoublePtr(
|
|
values: *const f64,
|
|
n_ticks: ::std::os::raw::c_int,
|
|
labels: *mut *const ::std::os::raw::c_char,
|
|
show_default: bool,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_SetNextPlotTicksXdouble(
|
|
x_min: f64,
|
|
x_max: f64,
|
|
n_ticks: ::std::os::raw::c_int,
|
|
labels: *mut *const ::std::os::raw::c_char,
|
|
show_default: bool,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_SetNextPlotTicksYdoublePtr(
|
|
values: *const f64,
|
|
n_ticks: ::std::os::raw::c_int,
|
|
labels: *mut *const ::std::os::raw::c_char,
|
|
show_default: bool,
|
|
y_axis: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_SetNextPlotTicksYdouble(
|
|
y_min: f64,
|
|
y_max: f64,
|
|
n_ticks: ::std::os::raw::c_int,
|
|
labels: *mut *const ::std::os::raw::c_char,
|
|
show_default: bool,
|
|
y_axis: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_SetPlotYAxis(y_axis: ::std::os::raw::c_int);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PixelsToPlotVec2(
|
|
pOut: *mut ImPlotPoint,
|
|
pix: ImVec2,
|
|
y_axis: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PixelsToPlotFloat(
|
|
pOut: *mut ImPlotPoint,
|
|
x: f32,
|
|
y: f32,
|
|
y_axis: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotToPixelsPlotPoInt(
|
|
pOut: *mut ImVec2,
|
|
plt: ImPlotPoint,
|
|
y_axis: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PlotToPixelsdouble(
|
|
pOut: *mut ImVec2,
|
|
x: f64,
|
|
y: f64,
|
|
y_axis: ::std::os::raw::c_int,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_GetPlotPos(pOut: *mut ImVec2);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_GetPlotSize(pOut: *mut ImVec2);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_IsPlotHovered() -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_IsPlotXAxisHovered() -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_IsPlotYAxisHovered(y_axis: ::std::os::raw::c_int) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_GetPlotMousePos(pOut: *mut ImPlotPoint, y_axis: ::std::os::raw::c_int);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_GetPlotLimits(pOut: *mut ImPlotLimits, y_axis: ::std::os::raw::c_int);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_IsPlotQueried() -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_GetPlotQuery(pOut: *mut ImPlotLimits, y_axis: ::std::os::raw::c_int);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_GetStyle() -> *mut ImPlotStyle;
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_StyleColorsAuto(dst: *mut ImPlotStyle);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_StyleColorsClassic(dst: *mut ImPlotStyle);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_StyleColorsDark(dst: *mut ImPlotStyle);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_StyleColorsLight(dst: *mut ImPlotStyle);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PushStyleColorU32(idx: ImPlotCol, col: ImU32);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PushStyleColorVec4(idx: ImPlotCol, col: ImVec4);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PopStyleColor(count: ::std::os::raw::c_int);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PushStyleVarFloat(idx: ImPlotStyleVar, val: f32);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PushStyleVarInt(idx: ImPlotStyleVar, val: ::std::os::raw::c_int);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PushStyleVarVec2(idx: ImPlotStyleVar, val: ImVec2);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PopStyleVar(count: ::std::os::raw::c_int);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_SetNextLineStyle(col: ImVec4, weight: f32);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_SetNextFillStyle(col: ImVec4, alpha_mod: f32);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_SetNextMarkerStyle(
|
|
marker: ImPlotMarker,
|
|
size: f32,
|
|
fill: ImVec4,
|
|
weight: f32,
|
|
outline: ImVec4,
|
|
);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_SetNextErrorBarStyle(col: ImVec4, size: f32, weight: f32);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_GetStyleColorName(color: ImPlotCol) -> *const ::std::os::raw::c_char;
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_GetMarkerName(marker: ImPlotMarker) -> *const ::std::os::raw::c_char;
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PushColormapPlotColormap(colormap: ImPlotColormap);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PushColormapVec4Ptr(colormap: *const ImVec4, size: ::std::os::raw::c_int);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PopColormap(count: ::std::os::raw::c_int);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_SetColormapVec4Ptr(colormap: *const ImVec4, size: ::std::os::raw::c_int);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_SetColormapPlotColormap(colormap: ImPlotColormap, samples: ::std::os::raw::c_int);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_GetColormapSize() -> ::std::os::raw::c_int;
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_GetColormapColor(pOut: *mut ImVec4, index: ::std::os::raw::c_int);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_LerpColormap(pOut: *mut ImVec4, t: f32);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_NextColormapColor(pOut: *mut ImVec4);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_ShowColormapScale(scale_min: f64, scale_max: f64, height: f32);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_GetColormapName(colormap: ImPlotColormap) -> *const ::std::os::raw::c_char;
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_IsLegendEntryHovered(label_id: *const ::std::os::raw::c_char) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_BeginLegendDragDropSource(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
flags: ImGuiDragDropFlags,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_EndLegendDragDropSource();
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_BeginLegendPopup(
|
|
label_id: *const ::std::os::raw::c_char,
|
|
mouse_button: ImGuiMouseButton,
|
|
) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_EndLegendPopup();
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_GetInputMap() -> *mut ImPlotInputMap;
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_GetPlotDrawList() -> *mut ImDrawList;
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PushPlotClipRect();
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_PopPlotClipRect();
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_ShowStyleSelector(label: *const ::std::os::raw::c_char) -> bool;
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_ShowStyleEditor(ref_: *mut ImPlotStyle);
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_ShowUserGuide();
|
|
}
|
|
extern "C" {
|
|
pub fn ImPlot_ShowDemoWindow(p_open: *mut bool);
|
|
}
|
|
pub type __builtin_va_list = [__va_list_tag; 1usize];
|
|
#[repr(C)]
|
|
#[derive(Debug, Copy, Clone)]
|
|
pub struct __va_list_tag {
|
|
pub gp_offset: ::std::os::raw::c_uint,
|
|
pub fp_offset: ::std::os::raw::c_uint,
|
|
pub overflow_arg_area: *mut ::std::os::raw::c_void,
|
|
pub reg_save_area: *mut ::std::os::raw::c_void,
|
|
}
|
|
#[test]
|
|
fn bindgen_test_layout___va_list_tag() {
|
|
assert_eq!(
|
|
::std::mem::size_of::<__va_list_tag>(),
|
|
24usize,
|
|
concat!("Size of: ", stringify!(__va_list_tag))
|
|
);
|
|
assert_eq!(
|
|
::std::mem::align_of::<__va_list_tag>(),
|
|
8usize,
|
|
concat!("Alignment of ", stringify!(__va_list_tag))
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<__va_list_tag>())).gp_offset as *const _ as usize },
|
|
0usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(__va_list_tag),
|
|
"::",
|
|
stringify!(gp_offset)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<__va_list_tag>())).fp_offset as *const _ as usize },
|
|
4usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(__va_list_tag),
|
|
"::",
|
|
stringify!(fp_offset)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<__va_list_tag>())).overflow_arg_area as *const _ as usize },
|
|
8usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(__va_list_tag),
|
|
"::",
|
|
stringify!(overflow_arg_area)
|
|
)
|
|
);
|
|
assert_eq!(
|
|
unsafe { &(*(::std::ptr::null::<__va_list_tag>())).reg_save_area as *const _ as usize },
|
|
16usize,
|
|
concat!(
|
|
"Offset of field: ",
|
|
stringify!(__va_list_tag),
|
|
"::",
|
|
stringify!(reg_save_area)
|
|
)
|
|
);
|
|
}
|