pub type __off_t = ::std::os::raw::c_long;
pub type __off64_t = ::std::os::raw::c_long;
pub type __time_t = ::std::os::raw::c_long;
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: usize,
pub _mode: ::std::os::raw::c_int,
pub _unused2: [::std::os::raw::c_char; 20usize],
}
#[test]
fn bindgen_test_layout__IO_FILE() {
const UNINIT: ::std::mem::MaybeUninit<_IO_FILE> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
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::addr_of!((*ptr)._flags) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_flags)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_read_ptr) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_read_ptr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_read_end) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_read_end)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_read_base) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_read_base)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_write_base) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_write_base)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_write_ptr) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_write_ptr)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_write_end) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_write_end)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_buf_base) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_buf_base)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_buf_end) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_buf_end)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_save_base) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_save_base)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_backup_base) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_backup_base)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._IO_save_end) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_save_end)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._markers) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_markers)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._chain) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_chain)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._fileno) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_fileno)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._flags2) as usize - ptr as usize },
116usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_flags2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._old_offset) as usize - ptr as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_old_offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._cur_column) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_cur_column)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._vtable_offset) as usize - ptr as usize },
130usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_vtable_offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._shortbuf) as usize - ptr as usize },
131usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_shortbuf)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._lock) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_lock)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._offset) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._codecvt) as usize - ptr as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_codecvt)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._wide_data) as usize - ptr as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_wide_data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._freeres_list) as usize - ptr as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_freeres_list)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._freeres_buf) as usize - ptr as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_freeres_buf)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).__pad5) as usize - ptr as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(__pad5)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._mode) as usize - ptr as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_mode)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr)._unused2) as usize - ptr as usize },
196usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_unused2)
)
);
}
pub type time_t = __time_t;
pub type lxw_row_t = u32;
pub type lxw_col_t = u16;
pub const lxw_boolean_LXW_FALSE: lxw_boolean = 0;
pub const lxw_boolean_LXW_TRUE: lxw_boolean = 1;
pub const lxw_boolean_LXW_EXPLICIT_FALSE: lxw_boolean = 2;
pub type lxw_boolean = ::std::os::raw::c_uint;
pub const lxw_error_LXW_NO_ERROR: lxw_error = 0;
pub const lxw_error_LXW_ERROR_MEMORY_MALLOC_FAILED: lxw_error = 1;
pub const lxw_error_LXW_ERROR_CREATING_XLSX_FILE: lxw_error = 2;
pub const lxw_error_LXW_ERROR_CREATING_TMPFILE: lxw_error = 3;
pub const lxw_error_LXW_ERROR_READING_TMPFILE: lxw_error = 4;
pub const lxw_error_LXW_ERROR_ZIP_FILE_OPERATION: lxw_error = 5;
pub const lxw_error_LXW_ERROR_ZIP_PARAMETER_ERROR: lxw_error = 6;
pub const lxw_error_LXW_ERROR_ZIP_BAD_ZIP_FILE: lxw_error = 7;
pub const lxw_error_LXW_ERROR_ZIP_INTERNAL_ERROR: lxw_error = 8;
pub const lxw_error_LXW_ERROR_ZIP_FILE_ADD: lxw_error = 9;
pub const lxw_error_LXW_ERROR_ZIP_CLOSE: lxw_error = 10;
pub const lxw_error_LXW_ERROR_FEATURE_NOT_SUPPORTED: lxw_error = 11;
pub const lxw_error_LXW_ERROR_NULL_PARAMETER_IGNORED: lxw_error = 12;
pub const lxw_error_LXW_ERROR_PARAMETER_VALIDATION: lxw_error = 13;
pub const lxw_error_LXW_ERROR_SHEETNAME_LENGTH_EXCEEDED: lxw_error = 14;
pub const lxw_error_LXW_ERROR_INVALID_SHEETNAME_CHARACTER: lxw_error = 15;
pub const lxw_error_LXW_ERROR_SHEETNAME_START_END_APOSTROPHE: lxw_error = 16;
pub const lxw_error_LXW_ERROR_SHEETNAME_ALREADY_USED: lxw_error = 17;
pub const lxw_error_LXW_ERROR_32_STRING_LENGTH_EXCEEDED: lxw_error = 18;
pub const lxw_error_LXW_ERROR_128_STRING_LENGTH_EXCEEDED: lxw_error = 19;
pub const lxw_error_LXW_ERROR_255_STRING_LENGTH_EXCEEDED: lxw_error = 20;
pub const lxw_error_LXW_ERROR_MAX_STRING_LENGTH_EXCEEDED: lxw_error = 21;
pub const lxw_error_LXW_ERROR_SHARED_STRING_INDEX_NOT_FOUND: lxw_error = 22;
pub const lxw_error_LXW_ERROR_WORKSHEET_INDEX_OUT_OF_RANGE: lxw_error = 23;
pub const lxw_error_LXW_ERROR_WORKSHEET_MAX_URL_LENGTH_EXCEEDED: lxw_error = 24;
pub const lxw_error_LXW_ERROR_WORKSHEET_MAX_NUMBER_URLS_EXCEEDED: lxw_error = 25;
pub const lxw_error_LXW_ERROR_IMAGE_DIMENSIONS: lxw_error = 26;
pub const lxw_error_LXW_MAX_ERRNO: lxw_error = 27;
pub type lxw_error = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_datetime {
pub year: ::std::os::raw::c_int,
pub month: ::std::os::raw::c_int,
pub day: ::std::os::raw::c_int,
pub hour: ::std::os::raw::c_int,
pub min: ::std::os::raw::c_int,
pub sec: f64,
}
#[test]
fn bindgen_test_layout_lxw_datetime() {
const UNINIT: ::std::mem::MaybeUninit<lxw_datetime> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_datetime>(),
32usize,
concat!("Size of: ", stringify!(lxw_datetime))
);
assert_eq!(
::std::mem::align_of::<lxw_datetime>(),
8usize,
concat!("Alignment of ", stringify!(lxw_datetime))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).year) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_datetime),
"::",
stringify!(year)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).month) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_datetime),
"::",
stringify!(month)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).day) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_datetime),
"::",
stringify!(day)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hour) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(lxw_datetime),
"::",
stringify!(hour)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).min) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_datetime),
"::",
stringify!(min)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sec) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_datetime),
"::",
stringify!(sec)
)
);
}
pub const lxw_custom_property_types_LXW_CUSTOM_NONE: lxw_custom_property_types = 0;
pub const lxw_custom_property_types_LXW_CUSTOM_STRING: lxw_custom_property_types = 1;
pub const lxw_custom_property_types_LXW_CUSTOM_DOUBLE: lxw_custom_property_types = 2;
pub const lxw_custom_property_types_LXW_CUSTOM_INTEGER: lxw_custom_property_types = 3;
pub const lxw_custom_property_types_LXW_CUSTOM_BOOLEAN: lxw_custom_property_types = 4;
pub const lxw_custom_property_types_LXW_CUSTOM_DATETIME: lxw_custom_property_types = 5;
pub type lxw_custom_property_types = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_formats {
pub stqh_first: *mut lxw_format,
pub stqh_last: *mut *mut lxw_format,
}
#[test]
fn bindgen_test_layout_lxw_formats() {
const UNINIT: ::std::mem::MaybeUninit<lxw_formats> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_formats>(),
16usize,
concat!("Size of: ", stringify!(lxw_formats))
);
assert_eq!(
::std::mem::align_of::<lxw_formats>(),
8usize,
concat!("Alignment of ", stringify!(lxw_formats))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_first) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_formats),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_last) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_formats),
"::",
stringify!(stqh_last)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_tuples {
pub stqh_first: *mut lxw_tuple,
pub stqh_last: *mut *mut lxw_tuple,
}
#[test]
fn bindgen_test_layout_lxw_tuples() {
const UNINIT: ::std::mem::MaybeUninit<lxw_tuples> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_tuples>(),
16usize,
concat!("Size of: ", stringify!(lxw_tuples))
);
assert_eq!(
::std::mem::align_of::<lxw_tuples>(),
8usize,
concat!("Alignment of ", stringify!(lxw_tuples))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_first) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_tuples),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_last) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_tuples),
"::",
stringify!(stqh_last)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_custom_properties {
pub stqh_first: *mut lxw_custom_property,
pub stqh_last: *mut *mut lxw_custom_property,
}
#[test]
fn bindgen_test_layout_lxw_custom_properties() {
const UNINIT: ::std::mem::MaybeUninit<lxw_custom_properties> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_custom_properties>(),
16usize,
concat!("Size of: ", stringify!(lxw_custom_properties))
);
assert_eq!(
::std::mem::align_of::<lxw_custom_properties>(),
8usize,
concat!("Alignment of ", stringify!(lxw_custom_properties))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_first) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_custom_properties),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_last) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_custom_properties),
"::",
stringify!(stqh_last)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_tuple {
pub key: *mut ::std::os::raw::c_char,
pub value: *mut ::std::os::raw::c_char,
pub list_pointers: lxw_tuple__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_tuple__bindgen_ty_1 {
pub stqe_next: *mut lxw_tuple,
}
#[test]
fn bindgen_test_layout_lxw_tuple__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<lxw_tuple__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_tuple__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(lxw_tuple__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<lxw_tuple__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(lxw_tuple__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqe_next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_tuple__bindgen_ty_1),
"::",
stringify!(stqe_next)
)
);
}
#[test]
fn bindgen_test_layout_lxw_tuple() {
const UNINIT: ::std::mem::MaybeUninit<lxw_tuple> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_tuple>(),
24usize,
concat!("Size of: ", stringify!(lxw_tuple))
);
assert_eq!(
::std::mem::align_of::<lxw_tuple>(),
8usize,
concat!("Alignment of ", stringify!(lxw_tuple))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).key) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_tuple),
"::",
stringify!(key)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_tuple),
"::",
stringify!(value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).list_pointers) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_tuple),
"::",
stringify!(list_pointers)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct lxw_custom_property {
pub type_: lxw_custom_property_types,
pub name: *mut ::std::os::raw::c_char,
pub u: lxw_custom_property__bindgen_ty_1,
pub list_pointers: lxw_custom_property__bindgen_ty_2,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union lxw_custom_property__bindgen_ty_1 {
pub string: *mut ::std::os::raw::c_char,
pub number: f64,
pub integer: i32,
pub boolean: u8,
pub datetime: lxw_datetime,
}
#[test]
fn bindgen_test_layout_lxw_custom_property__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<lxw_custom_property__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_custom_property__bindgen_ty_1>(),
32usize,
concat!("Size of: ", stringify!(lxw_custom_property__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<lxw_custom_property__bindgen_ty_1>(),
8usize,
concat!(
"Alignment of ",
stringify!(lxw_custom_property__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).string) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_custom_property__bindgen_ty_1),
"::",
stringify!(string)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).number) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_custom_property__bindgen_ty_1),
"::",
stringify!(number)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).integer) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_custom_property__bindgen_ty_1),
"::",
stringify!(integer)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).boolean) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_custom_property__bindgen_ty_1),
"::",
stringify!(boolean)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).datetime) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_custom_property__bindgen_ty_1),
"::",
stringify!(datetime)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_custom_property__bindgen_ty_2 {
pub stqe_next: *mut lxw_custom_property,
}
#[test]
fn bindgen_test_layout_lxw_custom_property__bindgen_ty_2() {
const UNINIT: ::std::mem::MaybeUninit<lxw_custom_property__bindgen_ty_2> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_custom_property__bindgen_ty_2>(),
8usize,
concat!("Size of: ", stringify!(lxw_custom_property__bindgen_ty_2))
);
assert_eq!(
::std::mem::align_of::<lxw_custom_property__bindgen_ty_2>(),
8usize,
concat!(
"Alignment of ",
stringify!(lxw_custom_property__bindgen_ty_2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqe_next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_custom_property__bindgen_ty_2),
"::",
stringify!(stqe_next)
)
);
}
#[test]
fn bindgen_test_layout_lxw_custom_property() {
const UNINIT: ::std::mem::MaybeUninit<lxw_custom_property> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_custom_property>(),
56usize,
concat!("Size of: ", stringify!(lxw_custom_property))
);
assert_eq!(
::std::mem::align_of::<lxw_custom_property>(),
8usize,
concat!("Alignment of ", stringify!(lxw_custom_property))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_custom_property),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_custom_property),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_custom_property),
"::",
stringify!(u)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).list_pointers) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_custom_property),
"::",
stringify!(list_pointers)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sst_rb_tree {
pub rbh_root: *mut sst_element,
}
#[test]
fn bindgen_test_layout_sst_rb_tree() {
const UNINIT: ::std::mem::MaybeUninit<sst_rb_tree> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<sst_rb_tree>(),
8usize,
concat!("Size of: ", stringify!(sst_rb_tree))
);
assert_eq!(
::std::mem::align_of::<sst_rb_tree>(),
8usize,
concat!("Alignment of ", stringify!(sst_rb_tree))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbh_root) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sst_rb_tree),
"::",
stringify!(rbh_root)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sst_order_list {
pub stqh_first: *mut sst_element,
pub stqh_last: *mut *mut sst_element,
}
#[test]
fn bindgen_test_layout_sst_order_list() {
const UNINIT: ::std::mem::MaybeUninit<sst_order_list> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<sst_order_list>(),
16usize,
concat!("Size of: ", stringify!(sst_order_list))
);
assert_eq!(
::std::mem::align_of::<sst_order_list>(),
8usize,
concat!("Alignment of ", stringify!(sst_order_list))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_first) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sst_order_list),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_last) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sst_order_list),
"::",
stringify!(stqh_last)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sst_element {
pub index: u32,
pub string: *mut ::std::os::raw::c_char,
pub is_rich_string: u8,
pub sst_order_pointers: sst_element__bindgen_ty_1,
pub sst_tree_pointers: sst_element__bindgen_ty_2,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sst_element__bindgen_ty_1 {
pub stqe_next: *mut sst_element,
}
#[test]
fn bindgen_test_layout_sst_element__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<sst_element__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<sst_element__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(sst_element__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<sst_element__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(sst_element__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqe_next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sst_element__bindgen_ty_1),
"::",
stringify!(stqe_next)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct sst_element__bindgen_ty_2 {
pub rbe_left: *mut sst_element,
pub rbe_right: *mut sst_element,
pub rbe_parent: *mut sst_element,
pub rbe_color: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_sst_element__bindgen_ty_2() {
const UNINIT: ::std::mem::MaybeUninit<sst_element__bindgen_ty_2> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<sst_element__bindgen_ty_2>(),
32usize,
concat!("Size of: ", stringify!(sst_element__bindgen_ty_2))
);
assert_eq!(
::std::mem::align_of::<sst_element__bindgen_ty_2>(),
8usize,
concat!("Alignment of ", stringify!(sst_element__bindgen_ty_2))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbe_left) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sst_element__bindgen_ty_2),
"::",
stringify!(rbe_left)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbe_right) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sst_element__bindgen_ty_2),
"::",
stringify!(rbe_right)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbe_parent) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(sst_element__bindgen_ty_2),
"::",
stringify!(rbe_parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbe_color) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(sst_element__bindgen_ty_2),
"::",
stringify!(rbe_color)
)
);
}
#[test]
fn bindgen_test_layout_sst_element() {
const UNINIT: ::std::mem::MaybeUninit<sst_element> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<sst_element>(),
64usize,
concat!("Size of: ", stringify!(sst_element))
);
assert_eq!(
::std::mem::align_of::<sst_element>(),
8usize,
concat!("Alignment of ", stringify!(sst_element))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).index) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sst_element),
"::",
stringify!(index)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).string) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sst_element),
"::",
stringify!(string)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).is_rich_string) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(sst_element),
"::",
stringify!(is_rich_string)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sst_order_pointers) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(sst_element),
"::",
stringify!(sst_order_pointers)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sst_tree_pointers) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(sst_element),
"::",
stringify!(sst_tree_pointers)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_sst {
pub file: *mut FILE,
pub string_count: u32,
pub unique_count: u32,
pub order_list: *mut sst_order_list,
pub rb_tree: *mut sst_rb_tree,
}
#[test]
fn bindgen_test_layout_lxw_sst() {
const UNINIT: ::std::mem::MaybeUninit<lxw_sst> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_sst>(),
32usize,
concat!("Size of: ", stringify!(lxw_sst))
);
assert_eq!(
::std::mem::align_of::<lxw_sst>(),
8usize,
concat!("Alignment of ", stringify!(lxw_sst))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).file) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_sst),
"::",
stringify!(file)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).string_count) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_sst),
"::",
stringify!(string_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).unique_count) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(lxw_sst),
"::",
stringify!(unique_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).order_list) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_sst),
"::",
stringify!(order_list)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rb_tree) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_sst),
"::",
stringify!(rb_tree)
)
);
}
extern "C" {
pub fn lxw_sst_new() -> *mut lxw_sst;
}
extern "C" {
pub fn lxw_sst_free(sst: *mut lxw_sst);
}
extern "C" {
pub fn lxw_get_sst_index(
sst: *mut lxw_sst,
string: *const ::std::os::raw::c_char,
is_rich_string: u8,
) -> *mut sst_element;
}
extern "C" {
pub fn lxw_sst_assemble_xml_file(self_: *mut lxw_sst);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_hash_order_list {
pub stqh_first: *mut lxw_hash_element,
pub stqh_last: *mut *mut lxw_hash_element,
}
#[test]
fn bindgen_test_layout_lxw_hash_order_list() {
const UNINIT: ::std::mem::MaybeUninit<lxw_hash_order_list> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_hash_order_list>(),
16usize,
concat!("Size of: ", stringify!(lxw_hash_order_list))
);
assert_eq!(
::std::mem::align_of::<lxw_hash_order_list>(),
8usize,
concat!("Alignment of ", stringify!(lxw_hash_order_list))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_first) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_hash_order_list),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_last) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_hash_order_list),
"::",
stringify!(stqh_last)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_hash_bucket_list {
pub slh_first: *mut lxw_hash_element,
}
#[test]
fn bindgen_test_layout_lxw_hash_bucket_list() {
const UNINIT: ::std::mem::MaybeUninit<lxw_hash_bucket_list> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_hash_bucket_list>(),
8usize,
concat!("Size of: ", stringify!(lxw_hash_bucket_list))
);
assert_eq!(
::std::mem::align_of::<lxw_hash_bucket_list>(),
8usize,
concat!("Alignment of ", stringify!(lxw_hash_bucket_list))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).slh_first) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_hash_bucket_list),
"::",
stringify!(slh_first)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_hash_table {
pub num_buckets: u32,
pub used_buckets: u32,
pub unique_count: u32,
pub free_key: u8,
pub free_value: u8,
pub order_list: *mut lxw_hash_order_list,
pub buckets: *mut *mut lxw_hash_bucket_list,
}
#[test]
fn bindgen_test_layout_lxw_hash_table() {
const UNINIT: ::std::mem::MaybeUninit<lxw_hash_table> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_hash_table>(),
32usize,
concat!("Size of: ", stringify!(lxw_hash_table))
);
assert_eq!(
::std::mem::align_of::<lxw_hash_table>(),
8usize,
concat!("Alignment of ", stringify!(lxw_hash_table))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).num_buckets) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_hash_table),
"::",
stringify!(num_buckets)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).used_buckets) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_hash_table),
"::",
stringify!(used_buckets)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).unique_count) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_hash_table),
"::",
stringify!(unique_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).free_key) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(lxw_hash_table),
"::",
stringify!(free_key)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).free_value) as usize - ptr as usize },
13usize,
concat!(
"Offset of field: ",
stringify!(lxw_hash_table),
"::",
stringify!(free_value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).order_list) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_hash_table),
"::",
stringify!(order_list)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).buckets) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_hash_table),
"::",
stringify!(buckets)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_hash_element {
pub key: *mut ::std::os::raw::c_void,
pub value: *mut ::std::os::raw::c_void,
pub lxw_hash_order_pointers: lxw_hash_element__bindgen_ty_1,
pub lxw_hash_list_pointers: lxw_hash_element__bindgen_ty_2,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_hash_element__bindgen_ty_1 {
pub stqe_next: *mut lxw_hash_element,
}
#[test]
fn bindgen_test_layout_lxw_hash_element__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<lxw_hash_element__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_hash_element__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(lxw_hash_element__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<lxw_hash_element__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(lxw_hash_element__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqe_next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_hash_element__bindgen_ty_1),
"::",
stringify!(stqe_next)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_hash_element__bindgen_ty_2 {
pub sle_next: *mut lxw_hash_element,
}
#[test]
fn bindgen_test_layout_lxw_hash_element__bindgen_ty_2() {
const UNINIT: ::std::mem::MaybeUninit<lxw_hash_element__bindgen_ty_2> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_hash_element__bindgen_ty_2>(),
8usize,
concat!("Size of: ", stringify!(lxw_hash_element__bindgen_ty_2))
);
assert_eq!(
::std::mem::align_of::<lxw_hash_element__bindgen_ty_2>(),
8usize,
concat!("Alignment of ", stringify!(lxw_hash_element__bindgen_ty_2))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sle_next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_hash_element__bindgen_ty_2),
"::",
stringify!(sle_next)
)
);
}
#[test]
fn bindgen_test_layout_lxw_hash_element() {
const UNINIT: ::std::mem::MaybeUninit<lxw_hash_element> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_hash_element>(),
32usize,
concat!("Size of: ", stringify!(lxw_hash_element))
);
assert_eq!(
::std::mem::align_of::<lxw_hash_element>(),
8usize,
concat!("Alignment of ", stringify!(lxw_hash_element))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).key) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_hash_element),
"::",
stringify!(key)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_hash_element),
"::",
stringify!(value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).lxw_hash_order_pointers) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_hash_element),
"::",
stringify!(lxw_hash_order_pointers)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).lxw_hash_list_pointers) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_hash_element),
"::",
stringify!(lxw_hash_list_pointers)
)
);
}
extern "C" {
pub fn lxw_hash_key_exists(
lxw_hash: *mut lxw_hash_table,
key: *mut ::std::os::raw::c_void,
key_len: usize,
) -> *mut lxw_hash_element;
}
extern "C" {
pub fn lxw_insert_hash_element(
lxw_hash: *mut lxw_hash_table,
key: *mut ::std::os::raw::c_void,
value: *mut ::std::os::raw::c_void,
key_len: usize,
) -> *mut lxw_hash_element;
}
extern "C" {
pub fn lxw_hash_new(num_buckets: u32, free_key: u8, free_value: u8) -> *mut lxw_hash_table;
}
extern "C" {
pub fn lxw_hash_free(lxw_hash: *mut lxw_hash_table);
}
pub type lxw_color_t = u32;
pub const lxw_format_underlines_LXW_UNDERLINE_NONE: lxw_format_underlines = 0;
pub const lxw_format_underlines_LXW_UNDERLINE_SINGLE: lxw_format_underlines = 1;
pub const lxw_format_underlines_LXW_UNDERLINE_DOUBLE: lxw_format_underlines = 2;
pub const lxw_format_underlines_LXW_UNDERLINE_SINGLE_ACCOUNTING: lxw_format_underlines = 3;
pub const lxw_format_underlines_LXW_UNDERLINE_DOUBLE_ACCOUNTING: lxw_format_underlines = 4;
pub type lxw_format_underlines = ::std::os::raw::c_uint;
pub const lxw_format_scripts_LXW_FONT_SUPERSCRIPT: lxw_format_scripts = 1;
pub const lxw_format_scripts_LXW_FONT_SUBSCRIPT: lxw_format_scripts = 2;
pub type lxw_format_scripts = ::std::os::raw::c_uint;
pub const lxw_format_alignments_LXW_ALIGN_NONE: lxw_format_alignments = 0;
pub const lxw_format_alignments_LXW_ALIGN_LEFT: lxw_format_alignments = 1;
pub const lxw_format_alignments_LXW_ALIGN_CENTER: lxw_format_alignments = 2;
pub const lxw_format_alignments_LXW_ALIGN_RIGHT: lxw_format_alignments = 3;
pub const lxw_format_alignments_LXW_ALIGN_FILL: lxw_format_alignments = 4;
pub const lxw_format_alignments_LXW_ALIGN_JUSTIFY: lxw_format_alignments = 5;
pub const lxw_format_alignments_LXW_ALIGN_CENTER_ACROSS: lxw_format_alignments = 6;
pub const lxw_format_alignments_LXW_ALIGN_DISTRIBUTED: lxw_format_alignments = 7;
pub const lxw_format_alignments_LXW_ALIGN_VERTICAL_TOP: lxw_format_alignments = 8;
pub const lxw_format_alignments_LXW_ALIGN_VERTICAL_BOTTOM: lxw_format_alignments = 9;
pub const lxw_format_alignments_LXW_ALIGN_VERTICAL_CENTER: lxw_format_alignments = 10;
pub const lxw_format_alignments_LXW_ALIGN_VERTICAL_JUSTIFY: lxw_format_alignments = 11;
pub const lxw_format_alignments_LXW_ALIGN_VERTICAL_DISTRIBUTED: lxw_format_alignments = 12;
pub type lxw_format_alignments = ::std::os::raw::c_uint;
pub const lxw_format_diagonal_types_LXW_DIAGONAL_BORDER_UP: lxw_format_diagonal_types = 1;
pub const lxw_format_diagonal_types_LXW_DIAGONAL_BORDER_DOWN: lxw_format_diagonal_types = 2;
pub const lxw_format_diagonal_types_LXW_DIAGONAL_BORDER_UP_DOWN: lxw_format_diagonal_types = 3;
pub type lxw_format_diagonal_types = ::std::os::raw::c_uint;
pub const lxw_defined_colors_LXW_COLOR_BLACK: lxw_defined_colors = 16777216;
pub const lxw_defined_colors_LXW_COLOR_BLUE: lxw_defined_colors = 255;
pub const lxw_defined_colors_LXW_COLOR_BROWN: lxw_defined_colors = 8388608;
pub const lxw_defined_colors_LXW_COLOR_CYAN: lxw_defined_colors = 65535;
pub const lxw_defined_colors_LXW_COLOR_GRAY: lxw_defined_colors = 8421504;
pub const lxw_defined_colors_LXW_COLOR_GREEN: lxw_defined_colors = 32768;
pub const lxw_defined_colors_LXW_COLOR_LIME: lxw_defined_colors = 65280;
pub const lxw_defined_colors_LXW_COLOR_MAGENTA: lxw_defined_colors = 16711935;
pub const lxw_defined_colors_LXW_COLOR_NAVY: lxw_defined_colors = 128;
pub const lxw_defined_colors_LXW_COLOR_ORANGE: lxw_defined_colors = 16737792;
pub const lxw_defined_colors_LXW_COLOR_PINK: lxw_defined_colors = 16711935;
pub const lxw_defined_colors_LXW_COLOR_PURPLE: lxw_defined_colors = 8388736;
pub const lxw_defined_colors_LXW_COLOR_RED: lxw_defined_colors = 16711680;
pub const lxw_defined_colors_LXW_COLOR_SILVER: lxw_defined_colors = 12632256;
pub const lxw_defined_colors_LXW_COLOR_WHITE: lxw_defined_colors = 16777215;
pub const lxw_defined_colors_LXW_COLOR_YELLOW: lxw_defined_colors = 16776960;
pub type lxw_defined_colors = ::std::os::raw::c_uint;
pub const lxw_format_patterns_LXW_PATTERN_NONE: lxw_format_patterns = 0;
pub const lxw_format_patterns_LXW_PATTERN_SOLID: lxw_format_patterns = 1;
pub const lxw_format_patterns_LXW_PATTERN_MEDIUM_GRAY: lxw_format_patterns = 2;
pub const lxw_format_patterns_LXW_PATTERN_DARK_GRAY: lxw_format_patterns = 3;
pub const lxw_format_patterns_LXW_PATTERN_LIGHT_GRAY: lxw_format_patterns = 4;
pub const lxw_format_patterns_LXW_PATTERN_DARK_HORIZONTAL: lxw_format_patterns = 5;
pub const lxw_format_patterns_LXW_PATTERN_DARK_VERTICAL: lxw_format_patterns = 6;
pub const lxw_format_patterns_LXW_PATTERN_DARK_DOWN: lxw_format_patterns = 7;
pub const lxw_format_patterns_LXW_PATTERN_DARK_UP: lxw_format_patterns = 8;
pub const lxw_format_patterns_LXW_PATTERN_DARK_GRID: lxw_format_patterns = 9;
pub const lxw_format_patterns_LXW_PATTERN_DARK_TRELLIS: lxw_format_patterns = 10;
pub const lxw_format_patterns_LXW_PATTERN_LIGHT_HORIZONTAL: lxw_format_patterns = 11;
pub const lxw_format_patterns_LXW_PATTERN_LIGHT_VERTICAL: lxw_format_patterns = 12;
pub const lxw_format_patterns_LXW_PATTERN_LIGHT_DOWN: lxw_format_patterns = 13;
pub const lxw_format_patterns_LXW_PATTERN_LIGHT_UP: lxw_format_patterns = 14;
pub const lxw_format_patterns_LXW_PATTERN_LIGHT_GRID: lxw_format_patterns = 15;
pub const lxw_format_patterns_LXW_PATTERN_LIGHT_TRELLIS: lxw_format_patterns = 16;
pub const lxw_format_patterns_LXW_PATTERN_GRAY_125: lxw_format_patterns = 17;
pub const lxw_format_patterns_LXW_PATTERN_GRAY_0625: lxw_format_patterns = 18;
pub type lxw_format_patterns = ::std::os::raw::c_uint;
pub const lxw_format_borders_LXW_BORDER_NONE: lxw_format_borders = 0;
pub const lxw_format_borders_LXW_BORDER_THIN: lxw_format_borders = 1;
pub const lxw_format_borders_LXW_BORDER_MEDIUM: lxw_format_borders = 2;
pub const lxw_format_borders_LXW_BORDER_DASHED: lxw_format_borders = 3;
pub const lxw_format_borders_LXW_BORDER_DOTTED: lxw_format_borders = 4;
pub const lxw_format_borders_LXW_BORDER_THICK: lxw_format_borders = 5;
pub const lxw_format_borders_LXW_BORDER_DOUBLE: lxw_format_borders = 6;
pub const lxw_format_borders_LXW_BORDER_HAIR: lxw_format_borders = 7;
pub const lxw_format_borders_LXW_BORDER_MEDIUM_DASHED: lxw_format_borders = 8;
pub const lxw_format_borders_LXW_BORDER_DASH_DOT: lxw_format_borders = 9;
pub const lxw_format_borders_LXW_BORDER_MEDIUM_DASH_DOT: lxw_format_borders = 10;
pub const lxw_format_borders_LXW_BORDER_DASH_DOT_DOT: lxw_format_borders = 11;
pub const lxw_format_borders_LXW_BORDER_MEDIUM_DASH_DOT_DOT: lxw_format_borders = 12;
pub const lxw_format_borders_LXW_BORDER_SLANT_DASH_DOT: lxw_format_borders = 13;
pub type lxw_format_borders = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_format {
pub file: *mut FILE,
pub xf_format_indices: *mut lxw_hash_table,
pub dxf_format_indices: *mut lxw_hash_table,
pub num_xf_formats: *mut u16,
pub num_dxf_formats: *mut u16,
pub xf_index: i32,
pub dxf_index: i32,
pub xf_id: i32,
pub num_format: [::std::os::raw::c_char; 128usize],
pub font_name: [::std::os::raw::c_char; 128usize],
pub font_scheme: [::std::os::raw::c_char; 128usize],
pub num_format_index: u16,
pub font_index: u16,
pub has_font: u8,
pub has_dxf_font: u8,
pub font_size: f64,
pub bold: u8,
pub italic: u8,
pub font_color: lxw_color_t,
pub underline: u8,
pub font_strikeout: u8,
pub font_outline: u8,
pub font_shadow: u8,
pub font_script: u8,
pub font_family: u8,
pub font_charset: u8,
pub font_condense: u8,
pub font_extend: u8,
pub theme: u8,
pub hyperlink: u8,
pub hidden: u8,
pub locked: u8,
pub text_h_align: u8,
pub text_wrap: u8,
pub text_v_align: u8,
pub text_justlast: u8,
pub rotation: i16,
pub fg_color: lxw_color_t,
pub bg_color: lxw_color_t,
pub dxf_fg_color: lxw_color_t,
pub dxf_bg_color: lxw_color_t,
pub pattern: u8,
pub has_fill: u8,
pub has_dxf_fill: u8,
pub fill_index: i32,
pub fill_count: i32,
pub border_index: i32,
pub has_border: u8,
pub has_dxf_border: u8,
pub border_count: i32,
pub bottom: u8,
pub diag_border: u8,
pub diag_type: u8,
pub left: u8,
pub right: u8,
pub top: u8,
pub bottom_color: lxw_color_t,
pub diag_color: lxw_color_t,
pub left_color: lxw_color_t,
pub right_color: lxw_color_t,
pub top_color: lxw_color_t,
pub indent: u8,
pub shrink: u8,
pub merge_range: u8,
pub reading_order: u8,
pub just_distrib: u8,
pub color_indexed: u8,
pub font_only: u8,
pub list_pointers: lxw_format__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_format__bindgen_ty_1 {
pub stqe_next: *mut lxw_format,
}
#[test]
fn bindgen_test_layout_lxw_format__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<lxw_format__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_format__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(lxw_format__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<lxw_format__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(lxw_format__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqe_next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_format__bindgen_ty_1),
"::",
stringify!(stqe_next)
)
);
}
#[test]
fn bindgen_test_layout_lxw_format() {
const UNINIT: ::std::mem::MaybeUninit<lxw_format> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_format>(),
568usize,
concat!("Size of: ", stringify!(lxw_format))
);
assert_eq!(
::std::mem::align_of::<lxw_format>(),
8usize,
concat!("Alignment of ", stringify!(lxw_format))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).file) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(file)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xf_format_indices) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(xf_format_indices)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dxf_format_indices) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(dxf_format_indices)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).num_xf_formats) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(num_xf_formats)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).num_dxf_formats) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(num_dxf_formats)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xf_index) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(xf_index)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dxf_index) as usize - ptr as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(dxf_index)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xf_id) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(xf_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).num_format) as usize - ptr as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(num_format)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font_name) as usize - ptr as usize },
180usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(font_name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font_scheme) as usize - ptr as usize },
308usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(font_scheme)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).num_format_index) as usize - ptr as usize },
436usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(num_format_index)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font_index) as usize - ptr as usize },
438usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(font_index)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_font) as usize - ptr as usize },
440usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(has_font)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_dxf_font) as usize - ptr as usize },
441usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(has_dxf_font)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font_size) as usize - ptr as usize },
448usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(font_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bold) as usize - ptr as usize },
456usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(bold)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).italic) as usize - ptr as usize },
457usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(italic)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font_color) as usize - ptr as usize },
460usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(font_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).underline) as usize - ptr as usize },
464usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(underline)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font_strikeout) as usize - ptr as usize },
465usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(font_strikeout)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font_outline) as usize - ptr as usize },
466usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(font_outline)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font_shadow) as usize - ptr as usize },
467usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(font_shadow)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font_script) as usize - ptr as usize },
468usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(font_script)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font_family) as usize - ptr as usize },
469usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(font_family)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font_charset) as usize - ptr as usize },
470usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(font_charset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font_condense) as usize - ptr as usize },
471usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(font_condense)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font_extend) as usize - ptr as usize },
472usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(font_extend)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).theme) as usize - ptr as usize },
473usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(theme)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hyperlink) as usize - ptr as usize },
474usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(hyperlink)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hidden) as usize - ptr as usize },
475usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(hidden)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).locked) as usize - ptr as usize },
476usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(locked)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).text_h_align) as usize - ptr as usize },
477usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(text_h_align)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).text_wrap) as usize - ptr as usize },
478usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(text_wrap)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).text_v_align) as usize - ptr as usize },
479usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(text_v_align)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).text_justlast) as usize - ptr as usize },
480usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(text_justlast)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rotation) as usize - ptr as usize },
482usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(rotation)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fg_color) as usize - ptr as usize },
484usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(fg_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_color) as usize - ptr as usize },
488usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(bg_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dxf_fg_color) as usize - ptr as usize },
492usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(dxf_fg_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dxf_bg_color) as usize - ptr as usize },
496usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(dxf_bg_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pattern) as usize - ptr as usize },
500usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(pattern)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_fill) as usize - ptr as usize },
501usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(has_fill)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_dxf_fill) as usize - ptr as usize },
502usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(has_dxf_fill)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fill_index) as usize - ptr as usize },
504usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(fill_index)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fill_count) as usize - ptr as usize },
508usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(fill_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).border_index) as usize - ptr as usize },
512usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(border_index)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_border) as usize - ptr as usize },
516usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(has_border)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_dxf_border) as usize - ptr as usize },
517usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(has_dxf_border)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).border_count) as usize - ptr as usize },
520usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(border_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bottom) as usize - ptr as usize },
524usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(bottom)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).diag_border) as usize - ptr as usize },
525usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(diag_border)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).diag_type) as usize - ptr as usize },
526usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(diag_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).left) as usize - ptr as usize },
527usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(left)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).right) as usize - ptr as usize },
528usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(right)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).top) as usize - ptr as usize },
529usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(top)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bottom_color) as usize - ptr as usize },
532usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(bottom_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).diag_color) as usize - ptr as usize },
536usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(diag_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).left_color) as usize - ptr as usize },
540usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(left_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).right_color) as usize - ptr as usize },
544usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(right_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).top_color) as usize - ptr as usize },
548usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(top_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).indent) as usize - ptr as usize },
552usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(indent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).shrink) as usize - ptr as usize },
553usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(shrink)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).merge_range) as usize - ptr as usize },
554usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(merge_range)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).reading_order) as usize - ptr as usize },
555usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(reading_order)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).just_distrib) as usize - ptr as usize },
556usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(just_distrib)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).color_indexed) as usize - ptr as usize },
557usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(color_indexed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font_only) as usize - ptr as usize },
558usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(font_only)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).list_pointers) as usize - ptr as usize },
560usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(list_pointers)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_font {
pub font_name: [::std::os::raw::c_char; 128usize],
pub font_size: f64,
pub bold: u8,
pub italic: u8,
pub underline: u8,
pub theme: u8,
pub font_strikeout: u8,
pub font_outline: u8,
pub font_shadow: u8,
pub font_script: u8,
pub font_family: u8,
pub font_charset: u8,
pub font_condense: u8,
pub font_extend: u8,
pub font_color: lxw_color_t,
}
#[test]
fn bindgen_test_layout_lxw_font() {
const UNINIT: ::std::mem::MaybeUninit<lxw_font> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_font>(),
152usize,
concat!("Size of: ", stringify!(lxw_font))
);
assert_eq!(
::std::mem::align_of::<lxw_font>(),
8usize,
concat!("Alignment of ", stringify!(lxw_font))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font_name) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_font),
"::",
stringify!(font_name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font_size) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(lxw_font),
"::",
stringify!(font_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bold) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(lxw_font),
"::",
stringify!(bold)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).italic) as usize - ptr as usize },
137usize,
concat!(
"Offset of field: ",
stringify!(lxw_font),
"::",
stringify!(italic)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).underline) as usize - ptr as usize },
138usize,
concat!(
"Offset of field: ",
stringify!(lxw_font),
"::",
stringify!(underline)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).theme) as usize - ptr as usize },
139usize,
concat!(
"Offset of field: ",
stringify!(lxw_font),
"::",
stringify!(theme)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font_strikeout) as usize - ptr as usize },
140usize,
concat!(
"Offset of field: ",
stringify!(lxw_font),
"::",
stringify!(font_strikeout)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font_outline) as usize - ptr as usize },
141usize,
concat!(
"Offset of field: ",
stringify!(lxw_font),
"::",
stringify!(font_outline)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font_shadow) as usize - ptr as usize },
142usize,
concat!(
"Offset of field: ",
stringify!(lxw_font),
"::",
stringify!(font_shadow)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font_script) as usize - ptr as usize },
143usize,
concat!(
"Offset of field: ",
stringify!(lxw_font),
"::",
stringify!(font_script)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font_family) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(lxw_font),
"::",
stringify!(font_family)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font_charset) as usize - ptr as usize },
145usize,
concat!(
"Offset of field: ",
stringify!(lxw_font),
"::",
stringify!(font_charset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font_condense) as usize - ptr as usize },
146usize,
concat!(
"Offset of field: ",
stringify!(lxw_font),
"::",
stringify!(font_condense)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font_extend) as usize - ptr as usize },
147usize,
concat!(
"Offset of field: ",
stringify!(lxw_font),
"::",
stringify!(font_extend)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font_color) as usize - ptr as usize },
148usize,
concat!(
"Offset of field: ",
stringify!(lxw_font),
"::",
stringify!(font_color)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_border {
pub bottom: u8,
pub diag_border: u8,
pub diag_type: u8,
pub left: u8,
pub right: u8,
pub top: u8,
pub bottom_color: lxw_color_t,
pub diag_color: lxw_color_t,
pub left_color: lxw_color_t,
pub right_color: lxw_color_t,
pub top_color: lxw_color_t,
}
#[test]
fn bindgen_test_layout_lxw_border() {
const UNINIT: ::std::mem::MaybeUninit<lxw_border> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_border>(),
28usize,
concat!("Size of: ", stringify!(lxw_border))
);
assert_eq!(
::std::mem::align_of::<lxw_border>(),
4usize,
concat!("Alignment of ", stringify!(lxw_border))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bottom) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_border),
"::",
stringify!(bottom)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).diag_border) as usize - ptr as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(lxw_border),
"::",
stringify!(diag_border)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).diag_type) as usize - ptr as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(lxw_border),
"::",
stringify!(diag_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).left) as usize - ptr as usize },
3usize,
concat!(
"Offset of field: ",
stringify!(lxw_border),
"::",
stringify!(left)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).right) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_border),
"::",
stringify!(right)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).top) as usize - ptr as usize },
5usize,
concat!(
"Offset of field: ",
stringify!(lxw_border),
"::",
stringify!(top)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bottom_color) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_border),
"::",
stringify!(bottom_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).diag_color) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(lxw_border),
"::",
stringify!(diag_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).left_color) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_border),
"::",
stringify!(left_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).right_color) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(lxw_border),
"::",
stringify!(right_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).top_color) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_border),
"::",
stringify!(top_color)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_fill {
pub fg_color: lxw_color_t,
pub bg_color: lxw_color_t,
pub pattern: u8,
}
#[test]
fn bindgen_test_layout_lxw_fill() {
const UNINIT: ::std::mem::MaybeUninit<lxw_fill> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_fill>(),
12usize,
concat!("Size of: ", stringify!(lxw_fill))
);
assert_eq!(
::std::mem::align_of::<lxw_fill>(),
4usize,
concat!("Alignment of ", stringify!(lxw_fill))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fg_color) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_fill),
"::",
stringify!(fg_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_color) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_fill),
"::",
stringify!(bg_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pattern) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_fill),
"::",
stringify!(pattern)
)
);
}
extern "C" {
pub fn lxw_format_new() -> *mut lxw_format;
}
extern "C" {
pub fn lxw_format_free(format: *mut lxw_format);
}
extern "C" {
pub fn lxw_format_get_xf_index(format: *mut lxw_format) -> i32;
}
extern "C" {
pub fn lxw_format_get_dxf_index(format: *mut lxw_format) -> i32;
}
extern "C" {
pub fn lxw_format_get_font_key(format: *mut lxw_format) -> *mut lxw_font;
}
extern "C" {
pub fn lxw_format_get_border_key(format: *mut lxw_format) -> *mut lxw_border;
}
extern "C" {
pub fn lxw_format_get_fill_key(format: *mut lxw_format) -> *mut lxw_fill;
}
extern "C" {
pub fn format_set_font_name(format: *mut lxw_format, font_name: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn format_set_font_size(format: *mut lxw_format, size: f64);
}
extern "C" {
pub fn format_set_font_color(format: *mut lxw_format, color: lxw_color_t);
}
extern "C" {
pub fn format_set_bold(format: *mut lxw_format);
}
extern "C" {
pub fn format_set_italic(format: *mut lxw_format);
}
extern "C" {
pub fn format_set_underline(format: *mut lxw_format, style: u8);
}
extern "C" {
pub fn format_set_font_strikeout(format: *mut lxw_format);
}
extern "C" {
pub fn format_set_font_script(format: *mut lxw_format, style: u8);
}
extern "C" {
pub fn format_set_num_format(
format: *mut lxw_format,
num_format: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn format_set_num_format_index(format: *mut lxw_format, index: u8);
}
extern "C" {
pub fn format_set_unlocked(format: *mut lxw_format);
}
extern "C" {
pub fn format_set_hidden(format: *mut lxw_format);
}
extern "C" {
pub fn format_set_align(format: *mut lxw_format, alignment: u8);
}
extern "C" {
pub fn format_set_text_wrap(format: *mut lxw_format);
}
extern "C" {
pub fn format_set_rotation(format: *mut lxw_format, angle: i16);
}
extern "C" {
pub fn format_set_indent(format: *mut lxw_format, level: u8);
}
extern "C" {
pub fn format_set_shrink(format: *mut lxw_format);
}
extern "C" {
pub fn format_set_pattern(format: *mut lxw_format, index: u8);
}
extern "C" {
pub fn format_set_bg_color(format: *mut lxw_format, color: lxw_color_t);
}
extern "C" {
pub fn format_set_fg_color(format: *mut lxw_format, color: lxw_color_t);
}
extern "C" {
pub fn format_set_border(format: *mut lxw_format, style: u8);
}
extern "C" {
pub fn format_set_bottom(format: *mut lxw_format, style: u8);
}
extern "C" {
pub fn format_set_top(format: *mut lxw_format, style: u8);
}
extern "C" {
pub fn format_set_left(format: *mut lxw_format, style: u8);
}
extern "C" {
pub fn format_set_right(format: *mut lxw_format, style: u8);
}
extern "C" {
pub fn format_set_border_color(format: *mut lxw_format, color: lxw_color_t);
}
extern "C" {
pub fn format_set_bottom_color(format: *mut lxw_format, color: lxw_color_t);
}
extern "C" {
pub fn format_set_top_color(format: *mut lxw_format, color: lxw_color_t);
}
extern "C" {
pub fn format_set_left_color(format: *mut lxw_format, color: lxw_color_t);
}
extern "C" {
pub fn format_set_right_color(format: *mut lxw_format, color: lxw_color_t);
}
extern "C" {
pub fn format_set_diag_type(format: *mut lxw_format, type_: u8);
}
extern "C" {
pub fn format_set_diag_border(format: *mut lxw_format, style: u8);
}
extern "C" {
pub fn format_set_diag_color(format: *mut lxw_format, color: lxw_color_t);
}
extern "C" {
pub fn format_set_font_outline(format: *mut lxw_format);
}
extern "C" {
pub fn format_set_font_shadow(format: *mut lxw_format);
}
extern "C" {
pub fn format_set_font_family(format: *mut lxw_format, value: u8);
}
extern "C" {
pub fn format_set_font_charset(format: *mut lxw_format, value: u8);
}
extern "C" {
pub fn format_set_font_scheme(
format: *mut lxw_format,
font_scheme: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn format_set_font_condense(format: *mut lxw_format);
}
extern "C" {
pub fn format_set_font_extend(format: *mut lxw_format);
}
extern "C" {
pub fn format_set_reading_order(format: *mut lxw_format, value: u8);
}
extern "C" {
pub fn format_set_theme(format: *mut lxw_format, value: u8);
}
extern "C" {
pub fn format_set_hyperlink(format: *mut lxw_format);
}
extern "C" {
pub fn format_set_color_indexed(format: *mut lxw_format, value: u8);
}
extern "C" {
pub fn format_set_font_only(format: *mut lxw_format);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_chart_series_list {
pub stqh_first: *mut lxw_chart_series,
pub stqh_last: *mut *mut lxw_chart_series,
}
#[test]
fn bindgen_test_layout_lxw_chart_series_list() {
const UNINIT: ::std::mem::MaybeUninit<lxw_chart_series_list> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_chart_series_list>(),
16usize,
concat!("Size of: ", stringify!(lxw_chart_series_list))
);
assert_eq!(
::std::mem::align_of::<lxw_chart_series_list>(),
8usize,
concat!("Alignment of ", stringify!(lxw_chart_series_list))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_first) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series_list),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_last) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series_list),
"::",
stringify!(stqh_last)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_series_data_points {
pub stqh_first: *mut lxw_series_data_point,
pub stqh_last: *mut *mut lxw_series_data_point,
}
#[test]
fn bindgen_test_layout_lxw_series_data_points() {
const UNINIT: ::std::mem::MaybeUninit<lxw_series_data_points> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_series_data_points>(),
16usize,
concat!("Size of: ", stringify!(lxw_series_data_points))
);
assert_eq!(
::std::mem::align_of::<lxw_series_data_points>(),
8usize,
concat!("Alignment of ", stringify!(lxw_series_data_points))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_first) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_data_points),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_last) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_data_points),
"::",
stringify!(stqh_last)
)
);
}
pub const lxw_chart_type_LXW_CHART_NONE: lxw_chart_type = 0;
pub const lxw_chart_type_LXW_CHART_AREA: lxw_chart_type = 1;
pub const lxw_chart_type_LXW_CHART_AREA_STACKED: lxw_chart_type = 2;
pub const lxw_chart_type_LXW_CHART_AREA_STACKED_PERCENT: lxw_chart_type = 3;
pub const lxw_chart_type_LXW_CHART_BAR: lxw_chart_type = 4;
pub const lxw_chart_type_LXW_CHART_BAR_STACKED: lxw_chart_type = 5;
pub const lxw_chart_type_LXW_CHART_BAR_STACKED_PERCENT: lxw_chart_type = 6;
pub const lxw_chart_type_LXW_CHART_COLUMN: lxw_chart_type = 7;
pub const lxw_chart_type_LXW_CHART_COLUMN_STACKED: lxw_chart_type = 8;
pub const lxw_chart_type_LXW_CHART_COLUMN_STACKED_PERCENT: lxw_chart_type = 9;
pub const lxw_chart_type_LXW_CHART_DOUGHNUT: lxw_chart_type = 10;
pub const lxw_chart_type_LXW_CHART_LINE: lxw_chart_type = 11;
pub const lxw_chart_type_LXW_CHART_LINE_STACKED: lxw_chart_type = 12;
pub const lxw_chart_type_LXW_CHART_LINE_STACKED_PERCENT: lxw_chart_type = 13;
pub const lxw_chart_type_LXW_CHART_PIE: lxw_chart_type = 14;
pub const lxw_chart_type_LXW_CHART_SCATTER: lxw_chart_type = 15;
pub const lxw_chart_type_LXW_CHART_SCATTER_STRAIGHT: lxw_chart_type = 16;
pub const lxw_chart_type_LXW_CHART_SCATTER_STRAIGHT_WITH_MARKERS: lxw_chart_type = 17;
pub const lxw_chart_type_LXW_CHART_SCATTER_SMOOTH: lxw_chart_type = 18;
pub const lxw_chart_type_LXW_CHART_SCATTER_SMOOTH_WITH_MARKERS: lxw_chart_type = 19;
pub const lxw_chart_type_LXW_CHART_RADAR: lxw_chart_type = 20;
pub const lxw_chart_type_LXW_CHART_RADAR_WITH_MARKERS: lxw_chart_type = 21;
pub const lxw_chart_type_LXW_CHART_RADAR_FILLED: lxw_chart_type = 22;
pub type lxw_chart_type = ::std::os::raw::c_uint;
pub const lxw_chart_legend_position_LXW_CHART_LEGEND_NONE: lxw_chart_legend_position = 0;
pub const lxw_chart_legend_position_LXW_CHART_LEGEND_RIGHT: lxw_chart_legend_position = 1;
pub const lxw_chart_legend_position_LXW_CHART_LEGEND_LEFT: lxw_chart_legend_position = 2;
pub const lxw_chart_legend_position_LXW_CHART_LEGEND_TOP: lxw_chart_legend_position = 3;
pub const lxw_chart_legend_position_LXW_CHART_LEGEND_BOTTOM: lxw_chart_legend_position = 4;
pub const lxw_chart_legend_position_LXW_CHART_LEGEND_TOP_RIGHT: lxw_chart_legend_position = 5;
pub const lxw_chart_legend_position_LXW_CHART_LEGEND_OVERLAY_RIGHT: lxw_chart_legend_position = 6;
pub const lxw_chart_legend_position_LXW_CHART_LEGEND_OVERLAY_LEFT: lxw_chart_legend_position = 7;
pub const lxw_chart_legend_position_LXW_CHART_LEGEND_OVERLAY_TOP_RIGHT: lxw_chart_legend_position =
8;
pub type lxw_chart_legend_position = ::std::os::raw::c_uint;
pub const lxw_chart_line_dash_type_LXW_CHART_LINE_DASH_SOLID: lxw_chart_line_dash_type = 0;
pub const lxw_chart_line_dash_type_LXW_CHART_LINE_DASH_ROUND_DOT: lxw_chart_line_dash_type = 1;
pub const lxw_chart_line_dash_type_LXW_CHART_LINE_DASH_SQUARE_DOT: lxw_chart_line_dash_type = 2;
pub const lxw_chart_line_dash_type_LXW_CHART_LINE_DASH_DASH: lxw_chart_line_dash_type = 3;
pub const lxw_chart_line_dash_type_LXW_CHART_LINE_DASH_DASH_DOT: lxw_chart_line_dash_type = 4;
pub const lxw_chart_line_dash_type_LXW_CHART_LINE_DASH_LONG_DASH: lxw_chart_line_dash_type = 5;
pub const lxw_chart_line_dash_type_LXW_CHART_LINE_DASH_LONG_DASH_DOT: lxw_chart_line_dash_type = 6;
pub const lxw_chart_line_dash_type_LXW_CHART_LINE_DASH_LONG_DASH_DOT_DOT: lxw_chart_line_dash_type =
7;
pub const lxw_chart_line_dash_type_LXW_CHART_LINE_DASH_DOT: lxw_chart_line_dash_type = 8;
pub const lxw_chart_line_dash_type_LXW_CHART_LINE_DASH_SYSTEM_DASH_DOT: lxw_chart_line_dash_type =
9;
pub const lxw_chart_line_dash_type_LXW_CHART_LINE_DASH_SYSTEM_DASH_DOT_DOT:
lxw_chart_line_dash_type = 10;
pub type lxw_chart_line_dash_type = ::std::os::raw::c_uint;
pub const lxw_chart_marker_type_LXW_CHART_MARKER_AUTOMATIC: lxw_chart_marker_type = 0;
pub const lxw_chart_marker_type_LXW_CHART_MARKER_NONE: lxw_chart_marker_type = 1;
pub const lxw_chart_marker_type_LXW_CHART_MARKER_SQUARE: lxw_chart_marker_type = 2;
pub const lxw_chart_marker_type_LXW_CHART_MARKER_DIAMOND: lxw_chart_marker_type = 3;
pub const lxw_chart_marker_type_LXW_CHART_MARKER_TRIANGLE: lxw_chart_marker_type = 4;
pub const lxw_chart_marker_type_LXW_CHART_MARKER_X: lxw_chart_marker_type = 5;
pub const lxw_chart_marker_type_LXW_CHART_MARKER_STAR: lxw_chart_marker_type = 6;
pub const lxw_chart_marker_type_LXW_CHART_MARKER_SHORT_DASH: lxw_chart_marker_type = 7;
pub const lxw_chart_marker_type_LXW_CHART_MARKER_LONG_DASH: lxw_chart_marker_type = 8;
pub const lxw_chart_marker_type_LXW_CHART_MARKER_CIRCLE: lxw_chart_marker_type = 9;
pub const lxw_chart_marker_type_LXW_CHART_MARKER_PLUS: lxw_chart_marker_type = 10;
pub type lxw_chart_marker_type = ::std::os::raw::c_uint;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_NONE: lxw_chart_pattern_type = 0;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_PERCENT_5: lxw_chart_pattern_type = 1;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_PERCENT_10: lxw_chart_pattern_type = 2;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_PERCENT_20: lxw_chart_pattern_type = 3;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_PERCENT_25: lxw_chart_pattern_type = 4;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_PERCENT_30: lxw_chart_pattern_type = 5;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_PERCENT_40: lxw_chart_pattern_type = 6;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_PERCENT_50: lxw_chart_pattern_type = 7;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_PERCENT_60: lxw_chart_pattern_type = 8;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_PERCENT_70: lxw_chart_pattern_type = 9;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_PERCENT_75: lxw_chart_pattern_type = 10;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_PERCENT_80: lxw_chart_pattern_type = 11;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_PERCENT_90: lxw_chart_pattern_type = 12;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_LIGHT_DOWNWARD_DIAGONAL: lxw_chart_pattern_type =
13;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_LIGHT_UPWARD_DIAGONAL: lxw_chart_pattern_type =
14;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_DARK_DOWNWARD_DIAGONAL: lxw_chart_pattern_type =
15;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_DARK_UPWARD_DIAGONAL: lxw_chart_pattern_type =
16;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_WIDE_DOWNWARD_DIAGONAL: lxw_chart_pattern_type =
17;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_WIDE_UPWARD_DIAGONAL: lxw_chart_pattern_type =
18;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_LIGHT_VERTICAL: lxw_chart_pattern_type = 19;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_LIGHT_HORIZONTAL: lxw_chart_pattern_type = 20;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_NARROW_VERTICAL: lxw_chart_pattern_type = 21;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_NARROW_HORIZONTAL: lxw_chart_pattern_type = 22;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_DARK_VERTICAL: lxw_chart_pattern_type = 23;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_DARK_HORIZONTAL: lxw_chart_pattern_type = 24;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_DASHED_DOWNWARD_DIAGONAL:
lxw_chart_pattern_type = 25;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_DASHED_UPWARD_DIAGONAL: lxw_chart_pattern_type =
26;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_DASHED_HORIZONTAL: lxw_chart_pattern_type = 27;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_DASHED_VERTICAL: lxw_chart_pattern_type = 28;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_SMALL_CONFETTI: lxw_chart_pattern_type = 29;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_LARGE_CONFETTI: lxw_chart_pattern_type = 30;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_ZIGZAG: lxw_chart_pattern_type = 31;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_WAVE: lxw_chart_pattern_type = 32;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_DIAGONAL_BRICK: lxw_chart_pattern_type = 33;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_HORIZONTAL_BRICK: lxw_chart_pattern_type = 34;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_WEAVE: lxw_chart_pattern_type = 35;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_PLAID: lxw_chart_pattern_type = 36;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_DIVOT: lxw_chart_pattern_type = 37;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_DOTTED_GRID: lxw_chart_pattern_type = 38;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_DOTTED_DIAMOND: lxw_chart_pattern_type = 39;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_SHINGLE: lxw_chart_pattern_type = 40;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_TRELLIS: lxw_chart_pattern_type = 41;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_SPHERE: lxw_chart_pattern_type = 42;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_SMALL_GRID: lxw_chart_pattern_type = 43;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_LARGE_GRID: lxw_chart_pattern_type = 44;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_SMALL_CHECK: lxw_chart_pattern_type = 45;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_LARGE_CHECK: lxw_chart_pattern_type = 46;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_OUTLINED_DIAMOND: lxw_chart_pattern_type = 47;
pub const lxw_chart_pattern_type_LXW_CHART_PATTERN_SOLID_DIAMOND: lxw_chart_pattern_type = 48;
pub type lxw_chart_pattern_type = ::std::os::raw::c_uint;
pub const lxw_chart_label_position_LXW_CHART_LABEL_POSITION_DEFAULT: lxw_chart_label_position = 0;
pub const lxw_chart_label_position_LXW_CHART_LABEL_POSITION_CENTER: lxw_chart_label_position = 1;
pub const lxw_chart_label_position_LXW_CHART_LABEL_POSITION_RIGHT: lxw_chart_label_position = 2;
pub const lxw_chart_label_position_LXW_CHART_LABEL_POSITION_LEFT: lxw_chart_label_position = 3;
pub const lxw_chart_label_position_LXW_CHART_LABEL_POSITION_ABOVE: lxw_chart_label_position = 4;
pub const lxw_chart_label_position_LXW_CHART_LABEL_POSITION_BELOW: lxw_chart_label_position = 5;
pub const lxw_chart_label_position_LXW_CHART_LABEL_POSITION_INSIDE_BASE: lxw_chart_label_position =
6;
pub const lxw_chart_label_position_LXW_CHART_LABEL_POSITION_INSIDE_END: lxw_chart_label_position =
7;
pub const lxw_chart_label_position_LXW_CHART_LABEL_POSITION_OUTSIDE_END: lxw_chart_label_position =
8;
pub const lxw_chart_label_position_LXW_CHART_LABEL_POSITION_BEST_FIT: lxw_chart_label_position = 9;
pub type lxw_chart_label_position = ::std::os::raw::c_uint;
pub const lxw_chart_label_separator_LXW_CHART_LABEL_SEPARATOR_COMMA: lxw_chart_label_separator = 0;
pub const lxw_chart_label_separator_LXW_CHART_LABEL_SEPARATOR_SEMICOLON: lxw_chart_label_separator =
1;
pub const lxw_chart_label_separator_LXW_CHART_LABEL_SEPARATOR_PERIOD: lxw_chart_label_separator = 2;
pub const lxw_chart_label_separator_LXW_CHART_LABEL_SEPARATOR_NEWLINE: lxw_chart_label_separator =
3;
pub const lxw_chart_label_separator_LXW_CHART_LABEL_SEPARATOR_SPACE: lxw_chart_label_separator = 4;
pub type lxw_chart_label_separator = ::std::os::raw::c_uint;
pub const lxw_chart_axis_type_LXW_CHART_AXIS_TYPE_X: lxw_chart_axis_type = 0;
pub const lxw_chart_axis_type_LXW_CHART_AXIS_TYPE_Y: lxw_chart_axis_type = 1;
pub type lxw_chart_axis_type = ::std::os::raw::c_uint;
pub const lxw_chart_subtype_LXW_CHART_SUBTYPE_NONE: lxw_chart_subtype = 0;
pub const lxw_chart_subtype_LXW_CHART_SUBTYPE_STACKED: lxw_chart_subtype = 1;
pub const lxw_chart_subtype_LXW_CHART_SUBTYPE_STACKED_PERCENT: lxw_chart_subtype = 2;
pub type lxw_chart_subtype = ::std::os::raw::c_uint;
pub const lxw_chart_grouping_LXW_GROUPING_CLUSTERED: lxw_chart_grouping = 0;
pub const lxw_chart_grouping_LXW_GROUPING_STANDARD: lxw_chart_grouping = 1;
pub const lxw_chart_grouping_LXW_GROUPING_PERCENTSTACKED: lxw_chart_grouping = 2;
pub const lxw_chart_grouping_LXW_GROUPING_STACKED: lxw_chart_grouping = 3;
pub type lxw_chart_grouping = ::std::os::raw::c_uint;
pub const lxw_chart_axis_tick_position_LXW_CHART_AXIS_POSITION_DEFAULT:
lxw_chart_axis_tick_position = 0;
pub const lxw_chart_axis_tick_position_LXW_CHART_AXIS_POSITION_ON_TICK:
lxw_chart_axis_tick_position = 1;
pub const lxw_chart_axis_tick_position_LXW_CHART_AXIS_POSITION_BETWEEN:
lxw_chart_axis_tick_position = 2;
pub type lxw_chart_axis_tick_position = ::std::os::raw::c_uint;
pub const lxw_chart_axis_label_position_LXW_CHART_AXIS_LABEL_POSITION_NEXT_TO:
lxw_chart_axis_label_position = 0;
pub const lxw_chart_axis_label_position_LXW_CHART_AXIS_LABEL_POSITION_HIGH:
lxw_chart_axis_label_position = 1;
pub const lxw_chart_axis_label_position_LXW_CHART_AXIS_LABEL_POSITION_LOW:
lxw_chart_axis_label_position = 2;
pub const lxw_chart_axis_label_position_LXW_CHART_AXIS_LABEL_POSITION_NONE:
lxw_chart_axis_label_position = 3;
pub type lxw_chart_axis_label_position = ::std::os::raw::c_uint;
pub const lxw_chart_axis_label_alignment_LXW_CHART_AXIS_LABEL_ALIGN_CENTER:
lxw_chart_axis_label_alignment = 0;
pub const lxw_chart_axis_label_alignment_LXW_CHART_AXIS_LABEL_ALIGN_LEFT:
lxw_chart_axis_label_alignment = 1;
pub const lxw_chart_axis_label_alignment_LXW_CHART_AXIS_LABEL_ALIGN_RIGHT:
lxw_chart_axis_label_alignment = 2;
pub type lxw_chart_axis_label_alignment = ::std::os::raw::c_uint;
pub const lxw_chart_axis_display_unit_LXW_CHART_AXIS_UNITS_NONE: lxw_chart_axis_display_unit = 0;
pub const lxw_chart_axis_display_unit_LXW_CHART_AXIS_UNITS_HUNDREDS: lxw_chart_axis_display_unit =
1;
pub const lxw_chart_axis_display_unit_LXW_CHART_AXIS_UNITS_THOUSANDS: lxw_chart_axis_display_unit =
2;
pub const lxw_chart_axis_display_unit_LXW_CHART_AXIS_UNITS_TEN_THOUSANDS:
lxw_chart_axis_display_unit = 3;
pub const lxw_chart_axis_display_unit_LXW_CHART_AXIS_UNITS_HUNDRED_THOUSANDS:
lxw_chart_axis_display_unit = 4;
pub const lxw_chart_axis_display_unit_LXW_CHART_AXIS_UNITS_MILLIONS: lxw_chart_axis_display_unit =
5;
pub const lxw_chart_axis_display_unit_LXW_CHART_AXIS_UNITS_TEN_MILLIONS:
lxw_chart_axis_display_unit = 6;
pub const lxw_chart_axis_display_unit_LXW_CHART_AXIS_UNITS_HUNDRED_MILLIONS:
lxw_chart_axis_display_unit = 7;
pub const lxw_chart_axis_display_unit_LXW_CHART_AXIS_UNITS_BILLIONS: lxw_chart_axis_display_unit =
8;
pub const lxw_chart_axis_display_unit_LXW_CHART_AXIS_UNITS_TRILLIONS: lxw_chart_axis_display_unit =
9;
pub type lxw_chart_axis_display_unit = ::std::os::raw::c_uint;
pub const lxw_chart_axis_tick_mark_LXW_CHART_AXIS_TICK_MARK_DEFAULT: lxw_chart_axis_tick_mark = 0;
pub const lxw_chart_axis_tick_mark_LXW_CHART_AXIS_TICK_MARK_NONE: lxw_chart_axis_tick_mark = 1;
pub const lxw_chart_axis_tick_mark_LXW_CHART_AXIS_TICK_MARK_INSIDE: lxw_chart_axis_tick_mark = 2;
pub const lxw_chart_axis_tick_mark_LXW_CHART_AXIS_TICK_MARK_OUTSIDE: lxw_chart_axis_tick_mark = 3;
pub const lxw_chart_axis_tick_mark_LXW_CHART_AXIS_TICK_MARK_CROSSING: lxw_chart_axis_tick_mark = 4;
pub type lxw_chart_axis_tick_mark = ::std::os::raw::c_uint;
pub use self::lxw_chart_axis_tick_mark as lxw_chart_tick_mark;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_series_range {
pub formula: *mut ::std::os::raw::c_char,
pub sheetname: *mut ::std::os::raw::c_char,
pub first_row: lxw_row_t,
pub last_row: lxw_row_t,
pub first_col: lxw_col_t,
pub last_col: lxw_col_t,
pub ignore_cache: u8,
pub has_string_cache: u8,
pub num_data_points: u16,
pub data_cache: *mut lxw_series_data_points,
}
#[test]
fn bindgen_test_layout_lxw_series_range() {
const UNINIT: ::std::mem::MaybeUninit<lxw_series_range> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_series_range>(),
40usize,
concat!("Size of: ", stringify!(lxw_series_range))
);
assert_eq!(
::std::mem::align_of::<lxw_series_range>(),
8usize,
concat!("Alignment of ", stringify!(lxw_series_range))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).formula) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_range),
"::",
stringify!(formula)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sheetname) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_range),
"::",
stringify!(sheetname)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).first_row) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_range),
"::",
stringify!(first_row)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).last_row) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_range),
"::",
stringify!(last_row)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).first_col) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_range),
"::",
stringify!(first_col)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).last_col) as usize - ptr as usize },
26usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_range),
"::",
stringify!(last_col)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ignore_cache) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_range),
"::",
stringify!(ignore_cache)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_string_cache) as usize - ptr as usize },
29usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_range),
"::",
stringify!(has_string_cache)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).num_data_points) as usize - ptr as usize },
30usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_range),
"::",
stringify!(num_data_points)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data_cache) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_range),
"::",
stringify!(data_cache)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_series_data_point {
pub is_string: u8,
pub number: f64,
pub string: *mut ::std::os::raw::c_char,
pub no_data: u8,
pub list_pointers: lxw_series_data_point__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_series_data_point__bindgen_ty_1 {
pub stqe_next: *mut lxw_series_data_point,
}
#[test]
fn bindgen_test_layout_lxw_series_data_point__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<lxw_series_data_point__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_series_data_point__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(lxw_series_data_point__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<lxw_series_data_point__bindgen_ty_1>(),
8usize,
concat!(
"Alignment of ",
stringify!(lxw_series_data_point__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqe_next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_data_point__bindgen_ty_1),
"::",
stringify!(stqe_next)
)
);
}
#[test]
fn bindgen_test_layout_lxw_series_data_point() {
const UNINIT: ::std::mem::MaybeUninit<lxw_series_data_point> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_series_data_point>(),
40usize,
concat!("Size of: ", stringify!(lxw_series_data_point))
);
assert_eq!(
::std::mem::align_of::<lxw_series_data_point>(),
8usize,
concat!("Alignment of ", stringify!(lxw_series_data_point))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).is_string) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_data_point),
"::",
stringify!(is_string)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).number) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_data_point),
"::",
stringify!(number)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).string) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_data_point),
"::",
stringify!(string)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).no_data) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_data_point),
"::",
stringify!(no_data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).list_pointers) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_data_point),
"::",
stringify!(list_pointers)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_chart_line {
pub color: lxw_color_t,
pub none: u8,
pub width: f32,
pub dash_type: u8,
pub transparency: u8,
}
#[test]
fn bindgen_test_layout_lxw_chart_line() {
const UNINIT: ::std::mem::MaybeUninit<lxw_chart_line> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_chart_line>(),
16usize,
concat!("Size of: ", stringify!(lxw_chart_line))
);
assert_eq!(
::std::mem::align_of::<lxw_chart_line>(),
4usize,
concat!("Alignment of ", stringify!(lxw_chart_line))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).color) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_line),
"::",
stringify!(color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).none) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_line),
"::",
stringify!(none)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_line),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dash_type) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_line),
"::",
stringify!(dash_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).transparency) as usize - ptr as usize },
13usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_line),
"::",
stringify!(transparency)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_chart_fill {
pub color: lxw_color_t,
pub none: u8,
pub transparency: u8,
}
#[test]
fn bindgen_test_layout_lxw_chart_fill() {
const UNINIT: ::std::mem::MaybeUninit<lxw_chart_fill> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_chart_fill>(),
8usize,
concat!("Size of: ", stringify!(lxw_chart_fill))
);
assert_eq!(
::std::mem::align_of::<lxw_chart_fill>(),
4usize,
concat!("Alignment of ", stringify!(lxw_chart_fill))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).color) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_fill),
"::",
stringify!(color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).none) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_fill),
"::",
stringify!(none)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).transparency) as usize - ptr as usize },
5usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_fill),
"::",
stringify!(transparency)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_chart_pattern {
pub fg_color: lxw_color_t,
pub bg_color: lxw_color_t,
pub type_: u8,
}
#[test]
fn bindgen_test_layout_lxw_chart_pattern() {
const UNINIT: ::std::mem::MaybeUninit<lxw_chart_pattern> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_chart_pattern>(),
12usize,
concat!("Size of: ", stringify!(lxw_chart_pattern))
);
assert_eq!(
::std::mem::align_of::<lxw_chart_pattern>(),
4usize,
concat!("Alignment of ", stringify!(lxw_chart_pattern))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fg_color) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_pattern),
"::",
stringify!(fg_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bg_color) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_pattern),
"::",
stringify!(bg_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_pattern),
"::",
stringify!(type_)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_chart_font {
pub name: *mut ::std::os::raw::c_char,
pub size: f64,
pub bold: u8,
pub italic: u8,
pub underline: u8,
pub rotation: i32,
pub color: lxw_color_t,
pub pitch_family: u8,
pub charset: u8,
pub baseline: i8,
}
#[test]
fn bindgen_test_layout_lxw_chart_font() {
const UNINIT: ::std::mem::MaybeUninit<lxw_chart_font> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_chart_font>(),
32usize,
concat!("Size of: ", stringify!(lxw_chart_font))
);
assert_eq!(
::std::mem::align_of::<lxw_chart_font>(),
8usize,
concat!("Alignment of ", stringify!(lxw_chart_font))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_font),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_font),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bold) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_font),
"::",
stringify!(bold)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).italic) as usize - ptr as usize },
17usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_font),
"::",
stringify!(italic)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).underline) as usize - ptr as usize },
18usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_font),
"::",
stringify!(underline)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rotation) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_font),
"::",
stringify!(rotation)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).color) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_font),
"::",
stringify!(color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pitch_family) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_font),
"::",
stringify!(pitch_family)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).charset) as usize - ptr as usize },
29usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_font),
"::",
stringify!(charset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).baseline) as usize - ptr as usize },
30usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_font),
"::",
stringify!(baseline)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_chart_marker {
pub type_: u8,
pub size: u8,
pub line: *mut lxw_chart_line,
pub fill: *mut lxw_chart_fill,
pub pattern: *mut lxw_chart_pattern,
}
#[test]
fn bindgen_test_layout_lxw_chart_marker() {
const UNINIT: ::std::mem::MaybeUninit<lxw_chart_marker> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_chart_marker>(),
32usize,
concat!("Size of: ", stringify!(lxw_chart_marker))
);
assert_eq!(
::std::mem::align_of::<lxw_chart_marker>(),
8usize,
concat!("Alignment of ", stringify!(lxw_chart_marker))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_marker),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_marker),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).line) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_marker),
"::",
stringify!(line)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fill) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_marker),
"::",
stringify!(fill)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pattern) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_marker),
"::",
stringify!(pattern)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_chart_legend {
pub font: *mut lxw_chart_font,
pub position: u8,
}
#[test]
fn bindgen_test_layout_lxw_chart_legend() {
const UNINIT: ::std::mem::MaybeUninit<lxw_chart_legend> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_chart_legend>(),
16usize,
concat!("Size of: ", stringify!(lxw_chart_legend))
);
assert_eq!(
::std::mem::align_of::<lxw_chart_legend>(),
8usize,
concat!("Alignment of ", stringify!(lxw_chart_legend))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_legend),
"::",
stringify!(font)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).position) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_legend),
"::",
stringify!(position)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_chart_title {
pub name: *mut ::std::os::raw::c_char,
pub row: lxw_row_t,
pub col: lxw_col_t,
pub font: *mut lxw_chart_font,
pub off: u8,
pub is_horizontal: u8,
pub ignore_cache: u8,
pub range: *mut lxw_series_range,
pub data_point: lxw_series_data_point,
}
#[test]
fn bindgen_test_layout_lxw_chart_title() {
const UNINIT: ::std::mem::MaybeUninit<lxw_chart_title> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_chart_title>(),
80usize,
concat!("Size of: ", stringify!(lxw_chart_title))
);
assert_eq!(
::std::mem::align_of::<lxw_chart_title>(),
8usize,
concat!("Alignment of ", stringify!(lxw_chart_title))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_title),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).row) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_title),
"::",
stringify!(row)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).col) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_title),
"::",
stringify!(col)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_title),
"::",
stringify!(font)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).off) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_title),
"::",
stringify!(off)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).is_horizontal) as usize - ptr as usize },
25usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_title),
"::",
stringify!(is_horizontal)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ignore_cache) as usize - ptr as usize },
26usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_title),
"::",
stringify!(ignore_cache)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).range) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_title),
"::",
stringify!(range)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data_point) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_title),
"::",
stringify!(data_point)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_chart_point {
pub line: *mut lxw_chart_line,
pub fill: *mut lxw_chart_fill,
pub pattern: *mut lxw_chart_pattern,
}
#[test]
fn bindgen_test_layout_lxw_chart_point() {
const UNINIT: ::std::mem::MaybeUninit<lxw_chart_point> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_chart_point>(),
24usize,
concat!("Size of: ", stringify!(lxw_chart_point))
);
assert_eq!(
::std::mem::align_of::<lxw_chart_point>(),
8usize,
concat!("Alignment of ", stringify!(lxw_chart_point))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).line) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_point),
"::",
stringify!(line)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fill) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_point),
"::",
stringify!(fill)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pattern) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_point),
"::",
stringify!(pattern)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_chart_data_label {
pub value: *mut ::std::os::raw::c_char,
pub hide: u8,
pub font: *mut lxw_chart_font,
pub line: *mut lxw_chart_line,
pub fill: *mut lxw_chart_fill,
pub pattern: *mut lxw_chart_pattern,
}
#[test]
fn bindgen_test_layout_lxw_chart_data_label() {
const UNINIT: ::std::mem::MaybeUninit<lxw_chart_data_label> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_chart_data_label>(),
48usize,
concat!("Size of: ", stringify!(lxw_chart_data_label))
);
assert_eq!(
::std::mem::align_of::<lxw_chart_data_label>(),
8usize,
concat!("Alignment of ", stringify!(lxw_chart_data_label))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_data_label),
"::",
stringify!(value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hide) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_data_label),
"::",
stringify!(hide)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_data_label),
"::",
stringify!(font)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).line) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_data_label),
"::",
stringify!(line)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fill) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_data_label),
"::",
stringify!(fill)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pattern) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_data_label),
"::",
stringify!(pattern)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_chart_custom_label {
pub value: *mut ::std::os::raw::c_char,
pub hide: u8,
pub font: *mut lxw_chart_font,
pub line: *mut lxw_chart_line,
pub fill: *mut lxw_chart_fill,
pub pattern: *mut lxw_chart_pattern,
pub range: *mut lxw_series_range,
pub data_point: lxw_series_data_point,
}
#[test]
fn bindgen_test_layout_lxw_chart_custom_label() {
const UNINIT: ::std::mem::MaybeUninit<lxw_chart_custom_label> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_chart_custom_label>(),
96usize,
concat!("Size of: ", stringify!(lxw_chart_custom_label))
);
assert_eq!(
::std::mem::align_of::<lxw_chart_custom_label>(),
8usize,
concat!("Alignment of ", stringify!(lxw_chart_custom_label))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_custom_label),
"::",
stringify!(value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hide) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_custom_label),
"::",
stringify!(hide)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_custom_label),
"::",
stringify!(font)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).line) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_custom_label),
"::",
stringify!(line)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fill) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_custom_label),
"::",
stringify!(fill)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pattern) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_custom_label),
"::",
stringify!(pattern)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).range) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_custom_label),
"::",
stringify!(range)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data_point) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_custom_label),
"::",
stringify!(data_point)
)
);
}
pub const lxw_chart_blank_LXW_CHART_BLANKS_AS_GAP: lxw_chart_blank = 0;
pub const lxw_chart_blank_LXW_CHART_BLANKS_AS_ZERO: lxw_chart_blank = 1;
pub const lxw_chart_blank_LXW_CHART_BLANKS_AS_CONNECTED: lxw_chart_blank = 2;
pub type lxw_chart_blank = ::std::os::raw::c_uint;
pub const lxw_chart_position_LXW_CHART_AXIS_RIGHT: lxw_chart_position = 0;
pub const lxw_chart_position_LXW_CHART_AXIS_LEFT: lxw_chart_position = 1;
pub const lxw_chart_position_LXW_CHART_AXIS_TOP: lxw_chart_position = 2;
pub const lxw_chart_position_LXW_CHART_AXIS_BOTTOM: lxw_chart_position = 3;
pub type lxw_chart_position = ::std::os::raw::c_uint;
pub const lxw_chart_error_bar_type_LXW_CHART_ERROR_BAR_TYPE_STD_ERROR: lxw_chart_error_bar_type = 0;
pub const lxw_chart_error_bar_type_LXW_CHART_ERROR_BAR_TYPE_FIXED: lxw_chart_error_bar_type = 1;
pub const lxw_chart_error_bar_type_LXW_CHART_ERROR_BAR_TYPE_PERCENTAGE: lxw_chart_error_bar_type =
2;
pub const lxw_chart_error_bar_type_LXW_CHART_ERROR_BAR_TYPE_STD_DEV: lxw_chart_error_bar_type = 3;
pub type lxw_chart_error_bar_type = ::std::os::raw::c_uint;
pub const lxw_chart_error_bar_direction_LXW_CHART_ERROR_BAR_DIR_BOTH:
lxw_chart_error_bar_direction = 0;
pub const lxw_chart_error_bar_direction_LXW_CHART_ERROR_BAR_DIR_PLUS:
lxw_chart_error_bar_direction = 1;
pub const lxw_chart_error_bar_direction_LXW_CHART_ERROR_BAR_DIR_MINUS:
lxw_chart_error_bar_direction = 2;
pub type lxw_chart_error_bar_direction = ::std::os::raw::c_uint;
pub const lxw_chart_error_bar_axis_LXW_CHART_ERROR_BAR_AXIS_X: lxw_chart_error_bar_axis = 0;
pub const lxw_chart_error_bar_axis_LXW_CHART_ERROR_BAR_AXIS_Y: lxw_chart_error_bar_axis = 1;
pub type lxw_chart_error_bar_axis = ::std::os::raw::c_uint;
pub const lxw_chart_error_bar_cap_LXW_CHART_ERROR_BAR_END_CAP: lxw_chart_error_bar_cap = 0;
pub const lxw_chart_error_bar_cap_LXW_CHART_ERROR_BAR_NO_CAP: lxw_chart_error_bar_cap = 1;
pub type lxw_chart_error_bar_cap = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_series_error_bars {
pub type_: u8,
pub direction: u8,
pub endcap: u8,
pub has_value: u8,
pub is_set: u8,
pub is_x: u8,
pub chart_group: u8,
pub value: f64,
pub line: *mut lxw_chart_line,
}
#[test]
fn bindgen_test_layout_lxw_series_error_bars() {
const UNINIT: ::std::mem::MaybeUninit<lxw_series_error_bars> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_series_error_bars>(),
24usize,
concat!("Size of: ", stringify!(lxw_series_error_bars))
);
assert_eq!(
::std::mem::align_of::<lxw_series_error_bars>(),
8usize,
concat!("Alignment of ", stringify!(lxw_series_error_bars))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_error_bars),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).direction) as usize - ptr as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_error_bars),
"::",
stringify!(direction)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).endcap) as usize - ptr as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_error_bars),
"::",
stringify!(endcap)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_value) as usize - ptr as usize },
3usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_error_bars),
"::",
stringify!(has_value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).is_set) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_error_bars),
"::",
stringify!(is_set)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).is_x) as usize - ptr as usize },
5usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_error_bars),
"::",
stringify!(is_x)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).chart_group) as usize - ptr as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_error_bars),
"::",
stringify!(chart_group)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_error_bars),
"::",
stringify!(value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).line) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_error_bars),
"::",
stringify!(line)
)
);
}
pub const lxw_chart_trendline_type_LXW_CHART_TRENDLINE_TYPE_LINEAR: lxw_chart_trendline_type = 0;
pub const lxw_chart_trendline_type_LXW_CHART_TRENDLINE_TYPE_LOG: lxw_chart_trendline_type = 1;
pub const lxw_chart_trendline_type_LXW_CHART_TRENDLINE_TYPE_POLY: lxw_chart_trendline_type = 2;
pub const lxw_chart_trendline_type_LXW_CHART_TRENDLINE_TYPE_POWER: lxw_chart_trendline_type = 3;
pub const lxw_chart_trendline_type_LXW_CHART_TRENDLINE_TYPE_EXP: lxw_chart_trendline_type = 4;
pub const lxw_chart_trendline_type_LXW_CHART_TRENDLINE_TYPE_AVERAGE: lxw_chart_trendline_type = 5;
pub type lxw_chart_trendline_type = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_chart_series {
pub categories: *mut lxw_series_range,
pub values: *mut lxw_series_range,
pub title: lxw_chart_title,
pub line: *mut lxw_chart_line,
pub fill: *mut lxw_chart_fill,
pub pattern: *mut lxw_chart_pattern,
pub marker: *mut lxw_chart_marker,
pub points: *mut lxw_chart_point,
pub data_labels: *mut lxw_chart_custom_label,
pub point_count: u16,
pub data_label_count: u16,
pub smooth: u8,
pub invert_if_negative: u8,
pub has_labels: u8,
pub show_labels_value: u8,
pub show_labels_category: u8,
pub show_labels_name: u8,
pub show_labels_leader: u8,
pub show_labels_legend: u8,
pub show_labels_percent: u8,
pub label_position: u8,
pub label_separator: u8,
pub default_label_position: u8,
pub label_num_format: *mut ::std::os::raw::c_char,
pub label_font: *mut lxw_chart_font,
pub label_line: *mut lxw_chart_line,
pub label_fill: *mut lxw_chart_fill,
pub label_pattern: *mut lxw_chart_pattern,
pub x_error_bars: *mut lxw_series_error_bars,
pub y_error_bars: *mut lxw_series_error_bars,
pub has_trendline: u8,
pub has_trendline_forecast: u8,
pub has_trendline_equation: u8,
pub has_trendline_r_squared: u8,
pub has_trendline_intercept: u8,
pub trendline_type: u8,
pub trendline_value: u8,
pub trendline_forward: f64,
pub trendline_backward: f64,
pub trendline_value_type: u8,
pub trendline_name: *mut ::std::os::raw::c_char,
pub trendline_line: *mut lxw_chart_line,
pub trendline_intercept: f64,
pub list_pointers: lxw_chart_series__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_chart_series__bindgen_ty_1 {
pub stqe_next: *mut lxw_chart_series,
}
#[test]
fn bindgen_test_layout_lxw_chart_series__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<lxw_chart_series__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_chart_series__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(lxw_chart_series__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<lxw_chart_series__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(lxw_chart_series__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqe_next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series__bindgen_ty_1),
"::",
stringify!(stqe_next)
)
);
}
#[test]
fn bindgen_test_layout_lxw_chart_series() {
const UNINIT: ::std::mem::MaybeUninit<lxw_chart_series> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_chart_series>(),
280usize,
concat!("Size of: ", stringify!(lxw_chart_series))
);
assert_eq!(
::std::mem::align_of::<lxw_chart_series>(),
8usize,
concat!("Alignment of ", stringify!(lxw_chart_series))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).categories) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(categories)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).values) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(values)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).title) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(title)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).line) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(line)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fill) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(fill)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pattern) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(pattern)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).marker) as usize - ptr as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(marker)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).points) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(points)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data_labels) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(data_labels)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).point_count) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(point_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data_label_count) as usize - ptr as usize },
146usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(data_label_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).smooth) as usize - ptr as usize },
148usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(smooth)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).invert_if_negative) as usize - ptr as usize },
149usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(invert_if_negative)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_labels) as usize - ptr as usize },
150usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(has_labels)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).show_labels_value) as usize - ptr as usize },
151usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(show_labels_value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).show_labels_category) as usize - ptr as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(show_labels_category)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).show_labels_name) as usize - ptr as usize },
153usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(show_labels_name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).show_labels_leader) as usize - ptr as usize },
154usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(show_labels_leader)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).show_labels_legend) as usize - ptr as usize },
155usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(show_labels_legend)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).show_labels_percent) as usize - ptr as usize },
156usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(show_labels_percent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).label_position) as usize - ptr as usize },
157usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(label_position)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).label_separator) as usize - ptr as usize },
158usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(label_separator)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).default_label_position) as usize - ptr as usize },
159usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(default_label_position)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).label_num_format) as usize - ptr as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(label_num_format)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).label_font) as usize - ptr as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(label_font)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).label_line) as usize - ptr as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(label_line)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).label_fill) as usize - ptr as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(label_fill)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).label_pattern) as usize - ptr as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(label_pattern)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x_error_bars) as usize - ptr as usize },
200usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(x_error_bars)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y_error_bars) as usize - ptr as usize },
208usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(y_error_bars)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_trendline) as usize - ptr as usize },
216usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(has_trendline)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_trendline_forecast) as usize - ptr as usize },
217usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(has_trendline_forecast)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_trendline_equation) as usize - ptr as usize },
218usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(has_trendline_equation)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_trendline_r_squared) as usize - ptr as usize },
219usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(has_trendline_r_squared)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_trendline_intercept) as usize - ptr as usize },
220usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(has_trendline_intercept)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).trendline_type) as usize - ptr as usize },
221usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(trendline_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).trendline_value) as usize - ptr as usize },
222usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(trendline_value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).trendline_forward) as usize - ptr as usize },
224usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(trendline_forward)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).trendline_backward) as usize - ptr as usize },
232usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(trendline_backward)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).trendline_value_type) as usize - ptr as usize },
240usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(trendline_value_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).trendline_name) as usize - ptr as usize },
248usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(trendline_name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).trendline_line) as usize - ptr as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(trendline_line)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).trendline_intercept) as usize - ptr as usize },
264usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(trendline_intercept)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).list_pointers) as usize - ptr as usize },
272usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(list_pointers)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_chart_gridline {
pub visible: u8,
pub line: *mut lxw_chart_line,
}
#[test]
fn bindgen_test_layout_lxw_chart_gridline() {
const UNINIT: ::std::mem::MaybeUninit<lxw_chart_gridline> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_chart_gridline>(),
16usize,
concat!("Size of: ", stringify!(lxw_chart_gridline))
);
assert_eq!(
::std::mem::align_of::<lxw_chart_gridline>(),
8usize,
concat!("Alignment of ", stringify!(lxw_chart_gridline))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).visible) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_gridline),
"::",
stringify!(visible)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).line) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_gridline),
"::",
stringify!(line)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_chart_axis {
pub title: lxw_chart_title,
pub num_format: *mut ::std::os::raw::c_char,
pub default_num_format: *mut ::std::os::raw::c_char,
pub source_linked: u8,
pub major_tick_mark: u8,
pub minor_tick_mark: u8,
pub is_horizontal: u8,
pub major_gridlines: lxw_chart_gridline,
pub minor_gridlines: lxw_chart_gridline,
pub num_font: *mut lxw_chart_font,
pub line: *mut lxw_chart_line,
pub fill: *mut lxw_chart_fill,
pub pattern: *mut lxw_chart_pattern,
pub is_category: u8,
pub is_date: u8,
pub is_value: u8,
pub axis_position: u8,
pub position_axis: u8,
pub label_position: u8,
pub label_align: u8,
pub hidden: u8,
pub reverse: u8,
pub has_min: u8,
pub min: f64,
pub has_max: u8,
pub max: f64,
pub has_major_unit: u8,
pub major_unit: f64,
pub has_minor_unit: u8,
pub minor_unit: f64,
pub interval_unit: u16,
pub interval_tick: u16,
pub log_base: u16,
pub display_units: u8,
pub display_units_visible: u8,
pub has_crossing: u8,
pub crossing_min: u8,
pub crossing_max: u8,
pub crossing: f64,
}
#[test]
fn bindgen_test_layout_lxw_chart_axis() {
const UNINIT: ::std::mem::MaybeUninit<lxw_chart_axis> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_chart_axis>(),
264usize,
concat!("Size of: ", stringify!(lxw_chart_axis))
);
assert_eq!(
::std::mem::align_of::<lxw_chart_axis>(),
8usize,
concat!("Alignment of ", stringify!(lxw_chart_axis))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).title) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(title)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).num_format) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(num_format)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).default_num_format) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(default_num_format)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).source_linked) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(source_linked)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).major_tick_mark) as usize - ptr as usize },
97usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(major_tick_mark)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).minor_tick_mark) as usize - ptr as usize },
98usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(minor_tick_mark)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).is_horizontal) as usize - ptr as usize },
99usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(is_horizontal)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).major_gridlines) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(major_gridlines)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).minor_gridlines) as usize - ptr as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(minor_gridlines)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).num_font) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(num_font)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).line) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(line)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fill) as usize - ptr as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(fill)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pattern) as usize - ptr as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(pattern)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).is_category) as usize - ptr as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(is_category)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).is_date) as usize - ptr as usize },
169usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(is_date)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).is_value) as usize - ptr as usize },
170usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(is_value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).axis_position) as usize - ptr as usize },
171usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(axis_position)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).position_axis) as usize - ptr as usize },
172usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(position_axis)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).label_position) as usize - ptr as usize },
173usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(label_position)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).label_align) as usize - ptr as usize },
174usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(label_align)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hidden) as usize - ptr as usize },
175usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(hidden)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).reverse) as usize - ptr as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(reverse)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_min) as usize - ptr as usize },
177usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(has_min)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).min) as usize - ptr as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(min)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_max) as usize - ptr as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(has_max)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max) as usize - ptr as usize },
200usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(max)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_major_unit) as usize - ptr as usize },
208usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(has_major_unit)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).major_unit) as usize - ptr as usize },
216usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(major_unit)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_minor_unit) as usize - ptr as usize },
224usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(has_minor_unit)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).minor_unit) as usize - ptr as usize },
232usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(minor_unit)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).interval_unit) as usize - ptr as usize },
240usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(interval_unit)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).interval_tick) as usize - ptr as usize },
242usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(interval_tick)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).log_base) as usize - ptr as usize },
244usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(log_base)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).display_units) as usize - ptr as usize },
246usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(display_units)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).display_units_visible) as usize - ptr as usize },
247usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(display_units_visible)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_crossing) as usize - ptr as usize },
248usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(has_crossing)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).crossing_min) as usize - ptr as usize },
249usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(crossing_min)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).crossing_max) as usize - ptr as usize },
250usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(crossing_max)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).crossing) as usize - ptr as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(crossing)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_chart {
pub file: *mut FILE,
pub type_: u8,
pub subtype: u8,
pub series_index: u16,
pub write_chart_type: ::std::option::Option<unsafe extern "C" fn(arg1: *mut lxw_chart)>,
pub write_plot_area: ::std::option::Option<unsafe extern "C" fn(arg1: *mut lxw_chart)>,
pub x_axis: *mut lxw_chart_axis,
pub y_axis: *mut lxw_chart_axis,
pub title: lxw_chart_title,
pub id: u32,
pub axis_id_1: u32,
pub axis_id_2: u32,
pub axis_id_3: u32,
pub axis_id_4: u32,
pub in_use: u8,
pub chart_group: u8,
pub cat_has_num_fmt: u8,
pub is_chartsheet: u8,
pub has_horiz_cat_axis: u8,
pub has_horiz_val_axis: u8,
pub style_id: u8,
pub rotation: u16,
pub hole_size: u16,
pub no_title: u8,
pub has_overlap: u8,
pub overlap_y1: i8,
pub overlap_y2: i8,
pub gap_y1: u16,
pub gap_y2: u16,
pub grouping: u8,
pub default_cross_between: u8,
pub legend: lxw_chart_legend,
pub delete_series: *mut i16,
pub delete_series_count: u16,
pub default_marker: *mut lxw_chart_marker,
pub chartarea_line: *mut lxw_chart_line,
pub chartarea_fill: *mut lxw_chart_fill,
pub chartarea_pattern: *mut lxw_chart_pattern,
pub plotarea_line: *mut lxw_chart_line,
pub plotarea_fill: *mut lxw_chart_fill,
pub plotarea_pattern: *mut lxw_chart_pattern,
pub has_drop_lines: u8,
pub drop_lines_line: *mut lxw_chart_line,
pub has_high_low_lines: u8,
pub high_low_lines_line: *mut lxw_chart_line,
pub series_list: *mut lxw_chart_series_list,
pub has_table: u8,
pub has_table_vertical: u8,
pub has_table_horizontal: u8,
pub has_table_outline: u8,
pub has_table_legend_keys: u8,
pub table_font: *mut lxw_chart_font,
pub show_blanks_as: u8,
pub show_hidden_data: u8,
pub has_up_down_bars: u8,
pub up_bar_line: *mut lxw_chart_line,
pub down_bar_line: *mut lxw_chart_line,
pub up_bar_fill: *mut lxw_chart_fill,
pub down_bar_fill: *mut lxw_chart_fill,
pub default_label_position: u8,
pub is_protected: u8,
pub ordered_list_pointers: lxw_chart__bindgen_ty_1,
pub list_pointers: lxw_chart__bindgen_ty_2,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_chart__bindgen_ty_1 {
pub stqe_next: *mut lxw_chart,
}
#[test]
fn bindgen_test_layout_lxw_chart__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<lxw_chart__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_chart__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(lxw_chart__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<lxw_chart__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(lxw_chart__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqe_next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart__bindgen_ty_1),
"::",
stringify!(stqe_next)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_chart__bindgen_ty_2 {
pub stqe_next: *mut lxw_chart,
}
#[test]
fn bindgen_test_layout_lxw_chart__bindgen_ty_2() {
const UNINIT: ::std::mem::MaybeUninit<lxw_chart__bindgen_ty_2> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_chart__bindgen_ty_2>(),
8usize,
concat!("Size of: ", stringify!(lxw_chart__bindgen_ty_2))
);
assert_eq!(
::std::mem::align_of::<lxw_chart__bindgen_ty_2>(),
8usize,
concat!("Alignment of ", stringify!(lxw_chart__bindgen_ty_2))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqe_next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart__bindgen_ty_2),
"::",
stringify!(stqe_next)
)
);
}
#[test]
fn bindgen_test_layout_lxw_chart() {
const UNINIT: ::std::mem::MaybeUninit<lxw_chart> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_chart>(),
384usize,
concat!("Size of: ", stringify!(lxw_chart))
);
assert_eq!(
::std::mem::align_of::<lxw_chart>(),
8usize,
concat!("Alignment of ", stringify!(lxw_chart))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).file) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(file)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).subtype) as usize - ptr as usize },
9usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(subtype)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).series_index) as usize - ptr as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(series_index)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).write_chart_type) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(write_chart_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).write_plot_area) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(write_plot_area)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x_axis) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(x_axis)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y_axis) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(y_axis)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).title) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(title)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).axis_id_1) as usize - ptr as usize },
132usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(axis_id_1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).axis_id_2) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(axis_id_2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).axis_id_3) as usize - ptr as usize },
140usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(axis_id_3)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).axis_id_4) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(axis_id_4)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).in_use) as usize - ptr as usize },
148usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(in_use)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).chart_group) as usize - ptr as usize },
149usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(chart_group)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cat_has_num_fmt) as usize - ptr as usize },
150usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(cat_has_num_fmt)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).is_chartsheet) as usize - ptr as usize },
151usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(is_chartsheet)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_horiz_cat_axis) as usize - ptr as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(has_horiz_cat_axis)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_horiz_val_axis) as usize - ptr as usize },
153usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(has_horiz_val_axis)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).style_id) as usize - ptr as usize },
154usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(style_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rotation) as usize - ptr as usize },
156usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(rotation)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hole_size) as usize - ptr as usize },
158usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(hole_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).no_title) as usize - ptr as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(no_title)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_overlap) as usize - ptr as usize },
161usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(has_overlap)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).overlap_y1) as usize - ptr as usize },
162usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(overlap_y1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).overlap_y2) as usize - ptr as usize },
163usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(overlap_y2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).gap_y1) as usize - ptr as usize },
164usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(gap_y1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).gap_y2) as usize - ptr as usize },
166usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(gap_y2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).grouping) as usize - ptr as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(grouping)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).default_cross_between) as usize - ptr as usize },
169usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(default_cross_between)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).legend) as usize - ptr as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(legend)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).delete_series) as usize - ptr as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(delete_series)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).delete_series_count) as usize - ptr as usize },
200usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(delete_series_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).default_marker) as usize - ptr as usize },
208usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(default_marker)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).chartarea_line) as usize - ptr as usize },
216usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(chartarea_line)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).chartarea_fill) as usize - ptr as usize },
224usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(chartarea_fill)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).chartarea_pattern) as usize - ptr as usize },
232usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(chartarea_pattern)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).plotarea_line) as usize - ptr as usize },
240usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(plotarea_line)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).plotarea_fill) as usize - ptr as usize },
248usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(plotarea_fill)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).plotarea_pattern) as usize - ptr as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(plotarea_pattern)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_drop_lines) as usize - ptr as usize },
264usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(has_drop_lines)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).drop_lines_line) as usize - ptr as usize },
272usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(drop_lines_line)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_high_low_lines) as usize - ptr as usize },
280usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(has_high_low_lines)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).high_low_lines_line) as usize - ptr as usize },
288usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(high_low_lines_line)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).series_list) as usize - ptr as usize },
296usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(series_list)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_table) as usize - ptr as usize },
304usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(has_table)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_table_vertical) as usize - ptr as usize },
305usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(has_table_vertical)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_table_horizontal) as usize - ptr as usize },
306usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(has_table_horizontal)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_table_outline) as usize - ptr as usize },
307usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(has_table_outline)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_table_legend_keys) as usize - ptr as usize },
308usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(has_table_legend_keys)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).table_font) as usize - ptr as usize },
312usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(table_font)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).show_blanks_as) as usize - ptr as usize },
320usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(show_blanks_as)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).show_hidden_data) as usize - ptr as usize },
321usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(show_hidden_data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_up_down_bars) as usize - ptr as usize },
322usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(has_up_down_bars)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).up_bar_line) as usize - ptr as usize },
328usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(up_bar_line)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).down_bar_line) as usize - ptr as usize },
336usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(down_bar_line)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).up_bar_fill) as usize - ptr as usize },
344usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(up_bar_fill)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).down_bar_fill) as usize - ptr as usize },
352usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(down_bar_fill)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).default_label_position) as usize - ptr as usize },
360usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(default_label_position)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).is_protected) as usize - ptr as usize },
361usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(is_protected)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ordered_list_pointers) as usize - ptr as usize },
368usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(ordered_list_pointers)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).list_pointers) as usize - ptr as usize },
376usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(list_pointers)
)
);
}
extern "C" {
pub fn lxw_chart_new(type_: u8) -> *mut lxw_chart;
}
extern "C" {
pub fn lxw_chart_free(chart: *mut lxw_chart);
}
extern "C" {
pub fn lxw_chart_assemble_xml_file(chart: *mut lxw_chart);
}
extern "C" {
pub fn chart_add_series(
chart: *mut lxw_chart,
categories: *const ::std::os::raw::c_char,
values: *const ::std::os::raw::c_char,
) -> *mut lxw_chart_series;
}
extern "C" {
pub fn chart_series_set_categories(
series: *mut lxw_chart_series,
sheetname: *const ::std::os::raw::c_char,
first_row: lxw_row_t,
first_col: lxw_col_t,
last_row: lxw_row_t,
last_col: lxw_col_t,
);
}
extern "C" {
pub fn chart_series_set_values(
series: *mut lxw_chart_series,
sheetname: *const ::std::os::raw::c_char,
first_row: lxw_row_t,
first_col: lxw_col_t,
last_row: lxw_row_t,
last_col: lxw_col_t,
);
}
extern "C" {
pub fn chart_series_set_name(
series: *mut lxw_chart_series,
name: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn chart_series_set_name_range(
series: *mut lxw_chart_series,
sheetname: *const ::std::os::raw::c_char,
row: lxw_row_t,
col: lxw_col_t,
);
}
extern "C" {
pub fn chart_series_set_line(series: *mut lxw_chart_series, line: *mut lxw_chart_line);
}
extern "C" {
pub fn chart_series_set_fill(series: *mut lxw_chart_series, fill: *mut lxw_chart_fill);
}
extern "C" {
pub fn chart_series_set_invert_if_negative(series: *mut lxw_chart_series);
}
extern "C" {
pub fn chart_series_set_pattern(series: *mut lxw_chart_series, pattern: *mut lxw_chart_pattern);
}
extern "C" {
pub fn chart_series_set_marker_type(series: *mut lxw_chart_series, type_: u8);
}
extern "C" {
pub fn chart_series_set_marker_size(series: *mut lxw_chart_series, size: u8);
}
extern "C" {
pub fn chart_series_set_marker_line(series: *mut lxw_chart_series, line: *mut lxw_chart_line);
}
extern "C" {
pub fn chart_series_set_marker_fill(series: *mut lxw_chart_series, fill: *mut lxw_chart_fill);
}
extern "C" {
pub fn chart_series_set_marker_pattern(
series: *mut lxw_chart_series,
pattern: *mut lxw_chart_pattern,
);
}
extern "C" {
pub fn chart_series_set_points(
series: *mut lxw_chart_series,
points: *mut *mut lxw_chart_point,
) -> lxw_error;
}
extern "C" {
pub fn chart_series_set_smooth(series: *mut lxw_chart_series, smooth: u8);
}
extern "C" {
pub fn chart_series_set_labels(series: *mut lxw_chart_series);
}
extern "C" {
pub fn chart_series_set_labels_options(
series: *mut lxw_chart_series,
show_name: u8,
show_category: u8,
show_value: u8,
);
}
extern "C" {
pub fn chart_series_set_labels_custom(
series: *mut lxw_chart_series,
data_labels: *mut *mut lxw_chart_data_label,
) -> lxw_error;
}
extern "C" {
pub fn chart_series_set_labels_separator(series: *mut lxw_chart_series, separator: u8);
}
extern "C" {
pub fn chart_series_set_labels_position(series: *mut lxw_chart_series, position: u8);
}
extern "C" {
pub fn chart_series_set_labels_leader_line(series: *mut lxw_chart_series);
}
extern "C" {
pub fn chart_series_set_labels_legend(series: *mut lxw_chart_series);
}
extern "C" {
pub fn chart_series_set_labels_percentage(series: *mut lxw_chart_series);
}
extern "C" {
pub fn chart_series_set_labels_num_format(
series: *mut lxw_chart_series,
num_format: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn chart_series_set_labels_font(series: *mut lxw_chart_series, font: *mut lxw_chart_font);
}
extern "C" {
pub fn chart_series_set_labels_line(series: *mut lxw_chart_series, line: *mut lxw_chart_line);
}
extern "C" {
pub fn chart_series_set_labels_fill(series: *mut lxw_chart_series, fill: *mut lxw_chart_fill);
}
extern "C" {
pub fn chart_series_set_labels_pattern(
series: *mut lxw_chart_series,
pattern: *mut lxw_chart_pattern,
);
}
extern "C" {
pub fn chart_series_set_trendline(series: *mut lxw_chart_series, type_: u8, value: u8);
}
extern "C" {
pub fn chart_series_set_trendline_forecast(
series: *mut lxw_chart_series,
forward: f64,
backward: f64,
);
}
extern "C" {
pub fn chart_series_set_trendline_equation(series: *mut lxw_chart_series);
}
extern "C" {
pub fn chart_series_set_trendline_r_squared(series: *mut lxw_chart_series);
}
extern "C" {
pub fn chart_series_set_trendline_intercept(series: *mut lxw_chart_series, intercept: f64);
}
extern "C" {
pub fn chart_series_set_trendline_name(
series: *mut lxw_chart_series,
name: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn chart_series_set_trendline_line(
series: *mut lxw_chart_series,
line: *mut lxw_chart_line,
);
}
extern "C" {
pub fn chart_series_get_error_bars(
series: *mut lxw_chart_series,
axis_type: lxw_chart_error_bar_axis,
) -> *mut lxw_series_error_bars;
}
extern "C" {
pub fn chart_series_set_error_bars(
error_bars: *mut lxw_series_error_bars,
type_: u8,
value: f64,
);
}
extern "C" {
pub fn chart_series_set_error_bars_direction(
error_bars: *mut lxw_series_error_bars,
direction: u8,
);
}
extern "C" {
pub fn chart_series_set_error_bars_endcap(error_bars: *mut lxw_series_error_bars, endcap: u8);
}
extern "C" {
pub fn chart_series_set_error_bars_line(
error_bars: *mut lxw_series_error_bars,
line: *mut lxw_chart_line,
);
}
extern "C" {
pub fn chart_axis_get(
chart: *mut lxw_chart,
axis_type: lxw_chart_axis_type,
) -> *mut lxw_chart_axis;
}
extern "C" {
pub fn chart_axis_set_name(axis: *mut lxw_chart_axis, name: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn chart_axis_set_name_range(
axis: *mut lxw_chart_axis,
sheetname: *const ::std::os::raw::c_char,
row: lxw_row_t,
col: lxw_col_t,
);
}
extern "C" {
pub fn chart_axis_set_name_font(axis: *mut lxw_chart_axis, font: *mut lxw_chart_font);
}
extern "C" {
pub fn chart_axis_set_num_font(axis: *mut lxw_chart_axis, font: *mut lxw_chart_font);
}
extern "C" {
pub fn chart_axis_set_num_format(
axis: *mut lxw_chart_axis,
num_format: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn chart_axis_set_line(axis: *mut lxw_chart_axis, line: *mut lxw_chart_line);
}
extern "C" {
pub fn chart_axis_set_fill(axis: *mut lxw_chart_axis, fill: *mut lxw_chart_fill);
}
extern "C" {
pub fn chart_axis_set_pattern(axis: *mut lxw_chart_axis, pattern: *mut lxw_chart_pattern);
}
extern "C" {
pub fn chart_axis_set_reverse(axis: *mut lxw_chart_axis);
}
extern "C" {
pub fn chart_axis_set_crossing(axis: *mut lxw_chart_axis, value: f64);
}
extern "C" {
pub fn chart_axis_set_crossing_max(axis: *mut lxw_chart_axis);
}
extern "C" {
pub fn chart_axis_set_crossing_min(axis: *mut lxw_chart_axis);
}
extern "C" {
pub fn chart_axis_off(axis: *mut lxw_chart_axis);
}
extern "C" {
pub fn chart_axis_set_position(axis: *mut lxw_chart_axis, position: u8);
}
extern "C" {
pub fn chart_axis_set_label_position(axis: *mut lxw_chart_axis, position: u8);
}
extern "C" {
pub fn chart_axis_set_label_align(axis: *mut lxw_chart_axis, align: u8);
}
extern "C" {
pub fn chart_axis_set_min(axis: *mut lxw_chart_axis, min: f64);
}
extern "C" {
pub fn chart_axis_set_max(axis: *mut lxw_chart_axis, max: f64);
}
extern "C" {
pub fn chart_axis_set_log_base(axis: *mut lxw_chart_axis, log_base: u16);
}
extern "C" {
pub fn chart_axis_set_major_tick_mark(axis: *mut lxw_chart_axis, type_: u8);
}
extern "C" {
pub fn chart_axis_set_minor_tick_mark(axis: *mut lxw_chart_axis, type_: u8);
}
extern "C" {
pub fn chart_axis_set_interval_unit(axis: *mut lxw_chart_axis, unit: u16);
}
extern "C" {
pub fn chart_axis_set_interval_tick(axis: *mut lxw_chart_axis, unit: u16);
}
extern "C" {
pub fn chart_axis_set_major_unit(axis: *mut lxw_chart_axis, unit: f64);
}
extern "C" {
pub fn chart_axis_set_minor_unit(axis: *mut lxw_chart_axis, unit: f64);
}
extern "C" {
pub fn chart_axis_set_display_units(axis: *mut lxw_chart_axis, units: u8);
}
extern "C" {
pub fn chart_axis_set_display_units_visible(axis: *mut lxw_chart_axis, visible: u8);
}
extern "C" {
pub fn chart_axis_major_gridlines_set_visible(axis: *mut lxw_chart_axis, visible: u8);
}
extern "C" {
pub fn chart_axis_minor_gridlines_set_visible(axis: *mut lxw_chart_axis, visible: u8);
}
extern "C" {
pub fn chart_axis_major_gridlines_set_line(
axis: *mut lxw_chart_axis,
line: *mut lxw_chart_line,
);
}
extern "C" {
pub fn chart_axis_minor_gridlines_set_line(
axis: *mut lxw_chart_axis,
line: *mut lxw_chart_line,
);
}
extern "C" {
pub fn chart_title_set_name(chart: *mut lxw_chart, name: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn chart_title_set_name_range(
chart: *mut lxw_chart,
sheetname: *const ::std::os::raw::c_char,
row: lxw_row_t,
col: lxw_col_t,
);
}
extern "C" {
pub fn chart_title_set_name_font(chart: *mut lxw_chart, font: *mut lxw_chart_font);
}
extern "C" {
pub fn chart_title_off(chart: *mut lxw_chart);
}
extern "C" {
pub fn chart_legend_set_position(chart: *mut lxw_chart, position: u8);
}
extern "C" {
pub fn chart_legend_set_font(chart: *mut lxw_chart, font: *mut lxw_chart_font);
}
extern "C" {
pub fn chart_legend_delete_series(chart: *mut lxw_chart, delete_series: *mut i16) -> lxw_error;
}
extern "C" {
pub fn chart_chartarea_set_line(chart: *mut lxw_chart, line: *mut lxw_chart_line);
}
extern "C" {
pub fn chart_chartarea_set_fill(chart: *mut lxw_chart, fill: *mut lxw_chart_fill);
}
extern "C" {
pub fn chart_chartarea_set_pattern(chart: *mut lxw_chart, pattern: *mut lxw_chart_pattern);
}
extern "C" {
pub fn chart_plotarea_set_line(chart: *mut lxw_chart, line: *mut lxw_chart_line);
}
extern "C" {
pub fn chart_plotarea_set_fill(chart: *mut lxw_chart, fill: *mut lxw_chart_fill);
}
extern "C" {
pub fn chart_plotarea_set_pattern(chart: *mut lxw_chart, pattern: *mut lxw_chart_pattern);
}
extern "C" {
pub fn chart_set_style(chart: *mut lxw_chart, style_id: u8);
}
extern "C" {
pub fn chart_set_table(chart: *mut lxw_chart);
}
extern "C" {
pub fn chart_set_table_grid(
chart: *mut lxw_chart,
horizontal: u8,
vertical: u8,
outline: u8,
legend_keys: u8,
);
}
extern "C" {
pub fn chart_set_table_font(chart: *mut lxw_chart, font: *mut lxw_chart_font);
}
extern "C" {
pub fn chart_set_up_down_bars(chart: *mut lxw_chart);
}
extern "C" {
pub fn chart_set_up_down_bars_format(
chart: *mut lxw_chart,
up_bar_line: *mut lxw_chart_line,
up_bar_fill: *mut lxw_chart_fill,
down_bar_line: *mut lxw_chart_line,
down_bar_fill: *mut lxw_chart_fill,
);
}
extern "C" {
pub fn chart_set_drop_lines(chart: *mut lxw_chart, line: *mut lxw_chart_line);
}
extern "C" {
pub fn chart_set_high_low_lines(chart: *mut lxw_chart, line: *mut lxw_chart_line);
}
extern "C" {
pub fn chart_set_series_overlap(chart: *mut lxw_chart, overlap: i8);
}
extern "C" {
pub fn chart_set_series_gap(chart: *mut lxw_chart, gap: u16);
}
extern "C" {
pub fn chart_show_blanks_as(chart: *mut lxw_chart, option: u8);
}
extern "C" {
pub fn chart_show_hidden_data(chart: *mut lxw_chart);
}
extern "C" {
pub fn chart_set_rotation(chart: *mut lxw_chart, rotation: u16);
}
extern "C" {
pub fn chart_set_hole_size(chart: *mut lxw_chart, size: u8);
}
extern "C" {
pub fn lxw_chart_add_data_cache(
range: *mut lxw_series_range,
data: *mut u8,
rows: u16,
cols: u8,
col: u8,
) -> lxw_error;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_drawing_objects {
pub stqh_first: *mut lxw_drawing_object,
pub stqh_last: *mut *mut lxw_drawing_object,
}
#[test]
fn bindgen_test_layout_lxw_drawing_objects() {
const UNINIT: ::std::mem::MaybeUninit<lxw_drawing_objects> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_drawing_objects>(),
16usize,
concat!("Size of: ", stringify!(lxw_drawing_objects))
);
assert_eq!(
::std::mem::align_of::<lxw_drawing_objects>(),
8usize,
concat!("Alignment of ", stringify!(lxw_drawing_objects))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_first) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_objects),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_last) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_objects),
"::",
stringify!(stqh_last)
)
);
}
pub const lxw_drawing_types_LXW_DRAWING_NONE: lxw_drawing_types = 0;
pub const lxw_drawing_types_LXW_DRAWING_IMAGE: lxw_drawing_types = 1;
pub const lxw_drawing_types_LXW_DRAWING_CHART: lxw_drawing_types = 2;
pub const lxw_drawing_types_LXW_DRAWING_SHAPE: lxw_drawing_types = 3;
pub type lxw_drawing_types = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_drawing_coords {
pub col: u32,
pub row: u32,
pub col_offset: f64,
pub row_offset: f64,
}
#[test]
fn bindgen_test_layout_lxw_drawing_coords() {
const UNINIT: ::std::mem::MaybeUninit<lxw_drawing_coords> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_drawing_coords>(),
24usize,
concat!("Size of: ", stringify!(lxw_drawing_coords))
);
assert_eq!(
::std::mem::align_of::<lxw_drawing_coords>(),
8usize,
concat!("Alignment of ", stringify!(lxw_drawing_coords))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).col) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_coords),
"::",
stringify!(col)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).row) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_coords),
"::",
stringify!(row)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).col_offset) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_coords),
"::",
stringify!(col_offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).row_offset) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_coords),
"::",
stringify!(row_offset)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_drawing_object {
pub type_: u8,
pub anchor: u8,
pub from: lxw_drawing_coords,
pub to: lxw_drawing_coords,
pub col_absolute: u32,
pub row_absolute: u32,
pub width: u32,
pub height: u32,
pub shape: u8,
pub rel_index: u32,
pub url_rel_index: u32,
pub description: *mut ::std::os::raw::c_char,
pub tip: *mut ::std::os::raw::c_char,
pub decorative: u8,
pub list_pointers: lxw_drawing_object__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_drawing_object__bindgen_ty_1 {
pub stqe_next: *mut lxw_drawing_object,
}
#[test]
fn bindgen_test_layout_lxw_drawing_object__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<lxw_drawing_object__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_drawing_object__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(lxw_drawing_object__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<lxw_drawing_object__bindgen_ty_1>(),
8usize,
concat!(
"Alignment of ",
stringify!(lxw_drawing_object__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqe_next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_object__bindgen_ty_1),
"::",
stringify!(stqe_next)
)
);
}
#[test]
fn bindgen_test_layout_lxw_drawing_object() {
const UNINIT: ::std::mem::MaybeUninit<lxw_drawing_object> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_drawing_object>(),
120usize,
concat!("Size of: ", stringify!(lxw_drawing_object))
);
assert_eq!(
::std::mem::align_of::<lxw_drawing_object>(),
8usize,
concat!("Alignment of ", stringify!(lxw_drawing_object))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_object),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).anchor) as usize - ptr as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_object),
"::",
stringify!(anchor)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).from) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_object),
"::",
stringify!(from)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).to) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_object),
"::",
stringify!(to)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).col_absolute) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_object),
"::",
stringify!(col_absolute)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).row_absolute) as usize - ptr as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_object),
"::",
stringify!(row_absolute)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_object),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_object),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).shape) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_object),
"::",
stringify!(shape)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rel_index) as usize - ptr as usize },
76usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_object),
"::",
stringify!(rel_index)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).url_rel_index) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_object),
"::",
stringify!(url_rel_index)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).description) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_object),
"::",
stringify!(description)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tip) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_object),
"::",
stringify!(tip)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).decorative) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_object),
"::",
stringify!(decorative)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).list_pointers) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_object),
"::",
stringify!(list_pointers)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_drawing {
pub file: *mut FILE,
pub embedded: u8,
pub orientation: u8,
pub drawing_objects: *mut lxw_drawing_objects,
}
#[test]
fn bindgen_test_layout_lxw_drawing() {
const UNINIT: ::std::mem::MaybeUninit<lxw_drawing> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_drawing>(),
24usize,
concat!("Size of: ", stringify!(lxw_drawing))
);
assert_eq!(
::std::mem::align_of::<lxw_drawing>(),
8usize,
concat!("Alignment of ", stringify!(lxw_drawing))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).file) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing),
"::",
stringify!(file)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).embedded) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing),
"::",
stringify!(embedded)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).orientation) as usize - ptr as usize },
9usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing),
"::",
stringify!(orientation)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).drawing_objects) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing),
"::",
stringify!(drawing_objects)
)
);
}
extern "C" {
pub fn lxw_drawing_new() -> *mut lxw_drawing;
}
extern "C" {
pub fn lxw_drawing_free(drawing: *mut lxw_drawing);
}
extern "C" {
pub fn lxw_drawing_assemble_xml_file(self_: *mut lxw_drawing);
}
extern "C" {
pub fn lxw_free_drawing_object(drawing_object: *mut lxw_drawing_object);
}
extern "C" {
pub fn lxw_add_drawing_object(
drawing: *mut lxw_drawing,
drawing_object: *mut lxw_drawing_object,
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_styles {
pub file: *mut FILE,
pub font_count: u32,
pub xf_count: u32,
pub dxf_count: u32,
pub num_format_count: u32,
pub border_count: u32,
pub fill_count: u32,
pub xf_formats: *mut lxw_formats,
pub dxf_formats: *mut lxw_formats,
pub has_hyperlink: u8,
pub hyperlink_font_id: u16,
pub has_comments: u8,
}
#[test]
fn bindgen_test_layout_lxw_styles() {
const UNINIT: ::std::mem::MaybeUninit<lxw_styles> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_styles>(),
56usize,
concat!("Size of: ", stringify!(lxw_styles))
);
assert_eq!(
::std::mem::align_of::<lxw_styles>(),
8usize,
concat!("Alignment of ", stringify!(lxw_styles))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).file) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_styles),
"::",
stringify!(file)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font_count) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_styles),
"::",
stringify!(font_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xf_count) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(lxw_styles),
"::",
stringify!(xf_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dxf_count) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_styles),
"::",
stringify!(dxf_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).num_format_count) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(lxw_styles),
"::",
stringify!(num_format_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).border_count) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_styles),
"::",
stringify!(border_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fill_count) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(lxw_styles),
"::",
stringify!(fill_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).xf_formats) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_styles),
"::",
stringify!(xf_formats)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dxf_formats) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_styles),
"::",
stringify!(dxf_formats)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_hyperlink) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_styles),
"::",
stringify!(has_hyperlink)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hyperlink_font_id) as usize - ptr as usize },
50usize,
concat!(
"Offset of field: ",
stringify!(lxw_styles),
"::",
stringify!(hyperlink_font_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_comments) as usize - ptr as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(lxw_styles),
"::",
stringify!(has_comments)
)
);
}
extern "C" {
pub fn lxw_styles_new() -> *mut lxw_styles;
}
extern "C" {
pub fn lxw_styles_free(styles: *mut lxw_styles);
}
extern "C" {
pub fn lxw_styles_assemble_xml_file(self_: *mut lxw_styles);
}
extern "C" {
pub fn lxw_styles_write_string_fragment(
self_: *mut lxw_styles,
string: *mut ::std::os::raw::c_char,
);
}
extern "C" {
pub fn lxw_styles_write_rich_font(styles: *mut lxw_styles, format: *mut lxw_format);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct xml_attribute {
pub key: [::std::os::raw::c_char; 2080usize],
pub value: [::std::os::raw::c_char; 2080usize],
pub list_entries: xml_attribute__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct xml_attribute__bindgen_ty_1 {
pub stqe_next: *mut xml_attribute,
}
#[test]
fn bindgen_test_layout_xml_attribute__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<xml_attribute__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<xml_attribute__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(xml_attribute__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<xml_attribute__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(xml_attribute__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqe_next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(xml_attribute__bindgen_ty_1),
"::",
stringify!(stqe_next)
)
);
}
#[test]
fn bindgen_test_layout_xml_attribute() {
const UNINIT: ::std::mem::MaybeUninit<xml_attribute> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<xml_attribute>(),
4168usize,
concat!("Size of: ", stringify!(xml_attribute))
);
assert_eq!(
::std::mem::align_of::<xml_attribute>(),
8usize,
concat!("Alignment of ", stringify!(xml_attribute))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).key) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(xml_attribute),
"::",
stringify!(key)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
2080usize,
concat!(
"Offset of field: ",
stringify!(xml_attribute),
"::",
stringify!(value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).list_entries) as usize - ptr as usize },
4160usize,
concat!(
"Offset of field: ",
stringify!(xml_attribute),
"::",
stringify!(list_entries)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct xml_attribute_list {
pub stqh_first: *mut xml_attribute,
pub stqh_last: *mut *mut xml_attribute,
}
#[test]
fn bindgen_test_layout_xml_attribute_list() {
const UNINIT: ::std::mem::MaybeUninit<xml_attribute_list> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<xml_attribute_list>(),
16usize,
concat!("Size of: ", stringify!(xml_attribute_list))
);
assert_eq!(
::std::mem::align_of::<xml_attribute_list>(),
8usize,
concat!("Alignment of ", stringify!(xml_attribute_list))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_first) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(xml_attribute_list),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_last) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(xml_attribute_list),
"::",
stringify!(stqh_last)
)
);
}
extern "C" {
pub fn lxw_new_attribute_str(
key: *const ::std::os::raw::c_char,
value: *const ::std::os::raw::c_char,
) -> *mut xml_attribute;
}
extern "C" {
pub fn lxw_new_attribute_int(
key: *const ::std::os::raw::c_char,
value: u32,
) -> *mut xml_attribute;
}
extern "C" {
pub fn lxw_new_attribute_dbl(
key: *const ::std::os::raw::c_char,
value: f64,
) -> *mut xml_attribute;
}
extern "C" {
pub fn lxw_xml_declaration(xmlfile: *mut FILE);
}
extern "C" {
pub fn lxw_xml_start_tag(
xmlfile: *mut FILE,
tag: *const ::std::os::raw::c_char,
attributes: *mut xml_attribute_list,
);
}
extern "C" {
pub fn lxw_xml_start_tag_unencoded(
xmlfile: *mut FILE,
tag: *const ::std::os::raw::c_char,
attributes: *mut xml_attribute_list,
);
}
extern "C" {
pub fn lxw_xml_end_tag(xmlfile: *mut FILE, tag: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn lxw_xml_empty_tag(
xmlfile: *mut FILE,
tag: *const ::std::os::raw::c_char,
attributes: *mut xml_attribute_list,
);
}
extern "C" {
pub fn lxw_xml_empty_tag_unencoded(
xmlfile: *mut FILE,
tag: *const ::std::os::raw::c_char,
attributes: *mut xml_attribute_list,
);
}
extern "C" {
pub fn lxw_xml_data_element(
xmlfile: *mut FILE,
tag: *const ::std::os::raw::c_char,
data: *const ::std::os::raw::c_char,
attributes: *mut xml_attribute_list,
);
}
extern "C" {
pub fn lxw_xml_rich_si_element(xmlfile: *mut FILE, string: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn lxw_has_control_characters(string: *const ::std::os::raw::c_char) -> u8;
}
extern "C" {
pub fn lxw_escape_control_characters(
string: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn lxw_escape_url_characters(
string: *const ::std::os::raw::c_char,
escape_hash: u8,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn lxw_escape_data(data: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn lxw_version() -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn lxw_version_id() -> u16;
}
extern "C" {
pub fn lxw_strerror(error_num: lxw_error) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn lxw_quote_sheetname(str_: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn lxw_col_to_name(col_name: *mut ::std::os::raw::c_char, col_num: lxw_col_t, absolute: u8);
}
extern "C" {
pub fn lxw_rowcol_to_cell(
cell_name: *mut ::std::os::raw::c_char,
row: lxw_row_t,
col: lxw_col_t,
);
}
extern "C" {
pub fn lxw_rowcol_to_cell_abs(
cell_name: *mut ::std::os::raw::c_char,
row: lxw_row_t,
col: lxw_col_t,
abs_row: u8,
abs_col: u8,
);
}
extern "C" {
pub fn lxw_rowcol_to_range(
range: *mut ::std::os::raw::c_char,
first_row: lxw_row_t,
first_col: lxw_col_t,
last_row: lxw_row_t,
last_col: lxw_col_t,
);
}
extern "C" {
pub fn lxw_rowcol_to_range_abs(
range: *mut ::std::os::raw::c_char,
first_row: lxw_row_t,
first_col: lxw_col_t,
last_row: lxw_row_t,
last_col: lxw_col_t,
);
}
extern "C" {
pub fn lxw_rowcol_to_formula_abs(
formula: *mut ::std::os::raw::c_char,
sheetname: *const ::std::os::raw::c_char,
first_row: lxw_row_t,
first_col: lxw_col_t,
last_row: lxw_row_t,
last_col: lxw_col_t,
);
}
extern "C" {
pub fn lxw_name_to_row(row_str: *const ::std::os::raw::c_char) -> u32;
}
extern "C" {
pub fn lxw_name_to_col(col_str: *const ::std::os::raw::c_char) -> u16;
}
extern "C" {
pub fn lxw_name_to_row_2(row_str: *const ::std::os::raw::c_char) -> u32;
}
extern "C" {
pub fn lxw_name_to_col_2(col_str: *const ::std::os::raw::c_char) -> u16;
}
extern "C" {
pub fn lxw_datetime_to_excel_datetime(datetime: *mut lxw_datetime) -> f64;
}
extern "C" {
pub fn lxw_datetime_to_excel_date_epoch(datetime: *mut lxw_datetime, date_1904: u8) -> f64;
}
extern "C" {
pub fn lxw_unixtime_to_excel_date(unixtime: i64) -> f64;
}
extern "C" {
pub fn lxw_unixtime_to_excel_date_epoch(unixtime: i64, date_1904: u8) -> f64;
}
extern "C" {
pub fn lxw_strdup(str_: *const ::std::os::raw::c_char) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn lxw_strdup_formula(
formula: *const ::std::os::raw::c_char,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn lxw_utf8_strlen(str_: *const ::std::os::raw::c_char) -> usize;
}
extern "C" {
pub fn lxw_str_tolower(str_: *mut ::std::os::raw::c_char);
}
extern "C" {
pub fn lxw_tmpfile(tmpdir: *mut ::std::os::raw::c_char) -> *mut FILE;
}
extern "C" {
pub fn lxw_get_filehandle(
buf: *mut *mut ::std::os::raw::c_char,
size: *mut usize,
tmpdir: *mut ::std::os::raw::c_char,
) -> *mut FILE;
}
extern "C" {
pub fn lxw_fopen(
filename: *const ::std::os::raw::c_char,
mode: *const ::std::os::raw::c_char,
) -> *mut FILE;
}
extern "C" {
pub fn lxw_hash_password(password: *const ::std::os::raw::c_char) -> u16;
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_rel_tuples {
pub stqh_first: *mut lxw_rel_tuple,
pub stqh_last: *mut *mut lxw_rel_tuple,
}
#[test]
fn bindgen_test_layout_lxw_rel_tuples() {
const UNINIT: ::std::mem::MaybeUninit<lxw_rel_tuples> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_rel_tuples>(),
16usize,
concat!("Size of: ", stringify!(lxw_rel_tuples))
);
assert_eq!(
::std::mem::align_of::<lxw_rel_tuples>(),
8usize,
concat!("Alignment of ", stringify!(lxw_rel_tuples))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_first) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_rel_tuples),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_last) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_rel_tuples),
"::",
stringify!(stqh_last)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_rel_tuple {
pub type_: *mut ::std::os::raw::c_char,
pub target: *mut ::std::os::raw::c_char,
pub target_mode: *mut ::std::os::raw::c_char,
pub list_pointers: lxw_rel_tuple__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_rel_tuple__bindgen_ty_1 {
pub stqe_next: *mut lxw_rel_tuple,
}
#[test]
fn bindgen_test_layout_lxw_rel_tuple__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<lxw_rel_tuple__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_rel_tuple__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(lxw_rel_tuple__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<lxw_rel_tuple__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(lxw_rel_tuple__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqe_next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_rel_tuple__bindgen_ty_1),
"::",
stringify!(stqe_next)
)
);
}
#[test]
fn bindgen_test_layout_lxw_rel_tuple() {
const UNINIT: ::std::mem::MaybeUninit<lxw_rel_tuple> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_rel_tuple>(),
32usize,
concat!("Size of: ", stringify!(lxw_rel_tuple))
);
assert_eq!(
::std::mem::align_of::<lxw_rel_tuple>(),
8usize,
concat!("Alignment of ", stringify!(lxw_rel_tuple))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_rel_tuple),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).target) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_rel_tuple),
"::",
stringify!(target)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).target_mode) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_rel_tuple),
"::",
stringify!(target_mode)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).list_pointers) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_rel_tuple),
"::",
stringify!(list_pointers)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_relationships {
pub file: *mut FILE,
pub rel_id: u32,
pub relationships: *mut lxw_rel_tuples,
}
#[test]
fn bindgen_test_layout_lxw_relationships() {
const UNINIT: ::std::mem::MaybeUninit<lxw_relationships> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_relationships>(),
24usize,
concat!("Size of: ", stringify!(lxw_relationships))
);
assert_eq!(
::std::mem::align_of::<lxw_relationships>(),
8usize,
concat!("Alignment of ", stringify!(lxw_relationships))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).file) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_relationships),
"::",
stringify!(file)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rel_id) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_relationships),
"::",
stringify!(rel_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).relationships) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_relationships),
"::",
stringify!(relationships)
)
);
}
extern "C" {
pub fn lxw_relationships_new() -> *mut lxw_relationships;
}
extern "C" {
pub fn lxw_free_relationships(relationships: *mut lxw_relationships);
}
extern "C" {
pub fn lxw_relationships_assemble_xml_file(self_: *mut lxw_relationships);
}
extern "C" {
pub fn lxw_add_document_relationship(
self_: *mut lxw_relationships,
type_: *const ::std::os::raw::c_char,
target: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn lxw_add_package_relationship(
self_: *mut lxw_relationships,
type_: *const ::std::os::raw::c_char,
target: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn lxw_add_ms_package_relationship(
self_: *mut lxw_relationships,
type_: *const ::std::os::raw::c_char,
target: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn lxw_add_worksheet_relationship(
self_: *mut lxw_relationships,
type_: *const ::std::os::raw::c_char,
target: *const ::std::os::raw::c_char,
target_mode: *const ::std::os::raw::c_char,
);
}
pub const lxw_gridlines_LXW_HIDE_ALL_GRIDLINES: lxw_gridlines = 0;
pub const lxw_gridlines_LXW_SHOW_SCREEN_GRIDLINES: lxw_gridlines = 1;
pub const lxw_gridlines_LXW_SHOW_PRINT_GRIDLINES: lxw_gridlines = 2;
pub const lxw_gridlines_LXW_SHOW_ALL_GRIDLINES: lxw_gridlines = 3;
pub type lxw_gridlines = ::std::os::raw::c_uint;
pub const lxw_validation_boolean_LXW_VALIDATION_DEFAULT: lxw_validation_boolean = 0;
pub const lxw_validation_boolean_LXW_VALIDATION_OFF: lxw_validation_boolean = 1;
pub const lxw_validation_boolean_LXW_VALIDATION_ON: lxw_validation_boolean = 2;
pub type lxw_validation_boolean = ::std::os::raw::c_uint;
pub const lxw_validation_types_LXW_VALIDATION_TYPE_NONE: lxw_validation_types = 0;
pub const lxw_validation_types_LXW_VALIDATION_TYPE_INTEGER: lxw_validation_types = 1;
pub const lxw_validation_types_LXW_VALIDATION_TYPE_INTEGER_FORMULA: lxw_validation_types = 2;
pub const lxw_validation_types_LXW_VALIDATION_TYPE_DECIMAL: lxw_validation_types = 3;
pub const lxw_validation_types_LXW_VALIDATION_TYPE_DECIMAL_FORMULA: lxw_validation_types = 4;
pub const lxw_validation_types_LXW_VALIDATION_TYPE_LIST: lxw_validation_types = 5;
pub const lxw_validation_types_LXW_VALIDATION_TYPE_LIST_FORMULA: lxw_validation_types = 6;
pub const lxw_validation_types_LXW_VALIDATION_TYPE_DATE: lxw_validation_types = 7;
pub const lxw_validation_types_LXW_VALIDATION_TYPE_DATE_FORMULA: lxw_validation_types = 8;
pub const lxw_validation_types_LXW_VALIDATION_TYPE_DATE_NUMBER: lxw_validation_types = 9;
pub const lxw_validation_types_LXW_VALIDATION_TYPE_TIME: lxw_validation_types = 10;
pub const lxw_validation_types_LXW_VALIDATION_TYPE_TIME_FORMULA: lxw_validation_types = 11;
pub const lxw_validation_types_LXW_VALIDATION_TYPE_TIME_NUMBER: lxw_validation_types = 12;
pub const lxw_validation_types_LXW_VALIDATION_TYPE_LENGTH: lxw_validation_types = 13;
pub const lxw_validation_types_LXW_VALIDATION_TYPE_LENGTH_FORMULA: lxw_validation_types = 14;
pub const lxw_validation_types_LXW_VALIDATION_TYPE_CUSTOM_FORMULA: lxw_validation_types = 15;
pub const lxw_validation_types_LXW_VALIDATION_TYPE_ANY: lxw_validation_types = 16;
pub type lxw_validation_types = ::std::os::raw::c_uint;
pub const lxw_validation_criteria_LXW_VALIDATION_CRITERIA_NONE: lxw_validation_criteria = 0;
pub const lxw_validation_criteria_LXW_VALIDATION_CRITERIA_BETWEEN: lxw_validation_criteria = 1;
pub const lxw_validation_criteria_LXW_VALIDATION_CRITERIA_NOT_BETWEEN: lxw_validation_criteria = 2;
pub const lxw_validation_criteria_LXW_VALIDATION_CRITERIA_EQUAL_TO: lxw_validation_criteria = 3;
pub const lxw_validation_criteria_LXW_VALIDATION_CRITERIA_NOT_EQUAL_TO: lxw_validation_criteria = 4;
pub const lxw_validation_criteria_LXW_VALIDATION_CRITERIA_GREATER_THAN: lxw_validation_criteria = 5;
pub const lxw_validation_criteria_LXW_VALIDATION_CRITERIA_LESS_THAN: lxw_validation_criteria = 6;
pub const lxw_validation_criteria_LXW_VALIDATION_CRITERIA_GREATER_THAN_OR_EQUAL_TO:
lxw_validation_criteria = 7;
pub const lxw_validation_criteria_LXW_VALIDATION_CRITERIA_LESS_THAN_OR_EQUAL_TO:
lxw_validation_criteria = 8;
pub type lxw_validation_criteria = ::std::os::raw::c_uint;
pub const lxw_validation_error_types_LXW_VALIDATION_ERROR_TYPE_STOP: lxw_validation_error_types = 0;
pub const lxw_validation_error_types_LXW_VALIDATION_ERROR_TYPE_WARNING: lxw_validation_error_types =
1;
pub const lxw_validation_error_types_LXW_VALIDATION_ERROR_TYPE_INFORMATION:
lxw_validation_error_types = 2;
pub type lxw_validation_error_types = ::std::os::raw::c_uint;
pub const lxw_comment_display_types_LXW_COMMENT_DISPLAY_DEFAULT: lxw_comment_display_types = 0;
pub const lxw_comment_display_types_LXW_COMMENT_DISPLAY_HIDDEN: lxw_comment_display_types = 1;
pub const lxw_comment_display_types_LXW_COMMENT_DISPLAY_VISIBLE: lxw_comment_display_types = 2;
pub type lxw_comment_display_types = ::std::os::raw::c_uint;
pub const lxw_conditional_format_types_LXW_CONDITIONAL_TYPE_NONE: lxw_conditional_format_types = 0;
pub const lxw_conditional_format_types_LXW_CONDITIONAL_TYPE_CELL: lxw_conditional_format_types = 1;
pub const lxw_conditional_format_types_LXW_CONDITIONAL_TYPE_TEXT: lxw_conditional_format_types = 2;
pub const lxw_conditional_format_types_LXW_CONDITIONAL_TYPE_TIME_PERIOD:
lxw_conditional_format_types = 3;
pub const lxw_conditional_format_types_LXW_CONDITIONAL_TYPE_AVERAGE: lxw_conditional_format_types =
4;
pub const lxw_conditional_format_types_LXW_CONDITIONAL_TYPE_DUPLICATE:
lxw_conditional_format_types = 5;
pub const lxw_conditional_format_types_LXW_CONDITIONAL_TYPE_UNIQUE: lxw_conditional_format_types =
6;
pub const lxw_conditional_format_types_LXW_CONDITIONAL_TYPE_TOP: lxw_conditional_format_types = 7;
pub const lxw_conditional_format_types_LXW_CONDITIONAL_TYPE_BOTTOM: lxw_conditional_format_types =
8;
pub const lxw_conditional_format_types_LXW_CONDITIONAL_TYPE_BLANKS: lxw_conditional_format_types =
9;
pub const lxw_conditional_format_types_LXW_CONDITIONAL_TYPE_NO_BLANKS:
lxw_conditional_format_types = 10;
pub const lxw_conditional_format_types_LXW_CONDITIONAL_TYPE_ERRORS: lxw_conditional_format_types =
11;
pub const lxw_conditional_format_types_LXW_CONDITIONAL_TYPE_NO_ERRORS:
lxw_conditional_format_types = 12;
pub const lxw_conditional_format_types_LXW_CONDITIONAL_TYPE_FORMULA: lxw_conditional_format_types =
13;
pub const lxw_conditional_format_types_LXW_CONDITIONAL_2_COLOR_SCALE: lxw_conditional_format_types =
14;
pub const lxw_conditional_format_types_LXW_CONDITIONAL_3_COLOR_SCALE: lxw_conditional_format_types =
15;
pub const lxw_conditional_format_types_LXW_CONDITIONAL_DATA_BAR: lxw_conditional_format_types = 16;
pub const lxw_conditional_format_types_LXW_CONDITIONAL_TYPE_ICON_SETS:
lxw_conditional_format_types = 17;
pub const lxw_conditional_format_types_LXW_CONDITIONAL_TYPE_LAST: lxw_conditional_format_types = 18;
pub type lxw_conditional_format_types = ::std::os::raw::c_uint;
pub const lxw_conditional_criteria_LXW_CONDITIONAL_CRITERIA_NONE: lxw_conditional_criteria = 0;
pub const lxw_conditional_criteria_LXW_CONDITIONAL_CRITERIA_EQUAL_TO: lxw_conditional_criteria = 1;
pub const lxw_conditional_criteria_LXW_CONDITIONAL_CRITERIA_NOT_EQUAL_TO: lxw_conditional_criteria =
2;
pub const lxw_conditional_criteria_LXW_CONDITIONAL_CRITERIA_GREATER_THAN: lxw_conditional_criteria =
3;
pub const lxw_conditional_criteria_LXW_CONDITIONAL_CRITERIA_LESS_THAN: lxw_conditional_criteria = 4;
pub const lxw_conditional_criteria_LXW_CONDITIONAL_CRITERIA_GREATER_THAN_OR_EQUAL_TO:
lxw_conditional_criteria = 5;
pub const lxw_conditional_criteria_LXW_CONDITIONAL_CRITERIA_LESS_THAN_OR_EQUAL_TO:
lxw_conditional_criteria = 6;
pub const lxw_conditional_criteria_LXW_CONDITIONAL_CRITERIA_BETWEEN: lxw_conditional_criteria = 7;
pub const lxw_conditional_criteria_LXW_CONDITIONAL_CRITERIA_NOT_BETWEEN: lxw_conditional_criteria =
8;
pub const lxw_conditional_criteria_LXW_CONDITIONAL_CRITERIA_TEXT_CONTAINING:
lxw_conditional_criteria = 9;
pub const lxw_conditional_criteria_LXW_CONDITIONAL_CRITERIA_TEXT_NOT_CONTAINING:
lxw_conditional_criteria = 10;
pub const lxw_conditional_criteria_LXW_CONDITIONAL_CRITERIA_TEXT_BEGINS_WITH:
lxw_conditional_criteria = 11;
pub const lxw_conditional_criteria_LXW_CONDITIONAL_CRITERIA_TEXT_ENDS_WITH:
lxw_conditional_criteria = 12;
pub const lxw_conditional_criteria_LXW_CONDITIONAL_CRITERIA_TIME_PERIOD_YESTERDAY:
lxw_conditional_criteria = 13;
pub const lxw_conditional_criteria_LXW_CONDITIONAL_CRITERIA_TIME_PERIOD_TODAY:
lxw_conditional_criteria = 14;
pub const lxw_conditional_criteria_LXW_CONDITIONAL_CRITERIA_TIME_PERIOD_TOMORROW:
lxw_conditional_criteria = 15;
pub const lxw_conditional_criteria_LXW_CONDITIONAL_CRITERIA_TIME_PERIOD_LAST_7_DAYS:
lxw_conditional_criteria = 16;
pub const lxw_conditional_criteria_LXW_CONDITIONAL_CRITERIA_TIME_PERIOD_LAST_WEEK:
lxw_conditional_criteria = 17;
pub const lxw_conditional_criteria_LXW_CONDITIONAL_CRITERIA_TIME_PERIOD_THIS_WEEK:
lxw_conditional_criteria = 18;
pub const lxw_conditional_criteria_LXW_CONDITIONAL_CRITERIA_TIME_PERIOD_NEXT_WEEK:
lxw_conditional_criteria = 19;
pub const lxw_conditional_criteria_LXW_CONDITIONAL_CRITERIA_TIME_PERIOD_LAST_MONTH:
lxw_conditional_criteria = 20;
pub const lxw_conditional_criteria_LXW_CONDITIONAL_CRITERIA_TIME_PERIOD_THIS_MONTH:
lxw_conditional_criteria = 21;
pub const lxw_conditional_criteria_LXW_CONDITIONAL_CRITERIA_TIME_PERIOD_NEXT_MONTH:
lxw_conditional_criteria = 22;
pub const lxw_conditional_criteria_LXW_CONDITIONAL_CRITERIA_AVERAGE_ABOVE:
lxw_conditional_criteria = 23;
pub const lxw_conditional_criteria_LXW_CONDITIONAL_CRITERIA_AVERAGE_BELOW:
lxw_conditional_criteria = 24;
pub const lxw_conditional_criteria_LXW_CONDITIONAL_CRITERIA_AVERAGE_ABOVE_OR_EQUAL:
lxw_conditional_criteria = 25;
pub const lxw_conditional_criteria_LXW_CONDITIONAL_CRITERIA_AVERAGE_BELOW_OR_EQUAL:
lxw_conditional_criteria = 26;
pub const lxw_conditional_criteria_LXW_CONDITIONAL_CRITERIA_AVERAGE_1_STD_DEV_ABOVE:
lxw_conditional_criteria = 27;
pub const lxw_conditional_criteria_LXW_CONDITIONAL_CRITERIA_AVERAGE_1_STD_DEV_BELOW:
lxw_conditional_criteria = 28;
pub const lxw_conditional_criteria_LXW_CONDITIONAL_CRITERIA_AVERAGE_2_STD_DEV_ABOVE:
lxw_conditional_criteria = 29;
pub const lxw_conditional_criteria_LXW_CONDITIONAL_CRITERIA_AVERAGE_2_STD_DEV_BELOW:
lxw_conditional_criteria = 30;
pub const lxw_conditional_criteria_LXW_CONDITIONAL_CRITERIA_AVERAGE_3_STD_DEV_ABOVE:
lxw_conditional_criteria = 31;
pub const lxw_conditional_criteria_LXW_CONDITIONAL_CRITERIA_AVERAGE_3_STD_DEV_BELOW:
lxw_conditional_criteria = 32;
pub const lxw_conditional_criteria_LXW_CONDITIONAL_CRITERIA_TOP_OR_BOTTOM_PERCENT:
lxw_conditional_criteria = 33;
pub type lxw_conditional_criteria = ::std::os::raw::c_uint;
pub const lxw_conditional_format_rule_types_LXW_CONDITIONAL_RULE_TYPE_NONE:
lxw_conditional_format_rule_types = 0;
pub const lxw_conditional_format_rule_types_LXW_CONDITIONAL_RULE_TYPE_MINIMUM:
lxw_conditional_format_rule_types = 1;
pub const lxw_conditional_format_rule_types_LXW_CONDITIONAL_RULE_TYPE_NUMBER:
lxw_conditional_format_rule_types = 2;
pub const lxw_conditional_format_rule_types_LXW_CONDITIONAL_RULE_TYPE_PERCENT:
lxw_conditional_format_rule_types = 3;
pub const lxw_conditional_format_rule_types_LXW_CONDITIONAL_RULE_TYPE_PERCENTILE:
lxw_conditional_format_rule_types = 4;
pub const lxw_conditional_format_rule_types_LXW_CONDITIONAL_RULE_TYPE_FORMULA:
lxw_conditional_format_rule_types = 5;
pub const lxw_conditional_format_rule_types_LXW_CONDITIONAL_RULE_TYPE_MAXIMUM:
lxw_conditional_format_rule_types = 6;
pub const lxw_conditional_format_rule_types_LXW_CONDITIONAL_RULE_TYPE_AUTO_MIN:
lxw_conditional_format_rule_types = 7;
pub const lxw_conditional_format_rule_types_LXW_CONDITIONAL_RULE_TYPE_AUTO_MAX:
lxw_conditional_format_rule_types = 8;
pub type lxw_conditional_format_rule_types = ::std::os::raw::c_uint;
pub const lxw_conditional_format_bar_direction_LXW_CONDITIONAL_BAR_DIRECTION_CONTEXT:
lxw_conditional_format_bar_direction = 0;
pub const lxw_conditional_format_bar_direction_LXW_CONDITIONAL_BAR_DIRECTION_RIGHT_TO_LEFT:
lxw_conditional_format_bar_direction = 1;
pub const lxw_conditional_format_bar_direction_LXW_CONDITIONAL_BAR_DIRECTION_LEFT_TO_RIGHT:
lxw_conditional_format_bar_direction = 2;
pub type lxw_conditional_format_bar_direction = ::std::os::raw::c_uint;
pub const lxw_conditional_bar_axis_position_LXW_CONDITIONAL_BAR_AXIS_AUTOMATIC:
lxw_conditional_bar_axis_position = 0;
pub const lxw_conditional_bar_axis_position_LXW_CONDITIONAL_BAR_AXIS_MIDPOINT:
lxw_conditional_bar_axis_position = 1;
pub const lxw_conditional_bar_axis_position_LXW_CONDITIONAL_BAR_AXIS_NONE:
lxw_conditional_bar_axis_position = 2;
pub type lxw_conditional_bar_axis_position = ::std::os::raw::c_uint;
pub const lxw_conditional_icon_types_LXW_CONDITIONAL_ICONS_3_ARROWS_COLORED:
lxw_conditional_icon_types = 0;
pub const lxw_conditional_icon_types_LXW_CONDITIONAL_ICONS_3_ARROWS_GRAY:
lxw_conditional_icon_types = 1;
pub const lxw_conditional_icon_types_LXW_CONDITIONAL_ICONS_3_FLAGS: lxw_conditional_icon_types = 2;
pub const lxw_conditional_icon_types_LXW_CONDITIONAL_ICONS_3_TRAFFIC_LIGHTS_UNRIMMED:
lxw_conditional_icon_types = 3;
pub const lxw_conditional_icon_types_LXW_CONDITIONAL_ICONS_3_TRAFFIC_LIGHTS_RIMMED:
lxw_conditional_icon_types = 4;
pub const lxw_conditional_icon_types_LXW_CONDITIONAL_ICONS_3_SIGNS: lxw_conditional_icon_types = 5;
pub const lxw_conditional_icon_types_LXW_CONDITIONAL_ICONS_3_SYMBOLS_CIRCLED:
lxw_conditional_icon_types = 6;
pub const lxw_conditional_icon_types_LXW_CONDITIONAL_ICONS_3_SYMBOLS_UNCIRCLED:
lxw_conditional_icon_types = 7;
pub const lxw_conditional_icon_types_LXW_CONDITIONAL_ICONS_4_ARROWS_COLORED:
lxw_conditional_icon_types = 8;
pub const lxw_conditional_icon_types_LXW_CONDITIONAL_ICONS_4_ARROWS_GRAY:
lxw_conditional_icon_types = 9;
pub const lxw_conditional_icon_types_LXW_CONDITIONAL_ICONS_4_RED_TO_BLACK:
lxw_conditional_icon_types = 10;
pub const lxw_conditional_icon_types_LXW_CONDITIONAL_ICONS_4_RATINGS: lxw_conditional_icon_types =
11;
pub const lxw_conditional_icon_types_LXW_CONDITIONAL_ICONS_4_TRAFFIC_LIGHTS:
lxw_conditional_icon_types = 12;
pub const lxw_conditional_icon_types_LXW_CONDITIONAL_ICONS_5_ARROWS_COLORED:
lxw_conditional_icon_types = 13;
pub const lxw_conditional_icon_types_LXW_CONDITIONAL_ICONS_5_ARROWS_GRAY:
lxw_conditional_icon_types = 14;
pub const lxw_conditional_icon_types_LXW_CONDITIONAL_ICONS_5_RATINGS: lxw_conditional_icon_types =
15;
pub const lxw_conditional_icon_types_LXW_CONDITIONAL_ICONS_5_QUARTERS: lxw_conditional_icon_types =
16;
pub type lxw_conditional_icon_types = ::std::os::raw::c_uint;
pub const lxw_table_style_type_LXW_TABLE_STYLE_TYPE_DEFAULT: lxw_table_style_type = 0;
pub const lxw_table_style_type_LXW_TABLE_STYLE_TYPE_LIGHT: lxw_table_style_type = 1;
pub const lxw_table_style_type_LXW_TABLE_STYLE_TYPE_MEDIUM: lxw_table_style_type = 2;
pub const lxw_table_style_type_LXW_TABLE_STYLE_TYPE_DARK: lxw_table_style_type = 3;
pub type lxw_table_style_type = ::std::os::raw::c_uint;
pub const lxw_table_total_functions_LXW_TABLE_FUNCTION_NONE: lxw_table_total_functions = 0;
pub const lxw_table_total_functions_LXW_TABLE_FUNCTION_AVERAGE: lxw_table_total_functions = 101;
pub const lxw_table_total_functions_LXW_TABLE_FUNCTION_COUNT_NUMS: lxw_table_total_functions = 102;
pub const lxw_table_total_functions_LXW_TABLE_FUNCTION_COUNT: lxw_table_total_functions = 103;
pub const lxw_table_total_functions_LXW_TABLE_FUNCTION_MAX: lxw_table_total_functions = 104;
pub const lxw_table_total_functions_LXW_TABLE_FUNCTION_MIN: lxw_table_total_functions = 105;
pub const lxw_table_total_functions_LXW_TABLE_FUNCTION_STD_DEV: lxw_table_total_functions = 107;
pub const lxw_table_total_functions_LXW_TABLE_FUNCTION_SUM: lxw_table_total_functions = 109;
pub const lxw_table_total_functions_LXW_TABLE_FUNCTION_VAR: lxw_table_total_functions = 110;
pub type lxw_table_total_functions = ::std::os::raw::c_uint;
pub const lxw_filter_criteria_LXW_FILTER_CRITERIA_NONE: lxw_filter_criteria = 0;
pub const lxw_filter_criteria_LXW_FILTER_CRITERIA_EQUAL_TO: lxw_filter_criteria = 1;
pub const lxw_filter_criteria_LXW_FILTER_CRITERIA_NOT_EQUAL_TO: lxw_filter_criteria = 2;
pub const lxw_filter_criteria_LXW_FILTER_CRITERIA_GREATER_THAN: lxw_filter_criteria = 3;
pub const lxw_filter_criteria_LXW_FILTER_CRITERIA_LESS_THAN: lxw_filter_criteria = 4;
pub const lxw_filter_criteria_LXW_FILTER_CRITERIA_GREATER_THAN_OR_EQUAL_TO: lxw_filter_criteria = 5;
pub const lxw_filter_criteria_LXW_FILTER_CRITERIA_LESS_THAN_OR_EQUAL_TO: lxw_filter_criteria = 6;
pub const lxw_filter_criteria_LXW_FILTER_CRITERIA_BLANKS: lxw_filter_criteria = 7;
pub const lxw_filter_criteria_LXW_FILTER_CRITERIA_NON_BLANKS: lxw_filter_criteria = 8;
pub type lxw_filter_criteria = ::std::os::raw::c_uint;
pub const lxw_filter_operator_LXW_FILTER_AND: lxw_filter_operator = 0;
pub const lxw_filter_operator_LXW_FILTER_OR: lxw_filter_operator = 1;
pub type lxw_filter_operator = ::std::os::raw::c_uint;
pub const lxw_filter_type_LXW_FILTER_TYPE_NONE: lxw_filter_type = 0;
pub const lxw_filter_type_LXW_FILTER_TYPE_SINGLE: lxw_filter_type = 1;
pub const lxw_filter_type_LXW_FILTER_TYPE_AND: lxw_filter_type = 2;
pub const lxw_filter_type_LXW_FILTER_TYPE_OR: lxw_filter_type = 3;
pub const lxw_filter_type_LXW_FILTER_TYPE_STRING_LIST: lxw_filter_type = 4;
pub type lxw_filter_type = ::std::os::raw::c_uint;
pub const lxw_object_position_LXW_OBJECT_POSITION_DEFAULT: lxw_object_position = 0;
pub const lxw_object_position_LXW_OBJECT_MOVE_AND_SIZE: lxw_object_position = 1;
pub const lxw_object_position_LXW_OBJECT_MOVE_DONT_SIZE: lxw_object_position = 2;
pub const lxw_object_position_LXW_OBJECT_DONT_MOVE_DONT_SIZE: lxw_object_position = 3;
pub const lxw_object_position_LXW_OBJECT_MOVE_AND_SIZE_AFTER: lxw_object_position = 4;
pub type lxw_object_position = ::std::os::raw::c_uint;
pub const lxw_ignore_errors_LXW_IGNORE_NUMBER_STORED_AS_TEXT: lxw_ignore_errors = 1;
pub const lxw_ignore_errors_LXW_IGNORE_EVAL_ERROR: lxw_ignore_errors = 2;
pub const lxw_ignore_errors_LXW_IGNORE_FORMULA_DIFFERS: lxw_ignore_errors = 3;
pub const lxw_ignore_errors_LXW_IGNORE_FORMULA_RANGE: lxw_ignore_errors = 4;
pub const lxw_ignore_errors_LXW_IGNORE_FORMULA_UNLOCKED: lxw_ignore_errors = 5;
pub const lxw_ignore_errors_LXW_IGNORE_EMPTY_CELL_REFERENCE: lxw_ignore_errors = 6;
pub const lxw_ignore_errors_LXW_IGNORE_LIST_DATA_VALIDATION: lxw_ignore_errors = 7;
pub const lxw_ignore_errors_LXW_IGNORE_CALCULATED_COLUMN: lxw_ignore_errors = 8;
pub const lxw_ignore_errors_LXW_IGNORE_TWO_DIGIT_TEXT_YEAR: lxw_ignore_errors = 9;
pub const lxw_ignore_errors_LXW_IGNORE_LAST_OPTION: lxw_ignore_errors = 10;
pub type lxw_ignore_errors = ::std::os::raw::c_uint;
pub const cell_types_NUMBER_CELL: cell_types = 1;
pub const cell_types_STRING_CELL: cell_types = 2;
pub const cell_types_INLINE_STRING_CELL: cell_types = 3;
pub const cell_types_INLINE_RICH_STRING_CELL: cell_types = 4;
pub const cell_types_FORMULA_CELL: cell_types = 5;
pub const cell_types_ARRAY_FORMULA_CELL: cell_types = 6;
pub const cell_types_DYNAMIC_ARRAY_FORMULA_CELL: cell_types = 7;
pub const cell_types_BLANK_CELL: cell_types = 8;
pub const cell_types_BOOLEAN_CELL: cell_types = 9;
pub const cell_types_COMMENT: cell_types = 10;
pub const cell_types_HYPERLINK_URL: cell_types = 11;
pub const cell_types_HYPERLINK_INTERNAL: cell_types = 12;
pub const cell_types_HYPERLINK_EXTERNAL: cell_types = 13;
pub type cell_types = ::std::os::raw::c_uint;
pub const lxw_image_position_HEADER_LEFT: lxw_image_position = 0;
pub const lxw_image_position_HEADER_CENTER: lxw_image_position = 1;
pub const lxw_image_position_HEADER_RIGHT: lxw_image_position = 2;
pub const lxw_image_position_FOOTER_LEFT: lxw_image_position = 3;
pub const lxw_image_position_FOOTER_CENTER: lxw_image_position = 4;
pub const lxw_image_position_FOOTER_RIGHT: lxw_image_position = 5;
pub type lxw_image_position = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_table_cells {
pub rbh_root: *mut lxw_cell,
}
#[test]
fn bindgen_test_layout_lxw_table_cells() {
const UNINIT: ::std::mem::MaybeUninit<lxw_table_cells> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_table_cells>(),
8usize,
concat!("Size of: ", stringify!(lxw_table_cells))
);
assert_eq!(
::std::mem::align_of::<lxw_table_cells>(),
8usize,
concat!("Alignment of ", stringify!(lxw_table_cells))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbh_root) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_cells),
"::",
stringify!(rbh_root)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_drawing_rel_ids {
pub rbh_root: *mut lxw_drawing_rel_id,
}
#[test]
fn bindgen_test_layout_lxw_drawing_rel_ids() {
const UNINIT: ::std::mem::MaybeUninit<lxw_drawing_rel_ids> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_drawing_rel_ids>(),
8usize,
concat!("Size of: ", stringify!(lxw_drawing_rel_ids))
);
assert_eq!(
::std::mem::align_of::<lxw_drawing_rel_ids>(),
8usize,
concat!("Alignment of ", stringify!(lxw_drawing_rel_ids))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbh_root) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_rel_ids),
"::",
stringify!(rbh_root)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_vml_drawing_rel_ids {
pub rbh_root: *mut lxw_drawing_rel_id,
}
#[test]
fn bindgen_test_layout_lxw_vml_drawing_rel_ids() {
const UNINIT: ::std::mem::MaybeUninit<lxw_vml_drawing_rel_ids> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_vml_drawing_rel_ids>(),
8usize,
concat!("Size of: ", stringify!(lxw_vml_drawing_rel_ids))
);
assert_eq!(
::std::mem::align_of::<lxw_vml_drawing_rel_ids>(),
8usize,
concat!("Alignment of ", stringify!(lxw_vml_drawing_rel_ids))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbh_root) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_drawing_rel_ids),
"::",
stringify!(rbh_root)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_cond_format_hash {
pub rbh_root: *mut lxw_cond_format_hash_element,
}
#[test]
fn bindgen_test_layout_lxw_cond_format_hash() {
const UNINIT: ::std::mem::MaybeUninit<lxw_cond_format_hash> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_cond_format_hash>(),
8usize,
concat!("Size of: ", stringify!(lxw_cond_format_hash))
);
assert_eq!(
::std::mem::align_of::<lxw_cond_format_hash>(),
8usize,
concat!("Alignment of ", stringify!(lxw_cond_format_hash))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbh_root) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_hash),
"::",
stringify!(rbh_root)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_table_rows {
pub rbh_root: *mut lxw_row,
pub cached_row: *mut lxw_row,
pub cached_row_num: lxw_row_t,
}
#[test]
fn bindgen_test_layout_lxw_table_rows() {
const UNINIT: ::std::mem::MaybeUninit<lxw_table_rows> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_table_rows>(),
24usize,
concat!("Size of: ", stringify!(lxw_table_rows))
);
assert_eq!(
::std::mem::align_of::<lxw_table_rows>(),
8usize,
concat!("Alignment of ", stringify!(lxw_table_rows))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbh_root) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_rows),
"::",
stringify!(rbh_root)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cached_row) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_rows),
"::",
stringify!(cached_row)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cached_row_num) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_rows),
"::",
stringify!(cached_row_num)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_merged_ranges {
pub stqh_first: *mut lxw_merged_range,
pub stqh_last: *mut *mut lxw_merged_range,
}
#[test]
fn bindgen_test_layout_lxw_merged_ranges() {
const UNINIT: ::std::mem::MaybeUninit<lxw_merged_ranges> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_merged_ranges>(),
16usize,
concat!("Size of: ", stringify!(lxw_merged_ranges))
);
assert_eq!(
::std::mem::align_of::<lxw_merged_ranges>(),
8usize,
concat!("Alignment of ", stringify!(lxw_merged_ranges))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_first) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_merged_ranges),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_last) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_merged_ranges),
"::",
stringify!(stqh_last)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_selections {
pub stqh_first: *mut lxw_selection,
pub stqh_last: *mut *mut lxw_selection,
}
#[test]
fn bindgen_test_layout_lxw_selections() {
const UNINIT: ::std::mem::MaybeUninit<lxw_selections> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_selections>(),
16usize,
concat!("Size of: ", stringify!(lxw_selections))
);
assert_eq!(
::std::mem::align_of::<lxw_selections>(),
8usize,
concat!("Alignment of ", stringify!(lxw_selections))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_first) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_selections),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_last) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_selections),
"::",
stringify!(stqh_last)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_data_validations {
pub stqh_first: *mut lxw_data_val_obj,
pub stqh_last: *mut *mut lxw_data_val_obj,
}
#[test]
fn bindgen_test_layout_lxw_data_validations() {
const UNINIT: ::std::mem::MaybeUninit<lxw_data_validations> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_data_validations>(),
16usize,
concat!("Size of: ", stringify!(lxw_data_validations))
);
assert_eq!(
::std::mem::align_of::<lxw_data_validations>(),
8usize,
concat!("Alignment of ", stringify!(lxw_data_validations))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_first) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validations),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_last) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validations),
"::",
stringify!(stqh_last)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_cond_format_list {
pub stqh_first: *mut lxw_cond_format_obj,
pub stqh_last: *mut *mut lxw_cond_format_obj,
}
#[test]
fn bindgen_test_layout_lxw_cond_format_list() {
const UNINIT: ::std::mem::MaybeUninit<lxw_cond_format_list> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_cond_format_list>(),
16usize,
concat!("Size of: ", stringify!(lxw_cond_format_list))
);
assert_eq!(
::std::mem::align_of::<lxw_cond_format_list>(),
8usize,
concat!("Alignment of ", stringify!(lxw_cond_format_list))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_first) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_list),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_last) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_list),
"::",
stringify!(stqh_last)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_image_props {
pub stqh_first: *mut lxw_object_properties,
pub stqh_last: *mut *mut lxw_object_properties,
}
#[test]
fn bindgen_test_layout_lxw_image_props() {
const UNINIT: ::std::mem::MaybeUninit<lxw_image_props> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_image_props>(),
16usize,
concat!("Size of: ", stringify!(lxw_image_props))
);
assert_eq!(
::std::mem::align_of::<lxw_image_props>(),
8usize,
concat!("Alignment of ", stringify!(lxw_image_props))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_first) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_image_props),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_last) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_image_props),
"::",
stringify!(stqh_last)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_chart_props {
pub stqh_first: *mut lxw_object_properties,
pub stqh_last: *mut *mut lxw_object_properties,
}
#[test]
fn bindgen_test_layout_lxw_chart_props() {
const UNINIT: ::std::mem::MaybeUninit<lxw_chart_props> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_chart_props>(),
16usize,
concat!("Size of: ", stringify!(lxw_chart_props))
);
assert_eq!(
::std::mem::align_of::<lxw_chart_props>(),
8usize,
concat!("Alignment of ", stringify!(lxw_chart_props))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_first) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_props),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_last) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_props),
"::",
stringify!(stqh_last)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_comment_objs {
pub stqh_first: *mut lxw_vml_obj,
pub stqh_last: *mut *mut lxw_vml_obj,
}
#[test]
fn bindgen_test_layout_lxw_comment_objs() {
const UNINIT: ::std::mem::MaybeUninit<lxw_comment_objs> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_comment_objs>(),
16usize,
concat!("Size of: ", stringify!(lxw_comment_objs))
);
assert_eq!(
::std::mem::align_of::<lxw_comment_objs>(),
8usize,
concat!("Alignment of ", stringify!(lxw_comment_objs))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_first) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_comment_objs),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_last) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_comment_objs),
"::",
stringify!(stqh_last)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_table_objs {
pub stqh_first: *mut lxw_table_obj,
pub stqh_last: *mut *mut lxw_table_obj,
}
#[test]
fn bindgen_test_layout_lxw_table_objs() {
const UNINIT: ::std::mem::MaybeUninit<lxw_table_objs> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_table_objs>(),
16usize,
concat!("Size of: ", stringify!(lxw_table_objs))
);
assert_eq!(
::std::mem::align_of::<lxw_table_objs>(),
8usize,
concat!("Alignment of ", stringify!(lxw_table_objs))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_first) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_objs),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_last) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_objs),
"::",
stringify!(stqh_last)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_row_col_options {
pub hidden: u8,
pub level: u8,
pub collapsed: u8,
}
#[test]
fn bindgen_test_layout_lxw_row_col_options() {
const UNINIT: ::std::mem::MaybeUninit<lxw_row_col_options> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_row_col_options>(),
3usize,
concat!("Size of: ", stringify!(lxw_row_col_options))
);
assert_eq!(
::std::mem::align_of::<lxw_row_col_options>(),
1usize,
concat!("Alignment of ", stringify!(lxw_row_col_options))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hidden) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_row_col_options),
"::",
stringify!(hidden)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).level) as usize - ptr as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(lxw_row_col_options),
"::",
stringify!(level)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).collapsed) as usize - ptr as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(lxw_row_col_options),
"::",
stringify!(collapsed)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_col_options {
pub firstcol: lxw_col_t,
pub lastcol: lxw_col_t,
pub width: f64,
pub format: *mut lxw_format,
pub hidden: u8,
pub level: u8,
pub collapsed: u8,
}
#[test]
fn bindgen_test_layout_lxw_col_options() {
const UNINIT: ::std::mem::MaybeUninit<lxw_col_options> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_col_options>(),
32usize,
concat!("Size of: ", stringify!(lxw_col_options))
);
assert_eq!(
::std::mem::align_of::<lxw_col_options>(),
8usize,
concat!("Alignment of ", stringify!(lxw_col_options))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).firstcol) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_col_options),
"::",
stringify!(firstcol)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).lastcol) as usize - ptr as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(lxw_col_options),
"::",
stringify!(lastcol)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_col_options),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).format) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_col_options),
"::",
stringify!(format)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hidden) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_col_options),
"::",
stringify!(hidden)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).level) as usize - ptr as usize },
25usize,
concat!(
"Offset of field: ",
stringify!(lxw_col_options),
"::",
stringify!(level)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).collapsed) as usize - ptr as usize },
26usize,
concat!(
"Offset of field: ",
stringify!(lxw_col_options),
"::",
stringify!(collapsed)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_merged_range {
pub first_row: lxw_row_t,
pub last_row: lxw_row_t,
pub first_col: lxw_col_t,
pub last_col: lxw_col_t,
pub list_pointers: lxw_merged_range__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_merged_range__bindgen_ty_1 {
pub stqe_next: *mut lxw_merged_range,
}
#[test]
fn bindgen_test_layout_lxw_merged_range__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<lxw_merged_range__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_merged_range__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(lxw_merged_range__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<lxw_merged_range__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(lxw_merged_range__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqe_next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_merged_range__bindgen_ty_1),
"::",
stringify!(stqe_next)
)
);
}
#[test]
fn bindgen_test_layout_lxw_merged_range() {
const UNINIT: ::std::mem::MaybeUninit<lxw_merged_range> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_merged_range>(),
24usize,
concat!("Size of: ", stringify!(lxw_merged_range))
);
assert_eq!(
::std::mem::align_of::<lxw_merged_range>(),
8usize,
concat!("Alignment of ", stringify!(lxw_merged_range))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).first_row) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_merged_range),
"::",
stringify!(first_row)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).last_row) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_merged_range),
"::",
stringify!(last_row)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).first_col) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_merged_range),
"::",
stringify!(first_col)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).last_col) as usize - ptr as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(lxw_merged_range),
"::",
stringify!(last_col)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).list_pointers) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_merged_range),
"::",
stringify!(list_pointers)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_repeat_rows {
pub in_use: u8,
pub first_row: lxw_row_t,
pub last_row: lxw_row_t,
}
#[test]
fn bindgen_test_layout_lxw_repeat_rows() {
const UNINIT: ::std::mem::MaybeUninit<lxw_repeat_rows> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_repeat_rows>(),
12usize,
concat!("Size of: ", stringify!(lxw_repeat_rows))
);
assert_eq!(
::std::mem::align_of::<lxw_repeat_rows>(),
4usize,
concat!("Alignment of ", stringify!(lxw_repeat_rows))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).in_use) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_repeat_rows),
"::",
stringify!(in_use)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).first_row) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_repeat_rows),
"::",
stringify!(first_row)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).last_row) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_repeat_rows),
"::",
stringify!(last_row)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_repeat_cols {
pub in_use: u8,
pub first_col: lxw_col_t,
pub last_col: lxw_col_t,
}
#[test]
fn bindgen_test_layout_lxw_repeat_cols() {
const UNINIT: ::std::mem::MaybeUninit<lxw_repeat_cols> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_repeat_cols>(),
6usize,
concat!("Size of: ", stringify!(lxw_repeat_cols))
);
assert_eq!(
::std::mem::align_of::<lxw_repeat_cols>(),
2usize,
concat!("Alignment of ", stringify!(lxw_repeat_cols))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).in_use) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_repeat_cols),
"::",
stringify!(in_use)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).first_col) as usize - ptr as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(lxw_repeat_cols),
"::",
stringify!(first_col)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).last_col) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_repeat_cols),
"::",
stringify!(last_col)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_print_area {
pub in_use: u8,
pub first_row: lxw_row_t,
pub last_row: lxw_row_t,
pub first_col: lxw_col_t,
pub last_col: lxw_col_t,
}
#[test]
fn bindgen_test_layout_lxw_print_area() {
const UNINIT: ::std::mem::MaybeUninit<lxw_print_area> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_print_area>(),
16usize,
concat!("Size of: ", stringify!(lxw_print_area))
);
assert_eq!(
::std::mem::align_of::<lxw_print_area>(),
4usize,
concat!("Alignment of ", stringify!(lxw_print_area))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).in_use) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_print_area),
"::",
stringify!(in_use)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).first_row) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_print_area),
"::",
stringify!(first_row)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).last_row) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_print_area),
"::",
stringify!(last_row)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).first_col) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(lxw_print_area),
"::",
stringify!(first_col)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).last_col) as usize - ptr as usize },
14usize,
concat!(
"Offset of field: ",
stringify!(lxw_print_area),
"::",
stringify!(last_col)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_autofilter {
pub in_use: u8,
pub has_rules: u8,
pub first_row: lxw_row_t,
pub last_row: lxw_row_t,
pub first_col: lxw_col_t,
pub last_col: lxw_col_t,
}
#[test]
fn bindgen_test_layout_lxw_autofilter() {
const UNINIT: ::std::mem::MaybeUninit<lxw_autofilter> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_autofilter>(),
16usize,
concat!("Size of: ", stringify!(lxw_autofilter))
);
assert_eq!(
::std::mem::align_of::<lxw_autofilter>(),
4usize,
concat!("Alignment of ", stringify!(lxw_autofilter))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).in_use) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_autofilter),
"::",
stringify!(in_use)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_rules) as usize - ptr as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(lxw_autofilter),
"::",
stringify!(has_rules)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).first_row) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_autofilter),
"::",
stringify!(first_row)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).last_row) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_autofilter),
"::",
stringify!(last_row)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).first_col) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(lxw_autofilter),
"::",
stringify!(first_col)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).last_col) as usize - ptr as usize },
14usize,
concat!(
"Offset of field: ",
stringify!(lxw_autofilter),
"::",
stringify!(last_col)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_panes {
pub type_: u8,
pub first_row: lxw_row_t,
pub first_col: lxw_col_t,
pub top_row: lxw_row_t,
pub left_col: lxw_col_t,
pub x_split: f64,
pub y_split: f64,
}
#[test]
fn bindgen_test_layout_lxw_panes() {
const UNINIT: ::std::mem::MaybeUninit<lxw_panes> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_panes>(),
40usize,
concat!("Size of: ", stringify!(lxw_panes))
);
assert_eq!(
::std::mem::align_of::<lxw_panes>(),
8usize,
concat!("Alignment of ", stringify!(lxw_panes))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_panes),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).first_row) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_panes),
"::",
stringify!(first_row)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).first_col) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_panes),
"::",
stringify!(first_col)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).top_row) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(lxw_panes),
"::",
stringify!(top_row)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).left_col) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_panes),
"::",
stringify!(left_col)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x_split) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_panes),
"::",
stringify!(x_split)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y_split) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_panes),
"::",
stringify!(y_split)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_selection {
pub pane: [::std::os::raw::c_char; 12usize],
pub active_cell: [::std::os::raw::c_char; 28usize],
pub sqref: [::std::os::raw::c_char; 28usize],
pub list_pointers: lxw_selection__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_selection__bindgen_ty_1 {
pub stqe_next: *mut lxw_selection,
}
#[test]
fn bindgen_test_layout_lxw_selection__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<lxw_selection__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_selection__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(lxw_selection__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<lxw_selection__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(lxw_selection__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqe_next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_selection__bindgen_ty_1),
"::",
stringify!(stqe_next)
)
);
}
#[test]
fn bindgen_test_layout_lxw_selection() {
const UNINIT: ::std::mem::MaybeUninit<lxw_selection> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_selection>(),
80usize,
concat!("Size of: ", stringify!(lxw_selection))
);
assert_eq!(
::std::mem::align_of::<lxw_selection>(),
8usize,
concat!("Alignment of ", stringify!(lxw_selection))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pane) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_selection),
"::",
stringify!(pane)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).active_cell) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(lxw_selection),
"::",
stringify!(active_cell)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sqref) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_selection),
"::",
stringify!(sqref)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).list_pointers) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(lxw_selection),
"::",
stringify!(list_pointers)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_data_validation {
pub validate: u8,
pub criteria: u8,
pub ignore_blank: u8,
pub show_input: u8,
pub show_error: u8,
pub error_type: u8,
pub dropdown: u8,
pub value_number: f64,
pub value_formula: *mut ::std::os::raw::c_char,
pub value_list: *mut *mut ::std::os::raw::c_char,
pub value_datetime: lxw_datetime,
pub minimum_number: f64,
pub minimum_formula: *mut ::std::os::raw::c_char,
pub minimum_datetime: lxw_datetime,
pub maximum_number: f64,
pub maximum_formula: *mut ::std::os::raw::c_char,
pub maximum_datetime: lxw_datetime,
pub input_title: *mut ::std::os::raw::c_char,
pub input_message: *mut ::std::os::raw::c_char,
pub error_title: *mut ::std::os::raw::c_char,
pub error_message: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_lxw_data_validation() {
const UNINIT: ::std::mem::MaybeUninit<lxw_data_validation> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_data_validation>(),
192usize,
concat!("Size of: ", stringify!(lxw_data_validation))
);
assert_eq!(
::std::mem::align_of::<lxw_data_validation>(),
8usize,
concat!("Alignment of ", stringify!(lxw_data_validation))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).validate) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(validate)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).criteria) as usize - ptr as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(criteria)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ignore_blank) as usize - ptr as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(ignore_blank)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).show_input) as usize - ptr as usize },
3usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(show_input)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).show_error) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(show_error)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).error_type) as usize - ptr as usize },
5usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(error_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dropdown) as usize - ptr as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(dropdown)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value_number) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(value_number)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value_formula) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(value_formula)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value_list) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(value_list)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value_datetime) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(value_datetime)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).minimum_number) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(minimum_number)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).minimum_formula) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(minimum_formula)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).minimum_datetime) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(minimum_datetime)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).maximum_number) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(maximum_number)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).maximum_formula) as usize - ptr as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(maximum_formula)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).maximum_datetime) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(maximum_datetime)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).input_title) as usize - ptr as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(input_title)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).input_message) as usize - ptr as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(input_message)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).error_title) as usize - ptr as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(error_title)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).error_message) as usize - ptr as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(error_message)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_data_val_obj {
pub validate: u8,
pub criteria: u8,
pub ignore_blank: u8,
pub show_input: u8,
pub show_error: u8,
pub error_type: u8,
pub dropdown: u8,
pub value_number: f64,
pub value_formula: *mut ::std::os::raw::c_char,
pub value_list: *mut *mut ::std::os::raw::c_char,
pub minimum_number: f64,
pub minimum_formula: *mut ::std::os::raw::c_char,
pub minimum_datetime: lxw_datetime,
pub maximum_number: f64,
pub maximum_formula: *mut ::std::os::raw::c_char,
pub maximum_datetime: lxw_datetime,
pub input_title: *mut ::std::os::raw::c_char,
pub input_message: *mut ::std::os::raw::c_char,
pub error_title: *mut ::std::os::raw::c_char,
pub error_message: *mut ::std::os::raw::c_char,
pub sqref: [::std::os::raw::c_char; 28usize],
pub list_pointers: lxw_data_val_obj__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_data_val_obj__bindgen_ty_1 {
pub stqe_next: *mut lxw_data_val_obj,
}
#[test]
fn bindgen_test_layout_lxw_data_val_obj__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<lxw_data_val_obj__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_data_val_obj__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(lxw_data_val_obj__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<lxw_data_val_obj__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(lxw_data_val_obj__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqe_next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj__bindgen_ty_1),
"::",
stringify!(stqe_next)
)
);
}
#[test]
fn bindgen_test_layout_lxw_data_val_obj() {
const UNINIT: ::std::mem::MaybeUninit<lxw_data_val_obj> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_data_val_obj>(),
200usize,
concat!("Size of: ", stringify!(lxw_data_val_obj))
);
assert_eq!(
::std::mem::align_of::<lxw_data_val_obj>(),
8usize,
concat!("Alignment of ", stringify!(lxw_data_val_obj))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).validate) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(validate)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).criteria) as usize - ptr as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(criteria)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ignore_blank) as usize - ptr as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(ignore_blank)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).show_input) as usize - ptr as usize },
3usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(show_input)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).show_error) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(show_error)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).error_type) as usize - ptr as usize },
5usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(error_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dropdown) as usize - ptr as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(dropdown)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value_number) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(value_number)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value_formula) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(value_formula)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value_list) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(value_list)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).minimum_number) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(minimum_number)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).minimum_formula) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(minimum_formula)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).minimum_datetime) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(minimum_datetime)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).maximum_number) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(maximum_number)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).maximum_formula) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(maximum_formula)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).maximum_datetime) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(maximum_datetime)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).input_title) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(input_title)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).input_message) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(input_message)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).error_title) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(error_title)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).error_message) as usize - ptr as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(error_message)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sqref) as usize - ptr as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(sqref)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).list_pointers) as usize - ptr as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(list_pointers)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_conditional_format {
pub type_: u8,
pub criteria: u8,
pub value: f64,
pub value_string: *mut ::std::os::raw::c_char,
pub format: *mut lxw_format,
pub min_value: f64,
pub min_value_string: *mut ::std::os::raw::c_char,
pub min_rule_type: u8,
pub min_color: lxw_color_t,
pub mid_value: f64,
pub mid_value_string: *mut ::std::os::raw::c_char,
pub mid_rule_type: u8,
pub mid_color: lxw_color_t,
pub max_value: f64,
pub max_value_string: *mut ::std::os::raw::c_char,
pub max_rule_type: u8,
pub max_color: lxw_color_t,
pub bar_color: lxw_color_t,
pub bar_only: u8,
pub data_bar_2010: u8,
pub bar_solid: u8,
pub bar_negative_color: lxw_color_t,
pub bar_border_color: lxw_color_t,
pub bar_negative_border_color: lxw_color_t,
pub bar_negative_color_same: u8,
pub bar_negative_border_color_same: u8,
pub bar_no_border: u8,
pub bar_direction: u8,
pub bar_axis_position: u8,
pub bar_axis_color: lxw_color_t,
pub icon_style: u8,
pub reverse_icons: u8,
pub icons_only: u8,
pub multi_range: *mut ::std::os::raw::c_char,
pub stop_if_true: u8,
}
#[test]
fn bindgen_test_layout_lxw_conditional_format() {
const UNINIT: ::std::mem::MaybeUninit<lxw_conditional_format> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_conditional_format>(),
160usize,
concat!("Size of: ", stringify!(lxw_conditional_format))
);
assert_eq!(
::std::mem::align_of::<lxw_conditional_format>(),
8usize,
concat!("Alignment of ", stringify!(lxw_conditional_format))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).criteria) as usize - ptr as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(criteria)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value_string) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(value_string)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).format) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(format)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).min_value) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(min_value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).min_value_string) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(min_value_string)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).min_rule_type) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(min_rule_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).min_color) as usize - ptr as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(min_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mid_value) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(mid_value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mid_value_string) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(mid_value_string)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mid_rule_type) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(mid_rule_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mid_color) as usize - ptr as usize },
76usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(mid_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_value) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(max_value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_value_string) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(max_value_string)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_rule_type) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(max_rule_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_color) as usize - ptr as usize },
100usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(max_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bar_color) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(bar_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bar_only) as usize - ptr as usize },
108usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(bar_only)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data_bar_2010) as usize - ptr as usize },
109usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(data_bar_2010)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bar_solid) as usize - ptr as usize },
110usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(bar_solid)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bar_negative_color) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(bar_negative_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bar_border_color) as usize - ptr as usize },
116usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(bar_border_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bar_negative_border_color) as usize - ptr as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(bar_negative_border_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bar_negative_color_same) as usize - ptr as usize },
124usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(bar_negative_color_same)
)
);
assert_eq!(
unsafe {
::std::ptr::addr_of!((*ptr).bar_negative_border_color_same) as usize - ptr as usize
},
125usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(bar_negative_border_color_same)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bar_no_border) as usize - ptr as usize },
126usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(bar_no_border)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bar_direction) as usize - ptr as usize },
127usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(bar_direction)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bar_axis_position) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(bar_axis_position)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bar_axis_color) as usize - ptr as usize },
132usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(bar_axis_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).icon_style) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(icon_style)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).reverse_icons) as usize - ptr as usize },
137usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(reverse_icons)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).icons_only) as usize - ptr as usize },
138usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(icons_only)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).multi_range) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(multi_range)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stop_if_true) as usize - ptr as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(stop_if_true)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_cond_format_obj {
pub type_: u8,
pub criteria: u8,
pub min_value: f64,
pub min_value_string: *mut ::std::os::raw::c_char,
pub min_rule_type: u8,
pub min_color: lxw_color_t,
pub mid_value: f64,
pub mid_value_string: *mut ::std::os::raw::c_char,
pub mid_value_type: u8,
pub mid_rule_type: u8,
pub mid_color: lxw_color_t,
pub max_value: f64,
pub max_value_string: *mut ::std::os::raw::c_char,
pub max_value_type: u8,
pub max_rule_type: u8,
pub max_color: lxw_color_t,
pub data_bar_2010: u8,
pub auto_min: u8,
pub auto_max: u8,
pub bar_only: u8,
pub bar_solid: u8,
pub bar_negative_color_same: u8,
pub bar_negative_border_color_same: u8,
pub bar_no_border: u8,
pub bar_direction: u8,
pub bar_axis_position: u8,
pub bar_color: lxw_color_t,
pub bar_negative_color: lxw_color_t,
pub bar_border_color: lxw_color_t,
pub bar_negative_border_color: lxw_color_t,
pub bar_axis_color: lxw_color_t,
pub icon_style: u8,
pub reverse_icons: u8,
pub icons_only: u8,
pub stop_if_true: u8,
pub has_max: u8,
pub type_string: *mut ::std::os::raw::c_char,
pub guid: *mut ::std::os::raw::c_char,
pub dxf_index: i32,
pub dxf_priority: u32,
pub first_cell: [::std::os::raw::c_char; 14usize],
pub sqref: [::std::os::raw::c_char; 2080usize],
pub list_pointers: lxw_cond_format_obj__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_cond_format_obj__bindgen_ty_1 {
pub stqe_next: *mut lxw_cond_format_obj,
}
#[test]
fn bindgen_test_layout_lxw_cond_format_obj__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<lxw_cond_format_obj__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_cond_format_obj__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(lxw_cond_format_obj__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<lxw_cond_format_obj__bindgen_ty_1>(),
8usize,
concat!(
"Alignment of ",
stringify!(lxw_cond_format_obj__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqe_next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj__bindgen_ty_1),
"::",
stringify!(stqe_next)
)
);
}
#[test]
fn bindgen_test_layout_lxw_cond_format_obj() {
const UNINIT: ::std::mem::MaybeUninit<lxw_cond_format_obj> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_cond_format_obj>(),
2248usize,
concat!("Size of: ", stringify!(lxw_cond_format_obj))
);
assert_eq!(
::std::mem::align_of::<lxw_cond_format_obj>(),
8usize,
concat!("Alignment of ", stringify!(lxw_cond_format_obj))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).criteria) as usize - ptr as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(criteria)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).min_value) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(min_value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).min_value_string) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(min_value_string)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).min_rule_type) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(min_rule_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).min_color) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(min_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mid_value) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(mid_value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mid_value_string) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(mid_value_string)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mid_value_type) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(mid_value_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mid_rule_type) as usize - ptr as usize },
49usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(mid_rule_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).mid_color) as usize - ptr as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(mid_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_value) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(max_value)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_value_string) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(max_value_string)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_value_type) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(max_value_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_rule_type) as usize - ptr as usize },
73usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(max_rule_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_color) as usize - ptr as usize },
76usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(max_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data_bar_2010) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(data_bar_2010)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).auto_min) as usize - ptr as usize },
81usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(auto_min)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).auto_max) as usize - ptr as usize },
82usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(auto_max)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bar_only) as usize - ptr as usize },
83usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(bar_only)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bar_solid) as usize - ptr as usize },
84usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(bar_solid)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bar_negative_color_same) as usize - ptr as usize },
85usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(bar_negative_color_same)
)
);
assert_eq!(
unsafe {
::std::ptr::addr_of!((*ptr).bar_negative_border_color_same) as usize - ptr as usize
},
86usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(bar_negative_border_color_same)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bar_no_border) as usize - ptr as usize },
87usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(bar_no_border)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bar_direction) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(bar_direction)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bar_axis_position) as usize - ptr as usize },
89usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(bar_axis_position)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bar_color) as usize - ptr as usize },
92usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(bar_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bar_negative_color) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(bar_negative_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bar_border_color) as usize - ptr as usize },
100usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(bar_border_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bar_negative_border_color) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(bar_negative_border_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).bar_axis_color) as usize - ptr as usize },
108usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(bar_axis_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).icon_style) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(icon_style)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).reverse_icons) as usize - ptr as usize },
113usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(reverse_icons)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).icons_only) as usize - ptr as usize },
114usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(icons_only)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stop_if_true) as usize - ptr as usize },
115usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(stop_if_true)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_max) as usize - ptr as usize },
116usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(has_max)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_string) as usize - ptr as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(type_string)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).guid) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(guid)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dxf_index) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(dxf_index)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dxf_priority) as usize - ptr as usize },
140usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(dxf_priority)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).first_cell) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(first_cell)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sqref) as usize - ptr as usize },
158usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(sqref)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).list_pointers) as usize - ptr as usize },
2240usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(list_pointers)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_cond_format_hash_element {
pub sqref: [::std::os::raw::c_char; 2080usize],
pub cond_formats: *mut lxw_cond_format_list,
pub tree_pointers: lxw_cond_format_hash_element__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_cond_format_hash_element__bindgen_ty_1 {
pub rbe_left: *mut lxw_cond_format_hash_element,
pub rbe_right: *mut lxw_cond_format_hash_element,
pub rbe_parent: *mut lxw_cond_format_hash_element,
pub rbe_color: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_lxw_cond_format_hash_element__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<lxw_cond_format_hash_element__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_cond_format_hash_element__bindgen_ty_1>(),
32usize,
concat!(
"Size of: ",
stringify!(lxw_cond_format_hash_element__bindgen_ty_1)
)
);
assert_eq!(
::std::mem::align_of::<lxw_cond_format_hash_element__bindgen_ty_1>(),
8usize,
concat!(
"Alignment of ",
stringify!(lxw_cond_format_hash_element__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbe_left) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_hash_element__bindgen_ty_1),
"::",
stringify!(rbe_left)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbe_right) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_hash_element__bindgen_ty_1),
"::",
stringify!(rbe_right)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbe_parent) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_hash_element__bindgen_ty_1),
"::",
stringify!(rbe_parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbe_color) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_hash_element__bindgen_ty_1),
"::",
stringify!(rbe_color)
)
);
}
#[test]
fn bindgen_test_layout_lxw_cond_format_hash_element() {
const UNINIT: ::std::mem::MaybeUninit<lxw_cond_format_hash_element> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_cond_format_hash_element>(),
2120usize,
concat!("Size of: ", stringify!(lxw_cond_format_hash_element))
);
assert_eq!(
::std::mem::align_of::<lxw_cond_format_hash_element>(),
8usize,
concat!("Alignment of ", stringify!(lxw_cond_format_hash_element))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sqref) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_hash_element),
"::",
stringify!(sqref)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cond_formats) as usize - ptr as usize },
2080usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_hash_element),
"::",
stringify!(cond_formats)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tree_pointers) as usize - ptr as usize },
2088usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_hash_element),
"::",
stringify!(tree_pointers)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_table_column {
pub header: *mut ::std::os::raw::c_char,
pub formula: *mut ::std::os::raw::c_char,
pub total_string: *mut ::std::os::raw::c_char,
pub total_function: u8,
pub header_format: *mut lxw_format,
pub format: *mut lxw_format,
pub total_value: f64,
}
#[test]
fn bindgen_test_layout_lxw_table_column() {
const UNINIT: ::std::mem::MaybeUninit<lxw_table_column> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_table_column>(),
56usize,
concat!("Size of: ", stringify!(lxw_table_column))
);
assert_eq!(
::std::mem::align_of::<lxw_table_column>(),
8usize,
concat!("Alignment of ", stringify!(lxw_table_column))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_column),
"::",
stringify!(header)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).formula) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_column),
"::",
stringify!(formula)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).total_string) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_column),
"::",
stringify!(total_string)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).total_function) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_column),
"::",
stringify!(total_function)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).header_format) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_column),
"::",
stringify!(header_format)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).format) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_column),
"::",
stringify!(format)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).total_value) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_column),
"::",
stringify!(total_value)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_table_options {
pub name: *mut ::std::os::raw::c_char,
pub no_header_row: u8,
pub no_autofilter: u8,
pub no_banded_rows: u8,
pub banded_columns: u8,
pub first_column: u8,
pub last_column: u8,
pub style_type: u8,
pub style_type_number: u8,
pub total_row: u8,
pub columns: *mut *mut lxw_table_column,
}
#[test]
fn bindgen_test_layout_lxw_table_options() {
const UNINIT: ::std::mem::MaybeUninit<lxw_table_options> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_table_options>(),
32usize,
concat!("Size of: ", stringify!(lxw_table_options))
);
assert_eq!(
::std::mem::align_of::<lxw_table_options>(),
8usize,
concat!("Alignment of ", stringify!(lxw_table_options))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_options),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).no_header_row) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_options),
"::",
stringify!(no_header_row)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).no_autofilter) as usize - ptr as usize },
9usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_options),
"::",
stringify!(no_autofilter)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).no_banded_rows) as usize - ptr as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_options),
"::",
stringify!(no_banded_rows)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).banded_columns) as usize - ptr as usize },
11usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_options),
"::",
stringify!(banded_columns)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).first_column) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_options),
"::",
stringify!(first_column)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).last_column) as usize - ptr as usize },
13usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_options),
"::",
stringify!(last_column)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).style_type) as usize - ptr as usize },
14usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_options),
"::",
stringify!(style_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).style_type_number) as usize - ptr as usize },
15usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_options),
"::",
stringify!(style_type_number)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).total_row) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_options),
"::",
stringify!(total_row)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).columns) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_options),
"::",
stringify!(columns)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_table_obj {
pub name: *mut ::std::os::raw::c_char,
pub total_string: *mut ::std::os::raw::c_char,
pub columns: *mut *mut lxw_table_column,
pub banded_columns: u8,
pub first_column: u8,
pub last_column: u8,
pub no_autofilter: u8,
pub no_banded_rows: u8,
pub no_header_row: u8,
pub style_type: u8,
pub style_type_number: u8,
pub total_row: u8,
pub first_row: lxw_row_t,
pub first_col: lxw_col_t,
pub last_row: lxw_row_t,
pub last_col: lxw_col_t,
pub num_cols: lxw_col_t,
pub id: u32,
pub sqref: [::std::os::raw::c_char; 2080usize],
pub filter_sqref: [::std::os::raw::c_char; 2080usize],
pub list_pointers: lxw_table_obj__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_table_obj__bindgen_ty_1 {
pub stqe_next: *mut lxw_table_obj,
}
#[test]
fn bindgen_test_layout_lxw_table_obj__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<lxw_table_obj__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_table_obj__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(lxw_table_obj__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<lxw_table_obj__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(lxw_table_obj__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqe_next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_obj__bindgen_ty_1),
"::",
stringify!(stqe_next)
)
);
}
#[test]
fn bindgen_test_layout_lxw_table_obj() {
const UNINIT: ::std::mem::MaybeUninit<lxw_table_obj> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_table_obj>(),
4224usize,
concat!("Size of: ", stringify!(lxw_table_obj))
);
assert_eq!(
::std::mem::align_of::<lxw_table_obj>(),
8usize,
concat!("Alignment of ", stringify!(lxw_table_obj))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_obj),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).total_string) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_obj),
"::",
stringify!(total_string)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).columns) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_obj),
"::",
stringify!(columns)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).banded_columns) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_obj),
"::",
stringify!(banded_columns)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).first_column) as usize - ptr as usize },
25usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_obj),
"::",
stringify!(first_column)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).last_column) as usize - ptr as usize },
26usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_obj),
"::",
stringify!(last_column)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).no_autofilter) as usize - ptr as usize },
27usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_obj),
"::",
stringify!(no_autofilter)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).no_banded_rows) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_obj),
"::",
stringify!(no_banded_rows)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).no_header_row) as usize - ptr as usize },
29usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_obj),
"::",
stringify!(no_header_row)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).style_type) as usize - ptr as usize },
30usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_obj),
"::",
stringify!(style_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).style_type_number) as usize - ptr as usize },
31usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_obj),
"::",
stringify!(style_type_number)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).total_row) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_obj),
"::",
stringify!(total_row)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).first_row) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_obj),
"::",
stringify!(first_row)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).first_col) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_obj),
"::",
stringify!(first_col)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).last_row) as usize - ptr as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_obj),
"::",
stringify!(last_row)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).last_col) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_obj),
"::",
stringify!(last_col)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).num_cols) as usize - ptr as usize },
50usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_obj),
"::",
stringify!(num_cols)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_obj),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sqref) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_obj),
"::",
stringify!(sqref)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).filter_sqref) as usize - ptr as usize },
2136usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_obj),
"::",
stringify!(filter_sqref)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).list_pointers) as usize - ptr as usize },
4216usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_obj),
"::",
stringify!(list_pointers)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_filter_rule {
pub criteria: u8,
pub value_string: *mut ::std::os::raw::c_char,
pub value: f64,
}
#[test]
fn bindgen_test_layout_lxw_filter_rule() {
const UNINIT: ::std::mem::MaybeUninit<lxw_filter_rule> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_filter_rule>(),
24usize,
concat!("Size of: ", stringify!(lxw_filter_rule))
);
assert_eq!(
::std::mem::align_of::<lxw_filter_rule>(),
8usize,
concat!("Alignment of ", stringify!(lxw_filter_rule))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).criteria) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_filter_rule),
"::",
stringify!(criteria)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value_string) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_filter_rule),
"::",
stringify!(value_string)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_filter_rule),
"::",
stringify!(value)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_filter_rule_obj {
pub type_: u8,
pub is_custom: u8,
pub has_blanks: u8,
pub col_num: lxw_col_t,
pub criteria1: u8,
pub criteria2: u8,
pub value1: f64,
pub value2: f64,
pub value1_string: *mut ::std::os::raw::c_char,
pub value2_string: *mut ::std::os::raw::c_char,
pub num_list_filters: u16,
pub list: *mut *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_lxw_filter_rule_obj() {
const UNINIT: ::std::mem::MaybeUninit<lxw_filter_rule_obj> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_filter_rule_obj>(),
56usize,
concat!("Size of: ", stringify!(lxw_filter_rule_obj))
);
assert_eq!(
::std::mem::align_of::<lxw_filter_rule_obj>(),
8usize,
concat!("Alignment of ", stringify!(lxw_filter_rule_obj))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_filter_rule_obj),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).is_custom) as usize - ptr as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(lxw_filter_rule_obj),
"::",
stringify!(is_custom)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_blanks) as usize - ptr as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(lxw_filter_rule_obj),
"::",
stringify!(has_blanks)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).col_num) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_filter_rule_obj),
"::",
stringify!(col_num)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).criteria1) as usize - ptr as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(lxw_filter_rule_obj),
"::",
stringify!(criteria1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).criteria2) as usize - ptr as usize },
7usize,
concat!(
"Offset of field: ",
stringify!(lxw_filter_rule_obj),
"::",
stringify!(criteria2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value1) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_filter_rule_obj),
"::",
stringify!(value1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value2) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_filter_rule_obj),
"::",
stringify!(value2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value1_string) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_filter_rule_obj),
"::",
stringify!(value1_string)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).value2_string) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_filter_rule_obj),
"::",
stringify!(value2_string)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).num_list_filters) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_filter_rule_obj),
"::",
stringify!(num_list_filters)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).list) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_filter_rule_obj),
"::",
stringify!(list)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_image_options {
pub x_offset: i32,
pub y_offset: i32,
pub x_scale: f64,
pub y_scale: f64,
pub object_position: u8,
pub description: *mut ::std::os::raw::c_char,
pub decorative: u8,
pub url: *mut ::std::os::raw::c_char,
pub tip: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_lxw_image_options() {
const UNINIT: ::std::mem::MaybeUninit<lxw_image_options> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_image_options>(),
64usize,
concat!("Size of: ", stringify!(lxw_image_options))
);
assert_eq!(
::std::mem::align_of::<lxw_image_options>(),
8usize,
concat!("Alignment of ", stringify!(lxw_image_options))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x_offset) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_image_options),
"::",
stringify!(x_offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y_offset) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_image_options),
"::",
stringify!(y_offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x_scale) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_image_options),
"::",
stringify!(x_scale)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y_scale) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_image_options),
"::",
stringify!(y_scale)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).object_position) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_image_options),
"::",
stringify!(object_position)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).description) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_image_options),
"::",
stringify!(description)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).decorative) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_image_options),
"::",
stringify!(decorative)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).url) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_image_options),
"::",
stringify!(url)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tip) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(lxw_image_options),
"::",
stringify!(tip)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_chart_options {
pub x_offset: i32,
pub y_offset: i32,
pub x_scale: f64,
pub y_scale: f64,
pub object_position: u8,
pub description: *mut ::std::os::raw::c_char,
pub decorative: u8,
}
#[test]
fn bindgen_test_layout_lxw_chart_options() {
const UNINIT: ::std::mem::MaybeUninit<lxw_chart_options> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_chart_options>(),
48usize,
concat!("Size of: ", stringify!(lxw_chart_options))
);
assert_eq!(
::std::mem::align_of::<lxw_chart_options>(),
8usize,
concat!("Alignment of ", stringify!(lxw_chart_options))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x_offset) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_options),
"::",
stringify!(x_offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y_offset) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_options),
"::",
stringify!(y_offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x_scale) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_options),
"::",
stringify!(x_scale)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y_scale) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_options),
"::",
stringify!(y_scale)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).object_position) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_options),
"::",
stringify!(object_position)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).description) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_options),
"::",
stringify!(description)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).decorative) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_options),
"::",
stringify!(decorative)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_object_properties {
pub x_offset: i32,
pub y_offset: i32,
pub x_scale: f64,
pub y_scale: f64,
pub row: lxw_row_t,
pub col: lxw_col_t,
pub filename: *mut ::std::os::raw::c_char,
pub description: *mut ::std::os::raw::c_char,
pub url: *mut ::std::os::raw::c_char,
pub tip: *mut ::std::os::raw::c_char,
pub object_position: u8,
pub stream: *mut FILE,
pub image_type: u8,
pub is_image_buffer: u8,
pub image_buffer: *mut ::std::os::raw::c_char,
pub image_buffer_size: usize,
pub width: f64,
pub height: f64,
pub extension: *mut ::std::os::raw::c_char,
pub x_dpi: f64,
pub y_dpi: f64,
pub chart: *mut lxw_chart,
pub is_duplicate: u8,
pub is_background: u8,
pub md5: *mut ::std::os::raw::c_char,
pub image_position: *mut ::std::os::raw::c_char,
pub decorative: u8,
pub list_pointers: lxw_object_properties__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_object_properties__bindgen_ty_1 {
pub stqe_next: *mut lxw_object_properties,
}
#[test]
fn bindgen_test_layout_lxw_object_properties__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<lxw_object_properties__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_object_properties__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(lxw_object_properties__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<lxw_object_properties__bindgen_ty_1>(),
8usize,
concat!(
"Alignment of ",
stringify!(lxw_object_properties__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqe_next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties__bindgen_ty_1),
"::",
stringify!(stqe_next)
)
);
}
#[test]
fn bindgen_test_layout_lxw_object_properties() {
const UNINIT: ::std::mem::MaybeUninit<lxw_object_properties> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_object_properties>(),
192usize,
concat!("Size of: ", stringify!(lxw_object_properties))
);
assert_eq!(
::std::mem::align_of::<lxw_object_properties>(),
8usize,
concat!("Alignment of ", stringify!(lxw_object_properties))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x_offset) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(x_offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y_offset) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(y_offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x_scale) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(x_scale)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y_scale) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(y_scale)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).row) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(row)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).col) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(col)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).filename) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(filename)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).description) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(description)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).url) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(url)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tip) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(tip)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).object_position) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(object_position)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stream) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(stream)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).image_type) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(image_type)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).is_image_buffer) as usize - ptr as usize },
81usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(is_image_buffer)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).image_buffer) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(image_buffer)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).image_buffer_size) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(image_buffer_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).extension) as usize - ptr as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(extension)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x_dpi) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(x_dpi)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y_dpi) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(y_dpi)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).chart) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(chart)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).is_duplicate) as usize - ptr as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(is_duplicate)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).is_background) as usize - ptr as usize },
153usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(is_background)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).md5) as usize - ptr as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(md5)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).image_position) as usize - ptr as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(image_position)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).decorative) as usize - ptr as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(decorative)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).list_pointers) as usize - ptr as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(list_pointers)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_comment_options {
pub visible: u8,
pub author: *mut ::std::os::raw::c_char,
pub width: u16,
pub height: u16,
pub x_scale: f64,
pub y_scale: f64,
pub color: lxw_color_t,
pub font_name: *mut ::std::os::raw::c_char,
pub font_size: f64,
pub font_family: u8,
pub start_row: lxw_row_t,
pub start_col: lxw_col_t,
pub x_offset: i32,
pub y_offset: i32,
}
#[test]
fn bindgen_test_layout_lxw_comment_options() {
const UNINIT: ::std::mem::MaybeUninit<lxw_comment_options> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_comment_options>(),
88usize,
concat!("Size of: ", stringify!(lxw_comment_options))
);
assert_eq!(
::std::mem::align_of::<lxw_comment_options>(),
8usize,
concat!("Alignment of ", stringify!(lxw_comment_options))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).visible) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_comment_options),
"::",
stringify!(visible)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).author) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_comment_options),
"::",
stringify!(author)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_comment_options),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
18usize,
concat!(
"Offset of field: ",
stringify!(lxw_comment_options),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x_scale) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_comment_options),
"::",
stringify!(x_scale)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y_scale) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_comment_options),
"::",
stringify!(y_scale)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).color) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_comment_options),
"::",
stringify!(color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font_name) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_comment_options),
"::",
stringify!(font_name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font_size) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(lxw_comment_options),
"::",
stringify!(font_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font_family) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(lxw_comment_options),
"::",
stringify!(font_family)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).start_row) as usize - ptr as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(lxw_comment_options),
"::",
stringify!(start_row)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).start_col) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(lxw_comment_options),
"::",
stringify!(start_col)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x_offset) as usize - ptr as usize },
76usize,
concat!(
"Offset of field: ",
stringify!(lxw_comment_options),
"::",
stringify!(x_offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y_offset) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(lxw_comment_options),
"::",
stringify!(y_offset)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_button_options {
pub caption: *mut ::std::os::raw::c_char,
pub macro_: *mut ::std::os::raw::c_char,
pub description: *mut ::std::os::raw::c_char,
pub width: u16,
pub height: u16,
pub x_scale: f64,
pub y_scale: f64,
pub x_offset: i32,
pub y_offset: i32,
}
#[test]
fn bindgen_test_layout_lxw_button_options() {
const UNINIT: ::std::mem::MaybeUninit<lxw_button_options> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_button_options>(),
56usize,
concat!("Size of: ", stringify!(lxw_button_options))
);
assert_eq!(
::std::mem::align_of::<lxw_button_options>(),
8usize,
concat!("Alignment of ", stringify!(lxw_button_options))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).caption) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_button_options),
"::",
stringify!(caption)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).macro_) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_button_options),
"::",
stringify!(macro_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).description) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_button_options),
"::",
stringify!(description)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_button_options),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
26usize,
concat!(
"Offset of field: ",
stringify!(lxw_button_options),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x_scale) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_button_options),
"::",
stringify!(x_scale)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y_scale) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_button_options),
"::",
stringify!(y_scale)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x_offset) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_button_options),
"::",
stringify!(x_offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y_offset) as usize - ptr as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(lxw_button_options),
"::",
stringify!(y_offset)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_vml_obj {
pub row: lxw_row_t,
pub col: lxw_col_t,
pub start_row: lxw_row_t,
pub start_col: lxw_col_t,
pub x_offset: i32,
pub y_offset: i32,
pub col_absolute: u32,
pub row_absolute: u32,
pub width: u32,
pub height: u32,
pub x_dpi: f64,
pub y_dpi: f64,
pub color: lxw_color_t,
pub font_family: u8,
pub visible: u8,
pub author_id: u32,
pub rel_index: u32,
pub font_size: f64,
pub from: lxw_drawing_coords,
pub to: lxw_drawing_coords,
pub author: *mut ::std::os::raw::c_char,
pub font_name: *mut ::std::os::raw::c_char,
pub text: *mut ::std::os::raw::c_char,
pub image_position: *mut ::std::os::raw::c_char,
pub name: *mut ::std::os::raw::c_char,
pub macro_: *mut ::std::os::raw::c_char,
pub list_pointers: lxw_vml_obj__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_vml_obj__bindgen_ty_1 {
pub stqe_next: *mut lxw_vml_obj,
}
#[test]
fn bindgen_test_layout_lxw_vml_obj__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<lxw_vml_obj__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_vml_obj__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(lxw_vml_obj__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<lxw_vml_obj__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(lxw_vml_obj__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqe_next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj__bindgen_ty_1),
"::",
stringify!(stqe_next)
)
);
}
#[test]
fn bindgen_test_layout_lxw_vml_obj() {
const UNINIT: ::std::mem::MaybeUninit<lxw_vml_obj> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_vml_obj>(),
184usize,
concat!("Size of: ", stringify!(lxw_vml_obj))
);
assert_eq!(
::std::mem::align_of::<lxw_vml_obj>(),
8usize,
concat!("Alignment of ", stringify!(lxw_vml_obj))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).row) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(row)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).col) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(col)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).start_row) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(start_row)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).start_col) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(start_col)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x_offset) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(x_offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y_offset) as usize - ptr as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(y_offset)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).col_absolute) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(col_absolute)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).row_absolute) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(row_absolute)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).x_dpi) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(x_dpi)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).y_dpi) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(y_dpi)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).color) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font_family) as usize - ptr as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(font_family)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).visible) as usize - ptr as usize },
61usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(visible)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).author_id) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(author_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rel_index) as usize - ptr as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(rel_index)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font_size) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(font_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).from) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(from)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).to) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(to)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).author) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(author)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font_name) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(font_name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).text) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(text)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).image_position) as usize - ptr as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(image_position)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).macro_) as usize - ptr as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(macro_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).list_pointers) as usize - ptr as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(list_pointers)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_header_footer_options {
pub margin: f64,
pub image_left: *mut ::std::os::raw::c_char,
pub image_center: *mut ::std::os::raw::c_char,
pub image_right: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_lxw_header_footer_options() {
const UNINIT: ::std::mem::MaybeUninit<lxw_header_footer_options> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_header_footer_options>(),
32usize,
concat!("Size of: ", stringify!(lxw_header_footer_options))
);
assert_eq!(
::std::mem::align_of::<lxw_header_footer_options>(),
8usize,
concat!("Alignment of ", stringify!(lxw_header_footer_options))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).margin) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_header_footer_options),
"::",
stringify!(margin)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).image_left) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_header_footer_options),
"::",
stringify!(image_left)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).image_center) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_header_footer_options),
"::",
stringify!(image_center)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).image_right) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_header_footer_options),
"::",
stringify!(image_right)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_protection {
pub no_select_locked_cells: u8,
pub no_select_unlocked_cells: u8,
pub format_cells: u8,
pub format_columns: u8,
pub format_rows: u8,
pub insert_columns: u8,
pub insert_rows: u8,
pub insert_hyperlinks: u8,
pub delete_columns: u8,
pub delete_rows: u8,
pub sort: u8,
pub autofilter: u8,
pub pivot_tables: u8,
pub scenarios: u8,
pub objects: u8,
pub no_content: u8,
pub no_objects: u8,
}
#[test]
fn bindgen_test_layout_lxw_protection() {
const UNINIT: ::std::mem::MaybeUninit<lxw_protection> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_protection>(),
17usize,
concat!("Size of: ", stringify!(lxw_protection))
);
assert_eq!(
::std::mem::align_of::<lxw_protection>(),
1usize,
concat!("Alignment of ", stringify!(lxw_protection))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).no_select_locked_cells) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection),
"::",
stringify!(no_select_locked_cells)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).no_select_unlocked_cells) as usize - ptr as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection),
"::",
stringify!(no_select_unlocked_cells)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).format_cells) as usize - ptr as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection),
"::",
stringify!(format_cells)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).format_columns) as usize - ptr as usize },
3usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection),
"::",
stringify!(format_columns)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).format_rows) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection),
"::",
stringify!(format_rows)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).insert_columns) as usize - ptr as usize },
5usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection),
"::",
stringify!(insert_columns)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).insert_rows) as usize - ptr as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection),
"::",
stringify!(insert_rows)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).insert_hyperlinks) as usize - ptr as usize },
7usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection),
"::",
stringify!(insert_hyperlinks)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).delete_columns) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection),
"::",
stringify!(delete_columns)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).delete_rows) as usize - ptr as usize },
9usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection),
"::",
stringify!(delete_rows)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sort) as usize - ptr as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection),
"::",
stringify!(sort)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).autofilter) as usize - ptr as usize },
11usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection),
"::",
stringify!(autofilter)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pivot_tables) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection),
"::",
stringify!(pivot_tables)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).scenarios) as usize - ptr as usize },
13usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection),
"::",
stringify!(scenarios)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).objects) as usize - ptr as usize },
14usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection),
"::",
stringify!(objects)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).no_content) as usize - ptr as usize },
15usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection),
"::",
stringify!(no_content)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).no_objects) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection),
"::",
stringify!(no_objects)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_protection_obj {
pub no_select_locked_cells: u8,
pub no_select_unlocked_cells: u8,
pub format_cells: u8,
pub format_columns: u8,
pub format_rows: u8,
pub insert_columns: u8,
pub insert_rows: u8,
pub insert_hyperlinks: u8,
pub delete_columns: u8,
pub delete_rows: u8,
pub sort: u8,
pub autofilter: u8,
pub pivot_tables: u8,
pub scenarios: u8,
pub objects: u8,
pub no_content: u8,
pub no_objects: u8,
pub no_sheet: u8,
pub is_configured: u8,
pub hash: [::std::os::raw::c_char; 5usize],
}
#[test]
fn bindgen_test_layout_lxw_protection_obj() {
const UNINIT: ::std::mem::MaybeUninit<lxw_protection_obj> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_protection_obj>(),
24usize,
concat!("Size of: ", stringify!(lxw_protection_obj))
);
assert_eq!(
::std::mem::align_of::<lxw_protection_obj>(),
1usize,
concat!("Alignment of ", stringify!(lxw_protection_obj))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).no_select_locked_cells) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(no_select_locked_cells)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).no_select_unlocked_cells) as usize - ptr as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(no_select_unlocked_cells)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).format_cells) as usize - ptr as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(format_cells)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).format_columns) as usize - ptr as usize },
3usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(format_columns)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).format_rows) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(format_rows)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).insert_columns) as usize - ptr as usize },
5usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(insert_columns)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).insert_rows) as usize - ptr as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(insert_rows)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).insert_hyperlinks) as usize - ptr as usize },
7usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(insert_hyperlinks)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).delete_columns) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(delete_columns)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).delete_rows) as usize - ptr as usize },
9usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(delete_rows)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sort) as usize - ptr as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(sort)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).autofilter) as usize - ptr as usize },
11usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(autofilter)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).pivot_tables) as usize - ptr as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(pivot_tables)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).scenarios) as usize - ptr as usize },
13usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(scenarios)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).objects) as usize - ptr as usize },
14usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(objects)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).no_content) as usize - ptr as usize },
15usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(no_content)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).no_objects) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(no_objects)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).no_sheet) as usize - ptr as usize },
17usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(no_sheet)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).is_configured) as usize - ptr as usize },
18usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(is_configured)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hash) as usize - ptr as usize },
19usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(hash)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_rich_string_tuple {
pub format: *mut lxw_format,
pub string: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_lxw_rich_string_tuple() {
const UNINIT: ::std::mem::MaybeUninit<lxw_rich_string_tuple> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_rich_string_tuple>(),
16usize,
concat!("Size of: ", stringify!(lxw_rich_string_tuple))
);
assert_eq!(
::std::mem::align_of::<lxw_rich_string_tuple>(),
8usize,
concat!("Alignment of ", stringify!(lxw_rich_string_tuple))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).format) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_rich_string_tuple),
"::",
stringify!(format)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).string) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_rich_string_tuple),
"::",
stringify!(string)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_worksheet {
pub file: *mut FILE,
pub optimize_tmpfile: *mut FILE,
pub optimize_buffer: *mut ::std::os::raw::c_char,
pub optimize_buffer_size: usize,
pub table: *mut lxw_table_rows,
pub hyperlinks: *mut lxw_table_rows,
pub comments: *mut lxw_table_rows,
pub array: *mut *mut lxw_cell,
pub merged_ranges: *mut lxw_merged_ranges,
pub selections: *mut lxw_selections,
pub data_validations: *mut lxw_data_validations,
pub conditional_formats: *mut lxw_cond_format_hash,
pub image_props: *mut lxw_image_props,
pub chart_data: *mut lxw_chart_props,
pub drawing_rel_ids: *mut lxw_drawing_rel_ids,
pub vml_drawing_rel_ids: *mut lxw_vml_drawing_rel_ids,
pub comment_objs: *mut lxw_comment_objs,
pub header_image_objs: *mut lxw_comment_objs,
pub button_objs: *mut lxw_comment_objs,
pub table_objs: *mut lxw_table_objs,
pub table_count: u16,
pub dim_rowmin: lxw_row_t,
pub dim_rowmax: lxw_row_t,
pub dim_colmin: lxw_col_t,
pub dim_colmax: lxw_col_t,
pub sst: *mut lxw_sst,
pub name: *mut ::std::os::raw::c_char,
pub quoted_name: *mut ::std::os::raw::c_char,
pub tmpdir: *mut ::std::os::raw::c_char,
pub index: u16,
pub active: u8,
pub selected: u8,
pub hidden: u8,
pub active_sheet: *mut u16,
pub first_sheet: *mut u16,
pub is_chartsheet: u8,
pub col_options: *mut *mut lxw_col_options,
pub col_options_max: u16,
pub col_sizes: *mut f64,
pub col_sizes_max: u16,
pub col_formats: *mut *mut lxw_format,
pub col_formats_max: u16,
pub col_size_changed: u8,
pub row_size_changed: u8,
pub optimize: u8,
pub optimize_row: *mut lxw_row,
pub fit_height: u16,
pub fit_width: u16,
pub horizontal_dpi: u16,
pub hlink_count: u16,
pub page_start: u16,
pub print_scale: u16,
pub rel_count: u16,
pub vertical_dpi: u16,
pub zoom: u16,
pub filter_on: u8,
pub fit_page: u8,
pub hcenter: u8,
pub orientation: u8,
pub outline_changed: u8,
pub outline_on: u8,
pub outline_style: u8,
pub outline_below: u8,
pub outline_right: u8,
pub page_order: u8,
pub page_setup_changed: u8,
pub page_view: u8,
pub paper_size: u8,
pub print_gridlines: u8,
pub print_headers: u8,
pub print_options_changed: u8,
pub right_to_left: u8,
pub screen_gridlines: u8,
pub show_zeros: u8,
pub vcenter: u8,
pub zoom_scale_normal: u8,
pub black_white: u8,
pub num_validations: u8,
pub has_dynamic_arrays: u8,
pub vba_codename: *mut ::std::os::raw::c_char,
pub num_buttons: u16,
pub tab_color: lxw_color_t,
pub margin_left: f64,
pub margin_right: f64,
pub margin_top: f64,
pub margin_bottom: f64,
pub margin_header: f64,
pub margin_footer: f64,
pub default_row_height: f64,
pub default_row_pixels: u32,
pub default_col_pixels: u32,
pub default_row_zeroed: u8,
pub default_row_set: u8,
pub outline_row_level: u8,
pub outline_col_level: u8,
pub header_footer_changed: u8,
pub header: *mut ::std::os::raw::c_char,
pub footer: *mut ::std::os::raw::c_char,
pub repeat_rows: lxw_repeat_rows,
pub repeat_cols: lxw_repeat_cols,
pub print_area: lxw_print_area,
pub autofilter: lxw_autofilter,
pub merged_range_count: u16,
pub max_url_length: u16,
pub hbreaks: *mut lxw_row_t,
pub vbreaks: *mut lxw_col_t,
pub hbreaks_count: u16,
pub vbreaks_count: u16,
pub drawing_rel_id: u32,
pub vml_drawing_rel_id: u32,
pub external_hyperlinks: *mut lxw_rel_tuples,
pub external_drawing_links: *mut lxw_rel_tuples,
pub drawing_links: *mut lxw_rel_tuples,
pub vml_drawing_links: *mut lxw_rel_tuples,
pub external_table_links: *mut lxw_rel_tuples,
pub panes: lxw_panes,
pub top_left_cell: [::std::os::raw::c_char; 14usize],
pub protection: lxw_protection_obj,
pub drawing: *mut lxw_drawing,
pub default_url_format: *mut lxw_format,
pub has_vml: u8,
pub has_comments: u8,
pub has_header_vml: u8,
pub has_background_image: u8,
pub has_buttons: u8,
pub external_vml_comment_link: *mut lxw_rel_tuple,
pub external_comment_link: *mut lxw_rel_tuple,
pub external_vml_header_link: *mut lxw_rel_tuple,
pub external_background_link: *mut lxw_rel_tuple,
pub comment_author: *mut ::std::os::raw::c_char,
pub vml_data_id_str: *mut ::std::os::raw::c_char,
pub vml_header_id_str: *mut ::std::os::raw::c_char,
pub vml_shape_id: u32,
pub vml_header_id: u32,
pub dxf_priority: u32,
pub comment_display_default: u8,
pub data_bar_2010_index: u32,
pub has_ignore_errors: u8,
pub ignore_number_stored_as_text: *mut ::std::os::raw::c_char,
pub ignore_eval_error: *mut ::std::os::raw::c_char,
pub ignore_formula_differs: *mut ::std::os::raw::c_char,
pub ignore_formula_range: *mut ::std::os::raw::c_char,
pub ignore_formula_unlocked: *mut ::std::os::raw::c_char,
pub ignore_empty_cell_reference: *mut ::std::os::raw::c_char,
pub ignore_list_data_validation: *mut ::std::os::raw::c_char,
pub ignore_calculated_column: *mut ::std::os::raw::c_char,
pub ignore_two_digit_text_year: *mut ::std::os::raw::c_char,
pub excel_version: u16,
pub header_footer_objs: [*mut *mut lxw_object_properties; 6usize],
pub header_left_object_props: *mut lxw_object_properties,
pub header_center_object_props: *mut lxw_object_properties,
pub header_right_object_props: *mut lxw_object_properties,
pub footer_left_object_props: *mut lxw_object_properties,
pub footer_center_object_props: *mut lxw_object_properties,
pub footer_right_object_props: *mut lxw_object_properties,
pub background_image: *mut lxw_object_properties,
pub filter_rules: *mut *mut lxw_filter_rule_obj,
pub num_filter_rules: lxw_col_t,
pub list_pointers: lxw_worksheet__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_worksheet__bindgen_ty_1 {
pub stqe_next: *mut lxw_worksheet,
}
#[test]
fn bindgen_test_layout_lxw_worksheet__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<lxw_worksheet__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_worksheet__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(lxw_worksheet__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<lxw_worksheet__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(lxw_worksheet__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqe_next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet__bindgen_ty_1),
"::",
stringify!(stqe_next)
)
);
}
#[test]
fn bindgen_test_layout_lxw_worksheet() {
const UNINIT: ::std::mem::MaybeUninit<lxw_worksheet> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_worksheet>(),
968usize,
concat!("Size of: ", stringify!(lxw_worksheet))
);
assert_eq!(
::std::mem::align_of::<lxw_worksheet>(),
8usize,
concat!("Alignment of ", stringify!(lxw_worksheet))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).file) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(file)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).optimize_tmpfile) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(optimize_tmpfile)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).optimize_buffer) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(optimize_buffer)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).optimize_buffer_size) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(optimize_buffer_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).table) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(table)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hyperlinks) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(hyperlinks)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comments) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(comments)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).array) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(array)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).merged_ranges) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(merged_ranges)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).selections) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(selections)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data_validations) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(data_validations)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).conditional_formats) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(conditional_formats)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).image_props) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(image_props)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).chart_data) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(chart_data)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).drawing_rel_ids) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(drawing_rel_ids)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vml_drawing_rel_ids) as usize - ptr as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(vml_drawing_rel_ids)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comment_objs) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(comment_objs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).header_image_objs) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(header_image_objs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).button_objs) as usize - ptr as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(button_objs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).table_objs) as usize - ptr as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(table_objs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).table_count) as usize - ptr as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(table_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dim_rowmin) as usize - ptr as usize },
164usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(dim_rowmin)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dim_rowmax) as usize - ptr as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(dim_rowmax)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dim_colmin) as usize - ptr as usize },
172usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(dim_colmin)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dim_colmax) as usize - ptr as usize },
174usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(dim_colmax)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sst) as usize - ptr as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(sst)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).quoted_name) as usize - ptr as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(quoted_name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tmpdir) as usize - ptr as usize },
200usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(tmpdir)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).index) as usize - ptr as usize },
208usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(index)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).active) as usize - ptr as usize },
210usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(active)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).selected) as usize - ptr as usize },
211usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(selected)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hidden) as usize - ptr as usize },
212usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(hidden)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).active_sheet) as usize - ptr as usize },
216usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(active_sheet)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).first_sheet) as usize - ptr as usize },
224usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(first_sheet)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).is_chartsheet) as usize - ptr as usize },
232usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(is_chartsheet)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).col_options) as usize - ptr as usize },
240usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(col_options)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).col_options_max) as usize - ptr as usize },
248usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(col_options_max)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).col_sizes) as usize - ptr as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(col_sizes)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).col_sizes_max) as usize - ptr as usize },
264usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(col_sizes_max)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).col_formats) as usize - ptr as usize },
272usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(col_formats)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).col_formats_max) as usize - ptr as usize },
280usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(col_formats_max)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).col_size_changed) as usize - ptr as usize },
282usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(col_size_changed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).row_size_changed) as usize - ptr as usize },
283usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(row_size_changed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).optimize) as usize - ptr as usize },
284usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(optimize)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).optimize_row) as usize - ptr as usize },
288usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(optimize_row)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fit_height) as usize - ptr as usize },
296usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(fit_height)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fit_width) as usize - ptr as usize },
298usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(fit_width)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).horizontal_dpi) as usize - ptr as usize },
300usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(horizontal_dpi)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hlink_count) as usize - ptr as usize },
302usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(hlink_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).page_start) as usize - ptr as usize },
304usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(page_start)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).print_scale) as usize - ptr as usize },
306usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(print_scale)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rel_count) as usize - ptr as usize },
308usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(rel_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vertical_dpi) as usize - ptr as usize },
310usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(vertical_dpi)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).zoom) as usize - ptr as usize },
312usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(zoom)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).filter_on) as usize - ptr as usize },
314usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(filter_on)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fit_page) as usize - ptr as usize },
315usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(fit_page)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hcenter) as usize - ptr as usize },
316usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(hcenter)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).orientation) as usize - ptr as usize },
317usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(orientation)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).outline_changed) as usize - ptr as usize },
318usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(outline_changed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).outline_on) as usize - ptr as usize },
319usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(outline_on)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).outline_style) as usize - ptr as usize },
320usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(outline_style)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).outline_below) as usize - ptr as usize },
321usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(outline_below)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).outline_right) as usize - ptr as usize },
322usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(outline_right)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).page_order) as usize - ptr as usize },
323usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(page_order)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).page_setup_changed) as usize - ptr as usize },
324usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(page_setup_changed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).page_view) as usize - ptr as usize },
325usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(page_view)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).paper_size) as usize - ptr as usize },
326usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(paper_size)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).print_gridlines) as usize - ptr as usize },
327usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(print_gridlines)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).print_headers) as usize - ptr as usize },
328usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(print_headers)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).print_options_changed) as usize - ptr as usize },
329usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(print_options_changed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).right_to_left) as usize - ptr as usize },
330usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(right_to_left)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).screen_gridlines) as usize - ptr as usize },
331usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(screen_gridlines)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).show_zeros) as usize - ptr as usize },
332usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(show_zeros)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vcenter) as usize - ptr as usize },
333usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(vcenter)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).zoom_scale_normal) as usize - ptr as usize },
334usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(zoom_scale_normal)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).black_white) as usize - ptr as usize },
335usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(black_white)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).num_validations) as usize - ptr as usize },
336usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(num_validations)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_dynamic_arrays) as usize - ptr as usize },
337usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(has_dynamic_arrays)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vba_codename) as usize - ptr as usize },
344usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(vba_codename)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).num_buttons) as usize - ptr as usize },
352usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(num_buttons)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tab_color) as usize - ptr as usize },
356usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(tab_color)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).margin_left) as usize - ptr as usize },
360usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(margin_left)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).margin_right) as usize - ptr as usize },
368usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(margin_right)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).margin_top) as usize - ptr as usize },
376usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(margin_top)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).margin_bottom) as usize - ptr as usize },
384usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(margin_bottom)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).margin_header) as usize - ptr as usize },
392usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(margin_header)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).margin_footer) as usize - ptr as usize },
400usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(margin_footer)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).default_row_height) as usize - ptr as usize },
408usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(default_row_height)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).default_row_pixels) as usize - ptr as usize },
416usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(default_row_pixels)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).default_col_pixels) as usize - ptr as usize },
420usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(default_col_pixels)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).default_row_zeroed) as usize - ptr as usize },
424usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(default_row_zeroed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).default_row_set) as usize - ptr as usize },
425usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(default_row_set)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).outline_row_level) as usize - ptr as usize },
426usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(outline_row_level)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).outline_col_level) as usize - ptr as usize },
427usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(outline_col_level)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).header_footer_changed) as usize - ptr as usize },
428usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(header_footer_changed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).header) as usize - ptr as usize },
432usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(header)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).footer) as usize - ptr as usize },
440usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(footer)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).repeat_rows) as usize - ptr as usize },
448usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(repeat_rows)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).repeat_cols) as usize - ptr as usize },
460usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(repeat_cols)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).print_area) as usize - ptr as usize },
468usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(print_area)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).autofilter) as usize - ptr as usize },
484usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(autofilter)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).merged_range_count) as usize - ptr as usize },
500usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(merged_range_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_url_length) as usize - ptr as usize },
502usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(max_url_length)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hbreaks) as usize - ptr as usize },
504usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(hbreaks)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vbreaks) as usize - ptr as usize },
512usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(vbreaks)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hbreaks_count) as usize - ptr as usize },
520usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(hbreaks_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vbreaks_count) as usize - ptr as usize },
522usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(vbreaks_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).drawing_rel_id) as usize - ptr as usize },
524usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(drawing_rel_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vml_drawing_rel_id) as usize - ptr as usize },
528usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(vml_drawing_rel_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).external_hyperlinks) as usize - ptr as usize },
536usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(external_hyperlinks)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).external_drawing_links) as usize - ptr as usize },
544usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(external_drawing_links)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).drawing_links) as usize - ptr as usize },
552usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(drawing_links)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vml_drawing_links) as usize - ptr as usize },
560usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(vml_drawing_links)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).external_table_links) as usize - ptr as usize },
568usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(external_table_links)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).panes) as usize - ptr as usize },
576usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(panes)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).top_left_cell) as usize - ptr as usize },
616usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(top_left_cell)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).protection) as usize - ptr as usize },
630usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(protection)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).drawing) as usize - ptr as usize },
656usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(drawing)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).default_url_format) as usize - ptr as usize },
664usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(default_url_format)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_vml) as usize - ptr as usize },
672usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(has_vml)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_comments) as usize - ptr as usize },
673usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(has_comments)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_header_vml) as usize - ptr as usize },
674usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(has_header_vml)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_background_image) as usize - ptr as usize },
675usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(has_background_image)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_buttons) as usize - ptr as usize },
676usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(has_buttons)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).external_vml_comment_link) as usize - ptr as usize },
680usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(external_vml_comment_link)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).external_comment_link) as usize - ptr as usize },
688usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(external_comment_link)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).external_vml_header_link) as usize - ptr as usize },
696usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(external_vml_header_link)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).external_background_link) as usize - ptr as usize },
704usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(external_background_link)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comment_author) as usize - ptr as usize },
712usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(comment_author)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vml_data_id_str) as usize - ptr as usize },
720usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(vml_data_id_str)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vml_header_id_str) as usize - ptr as usize },
728usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(vml_header_id_str)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vml_shape_id) as usize - ptr as usize },
736usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(vml_shape_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vml_header_id) as usize - ptr as usize },
740usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(vml_header_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).dxf_priority) as usize - ptr as usize },
744usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(dxf_priority)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comment_display_default) as usize - ptr as usize },
748usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(comment_display_default)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data_bar_2010_index) as usize - ptr as usize },
752usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(data_bar_2010_index)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_ignore_errors) as usize - ptr as usize },
756usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(has_ignore_errors)
)
);
assert_eq!(
unsafe {
::std::ptr::addr_of!((*ptr).ignore_number_stored_as_text) as usize - ptr as usize
},
760usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(ignore_number_stored_as_text)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ignore_eval_error) as usize - ptr as usize },
768usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(ignore_eval_error)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ignore_formula_differs) as usize - ptr as usize },
776usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(ignore_formula_differs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ignore_formula_range) as usize - ptr as usize },
784usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(ignore_formula_range)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ignore_formula_unlocked) as usize - ptr as usize },
792usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(ignore_formula_unlocked)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ignore_empty_cell_reference) as usize - ptr as usize },
800usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(ignore_empty_cell_reference)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ignore_list_data_validation) as usize - ptr as usize },
808usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(ignore_list_data_validation)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ignore_calculated_column) as usize - ptr as usize },
816usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(ignore_calculated_column)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ignore_two_digit_text_year) as usize - ptr as usize },
824usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(ignore_two_digit_text_year)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).excel_version) as usize - ptr as usize },
832usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(excel_version)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).header_footer_objs) as usize - ptr as usize },
840usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(header_footer_objs)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).header_left_object_props) as usize - ptr as usize },
888usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(header_left_object_props)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).header_center_object_props) as usize - ptr as usize },
896usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(header_center_object_props)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).header_right_object_props) as usize - ptr as usize },
904usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(header_right_object_props)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).footer_left_object_props) as usize - ptr as usize },
912usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(footer_left_object_props)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).footer_center_object_props) as usize - ptr as usize },
920usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(footer_center_object_props)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).footer_right_object_props) as usize - ptr as usize },
928usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(footer_right_object_props)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).background_image) as usize - ptr as usize },
936usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(background_image)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).filter_rules) as usize - ptr as usize },
944usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(filter_rules)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).num_filter_rules) as usize - ptr as usize },
952usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(num_filter_rules)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).list_pointers) as usize - ptr as usize },
960usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(list_pointers)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_worksheet_init_data {
pub index: u16,
pub hidden: u8,
pub optimize: u8,
pub active_sheet: *mut u16,
pub first_sheet: *mut u16,
pub sst: *mut lxw_sst,
pub name: *mut ::std::os::raw::c_char,
pub quoted_name: *mut ::std::os::raw::c_char,
pub tmpdir: *mut ::std::os::raw::c_char,
pub default_url_format: *mut lxw_format,
pub max_url_length: u16,
}
#[test]
fn bindgen_test_layout_lxw_worksheet_init_data() {
const UNINIT: ::std::mem::MaybeUninit<lxw_worksheet_init_data> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_worksheet_init_data>(),
72usize,
concat!("Size of: ", stringify!(lxw_worksheet_init_data))
);
assert_eq!(
::std::mem::align_of::<lxw_worksheet_init_data>(),
8usize,
concat!("Alignment of ", stringify!(lxw_worksheet_init_data))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).index) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet_init_data),
"::",
stringify!(index)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hidden) as usize - ptr as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet_init_data),
"::",
stringify!(hidden)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).optimize) as usize - ptr as usize },
3usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet_init_data),
"::",
stringify!(optimize)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).active_sheet) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet_init_data),
"::",
stringify!(active_sheet)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).first_sheet) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet_init_data),
"::",
stringify!(first_sheet)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sst) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet_init_data),
"::",
stringify!(sst)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet_init_data),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).quoted_name) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet_init_data),
"::",
stringify!(quoted_name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tmpdir) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet_init_data),
"::",
stringify!(tmpdir)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).default_url_format) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet_init_data),
"::",
stringify!(default_url_format)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_url_length) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet_init_data),
"::",
stringify!(max_url_length)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_row {
pub row_num: lxw_row_t,
pub height: f64,
pub format: *mut lxw_format,
pub hidden: u8,
pub level: u8,
pub collapsed: u8,
pub row_changed: u8,
pub data_changed: u8,
pub height_changed: u8,
pub cells: *mut lxw_table_cells,
pub tree_pointers: lxw_row__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_row__bindgen_ty_1 {
pub rbe_left: *mut lxw_row,
pub rbe_right: *mut lxw_row,
pub rbe_parent: *mut lxw_row,
pub rbe_color: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_lxw_row__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<lxw_row__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_row__bindgen_ty_1>(),
32usize,
concat!("Size of: ", stringify!(lxw_row__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<lxw_row__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(lxw_row__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbe_left) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_row__bindgen_ty_1),
"::",
stringify!(rbe_left)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbe_right) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_row__bindgen_ty_1),
"::",
stringify!(rbe_right)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbe_parent) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_row__bindgen_ty_1),
"::",
stringify!(rbe_parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbe_color) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_row__bindgen_ty_1),
"::",
stringify!(rbe_color)
)
);
}
#[test]
fn bindgen_test_layout_lxw_row() {
const UNINIT: ::std::mem::MaybeUninit<lxw_row> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_row>(),
72usize,
concat!("Size of: ", stringify!(lxw_row))
);
assert_eq!(
::std::mem::align_of::<lxw_row>(),
8usize,
concat!("Alignment of ", stringify!(lxw_row))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).row_num) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_row),
"::",
stringify!(row_num)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_row),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).format) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_row),
"::",
stringify!(format)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hidden) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_row),
"::",
stringify!(hidden)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).level) as usize - ptr as usize },
25usize,
concat!(
"Offset of field: ",
stringify!(lxw_row),
"::",
stringify!(level)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).collapsed) as usize - ptr as usize },
26usize,
concat!(
"Offset of field: ",
stringify!(lxw_row),
"::",
stringify!(collapsed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).row_changed) as usize - ptr as usize },
27usize,
concat!(
"Offset of field: ",
stringify!(lxw_row),
"::",
stringify!(row_changed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).data_changed) as usize - ptr as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(lxw_row),
"::",
stringify!(data_changed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).height_changed) as usize - ptr as usize },
29usize,
concat!(
"Offset of field: ",
stringify!(lxw_row),
"::",
stringify!(height_changed)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).cells) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_row),
"::",
stringify!(cells)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tree_pointers) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_row),
"::",
stringify!(tree_pointers)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct lxw_cell {
pub row_num: lxw_row_t,
pub col_num: lxw_col_t,
pub type_: cell_types,
pub format: *mut lxw_format,
pub comment: *mut lxw_vml_obj,
pub u: lxw_cell__bindgen_ty_1,
pub formula_result: f64,
pub user_data1: *mut ::std::os::raw::c_char,
pub user_data2: *mut ::std::os::raw::c_char,
pub sst_string: *mut ::std::os::raw::c_char,
pub tree_pointers: lxw_cell__bindgen_ty_2,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union lxw_cell__bindgen_ty_1 {
pub number: f64,
pub string_id: i32,
pub string: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_lxw_cell__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<lxw_cell__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_cell__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(lxw_cell__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<lxw_cell__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(lxw_cell__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).number) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_cell__bindgen_ty_1),
"::",
stringify!(number)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).string_id) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_cell__bindgen_ty_1),
"::",
stringify!(string_id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).string) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_cell__bindgen_ty_1),
"::",
stringify!(string)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_cell__bindgen_ty_2 {
pub rbe_left: *mut lxw_cell,
pub rbe_right: *mut lxw_cell,
pub rbe_parent: *mut lxw_cell,
pub rbe_color: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_lxw_cell__bindgen_ty_2() {
const UNINIT: ::std::mem::MaybeUninit<lxw_cell__bindgen_ty_2> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_cell__bindgen_ty_2>(),
32usize,
concat!("Size of: ", stringify!(lxw_cell__bindgen_ty_2))
);
assert_eq!(
::std::mem::align_of::<lxw_cell__bindgen_ty_2>(),
8usize,
concat!("Alignment of ", stringify!(lxw_cell__bindgen_ty_2))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbe_left) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_cell__bindgen_ty_2),
"::",
stringify!(rbe_left)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbe_right) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_cell__bindgen_ty_2),
"::",
stringify!(rbe_right)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbe_parent) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_cell__bindgen_ty_2),
"::",
stringify!(rbe_parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbe_color) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_cell__bindgen_ty_2),
"::",
stringify!(rbe_color)
)
);
}
#[test]
fn bindgen_test_layout_lxw_cell() {
const UNINIT: ::std::mem::MaybeUninit<lxw_cell> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_cell>(),
104usize,
concat!("Size of: ", stringify!(lxw_cell))
);
assert_eq!(
::std::mem::align_of::<lxw_cell>(),
8usize,
concat!("Alignment of ", stringify!(lxw_cell))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).row_num) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_cell),
"::",
stringify!(row_num)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).col_num) as usize - ptr as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_cell),
"::",
stringify!(col_num)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_cell),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).format) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_cell),
"::",
stringify!(format)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comment) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_cell),
"::",
stringify!(comment)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_cell),
"::",
stringify!(u)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).formula_result) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_cell),
"::",
stringify!(formula_result)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).user_data1) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_cell),
"::",
stringify!(user_data1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).user_data2) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(lxw_cell),
"::",
stringify!(user_data2)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sst_string) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(lxw_cell),
"::",
stringify!(sst_string)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tree_pointers) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(lxw_cell),
"::",
stringify!(tree_pointers)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_drawing_rel_id {
pub id: u32,
pub target: *mut ::std::os::raw::c_char,
pub tree_pointers: lxw_drawing_rel_id__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_drawing_rel_id__bindgen_ty_1 {
pub rbe_left: *mut lxw_drawing_rel_id,
pub rbe_right: *mut lxw_drawing_rel_id,
pub rbe_parent: *mut lxw_drawing_rel_id,
pub rbe_color: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_lxw_drawing_rel_id__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<lxw_drawing_rel_id__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_drawing_rel_id__bindgen_ty_1>(),
32usize,
concat!("Size of: ", stringify!(lxw_drawing_rel_id__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<lxw_drawing_rel_id__bindgen_ty_1>(),
8usize,
concat!(
"Alignment of ",
stringify!(lxw_drawing_rel_id__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbe_left) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_rel_id__bindgen_ty_1),
"::",
stringify!(rbe_left)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbe_right) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_rel_id__bindgen_ty_1),
"::",
stringify!(rbe_right)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbe_parent) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_rel_id__bindgen_ty_1),
"::",
stringify!(rbe_parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbe_color) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_rel_id__bindgen_ty_1),
"::",
stringify!(rbe_color)
)
);
}
#[test]
fn bindgen_test_layout_lxw_drawing_rel_id() {
const UNINIT: ::std::mem::MaybeUninit<lxw_drawing_rel_id> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_drawing_rel_id>(),
48usize,
concat!("Size of: ", stringify!(lxw_drawing_rel_id))
);
assert_eq!(
::std::mem::align_of::<lxw_drawing_rel_id>(),
8usize,
concat!("Alignment of ", stringify!(lxw_drawing_rel_id))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_rel_id),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).target) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_rel_id),
"::",
stringify!(target)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tree_pointers) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_rel_id),
"::",
stringify!(tree_pointers)
)
);
}
extern "C" {
pub fn worksheet_write_number(
worksheet: *mut lxw_worksheet,
row: lxw_row_t,
col: lxw_col_t,
number: f64,
format: *mut lxw_format,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_write_string(
worksheet: *mut lxw_worksheet,
row: lxw_row_t,
col: lxw_col_t,
string: *const ::std::os::raw::c_char,
format: *mut lxw_format,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_write_formula(
worksheet: *mut lxw_worksheet,
row: lxw_row_t,
col: lxw_col_t,
formula: *const ::std::os::raw::c_char,
format: *mut lxw_format,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_write_array_formula(
worksheet: *mut lxw_worksheet,
first_row: lxw_row_t,
first_col: lxw_col_t,
last_row: lxw_row_t,
last_col: lxw_col_t,
formula: *const ::std::os::raw::c_char,
format: *mut lxw_format,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_write_dynamic_array_formula(
worksheet: *mut lxw_worksheet,
first_row: lxw_row_t,
first_col: lxw_col_t,
last_row: lxw_row_t,
last_col: lxw_col_t,
formula: *const ::std::os::raw::c_char,
format: *mut lxw_format,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_write_dynamic_formula(
worksheet: *mut lxw_worksheet,
row: lxw_row_t,
col: lxw_col_t,
formula: *const ::std::os::raw::c_char,
format: *mut lxw_format,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_write_array_formula_num(
worksheet: *mut lxw_worksheet,
first_row: lxw_row_t,
first_col: lxw_col_t,
last_row: lxw_row_t,
last_col: lxw_col_t,
formula: *const ::std::os::raw::c_char,
format: *mut lxw_format,
result: f64,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_write_dynamic_array_formula_num(
worksheet: *mut lxw_worksheet,
first_row: lxw_row_t,
first_col: lxw_col_t,
last_row: lxw_row_t,
last_col: lxw_col_t,
formula: *const ::std::os::raw::c_char,
format: *mut lxw_format,
result: f64,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_write_dynamic_formula_num(
worksheet: *mut lxw_worksheet,
row: lxw_row_t,
col: lxw_col_t,
formula: *const ::std::os::raw::c_char,
format: *mut lxw_format,
result: f64,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_write_datetime(
worksheet: *mut lxw_worksheet,
row: lxw_row_t,
col: lxw_col_t,
datetime: *mut lxw_datetime,
format: *mut lxw_format,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_write_unixtime(
worksheet: *mut lxw_worksheet,
row: lxw_row_t,
col: lxw_col_t,
unixtime: i64,
format: *mut lxw_format,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_write_url(
worksheet: *mut lxw_worksheet,
row: lxw_row_t,
col: lxw_col_t,
url: *const ::std::os::raw::c_char,
format: *mut lxw_format,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_write_url_opt(
worksheet: *mut lxw_worksheet,
row_num: lxw_row_t,
col_num: lxw_col_t,
url: *const ::std::os::raw::c_char,
format: *mut lxw_format,
string: *const ::std::os::raw::c_char,
tooltip: *const ::std::os::raw::c_char,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_write_boolean(
worksheet: *mut lxw_worksheet,
row: lxw_row_t,
col: lxw_col_t,
value: ::std::os::raw::c_int,
format: *mut lxw_format,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_write_blank(
worksheet: *mut lxw_worksheet,
row: lxw_row_t,
col: lxw_col_t,
format: *mut lxw_format,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_write_formula_num(
worksheet: *mut lxw_worksheet,
row: lxw_row_t,
col: lxw_col_t,
formula: *const ::std::os::raw::c_char,
format: *mut lxw_format,
result: f64,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_write_formula_str(
worksheet: *mut lxw_worksheet,
row: lxw_row_t,
col: lxw_col_t,
formula: *const ::std::os::raw::c_char,
format: *mut lxw_format,
result: *const ::std::os::raw::c_char,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_write_rich_string(
worksheet: *mut lxw_worksheet,
row: lxw_row_t,
col: lxw_col_t,
rich_string: *mut *mut lxw_rich_string_tuple,
format: *mut lxw_format,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_write_comment(
worksheet: *mut lxw_worksheet,
row: lxw_row_t,
col: lxw_col_t,
string: *const ::std::os::raw::c_char,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_write_comment_opt(
worksheet: *mut lxw_worksheet,
row: lxw_row_t,
col: lxw_col_t,
string: *const ::std::os::raw::c_char,
options: *mut lxw_comment_options,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_set_row(
worksheet: *mut lxw_worksheet,
row: lxw_row_t,
height: f64,
format: *mut lxw_format,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_set_row_opt(
worksheet: *mut lxw_worksheet,
row: lxw_row_t,
height: f64,
format: *mut lxw_format,
options: *mut lxw_row_col_options,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_set_row_pixels(
worksheet: *mut lxw_worksheet,
row: lxw_row_t,
pixels: u32,
format: *mut lxw_format,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_set_row_pixels_opt(
worksheet: *mut lxw_worksheet,
row: lxw_row_t,
pixels: u32,
format: *mut lxw_format,
options: *mut lxw_row_col_options,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_set_column(
worksheet: *mut lxw_worksheet,
first_col: lxw_col_t,
last_col: lxw_col_t,
width: f64,
format: *mut lxw_format,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_set_column_opt(
worksheet: *mut lxw_worksheet,
first_col: lxw_col_t,
last_col: lxw_col_t,
width: f64,
format: *mut lxw_format,
options: *mut lxw_row_col_options,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_set_column_pixels(
worksheet: *mut lxw_worksheet,
first_col: lxw_col_t,
last_col: lxw_col_t,
pixels: u32,
format: *mut lxw_format,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_set_column_pixels_opt(
worksheet: *mut lxw_worksheet,
first_col: lxw_col_t,
last_col: lxw_col_t,
pixels: u32,
format: *mut lxw_format,
options: *mut lxw_row_col_options,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_insert_image(
worksheet: *mut lxw_worksheet,
row: lxw_row_t,
col: lxw_col_t,
filename: *const ::std::os::raw::c_char,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_insert_image_opt(
worksheet: *mut lxw_worksheet,
row: lxw_row_t,
col: lxw_col_t,
filename: *const ::std::os::raw::c_char,
options: *mut lxw_image_options,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_insert_image_buffer(
worksheet: *mut lxw_worksheet,
row: lxw_row_t,
col: lxw_col_t,
image_buffer: *const ::std::os::raw::c_uchar,
image_size: usize,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_insert_image_buffer_opt(
worksheet: *mut lxw_worksheet,
row: lxw_row_t,
col: lxw_col_t,
image_buffer: *const ::std::os::raw::c_uchar,
image_size: usize,
options: *mut lxw_image_options,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_set_background(
worksheet: *mut lxw_worksheet,
filename: *const ::std::os::raw::c_char,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_set_background_buffer(
worksheet: *mut lxw_worksheet,
image_buffer: *const ::std::os::raw::c_uchar,
image_size: usize,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_insert_chart(
worksheet: *mut lxw_worksheet,
row: lxw_row_t,
col: lxw_col_t,
chart: *mut lxw_chart,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_insert_chart_opt(
worksheet: *mut lxw_worksheet,
row: lxw_row_t,
col: lxw_col_t,
chart: *mut lxw_chart,
user_options: *mut lxw_chart_options,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_merge_range(
worksheet: *mut lxw_worksheet,
first_row: lxw_row_t,
first_col: lxw_col_t,
last_row: lxw_row_t,
last_col: lxw_col_t,
string: *const ::std::os::raw::c_char,
format: *mut lxw_format,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_autofilter(
worksheet: *mut lxw_worksheet,
first_row: lxw_row_t,
first_col: lxw_col_t,
last_row: lxw_row_t,
last_col: lxw_col_t,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_filter_column(
worksheet: *mut lxw_worksheet,
col: lxw_col_t,
rule: *mut lxw_filter_rule,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_filter_column2(
worksheet: *mut lxw_worksheet,
col: lxw_col_t,
rule1: *mut lxw_filter_rule,
rule2: *mut lxw_filter_rule,
and_or: u8,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_filter_list(
worksheet: *mut lxw_worksheet,
col: lxw_col_t,
list: *mut *mut ::std::os::raw::c_char,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_data_validation_cell(
worksheet: *mut lxw_worksheet,
row: lxw_row_t,
col: lxw_col_t,
validation: *mut lxw_data_validation,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_data_validation_range(
worksheet: *mut lxw_worksheet,
first_row: lxw_row_t,
first_col: lxw_col_t,
last_row: lxw_row_t,
last_col: lxw_col_t,
validation: *mut lxw_data_validation,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_conditional_format_cell(
worksheet: *mut lxw_worksheet,
row: lxw_row_t,
col: lxw_col_t,
conditional_format: *mut lxw_conditional_format,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_conditional_format_range(
worksheet: *mut lxw_worksheet,
first_row: lxw_row_t,
first_col: lxw_col_t,
last_row: lxw_row_t,
last_col: lxw_col_t,
conditional_format: *mut lxw_conditional_format,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_insert_button(
worksheet: *mut lxw_worksheet,
row: lxw_row_t,
col: lxw_col_t,
options: *mut lxw_button_options,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_add_table(
worksheet: *mut lxw_worksheet,
first_row: lxw_row_t,
first_col: lxw_col_t,
last_row: lxw_row_t,
last_col: lxw_col_t,
options: *mut lxw_table_options,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_activate(worksheet: *mut lxw_worksheet);
}
extern "C" {
pub fn worksheet_select(worksheet: *mut lxw_worksheet);
}
extern "C" {
pub fn worksheet_hide(worksheet: *mut lxw_worksheet);
}
extern "C" {
pub fn worksheet_set_first_sheet(worksheet: *mut lxw_worksheet);
}
extern "C" {
pub fn worksheet_freeze_panes(worksheet: *mut lxw_worksheet, row: lxw_row_t, col: lxw_col_t);
}
extern "C" {
pub fn worksheet_split_panes(worksheet: *mut lxw_worksheet, vertical: f64, horizontal: f64);
}
extern "C" {
pub fn worksheet_freeze_panes_opt(
worksheet: *mut lxw_worksheet,
first_row: lxw_row_t,
first_col: lxw_col_t,
top_row: lxw_row_t,
left_col: lxw_col_t,
type_: u8,
);
}
extern "C" {
pub fn worksheet_split_panes_opt(
worksheet: *mut lxw_worksheet,
vertical: f64,
horizontal: f64,
top_row: lxw_row_t,
left_col: lxw_col_t,
);
}
extern "C" {
pub fn worksheet_set_selection(
worksheet: *mut lxw_worksheet,
first_row: lxw_row_t,
first_col: lxw_col_t,
last_row: lxw_row_t,
last_col: lxw_col_t,
);
}
extern "C" {
pub fn worksheet_set_top_left_cell(
worksheet: *mut lxw_worksheet,
row: lxw_row_t,
col: lxw_col_t,
);
}
extern "C" {
pub fn worksheet_set_landscape(worksheet: *mut lxw_worksheet);
}
extern "C" {
pub fn worksheet_set_portrait(worksheet: *mut lxw_worksheet);
}
extern "C" {
pub fn worksheet_set_page_view(worksheet: *mut lxw_worksheet);
}
extern "C" {
pub fn worksheet_set_paper(worksheet: *mut lxw_worksheet, paper_type: u8);
}
extern "C" {
pub fn worksheet_set_margins(
worksheet: *mut lxw_worksheet,
left: f64,
right: f64,
top: f64,
bottom: f64,
);
}
extern "C" {
pub fn worksheet_set_header(
worksheet: *mut lxw_worksheet,
string: *const ::std::os::raw::c_char,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_set_footer(
worksheet: *mut lxw_worksheet,
string: *const ::std::os::raw::c_char,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_set_header_opt(
worksheet: *mut lxw_worksheet,
string: *const ::std::os::raw::c_char,
options: *mut lxw_header_footer_options,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_set_footer_opt(
worksheet: *mut lxw_worksheet,
string: *const ::std::os::raw::c_char,
options: *mut lxw_header_footer_options,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_set_h_pagebreaks(
worksheet: *mut lxw_worksheet,
breaks: *mut lxw_row_t,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_set_v_pagebreaks(
worksheet: *mut lxw_worksheet,
breaks: *mut lxw_col_t,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_print_across(worksheet: *mut lxw_worksheet);
}
extern "C" {
pub fn worksheet_set_zoom(worksheet: *mut lxw_worksheet, scale: u16);
}
extern "C" {
pub fn worksheet_gridlines(worksheet: *mut lxw_worksheet, option: u8);
}
extern "C" {
pub fn worksheet_center_horizontally(worksheet: *mut lxw_worksheet);
}
extern "C" {
pub fn worksheet_center_vertically(worksheet: *mut lxw_worksheet);
}
extern "C" {
pub fn worksheet_print_row_col_headers(worksheet: *mut lxw_worksheet);
}
extern "C" {
pub fn worksheet_repeat_rows(
worksheet: *mut lxw_worksheet,
first_row: lxw_row_t,
last_row: lxw_row_t,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_repeat_columns(
worksheet: *mut lxw_worksheet,
first_col: lxw_col_t,
last_col: lxw_col_t,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_print_area(
worksheet: *mut lxw_worksheet,
first_row: lxw_row_t,
first_col: lxw_col_t,
last_row: lxw_row_t,
last_col: lxw_col_t,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_fit_to_pages(worksheet: *mut lxw_worksheet, width: u16, height: u16);
}
extern "C" {
pub fn worksheet_set_start_page(worksheet: *mut lxw_worksheet, start_page: u16);
}
extern "C" {
pub fn worksheet_set_print_scale(worksheet: *mut lxw_worksheet, scale: u16);
}
extern "C" {
pub fn worksheet_print_black_and_white(worksheet: *mut lxw_worksheet);
}
extern "C" {
pub fn worksheet_right_to_left(worksheet: *mut lxw_worksheet);
}
extern "C" {
pub fn worksheet_hide_zero(worksheet: *mut lxw_worksheet);
}
extern "C" {
pub fn worksheet_set_tab_color(worksheet: *mut lxw_worksheet, color: lxw_color_t);
}
extern "C" {
pub fn worksheet_protect(
worksheet: *mut lxw_worksheet,
password: *const ::std::os::raw::c_char,
options: *mut lxw_protection,
);
}
extern "C" {
pub fn worksheet_outline_settings(
worksheet: *mut lxw_worksheet,
visible: u8,
symbols_below: u8,
symbols_right: u8,
auto_style: u8,
);
}
extern "C" {
pub fn worksheet_set_default_row(
worksheet: *mut lxw_worksheet,
height: f64,
hide_unused_rows: u8,
);
}
extern "C" {
pub fn worksheet_set_vba_name(
worksheet: *mut lxw_worksheet,
name: *const ::std::os::raw::c_char,
) -> lxw_error;
}
extern "C" {
pub fn worksheet_show_comments(worksheet: *mut lxw_worksheet);
}
extern "C" {
pub fn worksheet_set_comments_author(
worksheet: *mut lxw_worksheet,
author: *const ::std::os::raw::c_char,
);
}
extern "C" {
pub fn worksheet_ignore_errors(
worksheet: *mut lxw_worksheet,
type_: u8,
range: *const ::std::os::raw::c_char,
) -> lxw_error;
}
extern "C" {
pub fn lxw_worksheet_new(init_data: *mut lxw_worksheet_init_data) -> *mut lxw_worksheet;
}
extern "C" {
pub fn lxw_worksheet_free(worksheet: *mut lxw_worksheet);
}
extern "C" {
pub fn lxw_worksheet_assemble_xml_file(worksheet: *mut lxw_worksheet);
}
extern "C" {
pub fn lxw_worksheet_write_single_row(worksheet: *mut lxw_worksheet);
}
extern "C" {
pub fn lxw_worksheet_prepare_image(
worksheet: *mut lxw_worksheet,
image_ref_id: u32,
drawing_id: u32,
object_props: *mut lxw_object_properties,
);
}
extern "C" {
pub fn lxw_worksheet_prepare_header_image(
worksheet: *mut lxw_worksheet,
image_ref_id: u32,
object_props: *mut lxw_object_properties,
);
}
extern "C" {
pub fn lxw_worksheet_prepare_background(
worksheet: *mut lxw_worksheet,
image_ref_id: u32,
object_props: *mut lxw_object_properties,
);
}
extern "C" {
pub fn lxw_worksheet_prepare_chart(
worksheet: *mut lxw_worksheet,
chart_ref_id: u32,
drawing_id: u32,
object_props: *mut lxw_object_properties,
is_chartsheet: u8,
);
}
extern "C" {
pub fn lxw_worksheet_prepare_vml_objects(
worksheet: *mut lxw_worksheet,
vml_data_id: u32,
vml_shape_id: u32,
vml_drawing_id: u32,
comment_id: u32,
) -> u32;
}
extern "C" {
pub fn lxw_worksheet_prepare_header_vml_objects(
worksheet: *mut lxw_worksheet,
vml_header_id: u32,
vml_drawing_id: u32,
);
}
extern "C" {
pub fn lxw_worksheet_prepare_tables(worksheet: *mut lxw_worksheet, table_id: u32);
}
extern "C" {
pub fn lxw_worksheet_find_row(
worksheet: *mut lxw_worksheet,
row_num: lxw_row_t,
) -> *mut lxw_row;
}
extern "C" {
pub fn lxw_worksheet_find_cell_in_row(row: *mut lxw_row, col_num: lxw_col_t) -> *mut lxw_cell;
}
extern "C" {
pub fn lxw_worksheet_write_sheet_views(worksheet: *mut lxw_worksheet);
}
extern "C" {
pub fn lxw_worksheet_write_page_margins(worksheet: *mut lxw_worksheet);
}
extern "C" {
pub fn lxw_worksheet_write_drawings(worksheet: *mut lxw_worksheet);
}
extern "C" {
pub fn lxw_worksheet_write_sheet_protection(
worksheet: *mut lxw_worksheet,
protect: *mut lxw_protection_obj,
);
}
extern "C" {
pub fn lxw_worksheet_write_sheet_pr(worksheet: *mut lxw_worksheet);
}
extern "C" {
pub fn lxw_worksheet_write_page_setup(worksheet: *mut lxw_worksheet);
}
extern "C" {
pub fn lxw_worksheet_write_header_footer(worksheet: *mut lxw_worksheet);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_chartsheet {
pub file: *mut FILE,
pub worksheet: *mut lxw_worksheet,
pub chart: *mut lxw_chart,
pub protection: lxw_protection_obj,
pub is_protected: u8,
pub name: *mut ::std::os::raw::c_char,
pub quoted_name: *mut ::std::os::raw::c_char,
pub tmpdir: *mut ::std::os::raw::c_char,
pub index: u16,
pub active: u8,
pub selected: u8,
pub hidden: u8,
pub active_sheet: *mut u16,
pub first_sheet: *mut u16,
pub rel_count: u16,
pub list_pointers: lxw_chartsheet__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_chartsheet__bindgen_ty_1 {
pub stqe_next: *mut lxw_chartsheet,
}
#[test]
fn bindgen_test_layout_lxw_chartsheet__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<lxw_chartsheet__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_chartsheet__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(lxw_chartsheet__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<lxw_chartsheet__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(lxw_chartsheet__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqe_next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet__bindgen_ty_1),
"::",
stringify!(stqe_next)
)
);
}
#[test]
fn bindgen_test_layout_lxw_chartsheet() {
const UNINIT: ::std::mem::MaybeUninit<lxw_chartsheet> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_chartsheet>(),
120usize,
concat!("Size of: ", stringify!(lxw_chartsheet))
);
assert_eq!(
::std::mem::align_of::<lxw_chartsheet>(),
8usize,
concat!("Alignment of ", stringify!(lxw_chartsheet))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).file) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet),
"::",
stringify!(file)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).worksheet) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet),
"::",
stringify!(worksheet)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).chart) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet),
"::",
stringify!(chart)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).protection) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet),
"::",
stringify!(protection)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).is_protected) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet),
"::",
stringify!(is_protected)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).quoted_name) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet),
"::",
stringify!(quoted_name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tmpdir) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet),
"::",
stringify!(tmpdir)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).index) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet),
"::",
stringify!(index)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).active) as usize - ptr as usize },
82usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet),
"::",
stringify!(active)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).selected) as usize - ptr as usize },
83usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet),
"::",
stringify!(selected)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hidden) as usize - ptr as usize },
84usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet),
"::",
stringify!(hidden)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).active_sheet) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet),
"::",
stringify!(active_sheet)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).first_sheet) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet),
"::",
stringify!(first_sheet)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rel_count) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet),
"::",
stringify!(rel_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).list_pointers) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet),
"::",
stringify!(list_pointers)
)
);
}
extern "C" {
pub fn chartsheet_set_chart(
chartsheet: *mut lxw_chartsheet,
chart: *mut lxw_chart,
) -> lxw_error;
}
extern "C" {
pub fn chartsheet_set_chart_opt(
chartsheet: *mut lxw_chartsheet,
chart: *mut lxw_chart,
user_options: *mut lxw_chart_options,
) -> lxw_error;
}
extern "C" {
pub fn chartsheet_activate(chartsheet: *mut lxw_chartsheet);
}
extern "C" {
pub fn chartsheet_select(chartsheet: *mut lxw_chartsheet);
}
extern "C" {
pub fn chartsheet_hide(chartsheet: *mut lxw_chartsheet);
}
extern "C" {
pub fn chartsheet_set_first_sheet(chartsheet: *mut lxw_chartsheet);
}
extern "C" {
pub fn chartsheet_set_tab_color(chartsheet: *mut lxw_chartsheet, color: lxw_color_t);
}
extern "C" {
pub fn chartsheet_protect(
chartsheet: *mut lxw_chartsheet,
password: *const ::std::os::raw::c_char,
options: *mut lxw_protection,
);
}
extern "C" {
pub fn chartsheet_set_zoom(chartsheet: *mut lxw_chartsheet, scale: u16);
}
extern "C" {
pub fn chartsheet_set_landscape(chartsheet: *mut lxw_chartsheet);
}
extern "C" {
pub fn chartsheet_set_portrait(chartsheet: *mut lxw_chartsheet);
}
extern "C" {
pub fn chartsheet_set_paper(chartsheet: *mut lxw_chartsheet, paper_type: u8);
}
extern "C" {
pub fn chartsheet_set_margins(
chartsheet: *mut lxw_chartsheet,
left: f64,
right: f64,
top: f64,
bottom: f64,
);
}
extern "C" {
pub fn chartsheet_set_header(
chartsheet: *mut lxw_chartsheet,
string: *const ::std::os::raw::c_char,
) -> lxw_error;
}
extern "C" {
pub fn chartsheet_set_footer(
chartsheet: *mut lxw_chartsheet,
string: *const ::std::os::raw::c_char,
) -> lxw_error;
}
extern "C" {
pub fn chartsheet_set_header_opt(
chartsheet: *mut lxw_chartsheet,
string: *const ::std::os::raw::c_char,
options: *mut lxw_header_footer_options,
) -> lxw_error;
}
extern "C" {
pub fn chartsheet_set_footer_opt(
chartsheet: *mut lxw_chartsheet,
string: *const ::std::os::raw::c_char,
options: *mut lxw_header_footer_options,
) -> lxw_error;
}
extern "C" {
pub fn lxw_chartsheet_new(init_data: *mut lxw_worksheet_init_data) -> *mut lxw_chartsheet;
}
extern "C" {
pub fn lxw_chartsheet_free(chartsheet: *mut lxw_chartsheet);
}
extern "C" {
pub fn lxw_chartsheet_assemble_xml_file(chartsheet: *mut lxw_chartsheet);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_worksheet_names {
pub rbh_root: *mut lxw_worksheet_name,
}
#[test]
fn bindgen_test_layout_lxw_worksheet_names() {
const UNINIT: ::std::mem::MaybeUninit<lxw_worksheet_names> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_worksheet_names>(),
8usize,
concat!("Size of: ", stringify!(lxw_worksheet_names))
);
assert_eq!(
::std::mem::align_of::<lxw_worksheet_names>(),
8usize,
concat!("Alignment of ", stringify!(lxw_worksheet_names))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbh_root) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet_names),
"::",
stringify!(rbh_root)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_chartsheet_names {
pub rbh_root: *mut lxw_chartsheet_name,
}
#[test]
fn bindgen_test_layout_lxw_chartsheet_names() {
const UNINIT: ::std::mem::MaybeUninit<lxw_chartsheet_names> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_chartsheet_names>(),
8usize,
concat!("Size of: ", stringify!(lxw_chartsheet_names))
);
assert_eq!(
::std::mem::align_of::<lxw_chartsheet_names>(),
8usize,
concat!("Alignment of ", stringify!(lxw_chartsheet_names))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbh_root) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet_names),
"::",
stringify!(rbh_root)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_image_md5s {
pub rbh_root: *mut lxw_image_md5,
}
#[test]
fn bindgen_test_layout_lxw_image_md5s() {
const UNINIT: ::std::mem::MaybeUninit<lxw_image_md5s> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_image_md5s>(),
8usize,
concat!("Size of: ", stringify!(lxw_image_md5s))
);
assert_eq!(
::std::mem::align_of::<lxw_image_md5s>(),
8usize,
concat!("Alignment of ", stringify!(lxw_image_md5s))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbh_root) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_image_md5s),
"::",
stringify!(rbh_root)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_sheets {
pub stqh_first: *mut lxw_sheet,
pub stqh_last: *mut *mut lxw_sheet,
}
#[test]
fn bindgen_test_layout_lxw_sheets() {
const UNINIT: ::std::mem::MaybeUninit<lxw_sheets> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_sheets>(),
16usize,
concat!("Size of: ", stringify!(lxw_sheets))
);
assert_eq!(
::std::mem::align_of::<lxw_sheets>(),
8usize,
concat!("Alignment of ", stringify!(lxw_sheets))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_first) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_sheets),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_last) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_sheets),
"::",
stringify!(stqh_last)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_worksheets {
pub stqh_first: *mut lxw_worksheet,
pub stqh_last: *mut *mut lxw_worksheet,
}
#[test]
fn bindgen_test_layout_lxw_worksheets() {
const UNINIT: ::std::mem::MaybeUninit<lxw_worksheets> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_worksheets>(),
16usize,
concat!("Size of: ", stringify!(lxw_worksheets))
);
assert_eq!(
::std::mem::align_of::<lxw_worksheets>(),
8usize,
concat!("Alignment of ", stringify!(lxw_worksheets))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_first) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheets),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_last) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheets),
"::",
stringify!(stqh_last)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_chartsheets {
pub stqh_first: *mut lxw_chartsheet,
pub stqh_last: *mut *mut lxw_chartsheet,
}
#[test]
fn bindgen_test_layout_lxw_chartsheets() {
const UNINIT: ::std::mem::MaybeUninit<lxw_chartsheets> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_chartsheets>(),
16usize,
concat!("Size of: ", stringify!(lxw_chartsheets))
);
assert_eq!(
::std::mem::align_of::<lxw_chartsheets>(),
8usize,
concat!("Alignment of ", stringify!(lxw_chartsheets))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_first) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheets),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_last) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheets),
"::",
stringify!(stqh_last)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_charts {
pub stqh_first: *mut lxw_chart,
pub stqh_last: *mut *mut lxw_chart,
}
#[test]
fn bindgen_test_layout_lxw_charts() {
const UNINIT: ::std::mem::MaybeUninit<lxw_charts> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_charts>(),
16usize,
concat!("Size of: ", stringify!(lxw_charts))
);
assert_eq!(
::std::mem::align_of::<lxw_charts>(),
8usize,
concat!("Alignment of ", stringify!(lxw_charts))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_first) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_charts),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqh_last) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_charts),
"::",
stringify!(stqh_last)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_defined_names {
pub tqh_first: *mut lxw_defined_name,
pub tqh_last: *mut *mut lxw_defined_name,
}
#[test]
fn bindgen_test_layout_lxw_defined_names() {
const UNINIT: ::std::mem::MaybeUninit<lxw_defined_names> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_defined_names>(),
16usize,
concat!("Size of: ", stringify!(lxw_defined_names))
);
assert_eq!(
::std::mem::align_of::<lxw_defined_names>(),
8usize,
concat!("Alignment of ", stringify!(lxw_defined_names))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tqh_first) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_defined_names),
"::",
stringify!(tqh_first)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tqh_last) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_defined_names),
"::",
stringify!(tqh_last)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct lxw_sheet {
pub is_chartsheet: u8,
pub u: lxw_sheet__bindgen_ty_1,
pub list_pointers: lxw_sheet__bindgen_ty_2,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union lxw_sheet__bindgen_ty_1 {
pub worksheet: *mut lxw_worksheet,
pub chartsheet: *mut lxw_chartsheet,
}
#[test]
fn bindgen_test_layout_lxw_sheet__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<lxw_sheet__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_sheet__bindgen_ty_1>(),
8usize,
concat!("Size of: ", stringify!(lxw_sheet__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<lxw_sheet__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(lxw_sheet__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).worksheet) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_sheet__bindgen_ty_1),
"::",
stringify!(worksheet)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).chartsheet) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_sheet__bindgen_ty_1),
"::",
stringify!(chartsheet)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_sheet__bindgen_ty_2 {
pub stqe_next: *mut lxw_sheet,
}
#[test]
fn bindgen_test_layout_lxw_sheet__bindgen_ty_2() {
const UNINIT: ::std::mem::MaybeUninit<lxw_sheet__bindgen_ty_2> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_sheet__bindgen_ty_2>(),
8usize,
concat!("Size of: ", stringify!(lxw_sheet__bindgen_ty_2))
);
assert_eq!(
::std::mem::align_of::<lxw_sheet__bindgen_ty_2>(),
8usize,
concat!("Alignment of ", stringify!(lxw_sheet__bindgen_ty_2))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).stqe_next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_sheet__bindgen_ty_2),
"::",
stringify!(stqe_next)
)
);
}
#[test]
fn bindgen_test_layout_lxw_sheet() {
const UNINIT: ::std::mem::MaybeUninit<lxw_sheet> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_sheet>(),
24usize,
concat!("Size of: ", stringify!(lxw_sheet))
);
assert_eq!(
::std::mem::align_of::<lxw_sheet>(),
8usize,
concat!("Alignment of ", stringify!(lxw_sheet))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).is_chartsheet) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_sheet),
"::",
stringify!(is_chartsheet)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).u) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_sheet),
"::",
stringify!(u)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).list_pointers) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_sheet),
"::",
stringify!(list_pointers)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_worksheet_name {
pub name: *const ::std::os::raw::c_char,
pub worksheet: *mut lxw_worksheet,
pub tree_pointers: lxw_worksheet_name__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_worksheet_name__bindgen_ty_1 {
pub rbe_left: *mut lxw_worksheet_name,
pub rbe_right: *mut lxw_worksheet_name,
pub rbe_parent: *mut lxw_worksheet_name,
pub rbe_color: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_lxw_worksheet_name__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<lxw_worksheet_name__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_worksheet_name__bindgen_ty_1>(),
32usize,
concat!("Size of: ", stringify!(lxw_worksheet_name__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<lxw_worksheet_name__bindgen_ty_1>(),
8usize,
concat!(
"Alignment of ",
stringify!(lxw_worksheet_name__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbe_left) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet_name__bindgen_ty_1),
"::",
stringify!(rbe_left)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbe_right) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet_name__bindgen_ty_1),
"::",
stringify!(rbe_right)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbe_parent) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet_name__bindgen_ty_1),
"::",
stringify!(rbe_parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbe_color) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet_name__bindgen_ty_1),
"::",
stringify!(rbe_color)
)
);
}
#[test]
fn bindgen_test_layout_lxw_worksheet_name() {
const UNINIT: ::std::mem::MaybeUninit<lxw_worksheet_name> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_worksheet_name>(),
48usize,
concat!("Size of: ", stringify!(lxw_worksheet_name))
);
assert_eq!(
::std::mem::align_of::<lxw_worksheet_name>(),
8usize,
concat!("Alignment of ", stringify!(lxw_worksheet_name))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet_name),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).worksheet) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet_name),
"::",
stringify!(worksheet)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tree_pointers) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet_name),
"::",
stringify!(tree_pointers)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_chartsheet_name {
pub name: *const ::std::os::raw::c_char,
pub chartsheet: *mut lxw_chartsheet,
pub tree_pointers: lxw_chartsheet_name__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_chartsheet_name__bindgen_ty_1 {
pub rbe_left: *mut lxw_chartsheet_name,
pub rbe_right: *mut lxw_chartsheet_name,
pub rbe_parent: *mut lxw_chartsheet_name,
pub rbe_color: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_lxw_chartsheet_name__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<lxw_chartsheet_name__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_chartsheet_name__bindgen_ty_1>(),
32usize,
concat!("Size of: ", stringify!(lxw_chartsheet_name__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<lxw_chartsheet_name__bindgen_ty_1>(),
8usize,
concat!(
"Alignment of ",
stringify!(lxw_chartsheet_name__bindgen_ty_1)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbe_left) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet_name__bindgen_ty_1),
"::",
stringify!(rbe_left)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbe_right) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet_name__bindgen_ty_1),
"::",
stringify!(rbe_right)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbe_parent) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet_name__bindgen_ty_1),
"::",
stringify!(rbe_parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbe_color) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet_name__bindgen_ty_1),
"::",
stringify!(rbe_color)
)
);
}
#[test]
fn bindgen_test_layout_lxw_chartsheet_name() {
const UNINIT: ::std::mem::MaybeUninit<lxw_chartsheet_name> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_chartsheet_name>(),
48usize,
concat!("Size of: ", stringify!(lxw_chartsheet_name))
);
assert_eq!(
::std::mem::align_of::<lxw_chartsheet_name>(),
8usize,
concat!("Alignment of ", stringify!(lxw_chartsheet_name))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet_name),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).chartsheet) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet_name),
"::",
stringify!(chartsheet)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tree_pointers) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet_name),
"::",
stringify!(tree_pointers)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_image_md5 {
pub id: u32,
pub md5: *mut ::std::os::raw::c_char,
pub tree_pointers: lxw_image_md5__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_image_md5__bindgen_ty_1 {
pub rbe_left: *mut lxw_image_md5,
pub rbe_right: *mut lxw_image_md5,
pub rbe_parent: *mut lxw_image_md5,
pub rbe_color: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_lxw_image_md5__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<lxw_image_md5__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_image_md5__bindgen_ty_1>(),
32usize,
concat!("Size of: ", stringify!(lxw_image_md5__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<lxw_image_md5__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(lxw_image_md5__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbe_left) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_image_md5__bindgen_ty_1),
"::",
stringify!(rbe_left)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbe_right) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_image_md5__bindgen_ty_1),
"::",
stringify!(rbe_right)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbe_parent) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_image_md5__bindgen_ty_1),
"::",
stringify!(rbe_parent)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).rbe_color) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_image_md5__bindgen_ty_1),
"::",
stringify!(rbe_color)
)
);
}
#[test]
fn bindgen_test_layout_lxw_image_md5() {
const UNINIT: ::std::mem::MaybeUninit<lxw_image_md5> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_image_md5>(),
48usize,
concat!("Size of: ", stringify!(lxw_image_md5))
);
assert_eq!(
::std::mem::align_of::<lxw_image_md5>(),
8usize,
concat!("Alignment of ", stringify!(lxw_image_md5))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_image_md5),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).md5) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_image_md5),
"::",
stringify!(md5)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tree_pointers) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_image_md5),
"::",
stringify!(tree_pointers)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_defined_name {
pub index: i16,
pub hidden: u8,
pub name: [::std::os::raw::c_char; 128usize],
pub app_name: [::std::os::raw::c_char; 128usize],
pub formula: [::std::os::raw::c_char; 128usize],
pub normalised_name: [::std::os::raw::c_char; 128usize],
pub normalised_sheetname: [::std::os::raw::c_char; 128usize],
pub list_pointers: lxw_defined_name__bindgen_ty_1,
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_defined_name__bindgen_ty_1 {
pub tqe_next: *mut lxw_defined_name,
pub tqe_prev: *mut *mut lxw_defined_name,
}
#[test]
fn bindgen_test_layout_lxw_defined_name__bindgen_ty_1() {
const UNINIT: ::std::mem::MaybeUninit<lxw_defined_name__bindgen_ty_1> =
::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_defined_name__bindgen_ty_1>(),
16usize,
concat!("Size of: ", stringify!(lxw_defined_name__bindgen_ty_1))
);
assert_eq!(
::std::mem::align_of::<lxw_defined_name__bindgen_ty_1>(),
8usize,
concat!("Alignment of ", stringify!(lxw_defined_name__bindgen_ty_1))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tqe_next) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_defined_name__bindgen_ty_1),
"::",
stringify!(tqe_next)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tqe_prev) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_defined_name__bindgen_ty_1),
"::",
stringify!(tqe_prev)
)
);
}
#[test]
fn bindgen_test_layout_lxw_defined_name() {
const UNINIT: ::std::mem::MaybeUninit<lxw_defined_name> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_defined_name>(),
664usize,
concat!("Size of: ", stringify!(lxw_defined_name))
);
assert_eq!(
::std::mem::align_of::<lxw_defined_name>(),
8usize,
concat!("Alignment of ", stringify!(lxw_defined_name))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).index) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_defined_name),
"::",
stringify!(index)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hidden) as usize - ptr as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(lxw_defined_name),
"::",
stringify!(hidden)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).name) as usize - ptr as usize },
3usize,
concat!(
"Offset of field: ",
stringify!(lxw_defined_name),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).app_name) as usize - ptr as usize },
131usize,
concat!(
"Offset of field: ",
stringify!(lxw_defined_name),
"::",
stringify!(app_name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).formula) as usize - ptr as usize },
259usize,
concat!(
"Offset of field: ",
stringify!(lxw_defined_name),
"::",
stringify!(formula)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).normalised_name) as usize - ptr as usize },
387usize,
concat!(
"Offset of field: ",
stringify!(lxw_defined_name),
"::",
stringify!(normalised_name)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).normalised_sheetname) as usize - ptr as usize },
515usize,
concat!(
"Offset of field: ",
stringify!(lxw_defined_name),
"::",
stringify!(normalised_sheetname)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).list_pointers) as usize - ptr as usize },
648usize,
concat!(
"Offset of field: ",
stringify!(lxw_defined_name),
"::",
stringify!(list_pointers)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_doc_properties {
pub title: *mut ::std::os::raw::c_char,
pub subject: *mut ::std::os::raw::c_char,
pub author: *mut ::std::os::raw::c_char,
pub manager: *mut ::std::os::raw::c_char,
pub company: *mut ::std::os::raw::c_char,
pub category: *mut ::std::os::raw::c_char,
pub keywords: *mut ::std::os::raw::c_char,
pub comments: *mut ::std::os::raw::c_char,
pub status: *mut ::std::os::raw::c_char,
pub hyperlink_base: *mut ::std::os::raw::c_char,
pub created: time_t,
}
#[test]
fn bindgen_test_layout_lxw_doc_properties() {
const UNINIT: ::std::mem::MaybeUninit<lxw_doc_properties> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_doc_properties>(),
88usize,
concat!("Size of: ", stringify!(lxw_doc_properties))
);
assert_eq!(
::std::mem::align_of::<lxw_doc_properties>(),
8usize,
concat!("Alignment of ", stringify!(lxw_doc_properties))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).title) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_doc_properties),
"::",
stringify!(title)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).subject) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_doc_properties),
"::",
stringify!(subject)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).author) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_doc_properties),
"::",
stringify!(author)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).manager) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_doc_properties),
"::",
stringify!(manager)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).company) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_doc_properties),
"::",
stringify!(company)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).category) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_doc_properties),
"::",
stringify!(category)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).keywords) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_doc_properties),
"::",
stringify!(keywords)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comments) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(lxw_doc_properties),
"::",
stringify!(comments)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).status) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(lxw_doc_properties),
"::",
stringify!(status)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).hyperlink_base) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(lxw_doc_properties),
"::",
stringify!(hyperlink_base)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).created) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(lxw_doc_properties),
"::",
stringify!(created)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_workbook_options {
pub constant_memory: u8,
pub tmpdir: *mut ::std::os::raw::c_char,
pub use_zip64: u8,
pub output_buffer: *mut *mut ::std::os::raw::c_char,
pub output_buffer_size: *mut usize,
}
#[test]
fn bindgen_test_layout_lxw_workbook_options() {
const UNINIT: ::std::mem::MaybeUninit<lxw_workbook_options> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_workbook_options>(),
40usize,
concat!("Size of: ", stringify!(lxw_workbook_options))
);
assert_eq!(
::std::mem::align_of::<lxw_workbook_options>(),
8usize,
concat!("Alignment of ", stringify!(lxw_workbook_options))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).constant_memory) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook_options),
"::",
stringify!(constant_memory)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).tmpdir) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook_options),
"::",
stringify!(tmpdir)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).use_zip64) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook_options),
"::",
stringify!(use_zip64)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).output_buffer) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook_options),
"::",
stringify!(output_buffer)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).output_buffer_size) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook_options),
"::",
stringify!(output_buffer_size)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_workbook {
pub file: *mut FILE,
pub sheets: *mut lxw_sheets,
pub worksheets: *mut lxw_worksheets,
pub chartsheets: *mut lxw_chartsheets,
pub worksheet_names: *mut lxw_worksheet_names,
pub chartsheet_names: *mut lxw_chartsheet_names,
pub image_md5s: *mut lxw_image_md5s,
pub header_image_md5s: *mut lxw_image_md5s,
pub background_md5s: *mut lxw_image_md5s,
pub charts: *mut lxw_charts,
pub ordered_charts: *mut lxw_charts,
pub formats: *mut lxw_formats,
pub defined_names: *mut lxw_defined_names,
pub sst: *mut lxw_sst,
pub properties: *mut lxw_doc_properties,
pub custom_properties: *mut lxw_custom_properties,
pub filename: *mut ::std::os::raw::c_char,
pub options: lxw_workbook_options,
pub num_sheets: u16,
pub num_worksheets: u16,
pub num_chartsheets: u16,
pub first_sheet: u16,
pub active_sheet: u16,
pub num_xf_formats: u16,
pub num_dxf_formats: u16,
pub num_format_count: u16,
pub drawing_count: u16,
pub comment_count: u16,
pub font_count: u16,
pub border_count: u16,
pub fill_count: u16,
pub optimize: u8,
pub max_url_length: u16,
pub read_only: u8,
pub has_png: u8,
pub has_jpeg: u8,
pub has_bmp: u8,
pub has_gif: u8,
pub has_vml: u8,
pub has_comments: u8,
pub has_metadata: u8,
pub used_xf_formats: *mut lxw_hash_table,
pub used_dxf_formats: *mut lxw_hash_table,
pub vba_project: *mut ::std::os::raw::c_char,
pub vba_codename: *mut ::std::os::raw::c_char,
pub default_url_format: *mut lxw_format,
}
#[test]
fn bindgen_test_layout_lxw_workbook() {
const UNINIT: ::std::mem::MaybeUninit<lxw_workbook> = ::std::mem::MaybeUninit::uninit();
let ptr = UNINIT.as_ptr();
assert_eq!(
::std::mem::size_of::<lxw_workbook>(),
256usize,
concat!("Size of: ", stringify!(lxw_workbook))
);
assert_eq!(
::std::mem::align_of::<lxw_workbook>(),
8usize,
concat!("Alignment of ", stringify!(lxw_workbook))
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).file) as usize - ptr as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(file)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sheets) as usize - ptr as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(sheets)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).worksheets) as usize - ptr as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(worksheets)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).chartsheets) as usize - ptr as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(chartsheets)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).worksheet_names) as usize - ptr as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(worksheet_names)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).chartsheet_names) as usize - ptr as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(chartsheet_names)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).image_md5s) as usize - ptr as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(image_md5s)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).header_image_md5s) as usize - ptr as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(header_image_md5s)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).background_md5s) as usize - ptr as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(background_md5s)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).charts) as usize - ptr as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(charts)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).ordered_charts) as usize - ptr as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(ordered_charts)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).formats) as usize - ptr as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(formats)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).defined_names) as usize - ptr as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(defined_names)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).sst) as usize - ptr as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(sst)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).properties) as usize - ptr as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(properties)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).custom_properties) as usize - ptr as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(custom_properties)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).filename) as usize - ptr as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(filename)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).options) as usize - ptr as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(options)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).num_sheets) as usize - ptr as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(num_sheets)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).num_worksheets) as usize - ptr as usize },
178usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(num_worksheets)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).num_chartsheets) as usize - ptr as usize },
180usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(num_chartsheets)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).first_sheet) as usize - ptr as usize },
182usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(first_sheet)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).active_sheet) as usize - ptr as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(active_sheet)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).num_xf_formats) as usize - ptr as usize },
186usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(num_xf_formats)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).num_dxf_formats) as usize - ptr as usize },
188usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(num_dxf_formats)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).num_format_count) as usize - ptr as usize },
190usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(num_format_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).drawing_count) as usize - ptr as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(drawing_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).comment_count) as usize - ptr as usize },
194usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(comment_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).font_count) as usize - ptr as usize },
196usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(font_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).border_count) as usize - ptr as usize },
198usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(border_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).fill_count) as usize - ptr as usize },
200usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(fill_count)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).optimize) as usize - ptr as usize },
202usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(optimize)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).max_url_length) as usize - ptr as usize },
204usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(max_url_length)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).read_only) as usize - ptr as usize },
206usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(read_only)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_png) as usize - ptr as usize },
207usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(has_png)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_jpeg) as usize - ptr as usize },
208usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(has_jpeg)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_bmp) as usize - ptr as usize },
209usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(has_bmp)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_gif) as usize - ptr as usize },
210usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(has_gif)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_vml) as usize - ptr as usize },
211usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(has_vml)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_comments) as usize - ptr as usize },
212usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(has_comments)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).has_metadata) as usize - ptr as usize },
213usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(has_metadata)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).used_xf_formats) as usize - ptr as usize },
216usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(used_xf_formats)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).used_dxf_formats) as usize - ptr as usize },
224usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(used_dxf_formats)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vba_project) as usize - ptr as usize },
232usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(vba_project)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).vba_codename) as usize - ptr as usize },
240usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(vba_codename)
)
);
assert_eq!(
unsafe { ::std::ptr::addr_of!((*ptr).default_url_format) as usize - ptr as usize },
248usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(default_url_format)
)
);
}
extern "C" {
pub fn workbook_new(filename: *const ::std::os::raw::c_char) -> *mut lxw_workbook;
}
extern "C" {
pub fn workbook_new_opt(
filename: *const ::std::os::raw::c_char,
options: *mut lxw_workbook_options,
) -> *mut lxw_workbook;
}
extern "C" {
pub fn workbook_add_worksheet(
workbook: *mut lxw_workbook,
sheetname: *const ::std::os::raw::c_char,
) -> *mut lxw_worksheet;
}
extern "C" {
pub fn workbook_add_chartsheet(
workbook: *mut lxw_workbook,
sheetname: *const ::std::os::raw::c_char,
) -> *mut lxw_chartsheet;
}
extern "C" {
pub fn workbook_add_format(workbook: *mut lxw_workbook) -> *mut lxw_format;
}
extern "C" {
pub fn workbook_add_chart(workbook: *mut lxw_workbook, chart_type: u8) -> *mut lxw_chart;
}
extern "C" {
pub fn workbook_close(workbook: *mut lxw_workbook) -> lxw_error;
}
extern "C" {
pub fn workbook_set_properties(
workbook: *mut lxw_workbook,
properties: *mut lxw_doc_properties,
) -> lxw_error;
}
extern "C" {
pub fn workbook_set_custom_property_string(
workbook: *mut lxw_workbook,
name: *const ::std::os::raw::c_char,
value: *const ::std::os::raw::c_char,
) -> lxw_error;
}
extern "C" {
pub fn workbook_set_custom_property_number(
workbook: *mut lxw_workbook,
name: *const ::std::os::raw::c_char,
value: f64,
) -> lxw_error;
}
extern "C" {
pub fn workbook_set_custom_property_integer(
workbook: *mut lxw_workbook,
name: *const ::std::os::raw::c_char,
value: i32,
) -> lxw_error;
}
extern "C" {
pub fn workbook_set_custom_property_boolean(
workbook: *mut lxw_workbook,
name: *const ::std::os::raw::c_char,
value: u8,
) -> lxw_error;
}
extern "C" {
pub fn workbook_set_custom_property_datetime(
workbook: *mut lxw_workbook,
name: *const ::std::os::raw::c_char,
datetime: *mut lxw_datetime,
) -> lxw_error;
}
extern "C" {
pub fn workbook_define_name(
workbook: *mut lxw_workbook,
name: *const ::std::os::raw::c_char,
formula: *const ::std::os::raw::c_char,
) -> lxw_error;
}
extern "C" {
pub fn workbook_get_default_url_format(workbook: *mut lxw_workbook) -> *mut lxw_format;
}
extern "C" {
pub fn workbook_get_worksheet_by_name(
workbook: *mut lxw_workbook,
name: *const ::std::os::raw::c_char,
) -> *mut lxw_worksheet;
}
extern "C" {
pub fn workbook_get_chartsheet_by_name(
workbook: *mut lxw_workbook,
name: *const ::std::os::raw::c_char,
) -> *mut lxw_chartsheet;
}
extern "C" {
pub fn workbook_validate_sheet_name(
workbook: *mut lxw_workbook,
sheetname: *const ::std::os::raw::c_char,
) -> lxw_error;
}
extern "C" {
pub fn workbook_add_vba_project(
workbook: *mut lxw_workbook,
filename: *const ::std::os::raw::c_char,
) -> lxw_error;
}
extern "C" {
pub fn workbook_set_vba_name(
workbook: *mut lxw_workbook,
name: *const ::std::os::raw::c_char,
) -> lxw_error;
}
extern "C" {
pub fn workbook_read_only_recommended(workbook: *mut lxw_workbook);
}
extern "C" {
pub fn lxw_workbook_free(workbook: *mut lxw_workbook);
}
extern "C" {
pub fn lxw_workbook_assemble_xml_file(workbook: *mut lxw_workbook);
}
extern "C" {
pub fn lxw_workbook_set_default_xf_indices(workbook: *mut lxw_workbook);
}
extern "C" {
pub fn workbook_unset_default_url_format(workbook: *mut lxw_workbook);
}