pub type __int8_t = ::std::os::raw::c_schar;
pub type __uint8_t = ::std::os::raw::c_uchar;
pub type __int16_t = ::std::os::raw::c_short;
pub type __uint16_t = ::std::os::raw::c_ushort;
pub type __int32_t = ::std::os::raw::c_int;
pub type __uint32_t = ::std::os::raw::c_uint;
pub type __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 size_t = ::std::os::raw::c_ulong;
pub type FILE = _IO_FILE;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_marker {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_codecvt {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_wide_data {
_unused: [u8; 0],
}
pub type _IO_lock_t = ::std::os::raw::c_void;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct _IO_FILE {
pub _flags: ::std::os::raw::c_int,
pub _IO_read_ptr: *mut ::std::os::raw::c_char,
pub _IO_read_end: *mut ::std::os::raw::c_char,
pub _IO_read_base: *mut ::std::os::raw::c_char,
pub _IO_write_base: *mut ::std::os::raw::c_char,
pub _IO_write_ptr: *mut ::std::os::raw::c_char,
pub _IO_write_end: *mut ::std::os::raw::c_char,
pub _IO_buf_base: *mut ::std::os::raw::c_char,
pub _IO_buf_end: *mut ::std::os::raw::c_char,
pub _IO_save_base: *mut ::std::os::raw::c_char,
pub _IO_backup_base: *mut ::std::os::raw::c_char,
pub _IO_save_end: *mut ::std::os::raw::c_char,
pub _markers: *mut _IO_marker,
pub _chain: *mut _IO_FILE,
pub _fileno: ::std::os::raw::c_int,
pub _flags2: ::std::os::raw::c_int,
pub _old_offset: __off_t,
pub _cur_column: ::std::os::raw::c_ushort,
pub _vtable_offset: ::std::os::raw::c_schar,
pub _shortbuf: [::std::os::raw::c_char; 1usize],
pub _lock: *mut _IO_lock_t,
pub _offset: __off64_t,
pub _codecvt: *mut _IO_codecvt,
pub _wide_data: *mut _IO_wide_data,
pub _freeres_list: *mut _IO_FILE,
pub _freeres_buf: *mut ::std::os::raw::c_void,
pub __pad5: size_t,
pub _mode: ::std::os::raw::c_int,
pub _unused2: [::std::os::raw::c_char; 20usize],
}
#[test]
fn bindgen_test_layout__IO_FILE() {
assert_eq!(
::std::mem::size_of::<_IO_FILE>(),
216usize,
concat!("Size of: ", stringify!(_IO_FILE))
);
assert_eq!(
::std::mem::align_of::<_IO_FILE>(),
8usize,
concat!("Alignment of ", stringify!(_IO_FILE))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._flags as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_read_ptr as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_read_ptr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_read_end as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_read_end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_read_base as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_read_base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_write_base as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_write_base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_write_ptr as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_write_ptr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_write_end as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_write_end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_buf_base as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_buf_base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_buf_end as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_buf_end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_save_base as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_save_base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_backup_base as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_backup_base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._IO_save_end as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_IO_save_end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._markers as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_markers)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._chain as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_chain)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._fileno as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_fileno)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._flags2 as *const _ as usize },
116usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_flags2)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._old_offset as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_old_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._cur_column as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_cur_column)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._vtable_offset as *const _ as usize },
130usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_vtable_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._shortbuf as *const _ as usize },
131usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_shortbuf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._lock as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_lock)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._offset as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._codecvt as *const _ as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_codecvt)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._wide_data as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_wide_data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._freeres_list as *const _ as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_freeres_list)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._freeres_buf as *const _ as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_freeres_buf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>())).__pad5 as *const _ as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(__pad5)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._mode as *const _ as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_mode)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<_IO_FILE>()))._unused2 as *const _ as usize },
196usize,
concat!(
"Offset of field: ",
stringify!(_IO_FILE),
"::",
stringify!(_unused2)
)
);
}
pub type 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 type lxw_boolean = u32;
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 = u32;
#[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() {
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::null::<lxw_datetime>())).year as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_datetime),
"::",
stringify!(year)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_datetime>())).month as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_datetime),
"::",
stringify!(month)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_datetime>())).day as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_datetime),
"::",
stringify!(day)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_datetime>())).hour as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(lxw_datetime),
"::",
stringify!(hour)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_datetime>())).min as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_datetime),
"::",
stringify!(min)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_datetime>())).sec as *const _ 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 = u32;
#[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() {
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::null::<lxw_formats>())).stqh_first as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_formats),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_formats>())).stqh_last as *const _ 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() {
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::null::<lxw_tuples>())).stqh_first as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_tuples),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_tuples>())).stqh_last as *const _ 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() {
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::null::<lxw_custom_properties>())).stqh_first as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_custom_properties),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_custom_properties>())).stqh_last as *const _ 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() {
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::null::<lxw_tuple__bindgen_ty_1>())).stqe_next as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_tuple__bindgen_ty_1),
"::",
stringify!(stqe_next)
)
);
}
#[test]
fn bindgen_test_layout_lxw_tuple() {
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::null::<lxw_tuple>())).key as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_tuple),
"::",
stringify!(key)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_tuple>())).value as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_tuple),
"::",
stringify!(value)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_tuple>())).list_pointers as *const _ 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,
_bindgen_union_align: [u64; 4usize],
}
#[test]
fn bindgen_test_layout_lxw_custom_property__bindgen_ty_1() {
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::null::<lxw_custom_property__bindgen_ty_1>())).string as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_custom_property__bindgen_ty_1),
"::",
stringify!(string)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_custom_property__bindgen_ty_1>())).number as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_custom_property__bindgen_ty_1),
"::",
stringify!(number)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_custom_property__bindgen_ty_1>())).integer as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_custom_property__bindgen_ty_1),
"::",
stringify!(integer)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_custom_property__bindgen_ty_1>())).boolean as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_custom_property__bindgen_ty_1),
"::",
stringify!(boolean)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_custom_property__bindgen_ty_1>())).datetime as *const _
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() {
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::null::<lxw_custom_property__bindgen_ty_2>())).stqe_next as *const _
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() {
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::null::<lxw_custom_property>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_custom_property),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_custom_property>())).name as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_custom_property),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_custom_property>())).u as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_custom_property),
"::",
stringify!(u)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_custom_property>())).list_pointers as *const _ 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() {
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::null::<sst_rb_tree>())).rbh_root as *const _ 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() {
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::null::<sst_order_list>())).stqh_first as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sst_order_list),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sst_order_list>())).stqh_last as *const _ 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() {
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::null::<sst_element__bindgen_ty_1>())).stqe_next as *const _ 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() {
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::null::<sst_element__bindgen_ty_2>())).rbe_left as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(sst_element__bindgen_ty_2),
"::",
stringify!(rbe_left)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sst_element__bindgen_ty_2>())).rbe_right as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(sst_element__bindgen_ty_2),
"::",
stringify!(rbe_right)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sst_element__bindgen_ty_2>())).rbe_parent as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(sst_element__bindgen_ty_2),
"::",
stringify!(rbe_parent)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<sst_element__bindgen_ty_2>())).rbe_color as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(sst_element__bindgen_ty_2),
"::",
stringify!(rbe_color)
)
);
}
#[test]
fn bindgen_test_layout_sst_element() {
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::null::<sst_element>())).index as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(sst_element),
"::",
stringify!(index)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sst_element>())).string as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(sst_element),
"::",
stringify!(string)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sst_element>())).is_rich_string as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(sst_element),
"::",
stringify!(is_rich_string)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sst_element>())).sst_order_pointers as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(sst_element),
"::",
stringify!(sst_order_pointers)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<sst_element>())).sst_tree_pointers as *const _ 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() {
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::null::<lxw_sst>())).file as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_sst),
"::",
stringify!(file)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_sst>())).string_count as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_sst),
"::",
stringify!(string_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_sst>())).unique_count as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(lxw_sst),
"::",
stringify!(unique_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_sst>())).order_list as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_sst),
"::",
stringify!(order_list)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_sst>())).rb_tree as *const _ 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() {
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::null::<lxw_hash_order_list>())).stqh_first as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_hash_order_list),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_hash_order_list>())).stqh_last as *const _ 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() {
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::null::<lxw_hash_bucket_list>())).slh_first as *const _ 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() {
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::null::<lxw_hash_table>())).num_buckets as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_hash_table),
"::",
stringify!(num_buckets)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_hash_table>())).used_buckets as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_hash_table),
"::",
stringify!(used_buckets)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_hash_table>())).unique_count as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_hash_table),
"::",
stringify!(unique_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_hash_table>())).free_key as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(lxw_hash_table),
"::",
stringify!(free_key)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_hash_table>())).free_value as *const _ as usize },
13usize,
concat!(
"Offset of field: ",
stringify!(lxw_hash_table),
"::",
stringify!(free_value)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_hash_table>())).order_list as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_hash_table),
"::",
stringify!(order_list)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_hash_table>())).buckets as *const _ 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() {
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::null::<lxw_hash_element__bindgen_ty_1>())).stqe_next as *const _
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() {
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::null::<lxw_hash_element__bindgen_ty_2>())).sle_next as *const _ 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() {
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::null::<lxw_hash_element>())).key as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_hash_element),
"::",
stringify!(key)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_hash_element>())).value as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_hash_element),
"::",
stringify!(value)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_hash_element>())).lxw_hash_order_pointers as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_hash_element),
"::",
stringify!(lxw_hash_order_pointers)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_hash_element>())).lxw_hash_list_pointers as *const _ 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: size_t,
) -> *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: size_t,
) -> *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 = u32;
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 = u32;
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 = u32;
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 = u32;
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 = u32;
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 = u32;
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 = u32;
#[repr(C)]
#[derive(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() {
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::null::<lxw_format__bindgen_ty_1>())).stqe_next as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_format__bindgen_ty_1),
"::",
stringify!(stqe_next)
)
);
}
#[test]
fn bindgen_test_layout_lxw_format() {
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::null::<lxw_format>())).file as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(file)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).xf_format_indices as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(xf_format_indices)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).dxf_format_indices as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(dxf_format_indices)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).num_xf_formats as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(num_xf_formats)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).num_dxf_formats as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(num_dxf_formats)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).xf_index as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(xf_index)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).dxf_index as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(dxf_index)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).xf_id as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(xf_id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).num_format as *const _ as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(num_format)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).font_name as *const _ as usize },
180usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(font_name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).font_scheme as *const _ as usize },
308usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(font_scheme)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).num_format_index as *const _ as usize },
436usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(num_format_index)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).font_index as *const _ as usize },
438usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(font_index)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).has_font as *const _ as usize },
440usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(has_font)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).has_dxf_font as *const _ as usize },
441usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(has_dxf_font)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).font_size as *const _ as usize },
448usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(font_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).bold as *const _ as usize },
456usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(bold)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).italic as *const _ as usize },
457usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(italic)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).font_color as *const _ as usize },
460usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(font_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).underline as *const _ as usize },
464usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(underline)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).font_strikeout as *const _ as usize },
465usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(font_strikeout)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).font_outline as *const _ as usize },
466usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(font_outline)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).font_shadow as *const _ as usize },
467usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(font_shadow)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).font_script as *const _ as usize },
468usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(font_script)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).font_family as *const _ as usize },
469usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(font_family)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).font_charset as *const _ as usize },
470usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(font_charset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).font_condense as *const _ as usize },
471usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(font_condense)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).font_extend as *const _ as usize },
472usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(font_extend)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).theme as *const _ as usize },
473usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(theme)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).hyperlink as *const _ as usize },
474usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(hyperlink)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).hidden as *const _ as usize },
475usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(hidden)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).locked as *const _ as usize },
476usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(locked)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).text_h_align as *const _ as usize },
477usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(text_h_align)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).text_wrap as *const _ as usize },
478usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(text_wrap)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).text_v_align as *const _ as usize },
479usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(text_v_align)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).text_justlast as *const _ as usize },
480usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(text_justlast)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).rotation as *const _ as usize },
482usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(rotation)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).fg_color as *const _ as usize },
484usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(fg_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).bg_color as *const _ as usize },
488usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(bg_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).dxf_fg_color as *const _ as usize },
492usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(dxf_fg_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).dxf_bg_color as *const _ as usize },
496usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(dxf_bg_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).pattern as *const _ as usize },
500usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(pattern)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).has_fill as *const _ as usize },
501usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(has_fill)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).has_dxf_fill as *const _ as usize },
502usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(has_dxf_fill)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).fill_index as *const _ as usize },
504usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(fill_index)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).fill_count as *const _ as usize },
508usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(fill_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).border_index as *const _ as usize },
512usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(border_index)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).has_border as *const _ as usize },
516usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(has_border)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).has_dxf_border as *const _ as usize },
517usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(has_dxf_border)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).border_count as *const _ as usize },
520usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(border_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).bottom as *const _ as usize },
524usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(bottom)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).diag_border as *const _ as usize },
525usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(diag_border)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).diag_type as *const _ as usize },
526usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(diag_type)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).left as *const _ as usize },
527usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(left)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).right as *const _ as usize },
528usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(right)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).top as *const _ as usize },
529usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(top)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).bottom_color as *const _ as usize },
532usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(bottom_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).diag_color as *const _ as usize },
536usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(diag_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).left_color as *const _ as usize },
540usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(left_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).right_color as *const _ as usize },
544usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(right_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).top_color as *const _ as usize },
548usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(top_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).indent as *const _ as usize },
552usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(indent)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).shrink as *const _ as usize },
553usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(shrink)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).merge_range as *const _ as usize },
554usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(merge_range)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).reading_order as *const _ as usize },
555usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(reading_order)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).just_distrib as *const _ as usize },
556usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(just_distrib)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).color_indexed as *const _ as usize },
557usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(color_indexed)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).font_only as *const _ as usize },
558usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(font_only)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_format>())).list_pointers as *const _ as usize },
560usize,
concat!(
"Offset of field: ",
stringify!(lxw_format),
"::",
stringify!(list_pointers)
)
);
}
#[repr(C)]
#[derive(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() {
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::null::<lxw_font>())).font_name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_font),
"::",
stringify!(font_name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_font>())).font_size as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(lxw_font),
"::",
stringify!(font_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_font>())).bold as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(lxw_font),
"::",
stringify!(bold)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_font>())).italic as *const _ as usize },
137usize,
concat!(
"Offset of field: ",
stringify!(lxw_font),
"::",
stringify!(italic)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_font>())).underline as *const _ as usize },
138usize,
concat!(
"Offset of field: ",
stringify!(lxw_font),
"::",
stringify!(underline)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_font>())).theme as *const _ as usize },
139usize,
concat!(
"Offset of field: ",
stringify!(lxw_font),
"::",
stringify!(theme)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_font>())).font_strikeout as *const _ as usize },
140usize,
concat!(
"Offset of field: ",
stringify!(lxw_font),
"::",
stringify!(font_strikeout)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_font>())).font_outline as *const _ as usize },
141usize,
concat!(
"Offset of field: ",
stringify!(lxw_font),
"::",
stringify!(font_outline)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_font>())).font_shadow as *const _ as usize },
142usize,
concat!(
"Offset of field: ",
stringify!(lxw_font),
"::",
stringify!(font_shadow)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_font>())).font_script as *const _ as usize },
143usize,
concat!(
"Offset of field: ",
stringify!(lxw_font),
"::",
stringify!(font_script)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_font>())).font_family as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(lxw_font),
"::",
stringify!(font_family)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_font>())).font_charset as *const _ as usize },
145usize,
concat!(
"Offset of field: ",
stringify!(lxw_font),
"::",
stringify!(font_charset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_font>())).font_condense as *const _ as usize },
146usize,
concat!(
"Offset of field: ",
stringify!(lxw_font),
"::",
stringify!(font_condense)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_font>())).font_extend as *const _ as usize },
147usize,
concat!(
"Offset of field: ",
stringify!(lxw_font),
"::",
stringify!(font_extend)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_font>())).font_color as *const _ 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() {
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::null::<lxw_border>())).bottom as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_border),
"::",
stringify!(bottom)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_border>())).diag_border as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(lxw_border),
"::",
stringify!(diag_border)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_border>())).diag_type as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(lxw_border),
"::",
stringify!(diag_type)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_border>())).left as *const _ as usize },
3usize,
concat!(
"Offset of field: ",
stringify!(lxw_border),
"::",
stringify!(left)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_border>())).right as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_border),
"::",
stringify!(right)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_border>())).top as *const _ as usize },
5usize,
concat!(
"Offset of field: ",
stringify!(lxw_border),
"::",
stringify!(top)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_border>())).bottom_color as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_border),
"::",
stringify!(bottom_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_border>())).diag_color as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(lxw_border),
"::",
stringify!(diag_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_border>())).left_color as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_border),
"::",
stringify!(left_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_border>())).right_color as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(lxw_border),
"::",
stringify!(right_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_border>())).top_color as *const _ 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() {
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::null::<lxw_fill>())).fg_color as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_fill),
"::",
stringify!(fg_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_fill>())).bg_color as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_fill),
"::",
stringify!(bg_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_fill>())).pattern as *const _ 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, value: u8);
}
extern "C" {
pub fn format_set_diag_color(format: *mut lxw_format, color: lxw_color_t);
}
extern "C" {
pub fn format_set_diag_border(format: *mut lxw_format, value: u8);
}
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() {
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::null::<lxw_chart_series_list>())).stqh_first as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series_list),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_series_list>())).stqh_last as *const _ 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() {
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::null::<lxw_series_data_points>())).stqh_first as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_data_points),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_series_data_points>())).stqh_last as *const _ 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 = u32;
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 = u32;
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 = u32;
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 = u32;
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 = u32;
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 = u32;
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 = u32;
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 = u32;
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 = u32;
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 = u32;
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 = u32;
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 = u32;
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 = u32;
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 = u32;
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 = u32;
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() {
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::null::<lxw_series_range>())).formula as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_range),
"::",
stringify!(formula)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_series_range>())).sheetname as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_range),
"::",
stringify!(sheetname)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_series_range>())).first_row as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_range),
"::",
stringify!(first_row)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_series_range>())).last_row as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_range),
"::",
stringify!(last_row)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_series_range>())).first_col as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_range),
"::",
stringify!(first_col)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_series_range>())).last_col as *const _ as usize },
26usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_range),
"::",
stringify!(last_col)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_series_range>())).ignore_cache as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_range),
"::",
stringify!(ignore_cache)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_series_range>())).has_string_cache as *const _ as usize
},
29usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_range),
"::",
stringify!(has_string_cache)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_series_range>())).num_data_points as *const _ as usize
},
30usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_range),
"::",
stringify!(num_data_points)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_series_range>())).data_cache as *const _ 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() {
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::null::<lxw_series_data_point__bindgen_ty_1>())).stqe_next as *const _
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() {
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::null::<lxw_series_data_point>())).is_string as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_data_point),
"::",
stringify!(is_string)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_series_data_point>())).number as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_data_point),
"::",
stringify!(number)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_series_data_point>())).string as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_data_point),
"::",
stringify!(string)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_series_data_point>())).no_data as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_data_point),
"::",
stringify!(no_data)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_series_data_point>())).list_pointers as *const _ 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() {
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::null::<lxw_chart_line>())).color as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_line),
"::",
stringify!(color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_line>())).none as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_line),
"::",
stringify!(none)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_line>())).width as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_line),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_line>())).dash_type as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_line),
"::",
stringify!(dash_type)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_line>())).transparency as *const _ 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() {
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::null::<lxw_chart_fill>())).color as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_fill),
"::",
stringify!(color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_fill>())).none as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_fill),
"::",
stringify!(none)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_fill>())).transparency as *const _ 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() {
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::null::<lxw_chart_pattern>())).fg_color as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_pattern),
"::",
stringify!(fg_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_pattern>())).bg_color as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_pattern),
"::",
stringify!(bg_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_pattern>())).type_ as *const _ 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() {
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::null::<lxw_chart_font>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_font),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_font>())).size as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_font),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_font>())).bold as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_font),
"::",
stringify!(bold)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_font>())).italic as *const _ as usize },
17usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_font),
"::",
stringify!(italic)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_font>())).underline as *const _ as usize },
18usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_font),
"::",
stringify!(underline)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_font>())).rotation as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_font),
"::",
stringify!(rotation)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_font>())).color as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_font),
"::",
stringify!(color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_font>())).pitch_family as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_font),
"::",
stringify!(pitch_family)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_font>())).charset as *const _ as usize },
29usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_font),
"::",
stringify!(charset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_font>())).baseline as *const _ 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() {
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::null::<lxw_chart_marker>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_marker),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_marker>())).size as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_marker),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_marker>())).line as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_marker),
"::",
stringify!(line)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_marker>())).fill as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_marker),
"::",
stringify!(fill)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_marker>())).pattern as *const _ 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() {
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::null::<lxw_chart_legend>())).font as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_legend),
"::",
stringify!(font)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_legend>())).position as *const _ 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() {
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::null::<lxw_chart_title>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_title),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_title>())).row as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_title),
"::",
stringify!(row)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_title>())).col as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_title),
"::",
stringify!(col)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_title>())).font as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_title),
"::",
stringify!(font)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_title>())).off as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_title),
"::",
stringify!(off)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_title>())).is_horizontal as *const _ as usize },
25usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_title),
"::",
stringify!(is_horizontal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_title>())).ignore_cache as *const _ as usize },
26usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_title),
"::",
stringify!(ignore_cache)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_title>())).range as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_title),
"::",
stringify!(range)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_title>())).data_point as *const _ 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() {
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::null::<lxw_chart_point>())).line as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_point),
"::",
stringify!(line)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_point>())).fill as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_point),
"::",
stringify!(fill)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_point>())).pattern as *const _ 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() {
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::null::<lxw_chart_data_label>())).value as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_data_label),
"::",
stringify!(value)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_data_label>())).hide as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_data_label),
"::",
stringify!(hide)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_data_label>())).font as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_data_label),
"::",
stringify!(font)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_data_label>())).line as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_data_label),
"::",
stringify!(line)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_data_label>())).fill as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_data_label),
"::",
stringify!(fill)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_data_label>())).pattern as *const _ 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() {
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::null::<lxw_chart_custom_label>())).value as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_custom_label),
"::",
stringify!(value)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_custom_label>())).hide as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_custom_label),
"::",
stringify!(hide)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_custom_label>())).font as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_custom_label),
"::",
stringify!(font)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_custom_label>())).line as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_custom_label),
"::",
stringify!(line)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_custom_label>())).fill as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_custom_label),
"::",
stringify!(fill)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_custom_label>())).pattern as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_custom_label),
"::",
stringify!(pattern)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_custom_label>())).range as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_custom_label),
"::",
stringify!(range)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_chart_custom_label>())).data_point as *const _ 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 = u32;
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 = u32;
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 = u32;
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 = u32;
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 = u32;
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 = u32;
#[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() {
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::null::<lxw_series_error_bars>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_error_bars),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_series_error_bars>())).direction as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_error_bars),
"::",
stringify!(direction)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_series_error_bars>())).endcap as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_error_bars),
"::",
stringify!(endcap)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_series_error_bars>())).has_value as *const _ as usize },
3usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_error_bars),
"::",
stringify!(has_value)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_series_error_bars>())).is_set as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_error_bars),
"::",
stringify!(is_set)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_series_error_bars>())).is_x as *const _ as usize },
5usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_error_bars),
"::",
stringify!(is_x)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_series_error_bars>())).chart_group as *const _ as usize
},
6usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_error_bars),
"::",
stringify!(chart_group)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_series_error_bars>())).value as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_series_error_bars),
"::",
stringify!(value)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_series_error_bars>())).line as *const _ 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 = u32;
#[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() {
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::null::<lxw_chart_series__bindgen_ty_1>())).stqe_next as *const _
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() {
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::null::<lxw_chart_series>())).categories as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(categories)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_series>())).values as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(values)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_series>())).title as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(title)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_series>())).line as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(line)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_series>())).fill as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(fill)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_series>())).pattern as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(pattern)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_series>())).marker as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(marker)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_series>())).points as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(points)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_series>())).data_labels as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(data_labels)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_series>())).point_count as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(point_count)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_chart_series>())).data_label_count as *const _ as usize
},
146usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(data_label_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_series>())).smooth as *const _ as usize },
148usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(smooth)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_chart_series>())).invert_if_negative as *const _ as usize
},
149usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(invert_if_negative)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_series>())).has_labels as *const _ as usize },
150usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(has_labels)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_chart_series>())).show_labels_value as *const _ as usize
},
151usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(show_labels_value)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_chart_series>())).show_labels_category as *const _ as usize
},
152usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(show_labels_category)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_chart_series>())).show_labels_name as *const _ as usize
},
153usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(show_labels_name)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_chart_series>())).show_labels_leader as *const _ as usize
},
154usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(show_labels_leader)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_chart_series>())).show_labels_legend as *const _ as usize
},
155usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(show_labels_legend)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_chart_series>())).show_labels_percent as *const _ as usize
},
156usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(show_labels_percent)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_series>())).label_position as *const _ as usize },
157usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(label_position)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_chart_series>())).label_separator as *const _ as usize
},
158usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(label_separator)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_chart_series>())).default_label_position as *const _ as usize
},
159usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(default_label_position)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_chart_series>())).label_num_format as *const _ as usize
},
160usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(label_num_format)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_series>())).label_font as *const _ as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(label_font)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_series>())).label_line as *const _ as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(label_line)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_series>())).label_fill as *const _ as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(label_fill)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_series>())).label_pattern as *const _ as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(label_pattern)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_series>())).x_error_bars as *const _ as usize },
200usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(x_error_bars)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_series>())).y_error_bars as *const _ as usize },
208usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(y_error_bars)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_series>())).has_trendline as *const _ as usize },
216usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(has_trendline)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_chart_series>())).has_trendline_forecast as *const _ as usize
},
217usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(has_trendline_forecast)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_chart_series>())).has_trendline_equation as *const _ as usize
},
218usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(has_trendline_equation)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_chart_series>())).has_trendline_r_squared as *const _
as usize
},
219usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(has_trendline_r_squared)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_chart_series>())).has_trendline_intercept as *const _
as usize
},
220usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(has_trendline_intercept)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_series>())).trendline_type as *const _ as usize },
221usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(trendline_type)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_chart_series>())).trendline_value as *const _ as usize
},
222usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(trendline_value)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_chart_series>())).trendline_forward as *const _ as usize
},
224usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(trendline_forward)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_chart_series>())).trendline_backward as *const _ as usize
},
232usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(trendline_backward)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_chart_series>())).trendline_value_type as *const _ as usize
},
240usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(trendline_value_type)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_series>())).trendline_name as *const _ as usize },
248usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(trendline_name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_series>())).trendline_line as *const _ as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(trendline_line)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_chart_series>())).trendline_intercept as *const _ as usize
},
264usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_series),
"::",
stringify!(trendline_intercept)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_series>())).list_pointers as *const _ 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() {
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::null::<lxw_chart_gridline>())).visible as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_gridline),
"::",
stringify!(visible)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_gridline>())).line as *const _ 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_max: u8,
pub crossing: f64,
}
#[test]
fn bindgen_test_layout_lxw_chart_axis() {
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::null::<lxw_chart_axis>())).title as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(title)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_axis>())).num_format as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(num_format)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_chart_axis>())).default_num_format as *const _ as usize
},
88usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(default_num_format)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_axis>())).source_linked as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(source_linked)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_axis>())).major_tick_mark as *const _ as usize },
97usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(major_tick_mark)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_axis>())).minor_tick_mark as *const _ as usize },
98usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(minor_tick_mark)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_axis>())).is_horizontal as *const _ as usize },
99usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(is_horizontal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_axis>())).major_gridlines as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(major_gridlines)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_axis>())).minor_gridlines as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(minor_gridlines)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_axis>())).num_font as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(num_font)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_axis>())).line as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(line)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_axis>())).fill as *const _ as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(fill)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_axis>())).pattern as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(pattern)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_axis>())).is_category as *const _ as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(is_category)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_axis>())).is_date as *const _ as usize },
169usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(is_date)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_axis>())).is_value as *const _ as usize },
170usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(is_value)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_axis>())).axis_position as *const _ as usize },
171usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(axis_position)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_axis>())).position_axis as *const _ as usize },
172usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(position_axis)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_axis>())).label_position as *const _ as usize },
173usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(label_position)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_axis>())).label_align as *const _ as usize },
174usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(label_align)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_axis>())).hidden as *const _ as usize },
175usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(hidden)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_axis>())).reverse as *const _ as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(reverse)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_axis>())).has_min as *const _ as usize },
177usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(has_min)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_axis>())).min as *const _ as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(min)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_axis>())).has_max as *const _ as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(has_max)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_axis>())).max as *const _ as usize },
200usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(max)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_axis>())).has_major_unit as *const _ as usize },
208usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(has_major_unit)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_axis>())).major_unit as *const _ as usize },
216usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(major_unit)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_axis>())).has_minor_unit as *const _ as usize },
224usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(has_minor_unit)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_axis>())).minor_unit as *const _ as usize },
232usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(minor_unit)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_axis>())).interval_unit as *const _ as usize },
240usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(interval_unit)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_axis>())).interval_tick as *const _ as usize },
242usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(interval_tick)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_axis>())).log_base as *const _ as usize },
244usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(log_base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_axis>())).display_units as *const _ as usize },
246usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(display_units)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_chart_axis>())).display_units_visible as *const _ as usize
},
247usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(display_units_visible)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_axis>())).has_crossing as *const _ as usize },
248usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(has_crossing)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_axis>())).crossing_max as *const _ as usize },
249usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_axis),
"::",
stringify!(crossing_max)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_axis>())).crossing as *const _ 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() {
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::null::<lxw_chart__bindgen_ty_1>())).stqe_next as *const _ 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() {
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::null::<lxw_chart__bindgen_ty_2>())).stqe_next as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart__bindgen_ty_2),
"::",
stringify!(stqe_next)
)
);
}
#[test]
fn bindgen_test_layout_lxw_chart() {
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::null::<lxw_chart>())).file as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(file)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).type_ as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).subtype as *const _ as usize },
9usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(subtype)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).series_index as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(series_index)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).write_chart_type as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(write_chart_type)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).write_plot_area as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(write_plot_area)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).x_axis as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(x_axis)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).y_axis as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(y_axis)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).title as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(title)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).id as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).axis_id_1 as *const _ as usize },
132usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(axis_id_1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).axis_id_2 as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(axis_id_2)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).axis_id_3 as *const _ as usize },
140usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(axis_id_3)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).axis_id_4 as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(axis_id_4)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).in_use as *const _ as usize },
148usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(in_use)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).chart_group as *const _ as usize },
149usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(chart_group)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).cat_has_num_fmt as *const _ as usize },
150usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(cat_has_num_fmt)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).is_chartsheet as *const _ as usize },
151usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(is_chartsheet)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).has_horiz_cat_axis as *const _ as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(has_horiz_cat_axis)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).has_horiz_val_axis as *const _ as usize },
153usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(has_horiz_val_axis)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).style_id as *const _ as usize },
154usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(style_id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).rotation as *const _ as usize },
156usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(rotation)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).hole_size as *const _ as usize },
158usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(hole_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).no_title as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(no_title)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).has_overlap as *const _ as usize },
161usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(has_overlap)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).overlap_y1 as *const _ as usize },
162usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(overlap_y1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).overlap_y2 as *const _ as usize },
163usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(overlap_y2)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).gap_y1 as *const _ as usize },
164usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(gap_y1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).gap_y2 as *const _ as usize },
166usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(gap_y2)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).grouping as *const _ as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(grouping)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).default_cross_between as *const _ as usize },
169usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(default_cross_between)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).legend as *const _ as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(legend)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).delete_series as *const _ as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(delete_series)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).delete_series_count as *const _ as usize },
200usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(delete_series_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).default_marker as *const _ as usize },
208usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(default_marker)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).chartarea_line as *const _ as usize },
216usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(chartarea_line)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).chartarea_fill as *const _ as usize },
224usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(chartarea_fill)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).chartarea_pattern as *const _ as usize },
232usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(chartarea_pattern)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).plotarea_line as *const _ as usize },
240usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(plotarea_line)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).plotarea_fill as *const _ as usize },
248usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(plotarea_fill)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).plotarea_pattern as *const _ as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(plotarea_pattern)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).has_drop_lines as *const _ as usize },
264usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(has_drop_lines)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).drop_lines_line as *const _ as usize },
272usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(drop_lines_line)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).has_high_low_lines as *const _ as usize },
280usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(has_high_low_lines)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).high_low_lines_line as *const _ as usize },
288usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(high_low_lines_line)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).series_list as *const _ as usize },
296usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(series_list)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).has_table as *const _ as usize },
304usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(has_table)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).has_table_vertical as *const _ as usize },
305usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(has_table_vertical)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).has_table_horizontal as *const _ as usize },
306usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(has_table_horizontal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).has_table_outline as *const _ as usize },
307usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(has_table_outline)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).has_table_legend_keys as *const _ as usize },
308usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(has_table_legend_keys)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).table_font as *const _ as usize },
312usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(table_font)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).show_blanks_as as *const _ as usize },
320usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(show_blanks_as)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).show_hidden_data as *const _ as usize },
321usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(show_hidden_data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).has_up_down_bars as *const _ as usize },
322usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(has_up_down_bars)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).up_bar_line as *const _ as usize },
328usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(up_bar_line)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).down_bar_line as *const _ as usize },
336usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(down_bar_line)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).up_bar_fill as *const _ as usize },
344usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(up_bar_fill)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).down_bar_fill as *const _ as usize },
352usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(down_bar_fill)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_chart>())).default_label_position as *const _ as usize
},
360usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(default_label_position)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).is_protected as *const _ as usize },
361usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(is_protected)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).ordered_list_pointers as *const _ as usize },
368usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart),
"::",
stringify!(ordered_list_pointers)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart>())).list_pointers as *const _ 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_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() {
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::null::<lxw_drawing_objects>())).stqh_first as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_objects),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_drawing_objects>())).stqh_last as *const _ 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 = u32;
#[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() {
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::null::<lxw_drawing_coords>())).col as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_coords),
"::",
stringify!(col)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_drawing_coords>())).row as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_coords),
"::",
stringify!(row)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_drawing_coords>())).col_offset as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_coords),
"::",
stringify!(col_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_drawing_coords>())).row_offset as *const _ 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 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() {
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::null::<lxw_drawing_object__bindgen_ty_1>())).stqe_next as *const _
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() {
assert_eq!(
::std::mem::size_of::<lxw_drawing_object>(),
112usize,
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::null::<lxw_drawing_object>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_object),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_drawing_object>())).anchor as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_object),
"::",
stringify!(anchor)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_drawing_object>())).from as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_object),
"::",
stringify!(from)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_drawing_object>())).to as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_object),
"::",
stringify!(to)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_drawing_object>())).col_absolute as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_object),
"::",
stringify!(col_absolute)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_drawing_object>())).row_absolute as *const _ as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_object),
"::",
stringify!(row_absolute)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_drawing_object>())).width as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_object),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_drawing_object>())).height as *const _ as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_object),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_drawing_object>())).shape as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_object),
"::",
stringify!(shape)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_drawing_object>())).rel_index as *const _ as usize },
76usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_object),
"::",
stringify!(rel_index)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_drawing_object>())).url_rel_index as *const _ as usize
},
80usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_object),
"::",
stringify!(url_rel_index)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_drawing_object>())).description as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_object),
"::",
stringify!(description)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_drawing_object>())).tip as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_object),
"::",
stringify!(tip)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_drawing_object>())).list_pointers as *const _ as usize
},
104usize,
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() {
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::null::<lxw_drawing>())).file as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing),
"::",
stringify!(file)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_drawing>())).embedded as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing),
"::",
stringify!(embedded)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_drawing>())).orientation as *const _ as usize },
9usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing),
"::",
stringify!(orientation)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_drawing>())).drawing_objects as *const _ 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() {
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::null::<lxw_styles>())).file as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_styles),
"::",
stringify!(file)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_styles>())).font_count as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_styles),
"::",
stringify!(font_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_styles>())).xf_count as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(lxw_styles),
"::",
stringify!(xf_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_styles>())).dxf_count as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_styles),
"::",
stringify!(dxf_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_styles>())).num_format_count as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(lxw_styles),
"::",
stringify!(num_format_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_styles>())).border_count as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_styles),
"::",
stringify!(border_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_styles>())).fill_count as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(lxw_styles),
"::",
stringify!(fill_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_styles>())).xf_formats as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_styles),
"::",
stringify!(xf_formats)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_styles>())).dxf_formats as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_styles),
"::",
stringify!(dxf_formats)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_styles>())).has_hyperlink as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_styles),
"::",
stringify!(has_hyperlink)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_styles>())).hyperlink_font_id as *const _ as usize },
50usize,
concat!(
"Offset of field: ",
stringify!(lxw_styles),
"::",
stringify!(hyperlink_font_id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_styles>())).has_comments as *const _ 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(lxw_styles: *mut lxw_styles, format: *mut lxw_format);
}
#[repr(C)]
#[derive(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() {
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::null::<xml_attribute__bindgen_ty_1>())).stqe_next as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(xml_attribute__bindgen_ty_1),
"::",
stringify!(stqe_next)
)
);
}
#[test]
fn bindgen_test_layout_xml_attribute() {
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::null::<xml_attribute>())).key as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(xml_attribute),
"::",
stringify!(key)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<xml_attribute>())).value as *const _ as usize },
2080usize,
concat!(
"Offset of field: ",
stringify!(xml_attribute),
"::",
stringify!(value)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<xml_attribute>())).list_entries as *const _ 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() {
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::null::<xml_attribute_list>())).stqh_first as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(xml_attribute_list),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<xml_attribute_list>())).stqh_last as *const _ 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_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) -> size_t;
}
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_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() {
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::null::<lxw_rel_tuples>())).stqh_first as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_rel_tuples),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_rel_tuples>())).stqh_last as *const _ 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() {
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::null::<lxw_rel_tuple__bindgen_ty_1>())).stqe_next as *const _ 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() {
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::null::<lxw_rel_tuple>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_rel_tuple),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_rel_tuple>())).target as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_rel_tuple),
"::",
stringify!(target)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_rel_tuple>())).target_mode as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_rel_tuple),
"::",
stringify!(target_mode)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_rel_tuple>())).list_pointers as *const _ 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() {
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::null::<lxw_relationships>())).file as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_relationships),
"::",
stringify!(file)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_relationships>())).rel_id as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_relationships),
"::",
stringify!(rel_id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_relationships>())).relationships as *const _ 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 = u32;
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 = u32;
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 = u32;
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 = u32;
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 = u32;
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 = u32;
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 = u32;
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 = u32;
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 = u32;
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 = u32;
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 = u32;
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 = u32;
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 = u32;
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 = u32;
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_BLANK_CELL: cell_types = 7;
pub const cell_types_BOOLEAN_CELL: cell_types = 8;
pub const cell_types_COMMENT: cell_types = 9;
pub const cell_types_HYPERLINK_URL: cell_types = 10;
pub const cell_types_HYPERLINK_INTERNAL: cell_types = 11;
pub const cell_types_HYPERLINK_EXTERNAL: cell_types = 12;
pub type cell_types = u32;
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 = u32;
#[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() {
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::null::<lxw_table_cells>())).rbh_root as *const _ 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() {
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::null::<lxw_drawing_rel_ids>())).rbh_root as *const _ 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() {
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::null::<lxw_vml_drawing_rel_ids>())).rbh_root as *const _ 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() {
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::null::<lxw_cond_format_hash>())).rbh_root as *const _ 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() {
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::null::<lxw_table_rows>())).rbh_root as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_rows),
"::",
stringify!(rbh_root)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_table_rows>())).cached_row as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_table_rows),
"::",
stringify!(cached_row)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_table_rows>())).cached_row_num as *const _ 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() {
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::null::<lxw_merged_ranges>())).stqh_first as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_merged_ranges),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_merged_ranges>())).stqh_last as *const _ 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() {
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::null::<lxw_selections>())).stqh_first as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_selections),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_selections>())).stqh_last as *const _ 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() {
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::null::<lxw_data_validations>())).stqh_first as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validations),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_data_validations>())).stqh_last as *const _ 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() {
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::null::<lxw_cond_format_list>())).stqh_first as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_list),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_cond_format_list>())).stqh_last as *const _ 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() {
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::null::<lxw_image_props>())).stqh_first as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_image_props),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_image_props>())).stqh_last as *const _ 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() {
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::null::<lxw_chart_props>())).stqh_first as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_props),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_props>())).stqh_last as *const _ 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() {
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::null::<lxw_comment_objs>())).stqh_first as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_comment_objs),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_comment_objs>())).stqh_last as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_comment_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() {
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::null::<lxw_row_col_options>())).hidden as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_row_col_options),
"::",
stringify!(hidden)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_row_col_options>())).level as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(lxw_row_col_options),
"::",
stringify!(level)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_row_col_options>())).collapsed as *const _ 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() {
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::null::<lxw_col_options>())).firstcol as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_col_options),
"::",
stringify!(firstcol)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_col_options>())).lastcol as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(lxw_col_options),
"::",
stringify!(lastcol)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_col_options>())).width as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_col_options),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_col_options>())).format as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_col_options),
"::",
stringify!(format)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_col_options>())).hidden as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_col_options),
"::",
stringify!(hidden)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_col_options>())).level as *const _ as usize },
25usize,
concat!(
"Offset of field: ",
stringify!(lxw_col_options),
"::",
stringify!(level)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_col_options>())).collapsed as *const _ 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() {
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::null::<lxw_merged_range__bindgen_ty_1>())).stqe_next as *const _
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() {
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::null::<lxw_merged_range>())).first_row as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_merged_range),
"::",
stringify!(first_row)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_merged_range>())).last_row as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_merged_range),
"::",
stringify!(last_row)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_merged_range>())).first_col as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_merged_range),
"::",
stringify!(first_col)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_merged_range>())).last_col as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(lxw_merged_range),
"::",
stringify!(last_col)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_merged_range>())).list_pointers as *const _ 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() {
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::null::<lxw_repeat_rows>())).in_use as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_repeat_rows),
"::",
stringify!(in_use)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_repeat_rows>())).first_row as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_repeat_rows),
"::",
stringify!(first_row)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_repeat_rows>())).last_row as *const _ 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() {
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::null::<lxw_repeat_cols>())).in_use as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_repeat_cols),
"::",
stringify!(in_use)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_repeat_cols>())).first_col as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(lxw_repeat_cols),
"::",
stringify!(first_col)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_repeat_cols>())).last_col as *const _ 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() {
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::null::<lxw_print_area>())).in_use as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_print_area),
"::",
stringify!(in_use)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_print_area>())).first_row as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_print_area),
"::",
stringify!(first_row)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_print_area>())).last_row as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_print_area),
"::",
stringify!(last_row)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_print_area>())).first_col as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(lxw_print_area),
"::",
stringify!(first_col)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_print_area>())).last_col as *const _ 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 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() {
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::null::<lxw_autofilter>())).in_use as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_autofilter),
"::",
stringify!(in_use)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_autofilter>())).first_row as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_autofilter),
"::",
stringify!(first_row)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_autofilter>())).last_row as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_autofilter),
"::",
stringify!(last_row)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_autofilter>())).first_col as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(lxw_autofilter),
"::",
stringify!(first_col)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_autofilter>())).last_col as *const _ 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() {
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::null::<lxw_panes>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_panes),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_panes>())).first_row as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_panes),
"::",
stringify!(first_row)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_panes>())).first_col as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_panes),
"::",
stringify!(first_col)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_panes>())).top_row as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(lxw_panes),
"::",
stringify!(top_row)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_panes>())).left_col as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_panes),
"::",
stringify!(left_col)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_panes>())).x_split as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_panes),
"::",
stringify!(x_split)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_panes>())).y_split as *const _ 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() {
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::null::<lxw_selection__bindgen_ty_1>())).stqe_next as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_selection__bindgen_ty_1),
"::",
stringify!(stqe_next)
)
);
}
#[test]
fn bindgen_test_layout_lxw_selection() {
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::null::<lxw_selection>())).pane as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_selection),
"::",
stringify!(pane)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_selection>())).active_cell as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(lxw_selection),
"::",
stringify!(active_cell)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_selection>())).sqref as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_selection),
"::",
stringify!(sqref)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_selection>())).list_pointers as *const _ 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() {
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::null::<lxw_data_validation>())).validate as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(validate)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_data_validation>())).criteria as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(criteria)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_data_validation>())).ignore_blank as *const _ as usize
},
2usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(ignore_blank)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_data_validation>())).show_input as *const _ as usize },
3usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(show_input)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_data_validation>())).show_error as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(show_error)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_data_validation>())).error_type as *const _ as usize },
5usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(error_type)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_data_validation>())).dropdown as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(dropdown)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_data_validation>())).value_number as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(value_number)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_data_validation>())).value_formula as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(value_formula)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_data_validation>())).value_list as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(value_list)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_data_validation>())).value_datetime as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(value_datetime)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_data_validation>())).minimum_number as *const _ as usize
},
64usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(minimum_number)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_data_validation>())).minimum_formula as *const _ as usize
},
72usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(minimum_formula)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_data_validation>())).minimum_datetime as *const _ as usize
},
80usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(minimum_datetime)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_data_validation>())).maximum_number as *const _ as usize
},
112usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(maximum_number)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_data_validation>())).maximum_formula as *const _ as usize
},
120usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(maximum_formula)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_data_validation>())).maximum_datetime as *const _ as usize
},
128usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(maximum_datetime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_data_validation>())).input_title as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(input_title)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_data_validation>())).input_message as *const _ as usize
},
168usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(input_message)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_data_validation>())).error_title as *const _ as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_validation),
"::",
stringify!(error_title)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_data_validation>())).error_message as *const _ 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() {
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::null::<lxw_data_val_obj__bindgen_ty_1>())).stqe_next as *const _
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() {
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::null::<lxw_data_val_obj>())).validate as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(validate)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_data_val_obj>())).criteria as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(criteria)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_data_val_obj>())).ignore_blank as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(ignore_blank)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_data_val_obj>())).show_input as *const _ as usize },
3usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(show_input)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_data_val_obj>())).show_error as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(show_error)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_data_val_obj>())).error_type as *const _ as usize },
5usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(error_type)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_data_val_obj>())).dropdown as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(dropdown)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_data_val_obj>())).value_number as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(value_number)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_data_val_obj>())).value_formula as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(value_formula)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_data_val_obj>())).value_list as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(value_list)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_data_val_obj>())).minimum_number as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(minimum_number)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_data_val_obj>())).minimum_formula as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(minimum_formula)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_data_val_obj>())).minimum_datetime as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(minimum_datetime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_data_val_obj>())).maximum_number as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(maximum_number)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_data_val_obj>())).maximum_formula as *const _ as usize
},
88usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(maximum_formula)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_data_val_obj>())).maximum_datetime as *const _ as usize
},
96usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(maximum_datetime)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_data_val_obj>())).input_title as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(input_title)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_data_val_obj>())).input_message as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(input_message)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_data_val_obj>())).error_title as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(error_title)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_data_val_obj>())).error_message as *const _ as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(error_message)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_data_val_obj>())).sqref as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(lxw_data_val_obj),
"::",
stringify!(sqref)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_data_val_obj>())).list_pointers as *const _ 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() {
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::null::<lxw_conditional_format>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_conditional_format>())).criteria as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(criteria)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_conditional_format>())).value as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(value)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_conditional_format>())).value_string as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(value_string)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_conditional_format>())).format as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(format)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_conditional_format>())).min_value as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(min_value)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_conditional_format>())).min_value_string as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(min_value_string)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_conditional_format>())).min_rule_type as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(min_rule_type)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_conditional_format>())).min_color as *const _ as usize
},
52usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(min_color)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_conditional_format>())).mid_value as *const _ as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(mid_value)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_conditional_format>())).mid_value_string as *const _ as usize
},
64usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(mid_value_string)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_conditional_format>())).mid_rule_type as *const _ as usize
},
72usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(mid_rule_type)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_conditional_format>())).mid_color as *const _ as usize
},
76usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(mid_color)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_conditional_format>())).max_value as *const _ as usize
},
80usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(max_value)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_conditional_format>())).max_value_string as *const _ as usize
},
88usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(max_value_string)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_conditional_format>())).max_rule_type as *const _ as usize
},
96usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(max_rule_type)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_conditional_format>())).max_color as *const _ as usize
},
100usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(max_color)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_conditional_format>())).bar_color as *const _ as usize
},
104usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(bar_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_conditional_format>())).bar_only as *const _ as usize },
108usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(bar_only)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_conditional_format>())).data_bar_2010 as *const _ as usize
},
109usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(data_bar_2010)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_conditional_format>())).bar_solid as *const _ as usize
},
110usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(bar_solid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_conditional_format>())).bar_negative_color as *const _
as usize
},
112usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(bar_negative_color)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_conditional_format>())).bar_border_color as *const _ as usize
},
116usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(bar_border_color)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_conditional_format>())).bar_negative_border_color as *const _
as usize
},
120usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(bar_negative_border_color)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_conditional_format>())).bar_negative_color_same as *const _
as usize
},
124usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(bar_negative_color_same)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_conditional_format>())).bar_negative_border_color_same
as *const _ as usize
},
125usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(bar_negative_border_color_same)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_conditional_format>())).bar_no_border as *const _ as usize
},
126usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(bar_no_border)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_conditional_format>())).bar_direction as *const _ as usize
},
127usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(bar_direction)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_conditional_format>())).bar_axis_position as *const _
as usize
},
128usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(bar_axis_position)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_conditional_format>())).bar_axis_color as *const _ as usize
},
132usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(bar_axis_color)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_conditional_format>())).icon_style as *const _ as usize
},
136usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(icon_style)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_conditional_format>())).reverse_icons as *const _ as usize
},
137usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(reverse_icons)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_conditional_format>())).icons_only as *const _ as usize
},
138usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(icons_only)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_conditional_format>())).multi_range as *const _ as usize
},
144usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(multi_range)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_conditional_format>())).stop_if_true as *const _ as usize
},
152usize,
concat!(
"Offset of field: ",
stringify!(lxw_conditional_format),
"::",
stringify!(stop_if_true)
)
);
}
#[repr(C)]
#[derive(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() {
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::null::<lxw_cond_format_obj__bindgen_ty_1>())).stqe_next as *const _
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() {
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::null::<lxw_cond_format_obj>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_cond_format_obj>())).criteria as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(criteria)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_cond_format_obj>())).min_value as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(min_value)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_cond_format_obj>())).min_value_string as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(min_value_string)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_cond_format_obj>())).min_rule_type as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(min_rule_type)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_cond_format_obj>())).min_color as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(min_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_cond_format_obj>())).mid_value as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(mid_value)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_cond_format_obj>())).mid_value_string as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(mid_value_string)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_cond_format_obj>())).mid_value_type as *const _ as usize
},
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(mid_value_type)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_cond_format_obj>())).mid_rule_type as *const _ as usize
},
49usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(mid_rule_type)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_cond_format_obj>())).mid_color as *const _ as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(mid_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_cond_format_obj>())).max_value as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(max_value)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_cond_format_obj>())).max_value_string as *const _ as usize
},
64usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(max_value_string)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_cond_format_obj>())).max_value_type as *const _ as usize
},
72usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(max_value_type)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_cond_format_obj>())).max_rule_type as *const _ as usize
},
73usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(max_rule_type)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_cond_format_obj>())).max_color as *const _ as usize },
76usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(max_color)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_cond_format_obj>())).data_bar_2010 as *const _ as usize
},
80usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(data_bar_2010)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_cond_format_obj>())).auto_min as *const _ as usize },
81usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(auto_min)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_cond_format_obj>())).auto_max as *const _ as usize },
82usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(auto_max)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_cond_format_obj>())).bar_only as *const _ as usize },
83usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(bar_only)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_cond_format_obj>())).bar_solid as *const _ as usize },
84usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(bar_solid)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_cond_format_obj>())).bar_negative_color_same as *const _
as usize
},
85usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(bar_negative_color_same)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_cond_format_obj>())).bar_negative_border_color_same
as *const _ as usize
},
86usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(bar_negative_border_color_same)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_cond_format_obj>())).bar_no_border as *const _ as usize
},
87usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(bar_no_border)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_cond_format_obj>())).bar_direction as *const _ as usize
},
88usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(bar_direction)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_cond_format_obj>())).bar_axis_position as *const _ as usize
},
89usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(bar_axis_position)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_cond_format_obj>())).bar_color as *const _ as usize },
92usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(bar_color)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_cond_format_obj>())).bar_negative_color as *const _ as usize
},
96usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(bar_negative_color)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_cond_format_obj>())).bar_border_color as *const _ as usize
},
100usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(bar_border_color)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_cond_format_obj>())).bar_negative_border_color as *const _
as usize
},
104usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(bar_negative_border_color)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_cond_format_obj>())).bar_axis_color as *const _ as usize
},
108usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(bar_axis_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_cond_format_obj>())).icon_style as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(icon_style)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_cond_format_obj>())).reverse_icons as *const _ as usize
},
113usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(reverse_icons)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_cond_format_obj>())).icons_only as *const _ as usize },
114usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(icons_only)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_cond_format_obj>())).stop_if_true as *const _ as usize
},
115usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(stop_if_true)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_cond_format_obj>())).has_max as *const _ as usize },
116usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(has_max)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_cond_format_obj>())).type_string as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(type_string)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_cond_format_obj>())).guid as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(guid)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_cond_format_obj>())).dxf_index as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(dxf_index)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_cond_format_obj>())).dxf_priority as *const _ as usize
},
140usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(dxf_priority)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_cond_format_obj>())).first_cell as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(first_cell)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_cond_format_obj>())).sqref as *const _ as usize },
158usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(sqref)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_cond_format_obj>())).list_pointers as *const _ as usize
},
2240usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_obj),
"::",
stringify!(list_pointers)
)
);
}
#[repr(C)]
#[derive(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() {
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::null::<lxw_cond_format_hash_element__bindgen_ty_1>())).rbe_left
as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_hash_element__bindgen_ty_1),
"::",
stringify!(rbe_left)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_cond_format_hash_element__bindgen_ty_1>())).rbe_right
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_hash_element__bindgen_ty_1),
"::",
stringify!(rbe_right)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_cond_format_hash_element__bindgen_ty_1>())).rbe_parent
as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_hash_element__bindgen_ty_1),
"::",
stringify!(rbe_parent)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_cond_format_hash_element__bindgen_ty_1>())).rbe_color
as *const _ 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() {
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::null::<lxw_cond_format_hash_element>())).sqref as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_hash_element),
"::",
stringify!(sqref)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_cond_format_hash_element>())).cond_formats as *const _
as usize
},
2080usize,
concat!(
"Offset of field: ",
stringify!(lxw_cond_format_hash_element),
"::",
stringify!(cond_formats)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_cond_format_hash_element>())).tree_pointers as *const _
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_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 url: *mut ::std::os::raw::c_char,
pub tip: *mut ::std::os::raw::c_char,
}
#[test]
fn bindgen_test_layout_lxw_image_options() {
assert_eq!(
::std::mem::size_of::<lxw_image_options>(),
56usize,
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::null::<lxw_image_options>())).x_offset as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_image_options),
"::",
stringify!(x_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_image_options>())).y_offset as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_image_options),
"::",
stringify!(y_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_image_options>())).x_scale as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_image_options),
"::",
stringify!(x_scale)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_image_options>())).y_scale as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_image_options),
"::",
stringify!(y_scale)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_image_options>())).object_position as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_image_options),
"::",
stringify!(object_position)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_image_options>())).description as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_image_options),
"::",
stringify!(description)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_image_options>())).url as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_image_options),
"::",
stringify!(url)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_image_options>())).tip as *const _ as usize },
48usize,
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,
}
#[test]
fn bindgen_test_layout_lxw_chart_options() {
assert_eq!(
::std::mem::size_of::<lxw_chart_options>(),
32usize,
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::null::<lxw_chart_options>())).x_offset as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_options),
"::",
stringify!(x_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_options>())).y_offset as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_options),
"::",
stringify!(y_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_options>())).x_scale as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_options),
"::",
stringify!(x_scale)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chart_options>())).y_scale as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_options),
"::",
stringify!(y_scale)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_chart_options>())).object_position as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_chart_options),
"::",
stringify!(object_position)
)
);
}
#[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_uchar,
pub image_buffer_size: size_t,
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 md5: *mut ::std::os::raw::c_char,
pub image_position: *mut ::std::os::raw::c_char,
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() {
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::null::<lxw_object_properties__bindgen_ty_1>())).stqe_next as *const _
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() {
assert_eq!(
::std::mem::size_of::<lxw_object_properties>(),
184usize,
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::null::<lxw_object_properties>())).x_offset as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(x_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_object_properties>())).y_offset as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(y_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_object_properties>())).x_scale as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(x_scale)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_object_properties>())).y_scale as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(y_scale)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_object_properties>())).row as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(row)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_object_properties>())).col as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(col)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_object_properties>())).filename as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(filename)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_object_properties>())).description as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(description)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_object_properties>())).url as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(url)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_object_properties>())).tip as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(tip)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_object_properties>())).object_position as *const _ as usize
},
64usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(object_position)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_object_properties>())).stream as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(stream)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_object_properties>())).image_type as *const _ as usize
},
80usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(image_type)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_object_properties>())).is_image_buffer as *const _ as usize
},
81usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(is_image_buffer)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_object_properties>())).image_buffer as *const _ as usize
},
88usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(image_buffer)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_object_properties>())).image_buffer_size as *const _ as usize
},
96usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(image_buffer_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_object_properties>())).width as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_object_properties>())).height as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_object_properties>())).extension as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(extension)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_object_properties>())).x_dpi as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(x_dpi)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_object_properties>())).y_dpi as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(y_dpi)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_object_properties>())).chart as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(chart)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_object_properties>())).is_duplicate as *const _ as usize
},
152usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(is_duplicate)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_object_properties>())).md5 as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(md5)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_object_properties>())).image_position as *const _ as usize
},
168usize,
concat!(
"Offset of field: ",
stringify!(lxw_object_properties),
"::",
stringify!(image_position)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_object_properties>())).list_pointers as *const _ as usize
},
176usize,
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() {
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::null::<lxw_comment_options>())).visible as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_comment_options),
"::",
stringify!(visible)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_comment_options>())).author as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_comment_options),
"::",
stringify!(author)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_comment_options>())).width as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_comment_options),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_comment_options>())).height as *const _ as usize },
18usize,
concat!(
"Offset of field: ",
stringify!(lxw_comment_options),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_comment_options>())).x_scale as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_comment_options),
"::",
stringify!(x_scale)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_comment_options>())).y_scale as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_comment_options),
"::",
stringify!(y_scale)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_comment_options>())).color as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_comment_options),
"::",
stringify!(color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_comment_options>())).font_name as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_comment_options),
"::",
stringify!(font_name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_comment_options>())).font_size as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(lxw_comment_options),
"::",
stringify!(font_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_comment_options>())).font_family as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(lxw_comment_options),
"::",
stringify!(font_family)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_comment_options>())).start_row as *const _ as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(lxw_comment_options),
"::",
stringify!(start_row)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_comment_options>())).start_col as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(lxw_comment_options),
"::",
stringify!(start_col)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_comment_options>())).x_offset as *const _ as usize },
76usize,
concat!(
"Offset of field: ",
stringify!(lxw_comment_options),
"::",
stringify!(x_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_comment_options>())).y_offset as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(lxw_comment_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 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() {
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::null::<lxw_vml_obj__bindgen_ty_1>())).stqe_next as *const _ 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() {
assert_eq!(
::std::mem::size_of::<lxw_vml_obj>(),
176usize,
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::null::<lxw_vml_obj>())).row as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(row)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_vml_obj>())).col as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(col)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_vml_obj>())).start_row as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(start_row)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_vml_obj>())).start_col as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(start_col)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_vml_obj>())).x_offset as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(x_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_vml_obj>())).y_offset as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(y_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_vml_obj>())).col_absolute as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(col_absolute)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_vml_obj>())).row_absolute as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(row_absolute)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_vml_obj>())).width as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_vml_obj>())).height as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_vml_obj>())).x_dpi as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(x_dpi)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_vml_obj>())).y_dpi as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(y_dpi)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_vml_obj>())).color as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_vml_obj>())).font_family as *const _ as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(font_family)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_vml_obj>())).visible as *const _ as usize },
61usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(visible)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_vml_obj>())).author_id as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(author_id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_vml_obj>())).rel_index as *const _ as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(rel_index)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_vml_obj>())).font_size as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(font_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_vml_obj>())).from as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(from)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_vml_obj>())).to as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(to)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_vml_obj>())).author as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(author)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_vml_obj>())).font_name as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(font_name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_vml_obj>())).text as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(text)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_vml_obj>())).image_position as *const _ as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(image_position)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_vml_obj>())).name as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(lxw_vml_obj),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_vml_obj>())).list_pointers as *const _ as usize },
168usize,
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() {
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::null::<lxw_header_footer_options>())).margin as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_header_footer_options),
"::",
stringify!(margin)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_header_footer_options>())).image_left as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_header_footer_options),
"::",
stringify!(image_left)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_header_footer_options>())).image_center as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_header_footer_options),
"::",
stringify!(image_center)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_header_footer_options>())).image_right as *const _ 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() {
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::null::<lxw_protection>())).no_select_locked_cells as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection),
"::",
stringify!(no_select_locked_cells)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_protection>())).no_select_unlocked_cells as *const _ as usize
},
1usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection),
"::",
stringify!(no_select_unlocked_cells)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_protection>())).format_cells as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection),
"::",
stringify!(format_cells)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_protection>())).format_columns as *const _ as usize },
3usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection),
"::",
stringify!(format_columns)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_protection>())).format_rows as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection),
"::",
stringify!(format_rows)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_protection>())).insert_columns as *const _ as usize },
5usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection),
"::",
stringify!(insert_columns)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_protection>())).insert_rows as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection),
"::",
stringify!(insert_rows)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_protection>())).insert_hyperlinks as *const _ as usize
},
7usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection),
"::",
stringify!(insert_hyperlinks)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_protection>())).delete_columns as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection),
"::",
stringify!(delete_columns)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_protection>())).delete_rows as *const _ as usize },
9usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection),
"::",
stringify!(delete_rows)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_protection>())).sort as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection),
"::",
stringify!(sort)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_protection>())).autofilter as *const _ as usize },
11usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection),
"::",
stringify!(autofilter)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_protection>())).pivot_tables as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection),
"::",
stringify!(pivot_tables)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_protection>())).scenarios as *const _ as usize },
13usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection),
"::",
stringify!(scenarios)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_protection>())).objects as *const _ as usize },
14usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection),
"::",
stringify!(objects)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_protection>())).no_content as *const _ as usize },
15usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection),
"::",
stringify!(no_content)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_protection>())).no_objects as *const _ 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() {
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::null::<lxw_protection_obj>())).no_select_locked_cells as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(no_select_locked_cells)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_protection_obj>())).no_select_unlocked_cells as *const _
as usize
},
1usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(no_select_unlocked_cells)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_protection_obj>())).format_cells as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(format_cells)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_protection_obj>())).format_columns as *const _ as usize
},
3usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(format_columns)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_protection_obj>())).format_rows as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(format_rows)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_protection_obj>())).insert_columns as *const _ as usize
},
5usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(insert_columns)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_protection_obj>())).insert_rows as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(insert_rows)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_protection_obj>())).insert_hyperlinks as *const _ as usize
},
7usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(insert_hyperlinks)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_protection_obj>())).delete_columns as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(delete_columns)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_protection_obj>())).delete_rows as *const _ as usize },
9usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(delete_rows)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_protection_obj>())).sort as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(sort)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_protection_obj>())).autofilter as *const _ as usize },
11usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(autofilter)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_protection_obj>())).pivot_tables as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(pivot_tables)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_protection_obj>())).scenarios as *const _ as usize },
13usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(scenarios)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_protection_obj>())).objects as *const _ as usize },
14usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(objects)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_protection_obj>())).no_content as *const _ as usize },
15usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(no_content)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_protection_obj>())).no_objects as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(no_objects)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_protection_obj>())).no_sheet as *const _ as usize },
17usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(no_sheet)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_protection_obj>())).is_configured as *const _ as usize
},
18usize,
concat!(
"Offset of field: ",
stringify!(lxw_protection_obj),
"::",
stringify!(is_configured)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_protection_obj>())).hash as *const _ 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() {
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::null::<lxw_rich_string_tuple>())).format as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_rich_string_tuple),
"::",
stringify!(format)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_rich_string_tuple>())).string as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_rich_string_tuple),
"::",
stringify!(string)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct lxw_worksheet {
pub file: *mut FILE,
pub optimize_tmpfile: *mut FILE,
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 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: u32,
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 num_validations: u8,
pub vba_codename: *mut ::std::os::raw::c_char,
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: [::std::os::raw::c_char; 255usize],
pub footer: [::std::os::raw::c_char; 255usize],
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 panes: lxw_panes,
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 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 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 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() {
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::null::<lxw_worksheet__bindgen_ty_1>())).stqe_next as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet__bindgen_ty_1),
"::",
stringify!(stqe_next)
)
);
}
#[test]
fn bindgen_test_layout_lxw_worksheet() {
assert_eq!(
::std::mem::size_of::<lxw_worksheet>(),
1368usize,
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::null::<lxw_worksheet>())).file as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(file)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).optimize_tmpfile as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(optimize_tmpfile)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).table as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(table)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).hyperlinks as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(hyperlinks)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).comments as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(comments)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).array as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(array)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).merged_ranges as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(merged_ranges)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).selections as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(selections)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).data_validations as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(data_validations)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet>())).conditional_formats as *const _ as usize
},
72usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(conditional_formats)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).image_props as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(image_props)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).chart_data as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(chart_data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).drawing_rel_ids as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(drawing_rel_ids)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet>())).vml_drawing_rel_ids as *const _ as usize
},
104usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(vml_drawing_rel_ids)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).comment_objs as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(comment_objs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).header_image_objs as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(header_image_objs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).dim_rowmin as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(dim_rowmin)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).dim_rowmax as *const _ as usize },
132usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(dim_rowmax)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).dim_colmin as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(dim_colmin)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).dim_colmax as *const _ as usize },
138usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(dim_colmax)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).sst as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(sst)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).name as *const _ as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).quoted_name as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(quoted_name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).tmpdir as *const _ as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(tmpdir)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).index as *const _ as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(index)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).active as *const _ as usize },
180usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(active)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).selected as *const _ as usize },
181usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(selected)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).hidden as *const _ as usize },
182usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(hidden)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).active_sheet as *const _ as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(active_sheet)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).first_sheet as *const _ as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(first_sheet)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).is_chartsheet as *const _ as usize },
200usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(is_chartsheet)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).col_options as *const _ as usize },
208usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(col_options)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).col_options_max as *const _ as usize },
216usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(col_options_max)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).col_sizes as *const _ as usize },
224usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(col_sizes)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).col_sizes_max as *const _ as usize },
232usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(col_sizes_max)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).col_formats as *const _ as usize },
240usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(col_formats)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).col_formats_max as *const _ as usize },
248usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(col_formats_max)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).col_size_changed as *const _ as usize },
250usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(col_size_changed)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).row_size_changed as *const _ as usize },
251usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(row_size_changed)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).optimize as *const _ as usize },
252usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(optimize)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).optimize_row as *const _ as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(optimize_row)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).fit_height as *const _ as usize },
264usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(fit_height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).fit_width as *const _ as usize },
266usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(fit_width)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).horizontal_dpi as *const _ as usize },
268usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(horizontal_dpi)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).hlink_count as *const _ as usize },
270usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(hlink_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).page_start as *const _ as usize },
272usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(page_start)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).print_scale as *const _ as usize },
274usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(print_scale)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).rel_count as *const _ as usize },
276usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(rel_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).vertical_dpi as *const _ as usize },
278usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(vertical_dpi)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).zoom as *const _ as usize },
280usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(zoom)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).filter_on as *const _ as usize },
282usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(filter_on)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).fit_page as *const _ as usize },
283usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(fit_page)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).hcenter as *const _ as usize },
284usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(hcenter)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).orientation as *const _ as usize },
285usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(orientation)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).outline_changed as *const _ as usize },
286usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(outline_changed)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).outline_on as *const _ as usize },
287usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(outline_on)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).outline_style as *const _ as usize },
288usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(outline_style)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).outline_below as *const _ as usize },
289usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(outline_below)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).outline_right as *const _ as usize },
290usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(outline_right)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).page_order as *const _ as usize },
291usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(page_order)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet>())).page_setup_changed as *const _ as usize
},
292usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(page_setup_changed)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).page_view as *const _ as usize },
293usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(page_view)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).paper_size as *const _ as usize },
294usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(paper_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).print_gridlines as *const _ as usize },
295usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(print_gridlines)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).print_headers as *const _ as usize },
296usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(print_headers)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet>())).print_options_changed as *const _ as usize
},
297usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(print_options_changed)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).right_to_left as *const _ as usize },
298usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(right_to_left)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).screen_gridlines as *const _ as usize },
299usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(screen_gridlines)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).show_zeros as *const _ as usize },
300usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(show_zeros)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).vcenter as *const _ as usize },
301usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(vcenter)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).zoom_scale_normal as *const _ as usize },
302usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(zoom_scale_normal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).num_validations as *const _ as usize },
303usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(num_validations)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).vba_codename as *const _ as usize },
304usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(vba_codename)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).tab_color as *const _ as usize },
312usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(tab_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).margin_left as *const _ as usize },
320usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(margin_left)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).margin_right as *const _ as usize },
328usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(margin_right)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).margin_top as *const _ as usize },
336usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(margin_top)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).margin_bottom as *const _ as usize },
344usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(margin_bottom)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).margin_header as *const _ as usize },
352usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(margin_header)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).margin_footer as *const _ as usize },
360usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(margin_footer)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet>())).default_row_height as *const _ as usize
},
368usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(default_row_height)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet>())).default_row_pixels as *const _ as usize
},
376usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(default_row_pixels)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet>())).default_col_pixels as *const _ as usize
},
380usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(default_col_pixels)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet>())).default_row_zeroed as *const _ as usize
},
384usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(default_row_zeroed)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).default_row_set as *const _ as usize },
385usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(default_row_set)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).outline_row_level as *const _ as usize },
386usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(outline_row_level)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).outline_col_level as *const _ as usize },
387usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(outline_col_level)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet>())).header_footer_changed as *const _ as usize
},
388usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(header_footer_changed)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).header as *const _ as usize },
389usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(header)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).footer as *const _ as usize },
644usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(footer)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).repeat_rows as *const _ as usize },
900usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(repeat_rows)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).repeat_cols as *const _ as usize },
912usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(repeat_cols)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).print_area as *const _ as usize },
920usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(print_area)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).autofilter as *const _ as usize },
936usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(autofilter)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet>())).merged_range_count as *const _ as usize
},
952usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(merged_range_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).max_url_length as *const _ as usize },
954usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(max_url_length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).hbreaks as *const _ as usize },
960usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(hbreaks)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).vbreaks as *const _ as usize },
968usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(vbreaks)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).hbreaks_count as *const _ as usize },
976usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(hbreaks_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).vbreaks_count as *const _ as usize },
978usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(vbreaks_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).drawing_rel_id as *const _ as usize },
980usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(drawing_rel_id)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet>())).vml_drawing_rel_id as *const _ as usize
},
984usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(vml_drawing_rel_id)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet>())).external_hyperlinks as *const _ as usize
},
992usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(external_hyperlinks)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet>())).external_drawing_links as *const _ as usize
},
1000usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(external_drawing_links)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).drawing_links as *const _ as usize },
1008usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(drawing_links)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).vml_drawing_links as *const _ as usize },
1016usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(vml_drawing_links)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).panes as *const _ as usize },
1024usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(panes)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).protection as *const _ as usize },
1064usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(protection)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).drawing as *const _ as usize },
1088usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(drawing)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet>())).default_url_format as *const _ as usize
},
1096usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(default_url_format)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).has_vml as *const _ as usize },
1104usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(has_vml)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).has_comments as *const _ as usize },
1105usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(has_comments)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).has_header_vml as *const _ as usize },
1106usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(has_header_vml)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet>())).external_vml_comment_link as *const _ as usize
},
1112usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(external_vml_comment_link)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet>())).external_comment_link as *const _ as usize
},
1120usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(external_comment_link)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet>())).external_vml_header_link as *const _ as usize
},
1128usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(external_vml_header_link)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).comment_author as *const _ as usize },
1136usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(comment_author)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).vml_data_id_str as *const _ as usize },
1144usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(vml_data_id_str)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).vml_header_id_str as *const _ as usize },
1152usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(vml_header_id_str)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).vml_shape_id as *const _ as usize },
1160usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(vml_shape_id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).vml_header_id as *const _ as usize },
1164usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(vml_header_id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).dxf_priority as *const _ as usize },
1168usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(dxf_priority)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet>())).comment_display_default as *const _ as usize
},
1172usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(comment_display_default)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet>())).data_bar_2010_index as *const _ as usize
},
1176usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(data_bar_2010_index)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).has_ignore_errors as *const _ as usize },
1180usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(has_ignore_errors)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet>())).ignore_number_stored_as_text as *const _
as usize
},
1184usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(ignore_number_stored_as_text)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).ignore_eval_error as *const _ as usize },
1192usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(ignore_eval_error)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet>())).ignore_formula_differs as *const _ as usize
},
1200usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(ignore_formula_differs)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet>())).ignore_formula_range as *const _ as usize
},
1208usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(ignore_formula_range)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet>())).ignore_formula_unlocked as *const _ as usize
},
1216usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(ignore_formula_unlocked)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet>())).ignore_empty_cell_reference as *const _
as usize
},
1224usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(ignore_empty_cell_reference)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet>())).ignore_list_data_validation as *const _
as usize
},
1232usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(ignore_list_data_validation)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet>())).ignore_calculated_column as *const _ as usize
},
1240usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(ignore_calculated_column)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet>())).ignore_two_digit_text_year as *const _
as usize
},
1248usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(ignore_two_digit_text_year)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).excel_version as *const _ as usize },
1256usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(excel_version)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet>())).header_footer_objs as *const _ as usize
},
1264usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(header_footer_objs)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet>())).header_left_object_props as *const _ as usize
},
1312usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(header_left_object_props)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet>())).header_center_object_props as *const _
as usize
},
1320usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(header_center_object_props)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet>())).header_right_object_props as *const _ as usize
},
1328usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(header_right_object_props)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet>())).footer_left_object_props as *const _ as usize
},
1336usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(footer_left_object_props)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet>())).footer_center_object_props as *const _
as usize
},
1344usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(footer_center_object_props)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet>())).footer_right_object_props as *const _ as usize
},
1352usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(footer_right_object_props)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet>())).list_pointers as *const _ as usize },
1360usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet),
"::",
stringify!(list_pointers)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct lxw_worksheet_init_data {
pub index: u32,
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() {
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::null::<lxw_worksheet_init_data>())).index as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet_init_data),
"::",
stringify!(index)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet_init_data>())).hidden as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet_init_data),
"::",
stringify!(hidden)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet_init_data>())).optimize as *const _ as usize
},
5usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet_init_data),
"::",
stringify!(optimize)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet_init_data>())).active_sheet as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet_init_data),
"::",
stringify!(active_sheet)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet_init_data>())).first_sheet as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet_init_data),
"::",
stringify!(first_sheet)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet_init_data>())).sst as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet_init_data),
"::",
stringify!(sst)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet_init_data>())).name as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet_init_data),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet_init_data>())).quoted_name as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet_init_data),
"::",
stringify!(quoted_name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet_init_data>())).tmpdir as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet_init_data),
"::",
stringify!(tmpdir)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet_init_data>())).default_url_format as *const _
as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet_init_data),
"::",
stringify!(default_url_format)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet_init_data>())).max_url_length as *const _ 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() {
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::null::<lxw_row__bindgen_ty_1>())).rbe_left as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_row__bindgen_ty_1),
"::",
stringify!(rbe_left)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_row__bindgen_ty_1>())).rbe_right as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_row__bindgen_ty_1),
"::",
stringify!(rbe_right)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_row__bindgen_ty_1>())).rbe_parent as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_row__bindgen_ty_1),
"::",
stringify!(rbe_parent)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_row__bindgen_ty_1>())).rbe_color as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_row__bindgen_ty_1),
"::",
stringify!(rbe_color)
)
);
}
#[test]
fn bindgen_test_layout_lxw_row() {
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::null::<lxw_row>())).row_num as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_row),
"::",
stringify!(row_num)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_row>())).height as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_row),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_row>())).format as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_row),
"::",
stringify!(format)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_row>())).hidden as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_row),
"::",
stringify!(hidden)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_row>())).level as *const _ as usize },
25usize,
concat!(
"Offset of field: ",
stringify!(lxw_row),
"::",
stringify!(level)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_row>())).collapsed as *const _ as usize },
26usize,
concat!(
"Offset of field: ",
stringify!(lxw_row),
"::",
stringify!(collapsed)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_row>())).row_changed as *const _ as usize },
27usize,
concat!(
"Offset of field: ",
stringify!(lxw_row),
"::",
stringify!(row_changed)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_row>())).data_changed as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(lxw_row),
"::",
stringify!(data_changed)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_row>())).height_changed as *const _ as usize },
29usize,
concat!(
"Offset of field: ",
stringify!(lxw_row),
"::",
stringify!(height_changed)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_row>())).cells as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_row),
"::",
stringify!(cells)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_row>())).tree_pointers as *const _ 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,
_bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout_lxw_cell__bindgen_ty_1() {
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::null::<lxw_cell__bindgen_ty_1>())).number as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_cell__bindgen_ty_1),
"::",
stringify!(number)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_cell__bindgen_ty_1>())).string_id as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_cell__bindgen_ty_1),
"::",
stringify!(string_id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_cell__bindgen_ty_1>())).string as *const _ 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() {
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::null::<lxw_cell__bindgen_ty_2>())).rbe_left as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_cell__bindgen_ty_2),
"::",
stringify!(rbe_left)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_cell__bindgen_ty_2>())).rbe_right as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_cell__bindgen_ty_2),
"::",
stringify!(rbe_right)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_cell__bindgen_ty_2>())).rbe_parent as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_cell__bindgen_ty_2),
"::",
stringify!(rbe_parent)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_cell__bindgen_ty_2>())).rbe_color as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_cell__bindgen_ty_2),
"::",
stringify!(rbe_color)
)
);
}
#[test]
fn bindgen_test_layout_lxw_cell() {
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::null::<lxw_cell>())).row_num as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_cell),
"::",
stringify!(row_num)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_cell>())).col_num as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(lxw_cell),
"::",
stringify!(col_num)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_cell>())).type_ as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_cell),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_cell>())).format as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_cell),
"::",
stringify!(format)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_cell>())).comment as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_cell),
"::",
stringify!(comment)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_cell>())).u as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_cell),
"::",
stringify!(u)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_cell>())).formula_result as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_cell),
"::",
stringify!(formula_result)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_cell>())).user_data1 as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_cell),
"::",
stringify!(user_data1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_cell>())).user_data2 as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(lxw_cell),
"::",
stringify!(user_data2)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_cell>())).sst_string as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(lxw_cell),
"::",
stringify!(sst_string)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_cell>())).tree_pointers as *const _ 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() {
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::null::<lxw_drawing_rel_id__bindgen_ty_1>())).rbe_left as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_rel_id__bindgen_ty_1),
"::",
stringify!(rbe_left)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_drawing_rel_id__bindgen_ty_1>())).rbe_right as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_rel_id__bindgen_ty_1),
"::",
stringify!(rbe_right)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_drawing_rel_id__bindgen_ty_1>())).rbe_parent as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_rel_id__bindgen_ty_1),
"::",
stringify!(rbe_parent)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_drawing_rel_id__bindgen_ty_1>())).rbe_color as *const _
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() {
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::null::<lxw_drawing_rel_id>())).id as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_rel_id),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_drawing_rel_id>())).target as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_drawing_rel_id),
"::",
stringify!(target)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_drawing_rel_id>())).tree_pointers as *const _ 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_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_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_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_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_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: size_t,
) -> 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: size_t,
options: *mut lxw_image_options,
) -> 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_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_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_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_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_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(
self_: *mut lxw_worksheet,
vml_header_id: u32,
vml_drawing_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: u32,
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() {
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::null::<lxw_chartsheet__bindgen_ty_1>())).stqe_next as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet__bindgen_ty_1),
"::",
stringify!(stqe_next)
)
);
}
#[test]
fn bindgen_test_layout_lxw_chartsheet() {
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::null::<lxw_chartsheet>())).file as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet),
"::",
stringify!(file)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chartsheet>())).worksheet as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet),
"::",
stringify!(worksheet)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chartsheet>())).chart as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet),
"::",
stringify!(chart)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chartsheet>())).protection as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet),
"::",
stringify!(protection)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chartsheet>())).is_protected as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet),
"::",
stringify!(is_protected)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chartsheet>())).name as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chartsheet>())).quoted_name as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet),
"::",
stringify!(quoted_name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chartsheet>())).tmpdir as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet),
"::",
stringify!(tmpdir)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chartsheet>())).index as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet),
"::",
stringify!(index)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chartsheet>())).active as *const _ as usize },
84usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet),
"::",
stringify!(active)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chartsheet>())).selected as *const _ as usize },
85usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet),
"::",
stringify!(selected)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chartsheet>())).hidden as *const _ as usize },
86usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet),
"::",
stringify!(hidden)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chartsheet>())).active_sheet as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet),
"::",
stringify!(active_sheet)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chartsheet>())).first_sheet as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet),
"::",
stringify!(first_sheet)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chartsheet>())).rel_count as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet),
"::",
stringify!(rel_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chartsheet>())).list_pointers as *const _ 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() {
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::null::<lxw_worksheet_names>())).rbh_root as *const _ 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() {
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::null::<lxw_chartsheet_names>())).rbh_root as *const _ 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() {
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::null::<lxw_image_md5s>())).rbh_root as *const _ 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() {
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::null::<lxw_sheets>())).stqh_first as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_sheets),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_sheets>())).stqh_last as *const _ 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() {
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::null::<lxw_worksheets>())).stqh_first as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheets),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheets>())).stqh_last as *const _ 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() {
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::null::<lxw_chartsheets>())).stqh_first as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheets),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chartsheets>())).stqh_last as *const _ 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() {
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::null::<lxw_charts>())).stqh_first as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_charts),
"::",
stringify!(stqh_first)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_charts>())).stqh_last as *const _ 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() {
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::null::<lxw_defined_names>())).tqh_first as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_defined_names),
"::",
stringify!(tqh_first)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_defined_names>())).tqh_last as *const _ 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,
_bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout_lxw_sheet__bindgen_ty_1() {
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::null::<lxw_sheet__bindgen_ty_1>())).worksheet as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_sheet__bindgen_ty_1),
"::",
stringify!(worksheet)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_sheet__bindgen_ty_1>())).chartsheet as *const _ 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() {
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::null::<lxw_sheet__bindgen_ty_2>())).stqe_next as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_sheet__bindgen_ty_2),
"::",
stringify!(stqe_next)
)
);
}
#[test]
fn bindgen_test_layout_lxw_sheet() {
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::null::<lxw_sheet>())).is_chartsheet as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_sheet),
"::",
stringify!(is_chartsheet)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_sheet>())).u as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_sheet),
"::",
stringify!(u)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_sheet>())).list_pointers as *const _ 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() {
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::null::<lxw_worksheet_name__bindgen_ty_1>())).rbe_left as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet_name__bindgen_ty_1),
"::",
stringify!(rbe_left)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet_name__bindgen_ty_1>())).rbe_right as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet_name__bindgen_ty_1),
"::",
stringify!(rbe_right)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet_name__bindgen_ty_1>())).rbe_parent as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet_name__bindgen_ty_1),
"::",
stringify!(rbe_parent)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet_name__bindgen_ty_1>())).rbe_color as *const _
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() {
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::null::<lxw_worksheet_name>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet_name),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_worksheet_name>())).worksheet as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_worksheet_name),
"::",
stringify!(worksheet)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_worksheet_name>())).tree_pointers as *const _ 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() {
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::null::<lxw_chartsheet_name__bindgen_ty_1>())).rbe_left as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet_name__bindgen_ty_1),
"::",
stringify!(rbe_left)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_chartsheet_name__bindgen_ty_1>())).rbe_right as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet_name__bindgen_ty_1),
"::",
stringify!(rbe_right)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_chartsheet_name__bindgen_ty_1>())).rbe_parent as *const _
as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet_name__bindgen_ty_1),
"::",
stringify!(rbe_parent)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_chartsheet_name__bindgen_ty_1>())).rbe_color as *const _
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() {
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::null::<lxw_chartsheet_name>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet_name),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_chartsheet_name>())).chartsheet as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_chartsheet_name),
"::",
stringify!(chartsheet)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_chartsheet_name>())).tree_pointers as *const _ 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() {
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::null::<lxw_image_md5__bindgen_ty_1>())).rbe_left as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_image_md5__bindgen_ty_1),
"::",
stringify!(rbe_left)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_image_md5__bindgen_ty_1>())).rbe_right as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_image_md5__bindgen_ty_1),
"::",
stringify!(rbe_right)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_image_md5__bindgen_ty_1>())).rbe_parent as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_image_md5__bindgen_ty_1),
"::",
stringify!(rbe_parent)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_image_md5__bindgen_ty_1>())).rbe_color as *const _ 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() {
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::null::<lxw_image_md5>())).id as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_image_md5),
"::",
stringify!(id)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_image_md5>())).md5 as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_image_md5),
"::",
stringify!(md5)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_image_md5>())).tree_pointers as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_image_md5),
"::",
stringify!(tree_pointers)
)
);
}
#[repr(C)]
#[derive(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() {
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::null::<lxw_defined_name__bindgen_ty_1>())).tqe_next as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_defined_name__bindgen_ty_1),
"::",
stringify!(tqe_next)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_defined_name__bindgen_ty_1>())).tqe_prev as *const _ 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() {
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::null::<lxw_defined_name>())).index as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_defined_name),
"::",
stringify!(index)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_defined_name>())).hidden as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(lxw_defined_name),
"::",
stringify!(hidden)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_defined_name>())).name as *const _ as usize },
3usize,
concat!(
"Offset of field: ",
stringify!(lxw_defined_name),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_defined_name>())).app_name as *const _ as usize },
131usize,
concat!(
"Offset of field: ",
stringify!(lxw_defined_name),
"::",
stringify!(app_name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_defined_name>())).formula as *const _ as usize },
259usize,
concat!(
"Offset of field: ",
stringify!(lxw_defined_name),
"::",
stringify!(formula)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_defined_name>())).normalised_name as *const _ as usize
},
387usize,
concat!(
"Offset of field: ",
stringify!(lxw_defined_name),
"::",
stringify!(normalised_name)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_defined_name>())).normalised_sheetname as *const _ as usize
},
515usize,
concat!(
"Offset of field: ",
stringify!(lxw_defined_name),
"::",
stringify!(normalised_sheetname)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_defined_name>())).list_pointers as *const _ 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() {
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::null::<lxw_doc_properties>())).title as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_doc_properties),
"::",
stringify!(title)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_doc_properties>())).subject as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_doc_properties),
"::",
stringify!(subject)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_doc_properties>())).author as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_doc_properties),
"::",
stringify!(author)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_doc_properties>())).manager as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_doc_properties),
"::",
stringify!(manager)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_doc_properties>())).company as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_doc_properties),
"::",
stringify!(company)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_doc_properties>())).category as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_doc_properties),
"::",
stringify!(category)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_doc_properties>())).keywords as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_doc_properties),
"::",
stringify!(keywords)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_doc_properties>())).comments as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(lxw_doc_properties),
"::",
stringify!(comments)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_doc_properties>())).status as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(lxw_doc_properties),
"::",
stringify!(status)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<lxw_doc_properties>())).hyperlink_base as *const _ as usize
},
72usize,
concat!(
"Offset of field: ",
stringify!(lxw_doc_properties),
"::",
stringify!(hyperlink_base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_doc_properties>())).created as *const _ 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,
}
#[test]
fn bindgen_test_layout_lxw_workbook_options() {
assert_eq!(
::std::mem::size_of::<lxw_workbook_options>(),
24usize,
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::null::<lxw_workbook_options>())).constant_memory as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook_options),
"::",
stringify!(constant_memory)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook_options>())).tmpdir as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook_options),
"::",
stringify!(tmpdir)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook_options>())).use_zip64 as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook_options),
"::",
stringify!(use_zip64)
)
);
}
#[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 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 has_png: u8,
pub has_jpeg: u8,
pub has_bmp: u8,
pub has_vml: u8,
pub has_comments: 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() {
assert_eq!(
::std::mem::size_of::<lxw_workbook>(),
232usize,
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::null::<lxw_workbook>())).file as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(file)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).sheets as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(sheets)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).worksheets as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(worksheets)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).chartsheets as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(chartsheets)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).worksheet_names as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(worksheet_names)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).chartsheet_names as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(chartsheet_names)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).image_md5s as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(image_md5s)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).header_image_md5s as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(header_image_md5s)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).charts as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(charts)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).ordered_charts as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(ordered_charts)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).formats as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(formats)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).defined_names as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(defined_names)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).sst as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(sst)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).properties as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(properties)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).custom_properties as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(custom_properties)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).filename as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(filename)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).options as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(options)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).num_sheets as *const _ as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(num_sheets)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).num_worksheets as *const _ as usize },
154usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(num_worksheets)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).num_chartsheets as *const _ as usize },
156usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(num_chartsheets)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).first_sheet as *const _ as usize },
158usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(first_sheet)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).active_sheet as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(active_sheet)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).num_xf_formats as *const _ as usize },
162usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(num_xf_formats)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).num_dxf_formats as *const _ as usize },
164usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(num_dxf_formats)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).num_format_count as *const _ as usize },
166usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(num_format_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).drawing_count as *const _ as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(drawing_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).comment_count as *const _ as usize },
170usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(comment_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).font_count as *const _ as usize },
172usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(font_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).border_count as *const _ as usize },
174usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(border_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).fill_count as *const _ as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(fill_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).optimize as *const _ as usize },
178usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(optimize)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).max_url_length as *const _ as usize },
180usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(max_url_length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).has_png as *const _ as usize },
182usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(has_png)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).has_jpeg as *const _ as usize },
183usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(has_jpeg)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).has_bmp as *const _ as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(has_bmp)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).has_vml as *const _ as usize },
185usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(has_vml)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).has_comments as *const _ as usize },
186usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(has_comments)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).used_xf_formats as *const _ as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(used_xf_formats)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).used_dxf_formats as *const _ as usize },
200usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(used_dxf_formats)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).vba_project as *const _ as usize },
208usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(vba_project)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).vba_codename as *const _ as usize },
216usize,
concat!(
"Offset of field: ",
stringify!(lxw_workbook),
"::",
stringify!(vba_codename)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<lxw_workbook>())).default_url_format as *const _ as usize },
224usize,
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 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);
}