#![allow(
dead_code,
non_camel_case_types,
non_upper_case_globals,
non_snake_case
)]
use std::fmt::Debug;
pub const NK_UNDEFINED: f64 = -1.0;
pub const NK_UTF_INVALID: u32 = 65533;
pub const NK_UTF_SIZE: u32 = 4;
pub const NK_INPUT_MAX: u32 = 16;
pub const NK_MAX_NUMBER_BUFFER: u32 = 64;
pub const NK_SCROLLBAR_HIDING_TIMEOUT: f64 = 4.0;
pub const NK_TEXTEDIT_UNDOSTATECOUNT: u32 = 99;
pub const NK_TEXTEDIT_UNDOCHARCOUNT: u32 = 999;
pub const NK_MAX_LAYOUT_ROW_TEMPLATE_COLUMNS: u32 = 16;
pub const NK_CHART_MAX_SLOT: u32 = 4;
pub const NK_WINDOW_MAX_NAME: u32 = 64;
pub const NK_BUTTON_BEHAVIOR_STACK_SIZE: u32 = 8;
pub const NK_FONT_STACK_SIZE: u32 = 8;
pub const NK_STYLE_ITEM_STACK_SIZE: u32 = 16;
pub const NK_FLOAT_STACK_SIZE: u32 = 32;
pub const NK_VECTOR_STACK_SIZE: u32 = 16;
pub const NK_FLAGS_STACK_SIZE: u32 = 32;
pub const NK_COLOR_STACK_SIZE: u32 = 32;
pub const NK_PI: f64 = ::std::f64::consts::PI;
pub const NK_MAX_FLOAT_PRECISION: u32 = 2;
pub type nk_char = ::std::os::raw::c_schar;
pub type nk_uchar = ::std::os::raw::c_uchar;
pub type nk_byte = ::std::os::raw::c_uchar;
pub type nk_short = ::std::os::raw::c_short;
pub type nk_ushort = ::std::os::raw::c_ushort;
pub type nk_int = ::std::os::raw::c_int;
pub type nk_uint = ::std::os::raw::c_uint;
pub type nk_size = usize;
pub type nk_ptr = usize;
pub type nk_hash = nk_uint;
pub type nk_flags = nk_uint;
pub type nk_rune = nk_uint;
pub type _dummy_array415 = [::std::os::raw::c_char; 1usize];
pub type _dummy_array416 = [::std::os::raw::c_char; 1usize];
pub type _dummy_array417 = [::std::os::raw::c_char; 1usize];
pub type _dummy_array418 = [::std::os::raw::c_char; 1usize];
pub type _dummy_array419 = [::std::os::raw::c_char; 1usize];
pub type _dummy_array420 = [::std::os::raw::c_char; 1usize];
pub type _dummy_array421 = [::std::os::raw::c_char; 1usize];
pub type _dummy_array422 = [::std::os::raw::c_char; 1usize];
pub type _dummy_array423 = [::std::os::raw::c_char; 1usize];
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nk_style_slide {
_unused: [u8; 0],
}
pub const nk_false: _bindgen_ty_1 = 0;
pub const nk_true: _bindgen_ty_1 = 1;
pub type _bindgen_ty_1 = u32;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone, PartialEq, Eq)]
pub struct nk_color {
pub r: nk_byte,
pub g: nk_byte,
pub b: nk_byte,
pub a: nk_byte,
}
impl From<u32> for nk_color {
fn from(v: u32) -> Self {
let v = v.to_be_bytes();
nk_color {
r: v[0],
g: v[1],
b: v[2],
a: v[3],
}
}
}
impl From<[u8; 4usize]> for nk_color {
fn from(v: [u8; 4usize]) -> Self {
nk_color {
r: v[0],
g: v[1],
b: v[2],
a: v[3],
}
}
}
impl From<(u8, u8, u8, u8)> for nk_color {
fn from(v: (u8, u8, u8, u8)) -> Self {
nk_color {
r: v.0,
g: v.1,
b: v.2,
a: v.3,
}
}
}
impl From<(f32, f32, f32, f32)> for nk_color {
fn from(v: (f32, f32, f32, f32)) -> Self {
nk_color {
r: (v.0 * 255.0).round() as u8,
g: (v.1 * 255.0).round() as u8,
b: (v.2 * 255.0).round() as u8,
a: (v.3 * 255.0).round() as u8,
}
}
}
impl From<nk_color> for u32 {
fn from(v: nk_color) -> Self {
u32::from_be_bytes([v.r, v.g, v.b, v.a])
}
}
impl From<nk_color> for [u8; 4usize] {
fn from(v: nk_color) -> Self {
[v.r, v.g, v.b, v.a]
}
}
impl From<nk_color> for (u8, u8, u8, u8) {
fn from(v: nk_color) -> Self {
(v.r, v.g, v.b, v.a)
}
}
impl From<nk_color> for (f32, f32, f32, f32) {
fn from(v: nk_color) -> Self {
(
v.r as f32 / 255.0,
v.g as f32 / 255.0,
v.b as f32 / 255.0,
v.a as f32 / 255.0,
)
}
}
impl nk_color {
pub fn inverted(&self) -> Self {
Self {
r: 255 - self.r,
g: 255 - self.g,
b: 255 - self.b,
a: self.a,
}
}
#[inline]
pub fn rgb_f(r: f32, g: f32, b: f32) -> Self {
unsafe { nk_rgb_f(r, g, b) }
}
}
#[test]
fn bindgen_test_layout_nk_color() {
assert_eq!(
::std::mem::size_of::<nk_color>(),
4usize,
concat!("Size of: ", stringify!(nk_color))
);
assert_eq!(
::std::mem::align_of::<nk_color>(),
1usize,
concat!("Alignment of ", stringify!(nk_color))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_color>())).r as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_color),
"::",
stringify!(r)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_color>())).g as *const _ as usize },
1usize,
concat!(
"Offset of field: ",
stringify!(nk_color),
"::",
stringify!(g)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_color>())).b as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(nk_color),
"::",
stringify!(b)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_color>())).a as *const _ as usize },
3usize,
concat!(
"Offset of field: ",
stringify!(nk_color),
"::",
stringify!(a)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct nk_colorf {
pub r: f32,
pub g: f32,
pub b: f32,
pub a: f32,
}
#[test]
fn bindgen_test_layout_nk_colorf() {
assert_eq!(
::std::mem::size_of::<nk_colorf>(),
16usize,
concat!("Size of: ", stringify!(nk_colorf))
);
assert_eq!(
::std::mem::align_of::<nk_colorf>(),
4usize,
concat!("Alignment of ", stringify!(nk_colorf))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_colorf>())).r as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_colorf),
"::",
stringify!(r)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_colorf>())).g as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(nk_colorf),
"::",
stringify!(g)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_colorf>())).b as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_colorf),
"::",
stringify!(b)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_colorf>())).a as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(nk_colorf),
"::",
stringify!(a)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct nk_vec2 {
pub x: f32,
pub y: f32,
}
impl From<nk_vec2i> for nk_vec2 {
fn from(v: nk_vec2i) -> nk_vec2 {
nk_vec2 {
x: v.x as f32,
y: v.y as f32,
}
}
}
impl From<(f32, f32)> for nk_vec2 {
fn from((x, y): (f32, f32)) -> nk_vec2 {
nk_vec2 { x, y }
}
}
impl From<(i16, i16)> for nk_vec2 {
fn from((x, y): (i16, i16)) -> nk_vec2 {
nk_vec2 {
x: x as f32,
y: y as f32,
}
}
}
impl From<(i32, i32)> for nk_vec2 {
fn from((x, y): (i32, i32)) -> nk_vec2 {
nk_vec2 {
x: x as f32,
y: y as f32,
}
}
}
impl From<[f32; 2usize]> for nk_vec2 {
fn from(v: [f32; 2usize]) -> nk_vec2 {
nk_vec2 { x: v[0], y: v[1] }
}
}
impl From<[i16; 2usize]> for nk_vec2 {
fn from(v: [i16; 2usize]) -> nk_vec2 {
nk_vec2 {
x: v[0] as f32,
y: v[1] as f32,
}
}
}
impl From<[i32; 2usize]> for nk_vec2 {
fn from(v: [i32; 2usize]) -> nk_vec2 {
nk_vec2 {
x: v[0] as f32,
y: v[1] as f32,
}
}
}
impl From<nk_vec2> for (f32, f32) {
fn from(v: nk_vec2) -> (f32, f32) {
(v.x, v.y)
}
}
impl From<nk_vec2> for (i16, i16) {
fn from(v: nk_vec2) -> (i16, i16) {
(v.x as i16, v.y as i16)
}
}
impl From<nk_vec2> for (i32, i32) {
fn from(v: nk_vec2) -> (i32, i32) {
(v.x as i32, v.y as i32)
}
}
impl From<nk_vec2> for [f32; 2usize] {
fn from(v: nk_vec2) -> [f32; 2usize] {
[v.x, v.y]
}
}
impl From<nk_vec2> for [i16; 2usize] {
fn from(v: nk_vec2) -> [i16; 2usize] {
[v.x as i16, v.y as i16]
}
}
impl From<nk_vec2> for [i32; 2usize] {
fn from(v: nk_vec2) -> [i32; 2usize] {
[v.x as i32, v.y as i32]
}
}
#[test]
fn bindgen_test_layout_nk_vec2() {
assert_eq!(
::std::mem::size_of::<nk_vec2>(),
8usize,
concat!("Size of: ", stringify!(nk_vec2))
);
assert_eq!(
::std::mem::align_of::<nk_vec2>(),
4usize,
concat!("Alignment of ", stringify!(nk_vec2))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_vec2>())).x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_vec2),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_vec2>())).y as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(nk_vec2),
"::",
stringify!(y)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct nk_vec2i {
pub x: ::std::os::raw::c_short,
pub y: ::std::os::raw::c_short,
}
impl From<nk_vec2> for nk_vec2i {
fn from(v: nk_vec2) -> nk_vec2i {
nk_vec2i {
x: v.x as i16,
y: v.y as i16,
}
}
}
impl From<(f32, f32)> for nk_vec2i {
fn from((x, y): (f32, f32)) -> nk_vec2i {
nk_vec2i {
x: x as i16,
y: y as i16,
}
}
}
impl From<(i16, i16)> for nk_vec2i {
fn from((x, y): (i16, i16)) -> nk_vec2i {
nk_vec2i { x, y }
}
}
impl From<(i32, i32)> for nk_vec2i {
fn from((x, y): (i32, i32)) -> nk_vec2i {
nk_vec2i {
x: x as i16,
y: y as i16,
}
}
}
impl From<[f32; 2usize]> for nk_vec2i {
fn from(v: [f32; 2usize]) -> nk_vec2i {
nk_vec2i {
x: v[0] as i16,
y: v[1] as i16,
}
}
}
impl From<[i16; 2usize]> for nk_vec2i {
fn from(v: [i16; 2usize]) -> nk_vec2i {
nk_vec2i { x: v[0], y: v[1] }
}
}
impl From<[i32; 2usize]> for nk_vec2i {
fn from(v: [i32; 2usize]) -> nk_vec2i {
nk_vec2i {
x: v[0] as i16,
y: v[1] as i16,
}
}
}
impl From<nk_vec2i> for (f32, f32) {
fn from(v: nk_vec2i) -> (f32, f32) {
(v.x as f32, v.y as f32)
}
}
impl From<nk_vec2i> for (i16, i16) {
fn from(v: nk_vec2i) -> (i16, i16) {
(v.x as i16, v.y as i16)
}
}
impl From<nk_vec2i> for (i32, i32) {
fn from(v: nk_vec2i) -> (i32, i32) {
(v.x as i32, v.y as i32)
}
}
impl From<nk_vec2i> for [f32; 2usize] {
fn from(v: nk_vec2i) -> [f32; 2usize] {
[v.x as f32, v.y as f32]
}
}
impl From<nk_vec2i> for [i16; 2usize] {
fn from(v: nk_vec2i) -> [i16; 2usize] {
[v.x as i16, v.y as i16]
}
}
impl From<nk_vec2i> for [i32; 2usize] {
fn from(v: nk_vec2i) -> [i32; 2usize] {
[v.x as i32, v.y as i32]
}
}
#[test]
fn bindgen_test_layout_nk_vec2i() {
assert_eq!(
::std::mem::size_of::<nk_vec2i>(),
4usize,
concat!("Size of: ", stringify!(nk_vec2i))
);
assert_eq!(
::std::mem::align_of::<nk_vec2i>(),
2usize,
concat!("Alignment of ", stringify!(nk_vec2i))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_vec2i>())).x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_vec2i),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_vec2i>())).y as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(nk_vec2i),
"::",
stringify!(y)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct nk_rect {
pub x: f32,
pub y: f32,
pub w: f32,
pub h: f32,
}
impl From<(nk_vec2, nk_vec2)> for nk_rect {
fn from((pos, size): (nk_vec2, nk_vec2)) -> nk_rect {
nk_rect {
x: pos.x,
y: pos.y,
w: size.x,
h: size.y,
}
}
}
impl From<(f32, f32, f32, f32)> for nk_rect {
fn from((x, y, w, h): (f32, f32, f32, f32)) -> nk_rect {
nk_rect { x, y, w, h }
}
}
impl From<[f32; 4usize]> for nk_rect {
fn from(v: [f32; 4usize]) -> nk_rect {
nk_rect {
x: v[0],
y: v[1],
w: v[2],
h: v[3],
}
}
}
impl From<nk_rect> for (nk_vec2, nk_vec2) {
fn from(rect: nk_rect) -> (nk_vec2, nk_vec2) {
(
nk_vec2 {
x: rect.x,
y: rect.y,
},
nk_vec2 {
x: rect.w,
y: rect.h,
},
)
}
}
impl From<nk_rect> for (f32, f32, f32, f32) {
fn from(rect: nk_rect) -> (f32, f32, f32, f32) {
(rect.x, rect.y, rect.w, rect.h)
}
}
impl From<nk_rect> for [f32; 4usize] {
fn from(rect: nk_rect) -> [f32; 4usize] {
[rect.x, rect.y, rect.w, rect.h]
}
}
#[test]
fn bindgen_test_layout_nk_rect() {
assert_eq!(
::std::mem::size_of::<nk_rect>(),
16usize,
concat!("Size of: ", stringify!(nk_rect))
);
assert_eq!(
::std::mem::align_of::<nk_rect>(),
4usize,
concat!("Alignment of ", stringify!(nk_rect))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_rect>())).x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_rect),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_rect>())).y as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(nk_rect),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_rect>())).w as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_rect),
"::",
stringify!(w)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_rect>())).h as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(nk_rect),
"::",
stringify!(h)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct nk_recti {
pub x: ::std::os::raw::c_short,
pub y: ::std::os::raw::c_short,
pub w: ::std::os::raw::c_short,
pub h: ::std::os::raw::c_short,
}
#[test]
fn bindgen_test_layout_nk_recti() {
assert_eq!(
::std::mem::size_of::<nk_recti>(),
8usize,
concat!("Size of: ", stringify!(nk_recti))
);
assert_eq!(
::std::mem::align_of::<nk_recti>(),
2usize,
concat!("Alignment of ", stringify!(nk_recti))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_recti>())).x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_recti),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_recti>())).y as *const _ as usize },
2usize,
concat!(
"Offset of field: ",
stringify!(nk_recti),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_recti>())).w as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(nk_recti),
"::",
stringify!(w)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_recti>())).h as *const _ as usize },
6usize,
concat!(
"Offset of field: ",
stringify!(nk_recti),
"::",
stringify!(h)
)
);
}
pub type nk_glyph = [::std::os::raw::c_char; 4usize];
#[repr(C)]
#[derive(Copy, Clone)]
pub union nk_handle {
pub ptr: *mut ::std::os::raw::c_void,
pub id: ::std::os::raw::c_int,
_bindgen_union_align: u64,
}
#[test]
fn bindgen_test_layout_nk_handle() {
assert_eq!(
::std::mem::size_of::<nk_handle>(),
8usize,
concat!("Size of: ", stringify!(nk_handle))
);
assert_eq!(
::std::mem::align_of::<nk_handle>(),
8usize,
concat!("Alignment of ", stringify!(nk_handle))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_handle>())).ptr as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_handle),
"::",
stringify!(ptr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_handle>())).id as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_handle),
"::",
stringify!(id)
)
);
}
impl Default for nk_handle {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
impl Debug for nk_handle {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
unsafe {
f.debug_struct("nk_handle")
.field("ptr", &self.ptr)
.field("id", &self.id)
.finish()
}
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_image {
pub handle: nk_handle,
pub w: ::std::os::raw::c_ushort,
pub h: ::std::os::raw::c_ushort,
pub region: [::std::os::raw::c_ushort; 4usize],
}
#[test]
fn bindgen_test_layout_nk_image() {
assert_eq!(
::std::mem::size_of::<nk_image>(),
24usize,
concat!("Size of: ", stringify!(nk_image))
);
assert_eq!(
::std::mem::align_of::<nk_image>(),
8usize,
concat!("Alignment of ", stringify!(nk_image))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_image>())).handle as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_image),
"::",
stringify!(handle)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_image>())).w as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_image),
"::",
stringify!(w)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_image>())).h as *const _ as usize },
10usize,
concat!(
"Offset of field: ",
stringify!(nk_image),
"::",
stringify!(h)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_image>())).region as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(nk_image),
"::",
stringify!(region)
)
);
}
impl Default for nk_image {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_cursor {
pub img: nk_image,
pub size: nk_vec2,
pub offset: nk_vec2,
}
#[test]
fn bindgen_test_layout_nk_cursor() {
assert_eq!(
::std::mem::size_of::<nk_cursor>(),
40usize,
concat!("Size of: ", stringify!(nk_cursor))
);
assert_eq!(
::std::mem::align_of::<nk_cursor>(),
8usize,
concat!("Alignment of ", stringify!(nk_cursor))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_cursor>())).img as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_cursor),
"::",
stringify!(img)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_cursor>())).size as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(nk_cursor),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_cursor>())).offset as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_cursor),
"::",
stringify!(offset)
)
);
}
impl Default for nk_cursor {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct nk_scroll {
pub x: nk_uint,
pub y: nk_uint,
}
#[test]
fn bindgen_test_layout_nk_scroll() {
assert_eq!(
::std::mem::size_of::<nk_scroll>(),
8usize,
concat!("Size of: ", stringify!(nk_scroll))
);
assert_eq!(
::std::mem::align_of::<nk_scroll>(),
4usize,
concat!("Alignment of ", stringify!(nk_scroll))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_scroll>())).x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_scroll),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_scroll>())).y as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(nk_scroll),
"::",
stringify!(y)
)
);
}
pub const nk_heading_NK_UP: nk_heading = 0;
pub const nk_heading_NK_RIGHT: nk_heading = 1;
pub const nk_heading_NK_DOWN: nk_heading = 2;
pub const nk_heading_NK_LEFT: nk_heading = 3;
pub type nk_heading = u32;
pub const nk_button_behavior_NK_BUTTON_DEFAULT: nk_button_behavior = 0;
pub const nk_button_behavior_NK_BUTTON_REPEATER: nk_button_behavior = 1;
pub type nk_button_behavior = u32;
pub const nk_modify_NK_FIXED: nk_modify = 0;
pub const nk_modify_NK_MODIFIABLE: nk_modify = 1;
pub type nk_modify = u32;
pub const nk_orientation_NK_VERTICAL: nk_orientation = 0;
pub const nk_orientation_NK_HORIZONTAL: nk_orientation = 1;
pub type nk_orientation = u32;
pub const nk_collapse_states_NK_MINIMIZED: nk_collapse_states = 0;
pub const nk_collapse_states_NK_MAXIMIZED: nk_collapse_states = 1;
pub type nk_collapse_states = u32;
pub const nk_show_states_NK_HIDDEN: nk_show_states = 0;
pub const nk_show_states_NK_SHOWN: nk_show_states = 1;
pub type nk_show_states = u32;
pub const nk_chart_type_NK_CHART_LINES: nk_chart_type = 0;
pub const nk_chart_type_NK_CHART_COLUMN: nk_chart_type = 1;
pub const nk_chart_type_NK_CHART_MAX: nk_chart_type = 2;
pub type nk_chart_type = u32;
pub const nk_chart_event_NK_CHART_HOVERING: nk_chart_event = 1;
pub const nk_chart_event_NK_CHART_CLICKED: nk_chart_event = 2;
pub type nk_chart_event = u32;
pub const nk_color_format_NK_RGB: nk_color_format = 0;
pub const nk_color_format_NK_RGBA: nk_color_format = 1;
pub type nk_color_format = u32;
pub const nk_popup_type_NK_POPUP_STATIC: nk_popup_type = 0;
pub const nk_popup_type_NK_POPUP_DYNAMIC: nk_popup_type = 1;
pub type nk_popup_type = u32;
pub const nk_layout_format_NK_DYNAMIC: nk_layout_format = 0;
pub const nk_layout_format_NK_STATIC: nk_layout_format = 1;
pub type nk_layout_format = u32;
pub const nk_tree_type_NK_TREE_NODE: nk_tree_type = 0;
pub const nk_tree_type_NK_TREE_TAB: nk_tree_type = 1;
pub type nk_tree_type = u32;
pub type nk_plugin_alloc = ::std::option::Option<
unsafe extern "C" fn(
arg1: nk_handle,
old: *mut ::std::os::raw::c_void,
arg2: nk_size,
) -> *mut ::std::os::raw::c_void,
>;
pub type nk_plugin_free =
::std::option::Option<unsafe extern "C" fn(arg1: nk_handle, old: *mut ::std::os::raw::c_void)>;
pub type nk_plugin_filter = ::std::option::Option<
unsafe extern "C" fn(arg1: *const nk_text_edit, unicode: nk_rune) -> ::std::os::raw::c_int,
>;
pub type nk_plugin_paste =
::std::option::Option<unsafe extern "C" fn(arg1: nk_handle, arg2: *mut nk_text_edit)>;
pub type nk_plugin_copy = ::std::option::Option<
unsafe extern "C" fn(
arg1: nk_handle,
arg2: *const ::std::os::raw::c_char,
len: ::std::os::raw::c_int,
),
>;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_allocator {
pub userdata: nk_handle,
pub alloc: nk_plugin_alloc,
pub free: nk_plugin_free,
}
#[test]
fn bindgen_test_layout_nk_allocator() {
assert_eq!(
::std::mem::size_of::<nk_allocator>(),
24usize,
concat!("Size of: ", stringify!(nk_allocator))
);
assert_eq!(
::std::mem::align_of::<nk_allocator>(),
8usize,
concat!("Alignment of ", stringify!(nk_allocator))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_allocator>())).userdata as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_allocator),
"::",
stringify!(userdata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_allocator>())).alloc as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_allocator),
"::",
stringify!(alloc)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_allocator>())).free as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(nk_allocator),
"::",
stringify!(free)
)
);
}
impl Default for nk_allocator {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
impl Debug for nk_allocator {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("nk_allocator")
.field("userdata", &self.userdata)
.field("alloc", &self.alloc)
.field("free", &self.free)
.finish()
}
}
pub const nk_symbol_type_NK_SYMBOL_NONE: nk_symbol_type = 0;
pub const nk_symbol_type_NK_SYMBOL_X: nk_symbol_type = 1;
pub const nk_symbol_type_NK_SYMBOL_UNDERSCORE: nk_symbol_type = 2;
pub const nk_symbol_type_NK_SYMBOL_CIRCLE_SOLID: nk_symbol_type = 3;
pub const nk_symbol_type_NK_SYMBOL_CIRCLE_OUTLINE: nk_symbol_type = 4;
pub const nk_symbol_type_NK_SYMBOL_RECT_SOLID: nk_symbol_type = 5;
pub const nk_symbol_type_NK_SYMBOL_RECT_OUTLINE: nk_symbol_type = 6;
pub const nk_symbol_type_NK_SYMBOL_TRIANGLE_UP: nk_symbol_type = 7;
pub const nk_symbol_type_NK_SYMBOL_TRIANGLE_DOWN: nk_symbol_type = 8;
pub const nk_symbol_type_NK_SYMBOL_TRIANGLE_LEFT: nk_symbol_type = 9;
pub const nk_symbol_type_NK_SYMBOL_TRIANGLE_RIGHT: nk_symbol_type = 10;
pub const nk_symbol_type_NK_SYMBOL_PLUS: nk_symbol_type = 11;
pub const nk_symbol_type_NK_SYMBOL_MINUS: nk_symbol_type = 12;
pub const nk_symbol_type_NK_SYMBOL_MAX: nk_symbol_type = 13;
pub type nk_symbol_type = u32;
extern "C" {
pub fn nk_init_fixed(
arg1: *mut nk_context,
memory: *mut ::std::os::raw::c_void,
size: nk_size,
arg2: *const nk_user_font,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_init(
arg1: *mut nk_context,
arg2: *mut nk_allocator,
arg3: *const nk_user_font,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_init_custom(
arg1: *mut nk_context,
cmds: *mut nk_buffer,
pool: *mut nk_buffer,
arg2: *const nk_user_font,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_clear(arg1: *mut nk_context);
}
extern "C" {
pub fn nk_free(arg1: *mut nk_context);
}
extern "C" {
pub fn nk_set_user_data(arg1: *mut nk_context, handle: nk_handle);
}
pub const nk_keys_NK_KEY_NONE: nk_keys = 0;
pub const nk_keys_NK_KEY_SHIFT: nk_keys = 1;
pub const nk_keys_NK_KEY_CTRL: nk_keys = 2;
pub const nk_keys_NK_KEY_DEL: nk_keys = 3;
pub const nk_keys_NK_KEY_ENTER: nk_keys = 4;
pub const nk_keys_NK_KEY_TAB: nk_keys = 5;
pub const nk_keys_NK_KEY_BACKSPACE: nk_keys = 6;
pub const nk_keys_NK_KEY_COPY: nk_keys = 7;
pub const nk_keys_NK_KEY_CUT: nk_keys = 8;
pub const nk_keys_NK_KEY_PASTE: nk_keys = 9;
pub const nk_keys_NK_KEY_UP: nk_keys = 10;
pub const nk_keys_NK_KEY_DOWN: nk_keys = 11;
pub const nk_keys_NK_KEY_LEFT: nk_keys = 12;
pub const nk_keys_NK_KEY_RIGHT: nk_keys = 13;
pub const nk_keys_NK_KEY_TEXT_INSERT_MODE: nk_keys = 14;
pub const nk_keys_NK_KEY_TEXT_REPLACE_MODE: nk_keys = 15;
pub const nk_keys_NK_KEY_TEXT_RESET_MODE: nk_keys = 16;
pub const nk_keys_NK_KEY_TEXT_LINE_START: nk_keys = 17;
pub const nk_keys_NK_KEY_TEXT_LINE_END: nk_keys = 18;
pub const nk_keys_NK_KEY_TEXT_START: nk_keys = 19;
pub const nk_keys_NK_KEY_TEXT_END: nk_keys = 20;
pub const nk_keys_NK_KEY_TEXT_UNDO: nk_keys = 21;
pub const nk_keys_NK_KEY_TEXT_REDO: nk_keys = 22;
pub const nk_keys_NK_KEY_TEXT_SELECT_ALL: nk_keys = 23;
pub const nk_keys_NK_KEY_TEXT_WORD_LEFT: nk_keys = 24;
pub const nk_keys_NK_KEY_TEXT_WORD_RIGHT: nk_keys = 25;
pub const nk_keys_NK_KEY_SCROLL_START: nk_keys = 26;
pub const nk_keys_NK_KEY_SCROLL_END: nk_keys = 27;
pub const nk_keys_NK_KEY_SCROLL_DOWN: nk_keys = 28;
pub const nk_keys_NK_KEY_SCROLL_UP: nk_keys = 29;
pub const nk_keys_NK_KEY_MAX: nk_keys = 30;
pub type nk_keys = u32;
pub const nk_buttons_NK_BUTTON_LEFT: nk_buttons = 0;
pub const nk_buttons_NK_BUTTON_MIDDLE: nk_buttons = 1;
pub const nk_buttons_NK_BUTTON_RIGHT: nk_buttons = 2;
pub const nk_buttons_NK_BUTTON_DOUBLE: nk_buttons = 3;
pub const nk_buttons_NK_BUTTON_MAX: nk_buttons = 4;
pub type nk_buttons = u32;
extern "C" {
pub fn nk_input_begin(arg1: *mut nk_context);
}
extern "C" {
pub fn nk_input_motion(
arg1: *mut nk_context,
x: ::std::os::raw::c_int,
y: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn nk_input_key(arg1: *mut nk_context, arg2: nk_keys, down: ::std::os::raw::c_int);
}
extern "C" {
pub fn nk_input_button(
arg1: *mut nk_context,
arg2: nk_buttons,
x: ::std::os::raw::c_int,
y: ::std::os::raw::c_int,
down: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn nk_input_scroll(arg1: *mut nk_context, val: nk_vec2);
}
extern "C" {
pub fn nk_input_char(arg1: *mut nk_context, arg2: ::std::os::raw::c_char);
}
extern "C" {
pub fn nk_input_glyph(arg1: *mut nk_context, arg2: *mut ::std::os::raw::c_char);
}
extern "C" {
pub fn nk_input_unicode(arg1: *mut nk_context, arg2: nk_rune);
}
extern "C" {
pub fn nk_input_end(arg1: *mut nk_context);
}
pub const nk_anti_aliasing_NK_ANTI_ALIASING_OFF: nk_anti_aliasing = 0;
pub const nk_anti_aliasing_NK_ANTI_ALIASING_ON: nk_anti_aliasing = 1;
pub type nk_anti_aliasing = u32;
pub const nk_convert_result_NK_CONVERT_SUCCESS: nk_convert_result = 0;
pub const nk_convert_result_NK_CONVERT_INVALID_PARAM: nk_convert_result = 1;
pub const nk_convert_result_NK_CONVERT_COMMAND_BUFFER_FULL: nk_convert_result = 2;
pub const nk_convert_result_NK_CONVERT_VERTEX_BUFFER_FULL: nk_convert_result = 4;
pub const nk_convert_result_NK_CONVERT_ELEMENT_BUFFER_FULL: nk_convert_result = 8;
pub type nk_convert_result = u32;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_draw_null_texture {
pub texture: nk_handle,
pub uv: nk_vec2,
}
#[test]
fn bindgen_test_layout_nk_draw_null_texture() {
assert_eq!(
::std::mem::size_of::<nk_draw_null_texture>(),
16usize,
concat!("Size of: ", stringify!(nk_draw_null_texture))
);
assert_eq!(
::std::mem::align_of::<nk_draw_null_texture>(),
8usize,
concat!("Alignment of ", stringify!(nk_draw_null_texture))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_draw_null_texture>())).texture as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_draw_null_texture),
"::",
stringify!(texture)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_draw_null_texture>())).uv as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_draw_null_texture),
"::",
stringify!(uv)
)
);
}
impl Default for nk_draw_null_texture {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
impl Debug for nk_draw_null_texture {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("nk_draw_null_texture")
.field("texture", &self.texture)
.field("uv", &self.uv)
.finish()
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_convert_config {
pub global_alpha: f32,
pub line_AA: nk_anti_aliasing,
pub shape_AA: nk_anti_aliasing,
pub circle_segment_count: ::std::os::raw::c_uint,
pub arc_segment_count: ::std::os::raw::c_uint,
pub curve_segment_count: ::std::os::raw::c_uint,
pub null: nk_draw_null_texture,
pub vertex_layout: *const nk_draw_vertex_layout_element,
pub vertex_size: nk_size,
pub vertex_alignment: nk_size,
}
#[test]
fn bindgen_test_layout_nk_convert_config() {
assert_eq!(
::std::mem::size_of::<nk_convert_config>(),
64usize,
concat!("Size of: ", stringify!(nk_convert_config))
);
assert_eq!(
::std::mem::align_of::<nk_convert_config>(),
8usize,
concat!("Alignment of ", stringify!(nk_convert_config))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_convert_config>())).global_alpha as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_convert_config),
"::",
stringify!(global_alpha)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_convert_config>())).line_AA as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(nk_convert_config),
"::",
stringify!(line_AA)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_convert_config>())).shape_AA as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_convert_config),
"::",
stringify!(shape_AA)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_convert_config>())).circle_segment_count as *const _ as usize
},
12usize,
concat!(
"Offset of field: ",
stringify!(nk_convert_config),
"::",
stringify!(circle_segment_count)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_convert_config>())).arc_segment_count as *const _ as usize
},
16usize,
concat!(
"Offset of field: ",
stringify!(nk_convert_config),
"::",
stringify!(arc_segment_count)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_convert_config>())).curve_segment_count as *const _ as usize
},
20usize,
concat!(
"Offset of field: ",
stringify!(nk_convert_config),
"::",
stringify!(curve_segment_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_convert_config>())).null as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(nk_convert_config),
"::",
stringify!(null)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_convert_config>())).vertex_layout as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(nk_convert_config),
"::",
stringify!(vertex_layout)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_convert_config>())).vertex_size as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(nk_convert_config),
"::",
stringify!(vertex_size)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_convert_config>())).vertex_alignment as *const _ as usize
},
56usize,
concat!(
"Offset of field: ",
stringify!(nk_convert_config),
"::",
stringify!(vertex_alignment)
)
);
}
impl Default for nk_convert_config {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
impl Debug for nk_convert_config {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("nk_convert_config")
.field("global_alpha", &self.global_alpha)
.field("line_AA", &self.line_AA)
.field("shape_AA", &self.shape_AA)
.field("circle_segment_count", &self.circle_segment_count)
.field("arc_segment_count", &self.arc_segment_count)
.field("curve_segment_count", &self.curve_segment_count)
.field("null", &self.null)
.field("vertex_layout", &self.vertex_layout)
.field("vertex_size", &self.vertex_size)
.field("vertex_alignment", &self.vertex_alignment)
.finish()
}
}
extern "C" {
pub fn nk__begin(arg1: *mut nk_context) -> *const nk_command;
}
extern "C" {
pub fn nk__next(arg1: *mut nk_context, arg2: *const nk_command) -> *const nk_command;
}
extern "C" {
pub fn nk_convert(
arg1: *mut nk_context,
cmds: *mut nk_buffer,
vertices: *mut nk_buffer,
elements: *mut nk_buffer,
arg2: *const nk_convert_config,
) -> nk_flags;
}
extern "C" {
pub fn nk__draw_begin(
arg1: *const nk_context,
arg2: *const nk_buffer,
) -> *const nk_draw_command;
}
extern "C" {
pub fn nk__draw_end(arg1: *const nk_context, arg2: *const nk_buffer) -> *const nk_draw_command;
}
extern "C" {
pub fn nk__draw_next(
arg1: *const nk_draw_command,
arg2: *const nk_buffer,
arg3: *const nk_context,
) -> *const nk_draw_command;
}
pub const nk_panel_flags_NK_WINDOW_BORDER: nk_panel_flags = 1;
pub const nk_panel_flags_NK_WINDOW_MOVABLE: nk_panel_flags = 2;
pub const nk_panel_flags_NK_WINDOW_SCALABLE: nk_panel_flags = 4;
pub const nk_panel_flags_NK_WINDOW_CLOSABLE: nk_panel_flags = 8;
pub const nk_panel_flags_NK_WINDOW_MINIMIZABLE: nk_panel_flags = 16;
pub const nk_panel_flags_NK_WINDOW_NO_SCROLLBAR: nk_panel_flags = 32;
pub const nk_panel_flags_NK_WINDOW_TITLE: nk_panel_flags = 64;
pub const nk_panel_flags_NK_WINDOW_SCROLL_AUTO_HIDE: nk_panel_flags = 128;
pub const nk_panel_flags_NK_WINDOW_BACKGROUND: nk_panel_flags = 256;
pub const nk_panel_flags_NK_WINDOW_SCALE_LEFT: nk_panel_flags = 512;
pub const nk_panel_flags_NK_WINDOW_NO_INPUT: nk_panel_flags = 1024;
pub type nk_panel_flags = u32;
extern "C" {
pub fn nk_begin(
ctx: *mut nk_context,
title: *const ::std::os::raw::c_char,
bounds: nk_rect,
flags: nk_flags,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_begin_titled(
ctx: *mut nk_context,
name: *const ::std::os::raw::c_char,
title: *const ::std::os::raw::c_char,
bounds: nk_rect,
flags: nk_flags,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_end(ctx: *mut nk_context);
}
extern "C" {
pub fn nk_window_find(
ctx: *mut nk_context,
name: *const ::std::os::raw::c_char,
) -> *mut nk_window;
}
extern "C" {
pub fn nk_window_get_bounds(ctx: *const nk_context) -> nk_rect;
}
extern "C" {
pub fn nk_window_get_position(ctx: *const nk_context) -> nk_vec2;
}
extern "C" {
pub fn nk_window_get_size(arg1: *const nk_context) -> nk_vec2;
}
extern "C" {
pub fn nk_window_get_width(arg1: *const nk_context) -> f32;
}
extern "C" {
pub fn nk_window_get_height(arg1: *const nk_context) -> f32;
}
extern "C" {
pub fn nk_window_get_panel(arg1: *mut nk_context) -> *mut nk_panel;
}
extern "C" {
pub fn nk_window_get_content_region(arg1: *mut nk_context) -> nk_rect;
}
extern "C" {
pub fn nk_window_get_content_region_min(arg1: *mut nk_context) -> nk_vec2;
}
extern "C" {
pub fn nk_window_get_content_region_max(arg1: *mut nk_context) -> nk_vec2;
}
extern "C" {
pub fn nk_window_get_content_region_size(arg1: *mut nk_context) -> nk_vec2;
}
extern "C" {
pub fn nk_window_get_canvas(arg1: *mut nk_context) -> *mut nk_command_buffer;
}
extern "C" {
pub fn nk_window_get_scroll(
arg1: *const nk_context,
offset_x: *mut nk_uint,
offset_y: *mut nk_uint,
);
}
extern "C" {
pub fn nk_window_has_focus(arg1: *const nk_context) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_window_is_hovered(arg1: *mut nk_context) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_window_is_collapsed(
ctx: *mut nk_context,
name: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_window_is_closed(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_window_is_hidden(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_window_is_active(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_window_is_any_hovered(arg1: *mut nk_context) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_item_is_any_active(arg1: *mut nk_context) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_window_set_bounds(
arg1: *mut nk_context,
name: *const ::std::os::raw::c_char,
bounds: nk_rect,
);
}
extern "C" {
pub fn nk_window_set_position(
arg1: *mut nk_context,
name: *const ::std::os::raw::c_char,
pos: nk_vec2,
);
}
extern "C" {
pub fn nk_window_set_size(
arg1: *mut nk_context,
name: *const ::std::os::raw::c_char,
arg2: nk_vec2,
);
}
extern "C" {
pub fn nk_window_set_focus(arg1: *mut nk_context, name: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn nk_window_set_scroll(arg1: *mut nk_context, offset_x: nk_uint, offset_y: nk_uint);
}
extern "C" {
pub fn nk_window_close(ctx: *mut nk_context, name: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn nk_window_collapse(
arg1: *mut nk_context,
name: *const ::std::os::raw::c_char,
state: nk_collapse_states,
);
}
extern "C" {
pub fn nk_window_collapse_if(
arg1: *mut nk_context,
name: *const ::std::os::raw::c_char,
arg2: nk_collapse_states,
cond: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn nk_window_show(
arg1: *mut nk_context,
name: *const ::std::os::raw::c_char,
arg2: nk_show_states,
);
}
extern "C" {
pub fn nk_window_show_if(
arg1: *mut nk_context,
name: *const ::std::os::raw::c_char,
arg2: nk_show_states,
cond: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn nk_layout_set_min_row_height(arg1: *mut nk_context, height: f32);
}
extern "C" {
pub fn nk_layout_reset_min_row_height(arg1: *mut nk_context);
}
extern "C" {
pub fn nk_layout_widget_bounds(arg1: *mut nk_context) -> nk_rect;
}
extern "C" {
pub fn nk_layout_ratio_from_pixel(arg1: *mut nk_context, pixel_width: f32) -> f32;
}
extern "C" {
pub fn nk_layout_row_dynamic(ctx: *mut nk_context, height: f32, cols: ::std::os::raw::c_int);
}
extern "C" {
pub fn nk_layout_row_static(
ctx: *mut nk_context,
height: f32,
item_width: ::std::os::raw::c_int,
cols: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn nk_layout_row_begin(
ctx: *mut nk_context,
fmt: nk_layout_format,
row_height: f32,
cols: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn nk_layout_row_push(arg1: *mut nk_context, value: f32);
}
extern "C" {
pub fn nk_layout_row_end(arg1: *mut nk_context);
}
extern "C" {
pub fn nk_layout_row(
arg1: *mut nk_context,
arg2: nk_layout_format,
height: f32,
cols: ::std::os::raw::c_int,
ratio: *const f32,
);
}
extern "C" {
pub fn nk_layout_row_colored(
arg1: *mut nk_context,
arg2: nk_layout_format,
height: f32,
cols: ::std::os::raw::c_int,
ratio: *const f32,
color: nk_color,
);
}
extern "C" {
pub fn nk_layout_row_template_begin(arg1: *mut nk_context, row_height: f32);
}
extern "C" {
pub fn nk_layout_row_template_push_dynamic(arg1: *mut nk_context);
}
extern "C" {
pub fn nk_layout_row_template_push_variable(arg1: *mut nk_context, min_width: f32);
}
extern "C" {
pub fn nk_layout_row_template_push_static(arg1: *mut nk_context, width: f32);
}
extern "C" {
pub fn nk_layout_row_template_end(arg1: *mut nk_context);
}
extern "C" {
pub fn nk_layout_space_begin(
arg1: *mut nk_context,
arg2: nk_layout_format,
height: f32,
widget_count: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn nk_layout_space_colored_begin(
arg1: *mut nk_context,
arg2: nk_layout_format,
height: f32,
widget_count: ::std::os::raw::c_int,
color: nk_color,
);
}
extern "C" {
pub fn nk_layout_space_push(arg1: *mut nk_context, bounds: nk_rect);
}
extern "C" {
pub fn nk_layout_space_end(arg1: *mut nk_context);
}
extern "C" {
pub fn nk_layout_space_bounds(arg1: *mut nk_context) -> nk_rect;
}
extern "C" {
pub fn nk_layout_space_to_screen(arg1: *mut nk_context, arg2: nk_vec2) -> nk_vec2;
}
extern "C" {
pub fn nk_layout_space_to_local(arg1: *mut nk_context, arg2: nk_vec2) -> nk_vec2;
}
extern "C" {
pub fn nk_layout_space_rect_to_screen(arg1: *mut nk_context, arg2: nk_rect) -> nk_rect;
}
extern "C" {
pub fn nk_layout_space_rect_to_local(arg1: *mut nk_context, arg2: nk_rect) -> nk_rect;
}
extern "C" {
pub fn nk_group_begin(
arg1: *mut nk_context,
title: *const ::std::os::raw::c_char,
arg2: nk_flags,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_group_begin_titled(
arg1: *mut nk_context,
name: *const ::std::os::raw::c_char,
title: *const ::std::os::raw::c_char,
arg2: nk_flags,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_group_end(arg1: *mut nk_context);
}
extern "C" {
pub fn nk_group_scrolled_offset_begin(
arg1: *mut nk_context,
x_offset: *mut nk_uint,
y_offset: *mut nk_uint,
title: *const ::std::os::raw::c_char,
flags: nk_flags,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_group_scrolled_begin(
arg1: *mut nk_context,
off: *mut nk_scroll,
title: *const ::std::os::raw::c_char,
arg2: nk_flags,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_group_scrolled_end(arg1: *mut nk_context);
}
extern "C" {
pub fn nk_group_get_scroll(
arg1: *mut nk_context,
id: *const ::std::os::raw::c_char,
x_offset: *mut nk_uint,
y_offset: *mut nk_uint,
);
}
extern "C" {
pub fn nk_group_set_scroll(
arg1: *mut nk_context,
id: *const ::std::os::raw::c_char,
x_offset: nk_uint,
y_offset: nk_uint,
);
}
extern "C" {
pub fn nk_tree_push_hashed(
arg1: *mut nk_context,
arg2: nk_tree_type,
title: *const ::std::os::raw::c_char,
initial_state: nk_collapse_states,
hash: *const ::std::os::raw::c_char,
len: ::std::os::raw::c_int,
seed: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_tree_image_push_hashed(
arg1: *mut nk_context,
arg2: nk_tree_type,
arg3: nk_image,
title: *const ::std::os::raw::c_char,
initial_state: nk_collapse_states,
hash: *const ::std::os::raw::c_char,
len: ::std::os::raw::c_int,
seed: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_tree_pop(arg1: *mut nk_context);
}
extern "C" {
pub fn nk_tree_state_push(
arg1: *mut nk_context,
arg2: nk_tree_type,
title: *const ::std::os::raw::c_char,
state: *mut nk_collapse_states,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_tree_state_image_push(
arg1: *mut nk_context,
arg2: nk_tree_type,
arg3: nk_image,
title: *const ::std::os::raw::c_char,
state: *mut nk_collapse_states,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_tree_state_pop(arg1: *mut nk_context);
}
extern "C" {
pub fn nk_tree_element_push_hashed(
arg1: *mut nk_context,
arg2: nk_tree_type,
title: *const ::std::os::raw::c_char,
initial_state: nk_collapse_states,
selected: *mut ::std::os::raw::c_int,
hash: *const ::std::os::raw::c_char,
len: ::std::os::raw::c_int,
seed: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_tree_element_image_push_hashed(
arg1: *mut nk_context,
arg2: nk_tree_type,
arg3: nk_image,
title: *const ::std::os::raw::c_char,
initial_state: nk_collapse_states,
selected: *mut ::std::os::raw::c_int,
hash: *const ::std::os::raw::c_char,
len: ::std::os::raw::c_int,
seed: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_tree_element_pop(arg1: *mut nk_context);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nk_list_view {
pub begin: ::std::os::raw::c_int,
pub end: ::std::os::raw::c_int,
pub count: ::std::os::raw::c_int,
pub total_height: ::std::os::raw::c_int,
pub ctx: *mut nk_context,
pub scroll_pointer: *mut nk_uint,
pub scroll_value: nk_uint,
}
#[test]
fn bindgen_test_layout_nk_list_view() {
assert_eq!(
::std::mem::size_of::<nk_list_view>(),
40usize,
concat!("Size of: ", stringify!(nk_list_view))
);
assert_eq!(
::std::mem::align_of::<nk_list_view>(),
8usize,
concat!("Alignment of ", stringify!(nk_list_view))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_list_view>())).begin as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_list_view),
"::",
stringify!(begin)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_list_view>())).end as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(nk_list_view),
"::",
stringify!(end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_list_view>())).count as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_list_view),
"::",
stringify!(count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_list_view>())).total_height as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(nk_list_view),
"::",
stringify!(total_height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_list_view>())).ctx as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(nk_list_view),
"::",
stringify!(ctx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_list_view>())).scroll_pointer as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(nk_list_view),
"::",
stringify!(scroll_pointer)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_list_view>())).scroll_value as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_list_view),
"::",
stringify!(scroll_value)
)
);
}
impl Default for nk_list_view {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
pub fn nk_list_view_begin(
arg1: *mut nk_context,
out: *mut nk_list_view,
id: *const ::std::os::raw::c_char,
arg2: nk_flags,
row_height: ::std::os::raw::c_int,
row_count: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_list_view_end(arg1: *mut nk_list_view);
}
pub const nk_widget_layout_states_NK_WIDGET_INVALID: nk_widget_layout_states = 0;
pub const nk_widget_layout_states_NK_WIDGET_VALID: nk_widget_layout_states = 1;
pub const nk_widget_layout_states_NK_WIDGET_ROM: nk_widget_layout_states = 2;
pub type nk_widget_layout_states = u32;
pub const nk_widget_states_NK_WIDGET_STATE_MODIFIED: nk_widget_states = 2;
pub const nk_widget_states_NK_WIDGET_STATE_INACTIVE: nk_widget_states = 4;
pub const nk_widget_states_NK_WIDGET_STATE_ENTERED: nk_widget_states = 8;
pub const nk_widget_states_NK_WIDGET_STATE_HOVER: nk_widget_states = 16;
pub const nk_widget_states_NK_WIDGET_STATE_ACTIVED: nk_widget_states = 32;
pub const nk_widget_states_NK_WIDGET_STATE_LEFT: nk_widget_states = 64;
pub const nk_widget_states_NK_WIDGET_STATE_HOVERED: nk_widget_states = 18;
pub const nk_widget_states_NK_WIDGET_STATE_ACTIVE: nk_widget_states = 34;
pub type nk_widget_states = u32;
extern "C" {
pub fn nk_widget(arg1: *mut nk_rect, arg2: *const nk_context) -> nk_widget_layout_states;
}
extern "C" {
pub fn nk_widget_fitting(
arg1: *mut nk_rect,
arg2: *mut nk_context,
arg3: nk_vec2,
) -> nk_widget_layout_states;
}
extern "C" {
pub fn nk_widget_bounds(arg1: *mut nk_context) -> nk_rect;
}
extern "C" {
pub fn nk_widget_position(arg1: *mut nk_context) -> nk_vec2;
}
extern "C" {
pub fn nk_widget_size(arg1: *mut nk_context) -> nk_vec2;
}
extern "C" {
pub fn nk_widget_width(arg1: *mut nk_context) -> f32;
}
extern "C" {
pub fn nk_widget_height(arg1: *mut nk_context) -> f32;
}
extern "C" {
pub fn nk_widget_is_hovered(arg1: *mut nk_context) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_widget_is_mouse_clicked(
arg1: *mut nk_context,
arg2: nk_buttons,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_widget_has_mouse_click_down(
arg1: *mut nk_context,
arg2: nk_buttons,
down: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_spacing(arg1: *mut nk_context, cols: ::std::os::raw::c_int);
}
pub const nk_text_align_NK_TEXT_ALIGN_LEFT: nk_text_align = 1;
pub const nk_text_align_NK_TEXT_ALIGN_CENTERED: nk_text_align = 2;
pub const nk_text_align_NK_TEXT_ALIGN_RIGHT: nk_text_align = 4;
pub const nk_text_align_NK_TEXT_ALIGN_TOP: nk_text_align = 8;
pub const nk_text_align_NK_TEXT_ALIGN_MIDDLE: nk_text_align = 16;
pub const nk_text_align_NK_TEXT_ALIGN_BOTTOM: nk_text_align = 32;
pub type nk_text_align = u32;
pub const nk_text_alignment_NK_TEXT_LEFT: nk_text_alignment = 17;
pub const nk_text_alignment_NK_TEXT_CENTERED: nk_text_alignment = 18;
pub const nk_text_alignment_NK_TEXT_RIGHT: nk_text_alignment = 20;
pub type nk_text_alignment = u32;
extern "C" {
pub fn nk_text(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
arg3: ::std::os::raw::c_int,
arg4: nk_flags,
);
}
extern "C" {
pub fn nk_text_colored(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
arg3: ::std::os::raw::c_int,
arg4: nk_flags,
arg5: nk_color,
);
}
extern "C" {
pub fn nk_text_wrap(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
arg3: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn nk_text_wrap_colored(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
arg3: ::std::os::raw::c_int,
arg4: nk_color,
);
}
extern "C" {
pub fn nk_label(arg1: *mut nk_context, arg2: *const ::std::os::raw::c_char, align: nk_flags);
}
extern "C" {
pub fn nk_label_colored(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
align: nk_flags,
arg3: nk_color,
);
}
extern "C" {
pub fn nk_label_wrap(arg1: *mut nk_context, arg2: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn nk_label_colored_wrap(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
arg3: nk_color,
);
}
extern "C" {
pub fn nk_image(arg1: *mut nk_context, arg2: nk_image);
}
extern "C" {
pub fn nk_image_color(arg1: *mut nk_context, arg2: nk_image, arg3: nk_color);
}
extern "C" {
pub fn nk_button_text(
arg1: *mut nk_context,
title: *const ::std::os::raw::c_char,
len: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_button_label(
arg1: *mut nk_context,
title: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_button_color(arg1: *mut nk_context, arg2: nk_color) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_button_symbol(arg1: *mut nk_context, arg2: nk_symbol_type) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_button_image(arg1: *mut nk_context, img: nk_image) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_button_symbol_label(
arg1: *mut nk_context,
arg2: nk_symbol_type,
arg3: *const ::std::os::raw::c_char,
text_alignment: nk_flags,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_button_symbol_text(
arg1: *mut nk_context,
arg2: nk_symbol_type,
arg3: *const ::std::os::raw::c_char,
arg4: ::std::os::raw::c_int,
alignment: nk_flags,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_button_image_label(
arg1: *mut nk_context,
img: nk_image,
arg2: *const ::std::os::raw::c_char,
text_alignment: nk_flags,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_button_image_text(
arg1: *mut nk_context,
img: nk_image,
arg2: *const ::std::os::raw::c_char,
arg3: ::std::os::raw::c_int,
alignment: nk_flags,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_button_text_styled(
arg1: *mut nk_context,
arg2: *const nk_style_button,
title: *const ::std::os::raw::c_char,
len: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_button_label_styled(
arg1: *mut nk_context,
arg2: *const nk_style_button,
title: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_button_symbol_styled(
arg1: *mut nk_context,
arg2: *const nk_style_button,
arg3: nk_symbol_type,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_button_image_styled(
arg1: *mut nk_context,
arg2: *const nk_style_button,
img: nk_image,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_button_symbol_text_styled(
arg1: *mut nk_context,
arg2: *const nk_style_button,
arg3: nk_symbol_type,
arg4: *const ::std::os::raw::c_char,
arg5: ::std::os::raw::c_int,
alignment: nk_flags,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_button_symbol_label_styled(
ctx: *mut nk_context,
style: *const nk_style_button,
symbol: nk_symbol_type,
title: *const ::std::os::raw::c_char,
align: nk_flags,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_button_image_label_styled(
arg1: *mut nk_context,
arg2: *const nk_style_button,
img: nk_image,
arg3: *const ::std::os::raw::c_char,
text_alignment: nk_flags,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_button_image_text_styled(
arg1: *mut nk_context,
arg2: *const nk_style_button,
img: nk_image,
arg3: *const ::std::os::raw::c_char,
arg4: ::std::os::raw::c_int,
alignment: nk_flags,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_button_set_behavior(arg1: *mut nk_context, arg2: nk_button_behavior);
}
extern "C" {
pub fn nk_button_push_behavior(
arg1: *mut nk_context,
arg2: nk_button_behavior,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_button_pop_behavior(arg1: *mut nk_context) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_check_label(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
active: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_check_text(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
arg3: ::std::os::raw::c_int,
active: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_check_flags_label(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
flags: ::std::os::raw::c_uint,
value: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn nk_check_flags_text(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
arg3: ::std::os::raw::c_int,
flags: ::std::os::raw::c_uint,
value: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_uint;
}
extern "C" {
pub fn nk_checkbox_label(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
active: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_checkbox_text(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
arg3: ::std::os::raw::c_int,
active: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_checkbox_flags_label(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
flags: *mut ::std::os::raw::c_uint,
value: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_checkbox_flags_text(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
arg3: ::std::os::raw::c_int,
flags: *mut ::std::os::raw::c_uint,
value: ::std::os::raw::c_uint,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_radio_label(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
active: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_radio_text(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
arg3: ::std::os::raw::c_int,
active: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_option_label(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
active: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_option_text(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
arg3: ::std::os::raw::c_int,
active: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_selectable_label(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
align: nk_flags,
value: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_selectable_text(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
arg3: ::std::os::raw::c_int,
align: nk_flags,
value: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_selectable_image_label(
arg1: *mut nk_context,
arg2: nk_image,
arg3: *const ::std::os::raw::c_char,
align: nk_flags,
value: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_selectable_image_text(
arg1: *mut nk_context,
arg2: nk_image,
arg3: *const ::std::os::raw::c_char,
arg4: ::std::os::raw::c_int,
align: nk_flags,
value: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_selectable_symbol_label(
arg1: *mut nk_context,
arg2: nk_symbol_type,
arg3: *const ::std::os::raw::c_char,
align: nk_flags,
value: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_selectable_symbol_text(
arg1: *mut nk_context,
arg2: nk_symbol_type,
arg3: *const ::std::os::raw::c_char,
arg4: ::std::os::raw::c_int,
align: nk_flags,
value: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_select_label(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
align: nk_flags,
value: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_select_text(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
arg3: ::std::os::raw::c_int,
align: nk_flags,
value: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_select_image_label(
arg1: *mut nk_context,
arg2: nk_image,
arg3: *const ::std::os::raw::c_char,
align: nk_flags,
value: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_select_image_text(
arg1: *mut nk_context,
arg2: nk_image,
arg3: *const ::std::os::raw::c_char,
arg4: ::std::os::raw::c_int,
align: nk_flags,
value: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_select_symbol_label(
arg1: *mut nk_context,
arg2: nk_symbol_type,
arg3: *const ::std::os::raw::c_char,
align: nk_flags,
value: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_select_symbol_text(
arg1: *mut nk_context,
arg2: nk_symbol_type,
arg3: *const ::std::os::raw::c_char,
arg4: ::std::os::raw::c_int,
align: nk_flags,
value: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_slide_float(arg1: *mut nk_context, min: f32, val: f32, max: f32, step: f32) -> f32;
}
extern "C" {
pub fn nk_slide_int(
arg1: *mut nk_context,
min: ::std::os::raw::c_int,
val: ::std::os::raw::c_int,
max: ::std::os::raw::c_int,
step: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_slider_float(
arg1: *mut nk_context,
min: f32,
val: *mut f32,
max: f32,
step: f32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_slider_int(
arg1: *mut nk_context,
min: ::std::os::raw::c_int,
val: *mut ::std::os::raw::c_int,
max: ::std::os::raw::c_int,
step: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_progress(
arg1: *mut nk_context,
cur: *mut nk_size,
max: nk_size,
modifyable: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_prog(
arg1: *mut nk_context,
cur: nk_size,
max: nk_size,
modifyable: ::std::os::raw::c_int,
) -> nk_size;
}
extern "C" {
pub fn nk_color_picker(
arg1: *mut nk_context,
arg2: nk_colorf,
arg3: nk_color_format,
) -> nk_colorf;
}
extern "C" {
pub fn nk_color_pick(
arg1: *mut nk_context,
arg2: *mut nk_colorf,
arg3: nk_color_format,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_property_int(
arg1: *mut nk_context,
name: *const ::std::os::raw::c_char,
min: ::std::os::raw::c_int,
val: *mut ::std::os::raw::c_int,
max: ::std::os::raw::c_int,
step: ::std::os::raw::c_int,
inc_per_pixel: f32,
);
}
extern "C" {
pub fn nk_property_float(
arg1: *mut nk_context,
name: *const ::std::os::raw::c_char,
min: f32,
val: *mut f32,
max: f32,
step: f32,
inc_per_pixel: f32,
);
}
extern "C" {
pub fn nk_property_double(
arg1: *mut nk_context,
name: *const ::std::os::raw::c_char,
min: f64,
val: *mut f64,
max: f64,
step: f64,
inc_per_pixel: f32,
);
}
extern "C" {
pub fn nk_propertyi(
arg1: *mut nk_context,
name: *const ::std::os::raw::c_char,
min: ::std::os::raw::c_int,
val: ::std::os::raw::c_int,
max: ::std::os::raw::c_int,
step: ::std::os::raw::c_int,
inc_per_pixel: f32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_propertyf(
arg1: *mut nk_context,
name: *const ::std::os::raw::c_char,
min: f32,
val: f32,
max: f32,
step: f32,
inc_per_pixel: f32,
) -> f32;
}
extern "C" {
pub fn nk_propertyd(
arg1: *mut nk_context,
name: *const ::std::os::raw::c_char,
min: f64,
val: f64,
max: f64,
step: f64,
inc_per_pixel: f32,
) -> f64;
}
pub const nk_edit_flags_NK_EDIT_DEFAULT: nk_edit_flags = 0;
pub const nk_edit_flags_NK_EDIT_READ_ONLY: nk_edit_flags = 1;
pub const nk_edit_flags_NK_EDIT_AUTO_SELECT: nk_edit_flags = 2;
pub const nk_edit_flags_NK_EDIT_SIG_ENTER: nk_edit_flags = 4;
pub const nk_edit_flags_NK_EDIT_ALLOW_TAB: nk_edit_flags = 8;
pub const nk_edit_flags_NK_EDIT_NO_CURSOR: nk_edit_flags = 16;
pub const nk_edit_flags_NK_EDIT_SELECTABLE: nk_edit_flags = 32;
pub const nk_edit_flags_NK_EDIT_CLIPBOARD: nk_edit_flags = 64;
pub const nk_edit_flags_NK_EDIT_CTRL_ENTER_NEWLINE: nk_edit_flags = 128;
pub const nk_edit_flags_NK_EDIT_NO_HORIZONTAL_SCROLL: nk_edit_flags = 256;
pub const nk_edit_flags_NK_EDIT_ALWAYS_INSERT_MODE: nk_edit_flags = 512;
pub const nk_edit_flags_NK_EDIT_MULTILINE: nk_edit_flags = 1024;
pub const nk_edit_flags_NK_EDIT_GOTO_END_ON_ACTIVATE: nk_edit_flags = 2048;
pub type nk_edit_flags = u32;
pub const nk_edit_types_NK_EDIT_SIMPLE: nk_edit_types = 512;
pub const nk_edit_types_NK_EDIT_FIELD: nk_edit_types = 608;
pub const nk_edit_types_NK_EDIT_BOX: nk_edit_types = 1640;
pub const nk_edit_types_NK_EDIT_EDITOR: nk_edit_types = 1128;
pub type nk_edit_types = u32;
pub const nk_edit_events_NK_EDIT_ACTIVE: nk_edit_events = 1;
pub const nk_edit_events_NK_EDIT_INACTIVE: nk_edit_events = 2;
pub const nk_edit_events_NK_EDIT_ACTIVATED: nk_edit_events = 4;
pub const nk_edit_events_NK_EDIT_DEACTIVATED: nk_edit_events = 8;
pub const nk_edit_events_NK_EDIT_COMMITED: nk_edit_events = 16;
pub type nk_edit_events = u32;
extern "C" {
pub fn nk_edit_string(
arg1: *mut nk_context,
arg2: nk_flags,
buffer: *mut ::std::os::raw::c_char,
len: *mut ::std::os::raw::c_int,
max: ::std::os::raw::c_int,
arg3: nk_plugin_filter,
) -> nk_flags;
}
extern "C" {
pub fn nk_edit_string_zero_terminated(
arg1: *mut nk_context,
arg2: nk_flags,
buffer: *mut ::std::os::raw::c_char,
max: ::std::os::raw::c_int,
arg3: nk_plugin_filter,
) -> nk_flags;
}
extern "C" {
pub fn nk_edit_buffer(
arg1: *mut nk_context,
arg2: nk_flags,
arg3: *mut nk_text_edit,
arg4: nk_plugin_filter,
) -> nk_flags;
}
extern "C" {
pub fn nk_edit_focus(arg1: *mut nk_context, flags: nk_flags);
}
extern "C" {
pub fn nk_edit_unfocus(arg1: *mut nk_context);
}
extern "C" {
pub fn nk_chart_begin(
arg1: *mut nk_context,
arg2: nk_chart_type,
num: ::std::os::raw::c_int,
min: f32,
max: f32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_chart_begin_colored(
arg1: *mut nk_context,
arg2: nk_chart_type,
arg3: nk_color,
active: nk_color,
num: ::std::os::raw::c_int,
min: f32,
max: f32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_chart_add_slot(
ctx: *mut nk_context,
arg1: nk_chart_type,
count: ::std::os::raw::c_int,
min_value: f32,
max_value: f32,
);
}
extern "C" {
pub fn nk_chart_add_slot_colored(
ctx: *mut nk_context,
arg1: nk_chart_type,
arg2: nk_color,
active: nk_color,
count: ::std::os::raw::c_int,
min_value: f32,
max_value: f32,
);
}
extern "C" {
pub fn nk_chart_push(arg1: *mut nk_context, arg2: f32) -> nk_flags;
}
extern "C" {
pub fn nk_chart_push_slot(
arg1: *mut nk_context,
arg2: f32,
arg3: ::std::os::raw::c_int,
) -> nk_flags;
}
extern "C" {
pub fn nk_chart_end(arg1: *mut nk_context);
}
extern "C" {
pub fn nk_plot(
arg1: *mut nk_context,
arg2: nk_chart_type,
values: *const f32,
count: ::std::os::raw::c_int,
offset: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn nk_plot_function(
arg1: *mut nk_context,
arg2: nk_chart_type,
userdata: *mut ::std::os::raw::c_void,
value_getter: ::std::option::Option<
unsafe extern "C" fn(
user: *mut ::std::os::raw::c_void,
index: ::std::os::raw::c_int,
) -> f32,
>,
count: ::std::os::raw::c_int,
offset: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn nk_popup_begin(
arg1: *mut nk_context,
arg2: nk_popup_type,
arg3: *const ::std::os::raw::c_char,
arg4: nk_flags,
bounds: nk_rect,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_popup_close(arg1: *mut nk_context);
}
extern "C" {
pub fn nk_popup_end(arg1: *mut nk_context);
}
extern "C" {
pub fn nk_popup_get_scroll(
arg1: *mut nk_context,
offset_x: *mut nk_uint,
offset_y: *mut nk_uint,
);
}
extern "C" {
pub fn nk_popup_set_scroll(arg1: *mut nk_context, offset_x: nk_uint, offset_y: nk_uint);
}
extern "C" {
pub fn nk_combo(
arg1: *mut nk_context,
items: *mut *const ::std::os::raw::c_char,
count: ::std::os::raw::c_int,
selected: ::std::os::raw::c_int,
item_height: ::std::os::raw::c_int,
size: nk_vec2,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_combo_separator(
arg1: *mut nk_context,
items_separated_by_separator: *const ::std::os::raw::c_char,
separator: ::std::os::raw::c_int,
selected: ::std::os::raw::c_int,
count: ::std::os::raw::c_int,
item_height: ::std::os::raw::c_int,
size: nk_vec2,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_combo_string(
arg1: *mut nk_context,
items_separated_by_zeros: *const ::std::os::raw::c_char,
selected: ::std::os::raw::c_int,
count: ::std::os::raw::c_int,
item_height: ::std::os::raw::c_int,
size: nk_vec2,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_combo_callback(
arg1: *mut nk_context,
item_getter: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut ::std::os::raw::c_void,
arg2: ::std::os::raw::c_int,
arg3: *mut *const ::std::os::raw::c_char,
),
>,
userdata: *mut ::std::os::raw::c_void,
selected: ::std::os::raw::c_int,
count: ::std::os::raw::c_int,
item_height: ::std::os::raw::c_int,
size: nk_vec2,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_combobox(
arg1: *mut nk_context,
items: *mut *const ::std::os::raw::c_char,
count: ::std::os::raw::c_int,
selected: *mut ::std::os::raw::c_int,
item_height: ::std::os::raw::c_int,
size: nk_vec2,
);
}
extern "C" {
pub fn nk_combobox_string(
arg1: *mut nk_context,
items_separated_by_zeros: *const ::std::os::raw::c_char,
selected: *mut ::std::os::raw::c_int,
count: ::std::os::raw::c_int,
item_height: ::std::os::raw::c_int,
size: nk_vec2,
);
}
extern "C" {
pub fn nk_combobox_separator(
arg1: *mut nk_context,
items_separated_by_separator: *const ::std::os::raw::c_char,
separator: ::std::os::raw::c_int,
selected: *mut ::std::os::raw::c_int,
count: ::std::os::raw::c_int,
item_height: ::std::os::raw::c_int,
size: nk_vec2,
);
}
extern "C" {
pub fn nk_combobox_callback(
arg1: *mut nk_context,
item_getter: ::std::option::Option<
unsafe extern "C" fn(
arg1: *mut ::std::os::raw::c_void,
arg2: ::std::os::raw::c_int,
arg3: *mut *const ::std::os::raw::c_char,
),
>,
arg2: *mut ::std::os::raw::c_void,
selected: *mut ::std::os::raw::c_int,
count: ::std::os::raw::c_int,
item_height: ::std::os::raw::c_int,
size: nk_vec2,
);
}
extern "C" {
pub fn nk_combo_begin_text(
arg1: *mut nk_context,
selected: *const ::std::os::raw::c_char,
arg2: ::std::os::raw::c_int,
size: nk_vec2,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_combo_begin_label(
arg1: *mut nk_context,
selected: *const ::std::os::raw::c_char,
size: nk_vec2,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_combo_begin_color(
arg1: *mut nk_context,
color: nk_color,
size: nk_vec2,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_combo_begin_symbol(
arg1: *mut nk_context,
arg2: nk_symbol_type,
size: nk_vec2,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_combo_begin_symbol_label(
arg1: *mut nk_context,
selected: *const ::std::os::raw::c_char,
arg2: nk_symbol_type,
size: nk_vec2,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_combo_begin_symbol_text(
arg1: *mut nk_context,
selected: *const ::std::os::raw::c_char,
arg2: ::std::os::raw::c_int,
arg3: nk_symbol_type,
size: nk_vec2,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_combo_begin_image(
arg1: *mut nk_context,
img: nk_image,
size: nk_vec2,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_combo_begin_image_label(
arg1: *mut nk_context,
selected: *const ::std::os::raw::c_char,
arg2: nk_image,
size: nk_vec2,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_combo_begin_image_text(
arg1: *mut nk_context,
selected: *const ::std::os::raw::c_char,
arg2: ::std::os::raw::c_int,
arg3: nk_image,
size: nk_vec2,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_combo_item_label(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
alignment: nk_flags,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_combo_item_text(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
arg3: ::std::os::raw::c_int,
alignment: nk_flags,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_combo_item_image_label(
arg1: *mut nk_context,
arg2: nk_image,
arg3: *const ::std::os::raw::c_char,
alignment: nk_flags,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_combo_item_image_text(
arg1: *mut nk_context,
arg2: nk_image,
arg3: *const ::std::os::raw::c_char,
arg4: ::std::os::raw::c_int,
alignment: nk_flags,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_combo_item_symbol_label(
arg1: *mut nk_context,
arg2: nk_symbol_type,
arg3: *const ::std::os::raw::c_char,
alignment: nk_flags,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_combo_item_symbol_text(
arg1: *mut nk_context,
arg2: nk_symbol_type,
arg3: *const ::std::os::raw::c_char,
arg4: ::std::os::raw::c_int,
alignment: nk_flags,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_combo_close(arg1: *mut nk_context);
}
extern "C" {
pub fn nk_combo_end(arg1: *mut nk_context);
}
extern "C" {
pub fn nk_contextual_begin(
arg1: *mut nk_context,
arg2: nk_flags,
arg3: nk_vec2,
trigger_bounds: nk_rect,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_contextual_item_text(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
arg3: ::std::os::raw::c_int,
align: nk_flags,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_contextual_item_label(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
align: nk_flags,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_contextual_item_image_label(
arg1: *mut nk_context,
arg2: nk_image,
arg3: *const ::std::os::raw::c_char,
alignment: nk_flags,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_contextual_item_image_text(
arg1: *mut nk_context,
arg2: nk_image,
arg3: *const ::std::os::raw::c_char,
len: ::std::os::raw::c_int,
alignment: nk_flags,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_contextual_item_symbol_label(
arg1: *mut nk_context,
arg2: nk_symbol_type,
arg3: *const ::std::os::raw::c_char,
alignment: nk_flags,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_contextual_item_symbol_text(
arg1: *mut nk_context,
arg2: nk_symbol_type,
arg3: *const ::std::os::raw::c_char,
arg4: ::std::os::raw::c_int,
alignment: nk_flags,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_contextual_close(arg1: *mut nk_context);
}
extern "C" {
pub fn nk_contextual_end(arg1: *mut nk_context);
}
extern "C" {
pub fn nk_tooltip(arg1: *mut nk_context, arg2: *const ::std::os::raw::c_char);
}
extern "C" {
pub fn nk_tooltip_begin(arg1: *mut nk_context, width: f32) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_tooltip_end(arg1: *mut nk_context);
}
extern "C" {
pub fn nk_menubar_begin(arg1: *mut nk_context);
}
extern "C" {
pub fn nk_menubar_end(arg1: *mut nk_context);
}
extern "C" {
pub fn nk_menu_begin_text(
arg1: *mut nk_context,
title: *const ::std::os::raw::c_char,
title_len: ::std::os::raw::c_int,
align: nk_flags,
size: nk_vec2,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_menu_begin_label(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
align: nk_flags,
size: nk_vec2,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_menu_begin_image(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
arg3: nk_image,
size: nk_vec2,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_menu_begin_image_text(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
arg3: ::std::os::raw::c_int,
align: nk_flags,
arg4: nk_image,
size: nk_vec2,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_menu_begin_image_label(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
align: nk_flags,
arg3: nk_image,
size: nk_vec2,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_menu_begin_symbol(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
arg3: nk_symbol_type,
size: nk_vec2,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_menu_begin_symbol_text(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
arg3: ::std::os::raw::c_int,
align: nk_flags,
arg4: nk_symbol_type,
size: nk_vec2,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_menu_begin_symbol_label(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
align: nk_flags,
arg3: nk_symbol_type,
size: nk_vec2,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_menu_item_text(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
arg3: ::std::os::raw::c_int,
align: nk_flags,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_menu_item_label(
arg1: *mut nk_context,
arg2: *const ::std::os::raw::c_char,
alignment: nk_flags,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_menu_item_image_label(
arg1: *mut nk_context,
arg2: nk_image,
arg3: *const ::std::os::raw::c_char,
alignment: nk_flags,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_menu_item_image_text(
arg1: *mut nk_context,
arg2: nk_image,
arg3: *const ::std::os::raw::c_char,
len: ::std::os::raw::c_int,
alignment: nk_flags,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_menu_item_symbol_text(
arg1: *mut nk_context,
arg2: nk_symbol_type,
arg3: *const ::std::os::raw::c_char,
arg4: ::std::os::raw::c_int,
alignment: nk_flags,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_menu_item_symbol_label(
arg1: *mut nk_context,
arg2: nk_symbol_type,
arg3: *const ::std::os::raw::c_char,
alignment: nk_flags,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_menu_close(arg1: *mut nk_context);
}
extern "C" {
pub fn nk_menu_end(arg1: *mut nk_context);
}
pub const nk_style_colors_NK_COLOR_TEXT: nk_style_colors = 0;
pub const nk_style_colors_NK_COLOR_WINDOW: nk_style_colors = 1;
pub const nk_style_colors_NK_COLOR_HEADER: nk_style_colors = 2;
pub const nk_style_colors_NK_COLOR_BORDER: nk_style_colors = 3;
pub const nk_style_colors_NK_COLOR_BUTTON: nk_style_colors = 4;
pub const nk_style_colors_NK_COLOR_BUTTON_HOVER: nk_style_colors = 5;
pub const nk_style_colors_NK_COLOR_BUTTON_ACTIVE: nk_style_colors = 6;
pub const nk_style_colors_NK_COLOR_TOGGLE: nk_style_colors = 7;
pub const nk_style_colors_NK_COLOR_TOGGLE_HOVER: nk_style_colors = 8;
pub const nk_style_colors_NK_COLOR_TOGGLE_CURSOR: nk_style_colors = 9;
pub const nk_style_colors_NK_COLOR_SELECT: nk_style_colors = 10;
pub const nk_style_colors_NK_COLOR_SELECT_ACTIVE: nk_style_colors = 11;
pub const nk_style_colors_NK_COLOR_SLIDER: nk_style_colors = 12;
pub const nk_style_colors_NK_COLOR_SLIDER_CURSOR: nk_style_colors = 13;
pub const nk_style_colors_NK_COLOR_SLIDER_CURSOR_HOVER: nk_style_colors = 14;
pub const nk_style_colors_NK_COLOR_SLIDER_CURSOR_ACTIVE: nk_style_colors = 15;
pub const nk_style_colors_NK_COLOR_PROPERTY: nk_style_colors = 16;
pub const nk_style_colors_NK_COLOR_EDIT: nk_style_colors = 17;
pub const nk_style_colors_NK_COLOR_EDIT_CURSOR: nk_style_colors = 18;
pub const nk_style_colors_NK_COLOR_COMBO: nk_style_colors = 19;
pub const nk_style_colors_NK_COLOR_CHART: nk_style_colors = 20;
pub const nk_style_colors_NK_COLOR_CHART_COLOR: nk_style_colors = 21;
pub const nk_style_colors_NK_COLOR_CHART_COLOR_HIGHLIGHT: nk_style_colors = 22;
pub const nk_style_colors_NK_COLOR_SCROLLBAR: nk_style_colors = 23;
pub const nk_style_colors_NK_COLOR_SCROLLBAR_CURSOR: nk_style_colors = 24;
pub const nk_style_colors_NK_COLOR_SCROLLBAR_CURSOR_HOVER: nk_style_colors = 25;
pub const nk_style_colors_NK_COLOR_SCROLLBAR_CURSOR_ACTIVE: nk_style_colors = 26;
pub const nk_style_colors_NK_COLOR_TAB_HEADER: nk_style_colors = 27;
pub const nk_style_colors_NK_COLOR_COUNT: nk_style_colors = 28;
pub type nk_style_colors = u32;
pub const nk_style_cursor_NK_CURSOR_ARROW: nk_style_cursor = 0;
pub const nk_style_cursor_NK_CURSOR_TEXT: nk_style_cursor = 1;
pub const nk_style_cursor_NK_CURSOR_MOVE: nk_style_cursor = 2;
pub const nk_style_cursor_NK_CURSOR_RESIZE_VERTICAL: nk_style_cursor = 3;
pub const nk_style_cursor_NK_CURSOR_RESIZE_HORIZONTAL: nk_style_cursor = 4;
pub const nk_style_cursor_NK_CURSOR_RESIZE_TOP_LEFT_DOWN_RIGHT: nk_style_cursor = 5;
pub const nk_style_cursor_NK_CURSOR_RESIZE_TOP_RIGHT_DOWN_LEFT: nk_style_cursor = 6;
pub const nk_style_cursor_NK_CURSOR_COUNT: nk_style_cursor = 7;
pub type nk_style_cursor = u32;
extern "C" {
pub fn nk_style_default(arg1: *mut nk_context);
}
extern "C" {
pub fn nk_style_from_table(arg1: *mut nk_context, arg2: *const nk_color);
}
extern "C" {
pub fn nk_style_load_cursor(
arg1: *mut nk_context,
arg2: nk_style_cursor,
arg3: *const nk_cursor,
);
}
extern "C" {
pub fn nk_style_load_all_cursors(arg1: *mut nk_context, arg2: *mut nk_cursor);
}
extern "C" {
pub fn nk_style_get_color_by_name(arg1: nk_style_colors) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn nk_style_set_font(arg1: *mut nk_context, arg2: *const nk_user_font);
}
extern "C" {
pub fn nk_style_set_cursor(
arg1: *mut nk_context,
arg2: nk_style_cursor,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_style_show_cursor(arg1: *mut nk_context);
}
extern "C" {
pub fn nk_style_hide_cursor(arg1: *mut nk_context);
}
extern "C" {
pub fn nk_style_push_font(
arg1: *mut nk_context,
arg2: *const nk_user_font,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_style_push_float(
arg1: *mut nk_context,
arg2: *mut f32,
arg3: f32,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_style_push_vec2(
arg1: *mut nk_context,
arg2: *mut nk_vec2,
arg3: nk_vec2,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_style_push_style_item(
arg1: *mut nk_context,
arg2: *mut nk_style_item,
arg3: nk_style_item,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_style_push_flags(
arg1: *mut nk_context,
arg2: *mut nk_flags,
arg3: nk_flags,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_style_push_color(
arg1: *mut nk_context,
arg2: *mut nk_color,
arg3: nk_color,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_style_pop_font(arg1: *mut nk_context) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_style_pop_float(arg1: *mut nk_context) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_style_pop_vec2(arg1: *mut nk_context) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_style_pop_style_item(arg1: *mut nk_context) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_style_pop_flags(arg1: *mut nk_context) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_style_pop_color(arg1: *mut nk_context) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_rgb(
r: ::std::os::raw::c_int,
g: ::std::os::raw::c_int,
b: ::std::os::raw::c_int,
) -> nk_color;
}
extern "C" {
pub fn nk_rgb_iv(rgb: *const ::std::os::raw::c_int) -> nk_color;
}
extern "C" {
pub fn nk_rgb_bv(rgb: *const nk_byte) -> nk_color;
}
extern "C" {
pub fn nk_rgb_f(r: f32, g: f32, b: f32) -> nk_color;
}
extern "C" {
pub fn nk_rgb_fv(rgb: *const f32) -> nk_color;
}
extern "C" {
pub fn nk_rgb_cf(c: nk_colorf) -> nk_color;
}
extern "C" {
pub fn nk_rgb_hex(rgb: *const ::std::os::raw::c_char) -> nk_color;
}
extern "C" {
pub fn nk_rgba(
r: ::std::os::raw::c_int,
g: ::std::os::raw::c_int,
b: ::std::os::raw::c_int,
a: ::std::os::raw::c_int,
) -> nk_color;
}
extern "C" {
pub fn nk_rgba_u32(arg1: nk_uint) -> nk_color;
}
extern "C" {
pub fn nk_rgba_iv(rgba: *const ::std::os::raw::c_int) -> nk_color;
}
extern "C" {
pub fn nk_rgba_bv(rgba: *const nk_byte) -> nk_color;
}
extern "C" {
pub fn nk_rgba_f(r: f32, g: f32, b: f32, a: f32) -> nk_color;
}
extern "C" {
pub fn nk_rgba_fv(rgba: *const f32) -> nk_color;
}
extern "C" {
pub fn nk_rgba_cf(c: nk_colorf) -> nk_color;
}
extern "C" {
pub fn nk_rgba_hex(rgb: *const ::std::os::raw::c_char) -> nk_color;
}
extern "C" {
pub fn nk_hsva_colorf(h: f32, s: f32, v: f32, a: f32) -> nk_colorf;
}
extern "C" {
pub fn nk_hsva_colorfv(c: *mut f32) -> nk_colorf;
}
extern "C" {
pub fn nk_colorf_hsva_f(
out_h: *mut f32,
out_s: *mut f32,
out_v: *mut f32,
out_a: *mut f32,
in_: nk_colorf,
);
}
extern "C" {
pub fn nk_colorf_hsva_fv(hsva: *mut f32, in_: nk_colorf);
}
extern "C" {
pub fn nk_hsv(
h: ::std::os::raw::c_int,
s: ::std::os::raw::c_int,
v: ::std::os::raw::c_int,
) -> nk_color;
}
extern "C" {
pub fn nk_hsv_iv(hsv: *const ::std::os::raw::c_int) -> nk_color;
}
extern "C" {
pub fn nk_hsv_bv(hsv: *const nk_byte) -> nk_color;
}
extern "C" {
pub fn nk_hsv_f(h: f32, s: f32, v: f32) -> nk_color;
}
extern "C" {
pub fn nk_hsv_fv(hsv: *const f32) -> nk_color;
}
extern "C" {
pub fn nk_hsva(
h: ::std::os::raw::c_int,
s: ::std::os::raw::c_int,
v: ::std::os::raw::c_int,
a: ::std::os::raw::c_int,
) -> nk_color;
}
extern "C" {
pub fn nk_hsva_iv(hsva: *const ::std::os::raw::c_int) -> nk_color;
}
extern "C" {
pub fn nk_hsva_bv(hsva: *const nk_byte) -> nk_color;
}
extern "C" {
pub fn nk_hsva_f(h: f32, s: f32, v: f32, a: f32) -> nk_color;
}
extern "C" {
pub fn nk_hsva_fv(hsva: *const f32) -> nk_color;
}
extern "C" {
pub fn nk_color_f(r: *mut f32, g: *mut f32, b: *mut f32, a: *mut f32, arg1: nk_color);
}
extern "C" {
pub fn nk_color_fv(rgba_out: *mut f32, arg1: nk_color);
}
extern "C" {
pub fn nk_color_cf(arg1: nk_color) -> nk_colorf;
}
extern "C" {
pub fn nk_color_d(r: *mut f64, g: *mut f64, b: *mut f64, a: *mut f64, arg1: nk_color);
}
extern "C" {
pub fn nk_color_dv(rgba_out: *mut f64, arg1: nk_color);
}
extern "C" {
pub fn nk_color_u32(arg1: nk_color) -> nk_uint;
}
extern "C" {
pub fn nk_color_hex_rgba(output: *mut ::std::os::raw::c_char, arg1: nk_color);
}
extern "C" {
pub fn nk_color_hex_rgb(output: *mut ::std::os::raw::c_char, arg1: nk_color);
}
extern "C" {
pub fn nk_color_hsv_i(
out_h: *mut ::std::os::raw::c_int,
out_s: *mut ::std::os::raw::c_int,
out_v: *mut ::std::os::raw::c_int,
arg1: nk_color,
);
}
extern "C" {
pub fn nk_color_hsv_b(
out_h: *mut nk_byte,
out_s: *mut nk_byte,
out_v: *mut nk_byte,
arg1: nk_color,
);
}
extern "C" {
pub fn nk_color_hsv_iv(hsv_out: *mut ::std::os::raw::c_int, arg1: nk_color);
}
extern "C" {
pub fn nk_color_hsv_bv(hsv_out: *mut nk_byte, arg1: nk_color);
}
extern "C" {
pub fn nk_color_hsv_f(out_h: *mut f32, out_s: *mut f32, out_v: *mut f32, arg1: nk_color);
}
extern "C" {
pub fn nk_color_hsv_fv(hsv_out: *mut f32, arg1: nk_color);
}
extern "C" {
pub fn nk_color_hsva_i(
h: *mut ::std::os::raw::c_int,
s: *mut ::std::os::raw::c_int,
v: *mut ::std::os::raw::c_int,
a: *mut ::std::os::raw::c_int,
arg1: nk_color,
);
}
extern "C" {
pub fn nk_color_hsva_b(
h: *mut nk_byte,
s: *mut nk_byte,
v: *mut nk_byte,
a: *mut nk_byte,
arg1: nk_color,
);
}
extern "C" {
pub fn nk_color_hsva_iv(hsva_out: *mut ::std::os::raw::c_int, arg1: nk_color);
}
extern "C" {
pub fn nk_color_hsva_bv(hsva_out: *mut nk_byte, arg1: nk_color);
}
extern "C" {
pub fn nk_color_hsva_f(
out_h: *mut f32,
out_s: *mut f32,
out_v: *mut f32,
out_a: *mut f32,
arg1: nk_color,
);
}
extern "C" {
pub fn nk_color_hsva_fv(hsva_out: *mut f32, arg1: nk_color);
}
extern "C" {
pub fn nk_handle_ptr(arg1: *mut ::std::os::raw::c_void) -> nk_handle;
}
extern "C" {
pub fn nk_handle_id(arg1: ::std::os::raw::c_int) -> nk_handle;
}
extern "C" {
pub fn nk_image_handle(arg1: nk_handle) -> nk_image;
}
extern "C" {
pub fn nk_image_ptr(arg1: *mut ::std::os::raw::c_void) -> nk_image;
}
extern "C" {
pub fn nk_image_id(arg1: ::std::os::raw::c_int) -> nk_image;
}
extern "C" {
pub fn nk_image_is_subimage(img: *const nk_image) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_subimage_ptr(
arg1: *mut ::std::os::raw::c_void,
w: ::std::os::raw::c_ushort,
h: ::std::os::raw::c_ushort,
sub_region: nk_rect,
) -> nk_image;
}
extern "C" {
pub fn nk_subimage_id(
arg1: ::std::os::raw::c_int,
w: ::std::os::raw::c_ushort,
h: ::std::os::raw::c_ushort,
sub_region: nk_rect,
) -> nk_image;
}
extern "C" {
pub fn nk_subimage_handle(
arg1: nk_handle,
w: ::std::os::raw::c_ushort,
h: ::std::os::raw::c_ushort,
sub_region: nk_rect,
) -> nk_image;
}
extern "C" {
pub fn nk_murmur_hash(
key: *const ::std::os::raw::c_void,
len: ::std::os::raw::c_int,
seed: nk_hash,
) -> nk_hash;
}
extern "C" {
pub fn nk_triangle_from_direction(
result: *mut nk_vec2,
r: nk_rect,
pad_x: f32,
pad_y: f32,
arg1: nk_heading,
);
}
extern "C" {
pub fn nk_vec2(x: f32, y: f32) -> nk_vec2;
}
extern "C" {
pub fn nk_vec2i(x: ::std::os::raw::c_int, y: ::std::os::raw::c_int) -> nk_vec2;
}
extern "C" {
pub fn nk_vec2v(xy: *const f32) -> nk_vec2;
}
extern "C" {
pub fn nk_vec2iv(xy: *const ::std::os::raw::c_int) -> nk_vec2;
}
extern "C" {
pub fn nk_get_null_rect() -> nk_rect;
}
extern "C" {
pub fn nk_rect(x: f32, y: f32, w: f32, h: f32) -> nk_rect;
}
extern "C" {
pub fn nk_recti(
x: ::std::os::raw::c_int,
y: ::std::os::raw::c_int,
w: ::std::os::raw::c_int,
h: ::std::os::raw::c_int,
) -> nk_rect;
}
extern "C" {
pub fn nk_recta(pos: nk_vec2, size: nk_vec2) -> nk_rect;
}
extern "C" {
pub fn nk_rectv(xywh: *const f32) -> nk_rect;
}
extern "C" {
pub fn nk_rectiv(xywh: *const ::std::os::raw::c_int) -> nk_rect;
}
extern "C" {
pub fn nk_rect_pos(arg1: nk_rect) -> nk_vec2;
}
extern "C" {
pub fn nk_rect_size(arg1: nk_rect) -> nk_vec2;
}
extern "C" {
pub fn nk_strlen(str: *const ::std::os::raw::c_char) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_stricmp(
s1: *const ::std::os::raw::c_char,
s2: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_stricmpn(
s1: *const ::std::os::raw::c_char,
s2: *const ::std::os::raw::c_char,
n: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_strtoi(
str: *const ::std::os::raw::c_char,
endptr: *mut *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_strtof(
str: *const ::std::os::raw::c_char,
endptr: *mut *const ::std::os::raw::c_char,
) -> f32;
}
extern "C" {
pub fn nk_strtod(
str: *const ::std::os::raw::c_char,
endptr: *mut *const ::std::os::raw::c_char,
) -> f64;
}
extern "C" {
pub fn nk_strfilter(
text: *const ::std::os::raw::c_char,
regexp: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_strmatch_fuzzy_string(
str: *const ::std::os::raw::c_char,
pattern: *const ::std::os::raw::c_char,
out_score: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_strmatch_fuzzy_text(
txt: *const ::std::os::raw::c_char,
txt_len: ::std::os::raw::c_int,
pattern: *const ::std::os::raw::c_char,
out_score: *mut ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_utf_decode(
arg1: *const ::std::os::raw::c_char,
arg2: *mut nk_rune,
arg3: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_utf_encode(
arg1: nk_rune,
arg2: *mut ::std::os::raw::c_char,
arg3: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_utf_len(
arg1: *const ::std::os::raw::c_char,
byte_len: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_utf_at(
buffer: *const ::std::os::raw::c_char,
length: ::std::os::raw::c_int,
index: ::std::os::raw::c_int,
unicode: *mut nk_rune,
len: *mut ::std::os::raw::c_int,
) -> *const ::std::os::raw::c_char;
}
pub type nk_text_width_f = ::std::option::Option<
unsafe extern "C" fn(
arg1: nk_handle,
h: f32,
arg2: *const ::std::os::raw::c_char,
len: ::std::os::raw::c_int,
) -> f32,
>;
pub type nk_query_font_glyph_f = ::std::option::Option<
unsafe extern "C" fn(
handle: nk_handle,
font_height: f32,
glyph: *mut nk_user_font_glyph,
codepoint: nk_rune,
next_codepoint: nk_rune,
),
>;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct nk_user_font_glyph {
pub uv: [nk_vec2; 2usize],
pub offset: nk_vec2,
pub width: f32,
pub height: f32,
pub xadvance: f32,
}
#[test]
fn bindgen_test_layout_nk_user_font_glyph() {
assert_eq!(
::std::mem::size_of::<nk_user_font_glyph>(),
36usize,
concat!("Size of: ", stringify!(nk_user_font_glyph))
);
assert_eq!(
::std::mem::align_of::<nk_user_font_glyph>(),
4usize,
concat!("Alignment of ", stringify!(nk_user_font_glyph))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_user_font_glyph>())).uv as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_user_font_glyph),
"::",
stringify!(uv)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_user_font_glyph>())).offset as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(nk_user_font_glyph),
"::",
stringify!(offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_user_font_glyph>())).width as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(nk_user_font_glyph),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_user_font_glyph>())).height as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(nk_user_font_glyph),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_user_font_glyph>())).xadvance as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_user_font_glyph),
"::",
stringify!(xadvance)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_user_font {
pub userdata: nk_handle,
pub height: f32,
pub width: nk_text_width_f,
pub query: nk_query_font_glyph_f,
pub texture: nk_handle,
}
#[test]
fn bindgen_test_layout_nk_user_font() {
assert_eq!(
::std::mem::size_of::<nk_user_font>(),
40usize,
concat!("Size of: ", stringify!(nk_user_font))
);
assert_eq!(
::std::mem::align_of::<nk_user_font>(),
8usize,
concat!("Alignment of ", stringify!(nk_user_font))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_user_font>())).userdata as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_user_font),
"::",
stringify!(userdata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_user_font>())).height as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_user_font),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_user_font>())).width as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(nk_user_font),
"::",
stringify!(width)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_user_font>())).query as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(nk_user_font),
"::",
stringify!(query)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_user_font>())).texture as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_user_font),
"::",
stringify!(texture)
)
);
}
impl Default for nk_user_font {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub const nk_font_coord_type_NK_COORD_UV: nk_font_coord_type = 0;
pub const nk_font_coord_type_NK_COORD_PIXEL: nk_font_coord_type = 1;
pub type nk_font_coord_type = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nk_baked_font {
pub height: f32,
pub ascent: f32,
pub descent: f32,
pub glyph_offset: nk_rune,
pub glyph_count: nk_rune,
pub ranges: *const nk_rune,
}
#[test]
fn bindgen_test_layout_nk_baked_font() {
assert_eq!(
::std::mem::size_of::<nk_baked_font>(),
32usize,
concat!("Size of: ", stringify!(nk_baked_font))
);
assert_eq!(
::std::mem::align_of::<nk_baked_font>(),
8usize,
concat!("Alignment of ", stringify!(nk_baked_font))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_baked_font>())).height as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_baked_font),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_baked_font>())).ascent as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(nk_baked_font),
"::",
stringify!(ascent)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_baked_font>())).descent as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_baked_font),
"::",
stringify!(descent)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_baked_font>())).glyph_offset as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(nk_baked_font),
"::",
stringify!(glyph_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_baked_font>())).glyph_count as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(nk_baked_font),
"::",
stringify!(glyph_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_baked_font>())).ranges as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(nk_baked_font),
"::",
stringify!(ranges)
)
);
}
impl Default for nk_baked_font {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nk_font_config {
pub next: *mut nk_font_config,
pub ttf_blob: *mut ::std::os::raw::c_void,
pub ttf_size: nk_size,
pub ttf_data_owned_by_atlas: ::std::os::raw::c_uchar,
pub merge_mode: ::std::os::raw::c_uchar,
pub pixel_snap: ::std::os::raw::c_uchar,
pub oversample_v: ::std::os::raw::c_uchar,
pub oversample_h: ::std::os::raw::c_uchar,
pub padding: [::std::os::raw::c_uchar; 3usize],
pub size: f32,
pub coord_type: nk_font_coord_type,
pub spacing: nk_vec2,
pub range: *const nk_rune,
pub font: *mut nk_baked_font,
pub fallback_glyph: nk_rune,
pub n: *mut nk_font_config,
pub p: *mut nk_font_config,
}
#[test]
fn bindgen_test_layout_nk_font_config() {
assert_eq!(
::std::mem::size_of::<nk_font_config>(),
88usize,
concat!("Size of: ", stringify!(nk_font_config))
);
assert_eq!(
::std::mem::align_of::<nk_font_config>(),
8usize,
concat!("Alignment of ", stringify!(nk_font_config))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_config>())).next as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_font_config),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_config>())).ttf_blob as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_font_config),
"::",
stringify!(ttf_blob)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_config>())).ttf_size as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(nk_font_config),
"::",
stringify!(ttf_size)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_font_config>())).ttf_data_owned_by_atlas as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(nk_font_config),
"::",
stringify!(ttf_data_owned_by_atlas)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_config>())).merge_mode as *const _ as usize },
25usize,
concat!(
"Offset of field: ",
stringify!(nk_font_config),
"::",
stringify!(merge_mode)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_config>())).pixel_snap as *const _ as usize },
26usize,
concat!(
"Offset of field: ",
stringify!(nk_font_config),
"::",
stringify!(pixel_snap)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_config>())).oversample_v as *const _ as usize },
27usize,
concat!(
"Offset of field: ",
stringify!(nk_font_config),
"::",
stringify!(oversample_v)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_config>())).oversample_h as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(nk_font_config),
"::",
stringify!(oversample_h)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_config>())).padding as *const _ as usize },
29usize,
concat!(
"Offset of field: ",
stringify!(nk_font_config),
"::",
stringify!(padding)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_config>())).size as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_font_config),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_config>())).coord_type as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(nk_font_config),
"::",
stringify!(coord_type)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_config>())).spacing as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(nk_font_config),
"::",
stringify!(spacing)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_config>())).range as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(nk_font_config),
"::",
stringify!(range)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_config>())).font as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(nk_font_config),
"::",
stringify!(font)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_config>())).fallback_glyph as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(nk_font_config),
"::",
stringify!(fallback_glyph)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_config>())).n as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(nk_font_config),
"::",
stringify!(n)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_config>())).p as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(nk_font_config),
"::",
stringify!(p)
)
);
}
impl Default for nk_font_config {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct nk_font_glyph {
pub codepoint: nk_rune,
pub xadvance: f32,
pub x0: f32,
pub y0: f32,
pub x1: f32,
pub y1: f32,
pub w: f32,
pub h: f32,
pub u0: f32,
pub v0: f32,
pub u1: f32,
pub v1: f32,
}
#[test]
fn bindgen_test_layout_nk_font_glyph() {
assert_eq!(
::std::mem::size_of::<nk_font_glyph>(),
48usize,
concat!("Size of: ", stringify!(nk_font_glyph))
);
assert_eq!(
::std::mem::align_of::<nk_font_glyph>(),
4usize,
concat!("Alignment of ", stringify!(nk_font_glyph))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_glyph>())).codepoint as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_font_glyph),
"::",
stringify!(codepoint)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_glyph>())).xadvance as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(nk_font_glyph),
"::",
stringify!(xadvance)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_glyph>())).x0 as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_font_glyph),
"::",
stringify!(x0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_glyph>())).y0 as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(nk_font_glyph),
"::",
stringify!(y0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_glyph>())).x1 as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(nk_font_glyph),
"::",
stringify!(x1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_glyph>())).y1 as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(nk_font_glyph),
"::",
stringify!(y1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_glyph>())).w as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(nk_font_glyph),
"::",
stringify!(w)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_glyph>())).h as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(nk_font_glyph),
"::",
stringify!(h)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_glyph>())).u0 as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_font_glyph),
"::",
stringify!(u0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_glyph>())).v0 as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(nk_font_glyph),
"::",
stringify!(v0)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_glyph>())).u1 as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(nk_font_glyph),
"::",
stringify!(u1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_glyph>())).v1 as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(nk_font_glyph),
"::",
stringify!(v1)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_font {
pub next: *mut nk_font,
pub handle: nk_user_font,
pub info: nk_baked_font,
pub scale: f32,
pub glyphs: *mut nk_font_glyph,
pub fallback: *const nk_font_glyph,
pub fallback_codepoint: nk_rune,
pub texture: nk_handle,
pub config: *mut nk_font_config,
}
#[test]
fn bindgen_test_layout_nk_font() {
assert_eq!(
::std::mem::size_of::<nk_font>(),
128usize,
concat!("Size of: ", stringify!(nk_font))
);
assert_eq!(
::std::mem::align_of::<nk_font>(),
8usize,
concat!("Alignment of ", stringify!(nk_font))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font>())).next as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_font),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font>())).handle as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_font),
"::",
stringify!(handle)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font>())).info as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(nk_font),
"::",
stringify!(info)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font>())).scale as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(nk_font),
"::",
stringify!(scale)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font>())).glyphs as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(nk_font),
"::",
stringify!(glyphs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font>())).fallback as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(nk_font),
"::",
stringify!(fallback)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font>())).fallback_codepoint as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(nk_font),
"::",
stringify!(fallback_codepoint)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font>())).texture as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(nk_font),
"::",
stringify!(texture)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font>())).config as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(nk_font),
"::",
stringify!(config)
)
);
}
impl Default for nk_font {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub const nk_font_atlas_format_NK_FONT_ATLAS_ALPHA8: nk_font_atlas_format = 0;
pub const nk_font_atlas_format_NK_FONT_ATLAS_RGBA32: nk_font_atlas_format = 1;
pub const nk_font_atlas_format_NK_FONT_ATLAS_ARGB32: nk_font_atlas_format = 2;
pub type nk_font_atlas_format = u32;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_font_atlas {
pub pixel: *mut ::std::os::raw::c_void,
pub tex_width: ::std::os::raw::c_int,
pub tex_height: ::std::os::raw::c_int,
pub permanent: nk_allocator,
pub temporary: nk_allocator,
pub custom: nk_recti,
pub cursors: [nk_cursor; 7usize],
pub glyph_count: ::std::os::raw::c_int,
pub glyphs: *mut nk_font_glyph,
pub default_font: *mut nk_font,
pub fonts: *mut nk_font,
pub config: *mut nk_font_config,
pub font_num: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_nk_font_atlas() {
assert_eq!(
::std::mem::size_of::<nk_font_atlas>(),
400usize,
concat!("Size of: ", stringify!(nk_font_atlas))
);
assert_eq!(
::std::mem::align_of::<nk_font_atlas>(),
8usize,
concat!("Alignment of ", stringify!(nk_font_atlas))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_atlas>())).pixel as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_font_atlas),
"::",
stringify!(pixel)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_atlas>())).tex_width as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_font_atlas),
"::",
stringify!(tex_width)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_atlas>())).tex_height as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(nk_font_atlas),
"::",
stringify!(tex_height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_atlas>())).permanent as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(nk_font_atlas),
"::",
stringify!(permanent)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_atlas>())).temporary as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(nk_font_atlas),
"::",
stringify!(temporary)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_atlas>())).custom as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(nk_font_atlas),
"::",
stringify!(custom)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_atlas>())).cursors as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(nk_font_atlas),
"::",
stringify!(cursors)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_atlas>())).glyph_count as *const _ as usize },
352usize,
concat!(
"Offset of field: ",
stringify!(nk_font_atlas),
"::",
stringify!(glyph_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_atlas>())).glyphs as *const _ as usize },
360usize,
concat!(
"Offset of field: ",
stringify!(nk_font_atlas),
"::",
stringify!(glyphs)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_atlas>())).default_font as *const _ as usize },
368usize,
concat!(
"Offset of field: ",
stringify!(nk_font_atlas),
"::",
stringify!(default_font)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_atlas>())).fonts as *const _ as usize },
376usize,
concat!(
"Offset of field: ",
stringify!(nk_font_atlas),
"::",
stringify!(fonts)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_atlas>())).config as *const _ as usize },
384usize,
concat!(
"Offset of field: ",
stringify!(nk_font_atlas),
"::",
stringify!(config)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_font_atlas>())).font_num as *const _ as usize },
392usize,
concat!(
"Offset of field: ",
stringify!(nk_font_atlas),
"::",
stringify!(font_num)
)
);
}
impl Default for nk_font_atlas {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
pub fn nk_font_default_glyph_ranges() -> *const nk_rune;
}
extern "C" {
pub fn nk_font_chinese_glyph_ranges() -> *const nk_rune;
}
extern "C" {
pub fn nk_font_cyrillic_glyph_ranges() -> *const nk_rune;
}
extern "C" {
pub fn nk_font_korean_glyph_ranges() -> *const nk_rune;
}
extern "C" {
pub fn nk_font_atlas_init(arg1: *mut nk_font_atlas, arg2: *mut nk_allocator);
}
extern "C" {
pub fn nk_font_atlas_init_custom(
arg1: *mut nk_font_atlas,
persistent: *mut nk_allocator,
transient: *mut nk_allocator,
);
}
extern "C" {
pub fn nk_font_atlas_begin(arg1: *mut nk_font_atlas);
}
extern "C" {
pub fn nk_font_config(pixel_height: f32) -> nk_font_config;
}
extern "C" {
pub fn nk_font_atlas_add(arg1: *mut nk_font_atlas, arg2: *const nk_font_config)
-> *mut nk_font;
}
extern "C" {
pub fn nk_font_atlas_add_from_memory(
atlas: *mut nk_font_atlas,
memory: *mut ::std::os::raw::c_void,
size: nk_size,
height: f32,
config: *const nk_font_config,
) -> *mut nk_font;
}
extern "C" {
pub fn nk_font_atlas_add_compressed(
arg1: *mut nk_font_atlas,
memory: *mut ::std::os::raw::c_void,
size: nk_size,
height: f32,
arg2: *const nk_font_config,
) -> *mut nk_font;
}
extern "C" {
pub fn nk_font_atlas_add_compressed_base85(
arg1: *mut nk_font_atlas,
data: *const ::std::os::raw::c_char,
height: f32,
config: *const nk_font_config,
) -> *mut nk_font;
}
extern "C" {
pub fn nk_font_atlas_bake(
arg1: *mut nk_font_atlas,
width: *mut ::std::os::raw::c_int,
height: *mut ::std::os::raw::c_int,
arg2: nk_font_atlas_format,
) -> *const ::std::os::raw::c_void;
}
extern "C" {
pub fn nk_font_atlas_end(
arg1: *mut nk_font_atlas,
tex: nk_handle,
arg2: *mut nk_draw_null_texture,
);
}
extern "C" {
pub fn nk_font_find_glyph(arg1: *mut nk_font, unicode: nk_rune) -> *const nk_font_glyph;
}
extern "C" {
pub fn nk_font_atlas_cleanup(atlas: *mut nk_font_atlas);
}
extern "C" {
pub fn nk_font_atlas_clear(arg1: *mut nk_font_atlas);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nk_memory_status {
pub memory: *mut ::std::os::raw::c_void,
pub type_: ::std::os::raw::c_uint,
pub size: nk_size,
pub allocated: nk_size,
pub needed: nk_size,
pub calls: nk_size,
}
#[test]
fn bindgen_test_layout_nk_memory_status() {
assert_eq!(
::std::mem::size_of::<nk_memory_status>(),
48usize,
concat!("Size of: ", stringify!(nk_memory_status))
);
assert_eq!(
::std::mem::align_of::<nk_memory_status>(),
8usize,
concat!("Alignment of ", stringify!(nk_memory_status))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_memory_status>())).memory as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_memory_status),
"::",
stringify!(memory)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_memory_status>())).type_ as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_memory_status),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_memory_status>())).size as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(nk_memory_status),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_memory_status>())).allocated as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(nk_memory_status),
"::",
stringify!(allocated)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_memory_status>())).needed as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_memory_status),
"::",
stringify!(needed)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_memory_status>())).calls as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(nk_memory_status),
"::",
stringify!(calls)
)
);
}
impl Default for nk_memory_status {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub const nk_allocation_type_NK_BUFFER_FIXED: nk_allocation_type = 0;
pub const nk_allocation_type_NK_BUFFER_DYNAMIC: nk_allocation_type = 1;
pub type nk_allocation_type = u32;
pub const nk_buffer_allocation_type_NK_BUFFER_FRONT: nk_buffer_allocation_type = 0;
pub const nk_buffer_allocation_type_NK_BUFFER_BACK: nk_buffer_allocation_type = 1;
pub const nk_buffer_allocation_type_NK_BUFFER_MAX: nk_buffer_allocation_type = 2;
pub type nk_buffer_allocation_type = u32;
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct nk_buffer_marker {
pub active: ::std::os::raw::c_int,
pub offset: nk_size,
}
#[test]
fn bindgen_test_layout_nk_buffer_marker() {
assert_eq!(
::std::mem::size_of::<nk_buffer_marker>(),
16usize,
concat!("Size of: ", stringify!(nk_buffer_marker))
);
assert_eq!(
::std::mem::align_of::<nk_buffer_marker>(),
8usize,
concat!("Alignment of ", stringify!(nk_buffer_marker))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_buffer_marker>())).active as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_buffer_marker),
"::",
stringify!(active)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_buffer_marker>())).offset as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_buffer_marker),
"::",
stringify!(offset)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nk_memory {
pub ptr: *mut ::std::os::raw::c_void,
pub size: nk_size,
}
#[test]
fn bindgen_test_layout_nk_memory() {
assert_eq!(
::std::mem::size_of::<nk_memory>(),
16usize,
concat!("Size of: ", stringify!(nk_memory))
);
assert_eq!(
::std::mem::align_of::<nk_memory>(),
8usize,
concat!("Alignment of ", stringify!(nk_memory))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_memory>())).ptr as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_memory),
"::",
stringify!(ptr)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_memory>())).size as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_memory),
"::",
stringify!(size)
)
);
}
impl Default for nk_memory {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_buffer {
pub marker: [nk_buffer_marker; 2usize],
pub pool: nk_allocator,
pub type_: nk_allocation_type,
pub memory: nk_memory,
pub grow_factor: f32,
pub allocated: nk_size,
pub needed: nk_size,
pub calls: nk_size,
pub size: nk_size,
}
#[test]
fn bindgen_test_layout_nk_buffer() {
assert_eq!(
::std::mem::size_of::<nk_buffer>(),
120usize,
concat!("Size of: ", stringify!(nk_buffer))
);
assert_eq!(
::std::mem::align_of::<nk_buffer>(),
8usize,
concat!("Alignment of ", stringify!(nk_buffer))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_buffer>())).marker as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_buffer),
"::",
stringify!(marker)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_buffer>())).pool as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_buffer),
"::",
stringify!(pool)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_buffer>())).type_ as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(nk_buffer),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_buffer>())).memory as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(nk_buffer),
"::",
stringify!(memory)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_buffer>())).grow_factor as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(nk_buffer),
"::",
stringify!(grow_factor)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_buffer>())).allocated as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(nk_buffer),
"::",
stringify!(allocated)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_buffer>())).needed as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(nk_buffer),
"::",
stringify!(needed)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_buffer>())).calls as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(nk_buffer),
"::",
stringify!(calls)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_buffer>())).size as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(nk_buffer),
"::",
stringify!(size)
)
);
}
impl Default for nk_buffer {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
impl Debug for nk_buffer {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("nk_buffer")
.field("marker", &self.pool)
.field("type_", &self.type_)
.field("memory", &self.memory)
.field("grow_factor", &self.grow_factor)
.field("allocated", &self.allocated)
.field("needed", &self.needed)
.field("calls", &self.calls)
.field("size", &self.size)
.finish()
}
}
extern "C" {
pub fn nk_buffer_init(arg1: *mut nk_buffer, arg2: *const nk_allocator, size: nk_size);
}
extern "C" {
pub fn nk_buffer_init_fixed(
arg1: *mut nk_buffer,
memory: *mut ::std::os::raw::c_void,
size: nk_size,
);
}
extern "C" {
pub fn nk_buffer_info(arg1: *mut nk_memory_status, arg2: *mut nk_buffer);
}
extern "C" {
pub fn nk_buffer_push(
arg1: *mut nk_buffer,
type_: nk_buffer_allocation_type,
memory: *const ::std::os::raw::c_void,
size: nk_size,
align: nk_size,
);
}
extern "C" {
pub fn nk_buffer_mark(arg1: *mut nk_buffer, type_: nk_buffer_allocation_type);
}
extern "C" {
pub fn nk_buffer_reset(arg1: *mut nk_buffer, type_: nk_buffer_allocation_type);
}
extern "C" {
pub fn nk_buffer_clear(arg1: *mut nk_buffer);
}
extern "C" {
pub fn nk_buffer_free(arg1: *mut nk_buffer);
}
extern "C" {
pub fn nk_buffer_memory(arg1: *mut nk_buffer) -> *mut ::std::os::raw::c_void;
}
extern "C" {
pub fn nk_buffer_memory_const(arg1: *const nk_buffer) -> *const ::std::os::raw::c_void;
}
extern "C" {
pub fn nk_buffer_total(arg1: *mut nk_buffer) -> nk_size;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_str {
pub buffer: nk_buffer,
pub len: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_nk_str() {
assert_eq!(
::std::mem::size_of::<nk_str>(),
128usize,
concat!("Size of: ", stringify!(nk_str))
);
assert_eq!(
::std::mem::align_of::<nk_str>(),
8usize,
concat!("Alignment of ", stringify!(nk_str))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_str>())).buffer as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_str),
"::",
stringify!(buffer)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_str>())).len as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(nk_str),
"::",
stringify!(len)
)
);
}
impl Default for nk_str {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
pub fn nk_str_init(arg1: *mut nk_str, arg2: *const nk_allocator, size: nk_size);
}
extern "C" {
pub fn nk_str_init_fixed(arg1: *mut nk_str, memory: *mut ::std::os::raw::c_void, size: nk_size);
}
extern "C" {
pub fn nk_str_clear(arg1: *mut nk_str);
}
extern "C" {
pub fn nk_str_free(arg1: *mut nk_str);
}
extern "C" {
pub fn nk_str_append_text_char(
arg1: *mut nk_str,
arg2: *const ::std::os::raw::c_char,
arg3: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_str_append_str_char(
arg1: *mut nk_str,
arg2: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_str_append_text_utf8(
arg1: *mut nk_str,
arg2: *const ::std::os::raw::c_char,
arg3: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_str_append_str_utf8(
arg1: *mut nk_str,
arg2: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_str_append_text_runes(
arg1: *mut nk_str,
arg2: *const nk_rune,
arg3: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_str_append_str_runes(
arg1: *mut nk_str,
arg2: *const nk_rune,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_str_insert_at_char(
arg1: *mut nk_str,
pos: ::std::os::raw::c_int,
arg2: *const ::std::os::raw::c_char,
arg3: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_str_insert_at_rune(
arg1: *mut nk_str,
pos: ::std::os::raw::c_int,
arg2: *const ::std::os::raw::c_char,
arg3: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_str_insert_text_char(
arg1: *mut nk_str,
pos: ::std::os::raw::c_int,
arg2: *const ::std::os::raw::c_char,
arg3: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_str_insert_str_char(
arg1: *mut nk_str,
pos: ::std::os::raw::c_int,
arg2: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_str_insert_text_utf8(
arg1: *mut nk_str,
pos: ::std::os::raw::c_int,
arg2: *const ::std::os::raw::c_char,
arg3: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_str_insert_str_utf8(
arg1: *mut nk_str,
pos: ::std::os::raw::c_int,
arg2: *const ::std::os::raw::c_char,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_str_insert_text_runes(
arg1: *mut nk_str,
pos: ::std::os::raw::c_int,
arg2: *const nk_rune,
arg3: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_str_insert_str_runes(
arg1: *mut nk_str,
pos: ::std::os::raw::c_int,
arg2: *const nk_rune,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_str_remove_chars(arg1: *mut nk_str, len: ::std::os::raw::c_int);
}
extern "C" {
pub fn nk_str_remove_runes(str: *mut nk_str, len: ::std::os::raw::c_int);
}
extern "C" {
pub fn nk_str_delete_chars(
arg1: *mut nk_str,
pos: ::std::os::raw::c_int,
len: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn nk_str_delete_runes(
arg1: *mut nk_str,
pos: ::std::os::raw::c_int,
len: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn nk_str_at_char(
arg1: *mut nk_str,
pos: ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn nk_str_at_rune(
arg1: *mut nk_str,
pos: ::std::os::raw::c_int,
unicode: *mut nk_rune,
len: *mut ::std::os::raw::c_int,
) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn nk_str_rune_at(arg1: *const nk_str, pos: ::std::os::raw::c_int) -> nk_rune;
}
extern "C" {
pub fn nk_str_at_char_const(
arg1: *const nk_str,
pos: ::std::os::raw::c_int,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn nk_str_at_const(
arg1: *const nk_str,
pos: ::std::os::raw::c_int,
unicode: *mut nk_rune,
len: *mut ::std::os::raw::c_int,
) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn nk_str_get(arg1: *mut nk_str) -> *mut ::std::os::raw::c_char;
}
extern "C" {
pub fn nk_str_get_const(arg1: *const nk_str) -> *const ::std::os::raw::c_char;
}
extern "C" {
pub fn nk_str_len(arg1: *mut nk_str) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_str_len_char(arg1: *mut nk_str) -> ::std::os::raw::c_int;
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_clipboard {
pub userdata: nk_handle,
pub paste: nk_plugin_paste,
pub copy: nk_plugin_copy,
}
#[test]
fn bindgen_test_layout_nk_clipboard() {
assert_eq!(
::std::mem::size_of::<nk_clipboard>(),
24usize,
concat!("Size of: ", stringify!(nk_clipboard))
);
assert_eq!(
::std::mem::align_of::<nk_clipboard>(),
8usize,
concat!("Alignment of ", stringify!(nk_clipboard))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_clipboard>())).userdata as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_clipboard),
"::",
stringify!(userdata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_clipboard>())).paste as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_clipboard),
"::",
stringify!(paste)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_clipboard>())).copy as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(nk_clipboard),
"::",
stringify!(copy)
)
);
}
impl Default for nk_clipboard {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct nk_text_undo_record {
pub where_: ::std::os::raw::c_int,
pub insert_length: ::std::os::raw::c_short,
pub delete_length: ::std::os::raw::c_short,
pub char_storage: ::std::os::raw::c_short,
}
#[test]
fn bindgen_test_layout_nk_text_undo_record() {
assert_eq!(
::std::mem::size_of::<nk_text_undo_record>(),
12usize,
concat!("Size of: ", stringify!(nk_text_undo_record))
);
assert_eq!(
::std::mem::align_of::<nk_text_undo_record>(),
4usize,
concat!("Alignment of ", stringify!(nk_text_undo_record))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_text_undo_record>())).where_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_text_undo_record),
"::",
stringify!(where_)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_text_undo_record>())).insert_length as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(nk_text_undo_record),
"::",
stringify!(insert_length)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_text_undo_record>())).delete_length as *const _ as usize
},
6usize,
concat!(
"Offset of field: ",
stringify!(nk_text_undo_record),
"::",
stringify!(delete_length)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_text_undo_record>())).char_storage as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(nk_text_undo_record),
"::",
stringify!(char_storage)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_text_undo_state {
pub undo_rec: [nk_text_undo_record; 99usize],
pub undo_char: [nk_rune; 999usize],
pub undo_point: ::std::os::raw::c_short,
pub redo_point: ::std::os::raw::c_short,
pub undo_char_point: ::std::os::raw::c_short,
pub redo_char_point: ::std::os::raw::c_short,
}
#[test]
fn bindgen_test_layout_nk_text_undo_state() {
assert_eq!(
::std::mem::size_of::<nk_text_undo_state>(),
5192usize,
concat!("Size of: ", stringify!(nk_text_undo_state))
);
assert_eq!(
::std::mem::align_of::<nk_text_undo_state>(),
4usize,
concat!("Alignment of ", stringify!(nk_text_undo_state))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_text_undo_state>())).undo_rec as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_text_undo_state),
"::",
stringify!(undo_rec)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_text_undo_state>())).undo_char as *const _ as usize },
1188usize,
concat!(
"Offset of field: ",
stringify!(nk_text_undo_state),
"::",
stringify!(undo_char)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_text_undo_state>())).undo_point as *const _ as usize },
5184usize,
concat!(
"Offset of field: ",
stringify!(nk_text_undo_state),
"::",
stringify!(undo_point)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_text_undo_state>())).redo_point as *const _ as usize },
5186usize,
concat!(
"Offset of field: ",
stringify!(nk_text_undo_state),
"::",
stringify!(redo_point)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_text_undo_state>())).undo_char_point as *const _ as usize
},
5188usize,
concat!(
"Offset of field: ",
stringify!(nk_text_undo_state),
"::",
stringify!(undo_char_point)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_text_undo_state>())).redo_char_point as *const _ as usize
},
5190usize,
concat!(
"Offset of field: ",
stringify!(nk_text_undo_state),
"::",
stringify!(redo_char_point)
)
);
}
impl Default for nk_text_undo_state {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub const nk_text_edit_type_NK_TEXT_EDIT_SINGLE_LINE: nk_text_edit_type = 0;
pub const nk_text_edit_type_NK_TEXT_EDIT_MULTI_LINE: nk_text_edit_type = 1;
pub type nk_text_edit_type = u32;
pub const nk_text_edit_mode_NK_TEXT_EDIT_MODE_VIEW: nk_text_edit_mode = 0;
pub const nk_text_edit_mode_NK_TEXT_EDIT_MODE_INSERT: nk_text_edit_mode = 1;
pub const nk_text_edit_mode_NK_TEXT_EDIT_MODE_REPLACE: nk_text_edit_mode = 2;
pub type nk_text_edit_mode = u32;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_text_edit {
pub clip: nk_clipboard,
pub string: nk_str,
pub filter: nk_plugin_filter,
pub scrollbar: nk_vec2,
pub cursor: ::std::os::raw::c_int,
pub select_start: ::std::os::raw::c_int,
pub select_end: ::std::os::raw::c_int,
pub mode: ::std::os::raw::c_uchar,
pub cursor_at_end_of_line: ::std::os::raw::c_uchar,
pub initialized: ::std::os::raw::c_uchar,
pub has_preferred_x: ::std::os::raw::c_uchar,
pub single_line: ::std::os::raw::c_uchar,
pub active: ::std::os::raw::c_uchar,
pub padding1: ::std::os::raw::c_uchar,
pub preferred_x: f32,
pub undo: nk_text_undo_state,
}
#[test]
fn bindgen_test_layout_nk_text_edit() {
assert_eq!(
::std::mem::size_of::<nk_text_edit>(),
5384usize,
concat!("Size of: ", stringify!(nk_text_edit))
);
assert_eq!(
::std::mem::align_of::<nk_text_edit>(),
8usize,
concat!("Alignment of ", stringify!(nk_text_edit))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_text_edit>())).clip as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_text_edit),
"::",
stringify!(clip)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_text_edit>())).string as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(nk_text_edit),
"::",
stringify!(string)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_text_edit>())).filter as *const _ as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(nk_text_edit),
"::",
stringify!(filter)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_text_edit>())).scrollbar as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(nk_text_edit),
"::",
stringify!(scrollbar)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_text_edit>())).cursor as *const _ as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(nk_text_edit),
"::",
stringify!(cursor)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_text_edit>())).select_start as *const _ as usize },
172usize,
concat!(
"Offset of field: ",
stringify!(nk_text_edit),
"::",
stringify!(select_start)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_text_edit>())).select_end as *const _ as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(nk_text_edit),
"::",
stringify!(select_end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_text_edit>())).mode as *const _ as usize },
180usize,
concat!(
"Offset of field: ",
stringify!(nk_text_edit),
"::",
stringify!(mode)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_text_edit>())).cursor_at_end_of_line as *const _ as usize
},
181usize,
concat!(
"Offset of field: ",
stringify!(nk_text_edit),
"::",
stringify!(cursor_at_end_of_line)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_text_edit>())).initialized as *const _ as usize },
182usize,
concat!(
"Offset of field: ",
stringify!(nk_text_edit),
"::",
stringify!(initialized)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_text_edit>())).has_preferred_x as *const _ as usize },
183usize,
concat!(
"Offset of field: ",
stringify!(nk_text_edit),
"::",
stringify!(has_preferred_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_text_edit>())).single_line as *const _ as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(nk_text_edit),
"::",
stringify!(single_line)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_text_edit>())).active as *const _ as usize },
185usize,
concat!(
"Offset of field: ",
stringify!(nk_text_edit),
"::",
stringify!(active)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_text_edit>())).padding1 as *const _ as usize },
186usize,
concat!(
"Offset of field: ",
stringify!(nk_text_edit),
"::",
stringify!(padding1)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_text_edit>())).preferred_x as *const _ as usize },
188usize,
concat!(
"Offset of field: ",
stringify!(nk_text_edit),
"::",
stringify!(preferred_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_text_edit>())).undo as *const _ as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(nk_text_edit),
"::",
stringify!(undo)
)
);
}
impl Default for nk_text_edit {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
pub fn nk_filter_default(arg1: *const nk_text_edit, unicode: nk_rune) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_filter_ascii(arg1: *const nk_text_edit, unicode: nk_rune) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_filter_float(arg1: *const nk_text_edit, unicode: nk_rune) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_filter_decimal(arg1: *const nk_text_edit, unicode: nk_rune) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_filter_hex(arg1: *const nk_text_edit, unicode: nk_rune) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_filter_oct(arg1: *const nk_text_edit, unicode: nk_rune) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_filter_binary(arg1: *const nk_text_edit, unicode: nk_rune) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_textedit_init(arg1: *mut nk_text_edit, arg2: *mut nk_allocator, size: nk_size);
}
extern "C" {
pub fn nk_textedit_init_fixed(
arg1: *mut nk_text_edit,
memory: *mut ::std::os::raw::c_void,
size: nk_size,
);
}
extern "C" {
pub fn nk_textedit_free(arg1: *mut nk_text_edit);
}
extern "C" {
pub fn nk_textedit_text(
arg1: *mut nk_text_edit,
arg2: *const ::std::os::raw::c_char,
total_len: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn nk_textedit_delete(
arg1: *mut nk_text_edit,
where_: ::std::os::raw::c_int,
len: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn nk_textedit_delete_selection(arg1: *mut nk_text_edit);
}
extern "C" {
pub fn nk_textedit_select_all(arg1: *mut nk_text_edit);
}
extern "C" {
pub fn nk_textedit_cut(arg1: *mut nk_text_edit) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_textedit_paste(
arg1: *mut nk_text_edit,
arg2: *const ::std::os::raw::c_char,
len: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_textedit_undo(arg1: *mut nk_text_edit);
}
extern "C" {
pub fn nk_textedit_redo(arg1: *mut nk_text_edit);
}
pub const nk_command_type_NK_COMMAND_NOP: nk_command_type = 0;
pub const nk_command_type_NK_COMMAND_SCISSOR: nk_command_type = 1;
pub const nk_command_type_NK_COMMAND_LINE: nk_command_type = 2;
pub const nk_command_type_NK_COMMAND_CURVE: nk_command_type = 3;
pub const nk_command_type_NK_COMMAND_RECT: nk_command_type = 4;
pub const nk_command_type_NK_COMMAND_RECT_FILLED: nk_command_type = 5;
pub const nk_command_type_NK_COMMAND_RECT_MULTI_COLOR: nk_command_type = 6;
pub const nk_command_type_NK_COMMAND_CIRCLE: nk_command_type = 7;
pub const nk_command_type_NK_COMMAND_CIRCLE_FILLED: nk_command_type = 8;
pub const nk_command_type_NK_COMMAND_ARC: nk_command_type = 9;
pub const nk_command_type_NK_COMMAND_ARC_FILLED: nk_command_type = 10;
pub const nk_command_type_NK_COMMAND_TRIANGLE: nk_command_type = 11;
pub const nk_command_type_NK_COMMAND_TRIANGLE_FILLED: nk_command_type = 12;
pub const nk_command_type_NK_COMMAND_POLYGON: nk_command_type = 13;
pub const nk_command_type_NK_COMMAND_POLYGON_FILLED: nk_command_type = 14;
pub const nk_command_type_NK_COMMAND_POLYLINE: nk_command_type = 15;
pub const nk_command_type_NK_COMMAND_TEXT: nk_command_type = 16;
pub const nk_command_type_NK_COMMAND_IMAGE: nk_command_type = 17;
pub const nk_command_type_NK_COMMAND_CUSTOM: nk_command_type = 18;
pub type nk_command_type = u32;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_command {
pub type_: nk_command_type,
pub next: nk_size,
pub userdata: nk_handle,
}
#[test]
fn bindgen_test_layout_nk_command() {
assert_eq!(
::std::mem::size_of::<nk_command>(),
24usize,
concat!("Size of: ", stringify!(nk_command))
);
assert_eq!(
::std::mem::align_of::<nk_command>(),
8usize,
concat!("Alignment of ", stringify!(nk_command))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_command),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command>())).next as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_command),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command>())).userdata as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(nk_command),
"::",
stringify!(userdata)
)
);
}
impl Default for nk_command {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_command_scissor {
pub header: nk_command,
pub x: ::std::os::raw::c_short,
pub y: ::std::os::raw::c_short,
pub w: ::std::os::raw::c_ushort,
pub h: ::std::os::raw::c_ushort,
}
#[test]
fn bindgen_test_layout_nk_command_scissor() {
assert_eq!(
::std::mem::size_of::<nk_command_scissor>(),
32usize,
concat!("Size of: ", stringify!(nk_command_scissor))
);
assert_eq!(
::std::mem::align_of::<nk_command_scissor>(),
8usize,
concat!("Alignment of ", stringify!(nk_command_scissor))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_scissor>())).header as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_command_scissor),
"::",
stringify!(header)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_scissor>())).x as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(nk_command_scissor),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_scissor>())).y as *const _ as usize },
26usize,
concat!(
"Offset of field: ",
stringify!(nk_command_scissor),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_scissor>())).w as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(nk_command_scissor),
"::",
stringify!(w)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_scissor>())).h as *const _ as usize },
30usize,
concat!(
"Offset of field: ",
stringify!(nk_command_scissor),
"::",
stringify!(h)
)
);
}
impl Default for nk_command_scissor {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_command_line {
pub header: nk_command,
pub line_thickness: ::std::os::raw::c_ushort,
pub begin: nk_vec2i,
pub end: nk_vec2i,
pub color: nk_color,
}
#[test]
fn bindgen_test_layout_nk_command_line() {
assert_eq!(
::std::mem::size_of::<nk_command_line>(),
40usize,
concat!("Size of: ", stringify!(nk_command_line))
);
assert_eq!(
::std::mem::align_of::<nk_command_line>(),
8usize,
concat!("Alignment of ", stringify!(nk_command_line))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_line>())).header as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_command_line),
"::",
stringify!(header)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_line>())).line_thickness as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(nk_command_line),
"::",
stringify!(line_thickness)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_line>())).begin as *const _ as usize },
26usize,
concat!(
"Offset of field: ",
stringify!(nk_command_line),
"::",
stringify!(begin)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_line>())).end as *const _ as usize },
30usize,
concat!(
"Offset of field: ",
stringify!(nk_command_line),
"::",
stringify!(end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_line>())).color as *const _ as usize },
34usize,
concat!(
"Offset of field: ",
stringify!(nk_command_line),
"::",
stringify!(color)
)
);
}
impl Default for nk_command_line {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_command_curve {
pub header: nk_command,
pub line_thickness: ::std::os::raw::c_ushort,
pub begin: nk_vec2i,
pub end: nk_vec2i,
pub ctrl: [nk_vec2i; 2usize],
pub color: nk_color,
}
#[test]
fn bindgen_test_layout_nk_command_curve() {
assert_eq!(
::std::mem::size_of::<nk_command_curve>(),
48usize,
concat!("Size of: ", stringify!(nk_command_curve))
);
assert_eq!(
::std::mem::align_of::<nk_command_curve>(),
8usize,
concat!("Alignment of ", stringify!(nk_command_curve))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_curve>())).header as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_command_curve),
"::",
stringify!(header)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_curve>())).line_thickness as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(nk_command_curve),
"::",
stringify!(line_thickness)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_curve>())).begin as *const _ as usize },
26usize,
concat!(
"Offset of field: ",
stringify!(nk_command_curve),
"::",
stringify!(begin)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_curve>())).end as *const _ as usize },
30usize,
concat!(
"Offset of field: ",
stringify!(nk_command_curve),
"::",
stringify!(end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_curve>())).ctrl as *const _ as usize },
34usize,
concat!(
"Offset of field: ",
stringify!(nk_command_curve),
"::",
stringify!(ctrl)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_curve>())).color as *const _ as usize },
42usize,
concat!(
"Offset of field: ",
stringify!(nk_command_curve),
"::",
stringify!(color)
)
);
}
impl Default for nk_command_curve {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_command_rect {
pub header: nk_command,
pub rounding: ::std::os::raw::c_ushort,
pub line_thickness: ::std::os::raw::c_ushort,
pub x: ::std::os::raw::c_short,
pub y: ::std::os::raw::c_short,
pub w: ::std::os::raw::c_ushort,
pub h: ::std::os::raw::c_ushort,
pub color: nk_color,
}
#[test]
fn bindgen_test_layout_nk_command_rect() {
assert_eq!(
::std::mem::size_of::<nk_command_rect>(),
40usize,
concat!("Size of: ", stringify!(nk_command_rect))
);
assert_eq!(
::std::mem::align_of::<nk_command_rect>(),
8usize,
concat!("Alignment of ", stringify!(nk_command_rect))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_rect>())).header as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_command_rect),
"::",
stringify!(header)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_rect>())).rounding as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(nk_command_rect),
"::",
stringify!(rounding)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_rect>())).line_thickness as *const _ as usize },
26usize,
concat!(
"Offset of field: ",
stringify!(nk_command_rect),
"::",
stringify!(line_thickness)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_rect>())).x as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(nk_command_rect),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_rect>())).y as *const _ as usize },
30usize,
concat!(
"Offset of field: ",
stringify!(nk_command_rect),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_rect>())).w as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_command_rect),
"::",
stringify!(w)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_rect>())).h as *const _ as usize },
34usize,
concat!(
"Offset of field: ",
stringify!(nk_command_rect),
"::",
stringify!(h)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_rect>())).color as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(nk_command_rect),
"::",
stringify!(color)
)
);
}
impl Default for nk_command_rect {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_command_rect_filled {
pub header: nk_command,
pub rounding: ::std::os::raw::c_ushort,
pub x: ::std::os::raw::c_short,
pub y: ::std::os::raw::c_short,
pub w: ::std::os::raw::c_ushort,
pub h: ::std::os::raw::c_ushort,
pub color: nk_color,
}
#[test]
fn bindgen_test_layout_nk_command_rect_filled() {
assert_eq!(
::std::mem::size_of::<nk_command_rect_filled>(),
40usize,
concat!("Size of: ", stringify!(nk_command_rect_filled))
);
assert_eq!(
::std::mem::align_of::<nk_command_rect_filled>(),
8usize,
concat!("Alignment of ", stringify!(nk_command_rect_filled))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_rect_filled>())).header as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_command_rect_filled),
"::",
stringify!(header)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_rect_filled>())).rounding as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(nk_command_rect_filled),
"::",
stringify!(rounding)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_rect_filled>())).x as *const _ as usize },
26usize,
concat!(
"Offset of field: ",
stringify!(nk_command_rect_filled),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_rect_filled>())).y as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(nk_command_rect_filled),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_rect_filled>())).w as *const _ as usize },
30usize,
concat!(
"Offset of field: ",
stringify!(nk_command_rect_filled),
"::",
stringify!(w)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_rect_filled>())).h as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_command_rect_filled),
"::",
stringify!(h)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_rect_filled>())).color as *const _ as usize },
34usize,
concat!(
"Offset of field: ",
stringify!(nk_command_rect_filled),
"::",
stringify!(color)
)
);
}
impl Default for nk_command_rect_filled {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_command_rect_multi_color {
pub header: nk_command,
pub x: ::std::os::raw::c_short,
pub y: ::std::os::raw::c_short,
pub w: ::std::os::raw::c_ushort,
pub h: ::std::os::raw::c_ushort,
pub left: nk_color,
pub top: nk_color,
pub bottom: nk_color,
pub right: nk_color,
}
#[test]
fn bindgen_test_layout_nk_command_rect_multi_color() {
assert_eq!(
::std::mem::size_of::<nk_command_rect_multi_color>(),
48usize,
concat!("Size of: ", stringify!(nk_command_rect_multi_color))
);
assert_eq!(
::std::mem::align_of::<nk_command_rect_multi_color>(),
8usize,
concat!("Alignment of ", stringify!(nk_command_rect_multi_color))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_command_rect_multi_color>())).header as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(nk_command_rect_multi_color),
"::",
stringify!(header)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_rect_multi_color>())).x as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(nk_command_rect_multi_color),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_rect_multi_color>())).y as *const _ as usize },
26usize,
concat!(
"Offset of field: ",
stringify!(nk_command_rect_multi_color),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_rect_multi_color>())).w as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(nk_command_rect_multi_color),
"::",
stringify!(w)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_rect_multi_color>())).h as *const _ as usize },
30usize,
concat!(
"Offset of field: ",
stringify!(nk_command_rect_multi_color),
"::",
stringify!(h)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_command_rect_multi_color>())).left as *const _ as usize
},
32usize,
concat!(
"Offset of field: ",
stringify!(nk_command_rect_multi_color),
"::",
stringify!(left)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_rect_multi_color>())).top as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(nk_command_rect_multi_color),
"::",
stringify!(top)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_command_rect_multi_color>())).bottom as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(nk_command_rect_multi_color),
"::",
stringify!(bottom)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_command_rect_multi_color>())).right as *const _ as usize
},
44usize,
concat!(
"Offset of field: ",
stringify!(nk_command_rect_multi_color),
"::",
stringify!(right)
)
);
}
impl Default for nk_command_rect_multi_color {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_command_triangle {
pub header: nk_command,
pub line_thickness: ::std::os::raw::c_ushort,
pub a: nk_vec2i,
pub b: nk_vec2i,
pub c: nk_vec2i,
pub color: nk_color,
}
#[test]
fn bindgen_test_layout_nk_command_triangle() {
assert_eq!(
::std::mem::size_of::<nk_command_triangle>(),
48usize,
concat!("Size of: ", stringify!(nk_command_triangle))
);
assert_eq!(
::std::mem::align_of::<nk_command_triangle>(),
8usize,
concat!("Alignment of ", stringify!(nk_command_triangle))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_triangle>())).header as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_command_triangle),
"::",
stringify!(header)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_command_triangle>())).line_thickness as *const _ as usize
},
24usize,
concat!(
"Offset of field: ",
stringify!(nk_command_triangle),
"::",
stringify!(line_thickness)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_triangle>())).a as *const _ as usize },
26usize,
concat!(
"Offset of field: ",
stringify!(nk_command_triangle),
"::",
stringify!(a)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_triangle>())).b as *const _ as usize },
30usize,
concat!(
"Offset of field: ",
stringify!(nk_command_triangle),
"::",
stringify!(b)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_triangle>())).c as *const _ as usize },
34usize,
concat!(
"Offset of field: ",
stringify!(nk_command_triangle),
"::",
stringify!(c)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_triangle>())).color as *const _ as usize },
38usize,
concat!(
"Offset of field: ",
stringify!(nk_command_triangle),
"::",
stringify!(color)
)
);
}
impl Default for nk_command_triangle {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_command_triangle_filled {
pub header: nk_command,
pub a: nk_vec2i,
pub b: nk_vec2i,
pub c: nk_vec2i,
pub color: nk_color,
}
#[test]
fn bindgen_test_layout_nk_command_triangle_filled() {
assert_eq!(
::std::mem::size_of::<nk_command_triangle_filled>(),
40usize,
concat!("Size of: ", stringify!(nk_command_triangle_filled))
);
assert_eq!(
::std::mem::align_of::<nk_command_triangle_filled>(),
8usize,
concat!("Alignment of ", stringify!(nk_command_triangle_filled))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_command_triangle_filled>())).header as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(nk_command_triangle_filled),
"::",
stringify!(header)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_triangle_filled>())).a as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(nk_command_triangle_filled),
"::",
stringify!(a)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_triangle_filled>())).b as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(nk_command_triangle_filled),
"::",
stringify!(b)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_triangle_filled>())).c as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_command_triangle_filled),
"::",
stringify!(c)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_command_triangle_filled>())).color as *const _ as usize
},
36usize,
concat!(
"Offset of field: ",
stringify!(nk_command_triangle_filled),
"::",
stringify!(color)
)
);
}
impl Default for nk_command_triangle_filled {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_command_circle {
pub header: nk_command,
pub x: ::std::os::raw::c_short,
pub y: ::std::os::raw::c_short,
pub line_thickness: ::std::os::raw::c_ushort,
pub w: ::std::os::raw::c_ushort,
pub h: ::std::os::raw::c_ushort,
pub color: nk_color,
}
#[test]
fn bindgen_test_layout_nk_command_circle() {
assert_eq!(
::std::mem::size_of::<nk_command_circle>(),
40usize,
concat!("Size of: ", stringify!(nk_command_circle))
);
assert_eq!(
::std::mem::align_of::<nk_command_circle>(),
8usize,
concat!("Alignment of ", stringify!(nk_command_circle))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_circle>())).header as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_command_circle),
"::",
stringify!(header)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_circle>())).x as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(nk_command_circle),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_circle>())).y as *const _ as usize },
26usize,
concat!(
"Offset of field: ",
stringify!(nk_command_circle),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_command_circle>())).line_thickness as *const _ as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(nk_command_circle),
"::",
stringify!(line_thickness)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_circle>())).w as *const _ as usize },
30usize,
concat!(
"Offset of field: ",
stringify!(nk_command_circle),
"::",
stringify!(w)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_circle>())).h as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_command_circle),
"::",
stringify!(h)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_circle>())).color as *const _ as usize },
34usize,
concat!(
"Offset of field: ",
stringify!(nk_command_circle),
"::",
stringify!(color)
)
);
}
impl Default for nk_command_circle {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_command_circle_filled {
pub header: nk_command,
pub x: ::std::os::raw::c_short,
pub y: ::std::os::raw::c_short,
pub w: ::std::os::raw::c_ushort,
pub h: ::std::os::raw::c_ushort,
pub color: nk_color,
}
#[test]
fn bindgen_test_layout_nk_command_circle_filled() {
assert_eq!(
::std::mem::size_of::<nk_command_circle_filled>(),
40usize,
concat!("Size of: ", stringify!(nk_command_circle_filled))
);
assert_eq!(
::std::mem::align_of::<nk_command_circle_filled>(),
8usize,
concat!("Alignment of ", stringify!(nk_command_circle_filled))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_circle_filled>())).header as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_command_circle_filled),
"::",
stringify!(header)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_circle_filled>())).x as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(nk_command_circle_filled),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_circle_filled>())).y as *const _ as usize },
26usize,
concat!(
"Offset of field: ",
stringify!(nk_command_circle_filled),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_circle_filled>())).w as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(nk_command_circle_filled),
"::",
stringify!(w)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_circle_filled>())).h as *const _ as usize },
30usize,
concat!(
"Offset of field: ",
stringify!(nk_command_circle_filled),
"::",
stringify!(h)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_circle_filled>())).color as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_command_circle_filled),
"::",
stringify!(color)
)
);
}
impl Default for nk_command_circle_filled {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_command_arc {
pub header: nk_command,
pub cx: ::std::os::raw::c_short,
pub cy: ::std::os::raw::c_short,
pub r: ::std::os::raw::c_ushort,
pub line_thickness: ::std::os::raw::c_ushort,
pub a: [f32; 2usize],
pub color: nk_color,
}
#[test]
fn bindgen_test_layout_nk_command_arc() {
assert_eq!(
::std::mem::size_of::<nk_command_arc>(),
48usize,
concat!("Size of: ", stringify!(nk_command_arc))
);
assert_eq!(
::std::mem::align_of::<nk_command_arc>(),
8usize,
concat!("Alignment of ", stringify!(nk_command_arc))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_arc>())).header as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_command_arc),
"::",
stringify!(header)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_arc>())).cx as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(nk_command_arc),
"::",
stringify!(cx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_arc>())).cy as *const _ as usize },
26usize,
concat!(
"Offset of field: ",
stringify!(nk_command_arc),
"::",
stringify!(cy)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_arc>())).r as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(nk_command_arc),
"::",
stringify!(r)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_arc>())).line_thickness as *const _ as usize },
30usize,
concat!(
"Offset of field: ",
stringify!(nk_command_arc),
"::",
stringify!(line_thickness)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_arc>())).a as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_command_arc),
"::",
stringify!(a)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_arc>())).color as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(nk_command_arc),
"::",
stringify!(color)
)
);
}
impl Default for nk_command_arc {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_command_arc_filled {
pub header: nk_command,
pub cx: ::std::os::raw::c_short,
pub cy: ::std::os::raw::c_short,
pub r: ::std::os::raw::c_ushort,
pub a: [f32; 2usize],
pub color: nk_color,
}
#[test]
fn bindgen_test_layout_nk_command_arc_filled() {
assert_eq!(
::std::mem::size_of::<nk_command_arc_filled>(),
48usize,
concat!("Size of: ", stringify!(nk_command_arc_filled))
);
assert_eq!(
::std::mem::align_of::<nk_command_arc_filled>(),
8usize,
concat!("Alignment of ", stringify!(nk_command_arc_filled))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_arc_filled>())).header as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_command_arc_filled),
"::",
stringify!(header)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_arc_filled>())).cx as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(nk_command_arc_filled),
"::",
stringify!(cx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_arc_filled>())).cy as *const _ as usize },
26usize,
concat!(
"Offset of field: ",
stringify!(nk_command_arc_filled),
"::",
stringify!(cy)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_arc_filled>())).r as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(nk_command_arc_filled),
"::",
stringify!(r)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_arc_filled>())).a as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_command_arc_filled),
"::",
stringify!(a)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_arc_filled>())).color as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(nk_command_arc_filled),
"::",
stringify!(color)
)
);
}
impl Default for nk_command_arc_filled {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_command_polygon {
pub header: nk_command,
pub color: nk_color,
pub line_thickness: ::std::os::raw::c_ushort,
pub point_count: ::std::os::raw::c_ushort,
pub points: [nk_vec2i; 1usize],
}
#[test]
fn bindgen_test_layout_nk_command_polygon() {
assert_eq!(
::std::mem::size_of::<nk_command_polygon>(),
40usize,
concat!("Size of: ", stringify!(nk_command_polygon))
);
assert_eq!(
::std::mem::align_of::<nk_command_polygon>(),
8usize,
concat!("Alignment of ", stringify!(nk_command_polygon))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_polygon>())).header as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_command_polygon),
"::",
stringify!(header)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_polygon>())).color as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(nk_command_polygon),
"::",
stringify!(color)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_command_polygon>())).line_thickness as *const _ as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(nk_command_polygon),
"::",
stringify!(line_thickness)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_polygon>())).point_count as *const _ as usize },
30usize,
concat!(
"Offset of field: ",
stringify!(nk_command_polygon),
"::",
stringify!(point_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_polygon>())).points as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_command_polygon),
"::",
stringify!(points)
)
);
}
impl Default for nk_command_polygon {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_command_polygon_filled {
pub header: nk_command,
pub color: nk_color,
pub point_count: ::std::os::raw::c_ushort,
pub points: [nk_vec2i; 1usize],
}
#[test]
fn bindgen_test_layout_nk_command_polygon_filled() {
assert_eq!(
::std::mem::size_of::<nk_command_polygon_filled>(),
40usize,
concat!("Size of: ", stringify!(nk_command_polygon_filled))
);
assert_eq!(
::std::mem::align_of::<nk_command_polygon_filled>(),
8usize,
concat!("Alignment of ", stringify!(nk_command_polygon_filled))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_command_polygon_filled>())).header as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(nk_command_polygon_filled),
"::",
stringify!(header)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_polygon_filled>())).color as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(nk_command_polygon_filled),
"::",
stringify!(color)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_command_polygon_filled>())).point_count as *const _ as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(nk_command_polygon_filled),
"::",
stringify!(point_count)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_command_polygon_filled>())).points as *const _ as usize
},
30usize,
concat!(
"Offset of field: ",
stringify!(nk_command_polygon_filled),
"::",
stringify!(points)
)
);
}
impl Default for nk_command_polygon_filled {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_command_polyline {
pub header: nk_command,
pub color: nk_color,
pub line_thickness: ::std::os::raw::c_ushort,
pub point_count: ::std::os::raw::c_ushort,
pub points: [nk_vec2i; 1usize],
}
#[test]
fn bindgen_test_layout_nk_command_polyline() {
assert_eq!(
::std::mem::size_of::<nk_command_polyline>(),
40usize,
concat!("Size of: ", stringify!(nk_command_polyline))
);
assert_eq!(
::std::mem::align_of::<nk_command_polyline>(),
8usize,
concat!("Alignment of ", stringify!(nk_command_polyline))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_polyline>())).header as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_command_polyline),
"::",
stringify!(header)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_polyline>())).color as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(nk_command_polyline),
"::",
stringify!(color)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_command_polyline>())).line_thickness as *const _ as usize
},
28usize,
concat!(
"Offset of field: ",
stringify!(nk_command_polyline),
"::",
stringify!(line_thickness)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_polyline>())).point_count as *const _ as usize },
30usize,
concat!(
"Offset of field: ",
stringify!(nk_command_polyline),
"::",
stringify!(point_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_polyline>())).points as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_command_polyline),
"::",
stringify!(points)
)
);
}
impl Default for nk_command_polyline {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_command_image {
pub header: nk_command,
pub x: ::std::os::raw::c_short,
pub y: ::std::os::raw::c_short,
pub w: ::std::os::raw::c_ushort,
pub h: ::std::os::raw::c_ushort,
pub img: nk_image,
pub col: nk_color,
}
#[test]
fn bindgen_test_layout_nk_command_image() {
assert_eq!(
::std::mem::size_of::<nk_command_image>(),
64usize,
concat!("Size of: ", stringify!(nk_command_image))
);
assert_eq!(
::std::mem::align_of::<nk_command_image>(),
8usize,
concat!("Alignment of ", stringify!(nk_command_image))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_image>())).header as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_command_image),
"::",
stringify!(header)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_image>())).x as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(nk_command_image),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_image>())).y as *const _ as usize },
26usize,
concat!(
"Offset of field: ",
stringify!(nk_command_image),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_image>())).w as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(nk_command_image),
"::",
stringify!(w)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_image>())).h as *const _ as usize },
30usize,
concat!(
"Offset of field: ",
stringify!(nk_command_image),
"::",
stringify!(h)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_image>())).img as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_command_image),
"::",
stringify!(img)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_image>())).col as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(nk_command_image),
"::",
stringify!(col)
)
);
}
impl Default for nk_command_image {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub type nk_command_custom_callback = ::std::option::Option<
unsafe extern "C" fn(
canvas: *mut ::std::os::raw::c_void,
x: ::std::os::raw::c_short,
y: ::std::os::raw::c_short,
w: ::std::os::raw::c_ushort,
h: ::std::os::raw::c_ushort,
callback_data: nk_handle,
),
>;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_command_custom {
pub header: nk_command,
pub x: ::std::os::raw::c_short,
pub y: ::std::os::raw::c_short,
pub w: ::std::os::raw::c_ushort,
pub h: ::std::os::raw::c_ushort,
pub callback_data: nk_handle,
pub callback: nk_command_custom_callback,
}
#[test]
fn bindgen_test_layout_nk_command_custom() {
assert_eq!(
::std::mem::size_of::<nk_command_custom>(),
48usize,
concat!("Size of: ", stringify!(nk_command_custom))
);
assert_eq!(
::std::mem::align_of::<nk_command_custom>(),
8usize,
concat!("Alignment of ", stringify!(nk_command_custom))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_custom>())).header as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_command_custom),
"::",
stringify!(header)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_custom>())).x as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(nk_command_custom),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_custom>())).y as *const _ as usize },
26usize,
concat!(
"Offset of field: ",
stringify!(nk_command_custom),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_custom>())).w as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(nk_command_custom),
"::",
stringify!(w)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_custom>())).h as *const _ as usize },
30usize,
concat!(
"Offset of field: ",
stringify!(nk_command_custom),
"::",
stringify!(h)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_custom>())).callback_data as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_command_custom),
"::",
stringify!(callback_data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_custom>())).callback as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(nk_command_custom),
"::",
stringify!(callback)
)
);
}
impl Default for nk_command_custom {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_command_text {
pub header: nk_command,
pub font: *const nk_user_font,
pub background: nk_color,
pub foreground: nk_color,
pub x: ::std::os::raw::c_short,
pub y: ::std::os::raw::c_short,
pub w: ::std::os::raw::c_ushort,
pub h: ::std::os::raw::c_ushort,
pub height: f32,
pub length: ::std::os::raw::c_int,
pub string: [::std::os::raw::c_char; 1usize],
}
#[test]
fn bindgen_test_layout_nk_command_text() {
assert_eq!(
::std::mem::size_of::<nk_command_text>(),
64usize,
concat!("Size of: ", stringify!(nk_command_text))
);
assert_eq!(
::std::mem::align_of::<nk_command_text>(),
8usize,
concat!("Alignment of ", stringify!(nk_command_text))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_text>())).header as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_command_text),
"::",
stringify!(header)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_text>())).font as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(nk_command_text),
"::",
stringify!(font)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_text>())).background as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_command_text),
"::",
stringify!(background)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_text>())).foreground as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(nk_command_text),
"::",
stringify!(foreground)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_text>())).x as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(nk_command_text),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_text>())).y as *const _ as usize },
42usize,
concat!(
"Offset of field: ",
stringify!(nk_command_text),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_text>())).w as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(nk_command_text),
"::",
stringify!(w)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_text>())).h as *const _ as usize },
46usize,
concat!(
"Offset of field: ",
stringify!(nk_command_text),
"::",
stringify!(h)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_text>())).height as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(nk_command_text),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_text>())).length as *const _ as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(nk_command_text),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_text>())).string as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(nk_command_text),
"::",
stringify!(string)
)
);
}
impl Default for nk_command_text {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub const nk_command_clipping_NK_CLIPPING_OFF: nk_command_clipping = 0;
pub const nk_command_clipping_NK_CLIPPING_ON: nk_command_clipping = 1;
pub type nk_command_clipping = u32;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_command_buffer {
pub base: *mut nk_buffer,
pub clip: nk_rect,
pub use_clipping: ::std::os::raw::c_int,
pub userdata: nk_handle,
pub begin: nk_size,
pub end: nk_size,
pub last: nk_size,
}
#[test]
fn bindgen_test_layout_nk_command_buffer() {
assert_eq!(
::std::mem::size_of::<nk_command_buffer>(),
64usize,
concat!("Size of: ", stringify!(nk_command_buffer))
);
assert_eq!(
::std::mem::align_of::<nk_command_buffer>(),
8usize,
concat!("Alignment of ", stringify!(nk_command_buffer))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_buffer>())).base as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_command_buffer),
"::",
stringify!(base)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_buffer>())).clip as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_command_buffer),
"::",
stringify!(clip)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_buffer>())).use_clipping as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(nk_command_buffer),
"::",
stringify!(use_clipping)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_buffer>())).userdata as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_command_buffer),
"::",
stringify!(userdata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_buffer>())).begin as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(nk_command_buffer),
"::",
stringify!(begin)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_buffer>())).end as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(nk_command_buffer),
"::",
stringify!(end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_command_buffer>())).last as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(nk_command_buffer),
"::",
stringify!(last)
)
);
}
impl Default for nk_command_buffer {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
pub fn nk_stroke_line(
b: *mut nk_command_buffer,
x0: f32,
y0: f32,
x1: f32,
y1: f32,
line_thickness: f32,
arg1: nk_color,
);
}
extern "C" {
pub fn nk_stroke_curve(
arg1: *mut nk_command_buffer,
arg2: f32,
arg3: f32,
arg4: f32,
arg5: f32,
arg6: f32,
arg7: f32,
arg8: f32,
arg9: f32,
line_thickness: f32,
arg10: nk_color,
);
}
extern "C" {
pub fn nk_stroke_rect(
arg1: *mut nk_command_buffer,
arg2: nk_rect,
rounding: f32,
line_thickness: f32,
arg3: nk_color,
);
}
extern "C" {
pub fn nk_stroke_circle(
arg1: *mut nk_command_buffer,
arg2: nk_rect,
line_thickness: f32,
arg3: nk_color,
);
}
extern "C" {
pub fn nk_stroke_arc(
arg1: *mut nk_command_buffer,
cx: f32,
cy: f32,
radius: f32,
a_min: f32,
a_max: f32,
line_thickness: f32,
arg2: nk_color,
);
}
extern "C" {
pub fn nk_stroke_triangle(
arg1: *mut nk_command_buffer,
arg2: f32,
arg3: f32,
arg4: f32,
arg5: f32,
arg6: f32,
arg7: f32,
line_thichness: f32,
arg8: nk_color,
);
}
extern "C" {
pub fn nk_stroke_polyline(
arg1: *mut nk_command_buffer,
points: *mut f32,
point_count: ::std::os::raw::c_int,
line_thickness: f32,
col: nk_color,
);
}
extern "C" {
pub fn nk_stroke_polygon(
arg1: *mut nk_command_buffer,
arg2: *mut f32,
point_count: ::std::os::raw::c_int,
line_thickness: f32,
arg3: nk_color,
);
}
extern "C" {
pub fn nk_fill_rect(arg1: *mut nk_command_buffer, arg2: nk_rect, rounding: f32, arg3: nk_color);
}
extern "C" {
pub fn nk_fill_rect_multi_color(
arg1: *mut nk_command_buffer,
arg2: nk_rect,
left: nk_color,
top: nk_color,
right: nk_color,
bottom: nk_color,
);
}
extern "C" {
pub fn nk_fill_circle(arg1: *mut nk_command_buffer, arg2: nk_rect, arg3: nk_color);
}
extern "C" {
pub fn nk_fill_arc(
arg1: *mut nk_command_buffer,
cx: f32,
cy: f32,
radius: f32,
a_min: f32,
a_max: f32,
arg2: nk_color,
);
}
extern "C" {
pub fn nk_fill_triangle(
arg1: *mut nk_command_buffer,
x0: f32,
y0: f32,
x1: f32,
y1: f32,
x2: f32,
y2: f32,
arg2: nk_color,
);
}
extern "C" {
pub fn nk_fill_polygon(
arg1: *mut nk_command_buffer,
arg2: *mut f32,
point_count: ::std::os::raw::c_int,
arg3: nk_color,
);
}
extern "C" {
pub fn nk_draw_image(
arg1: *mut nk_command_buffer,
arg2: nk_rect,
arg3: *const nk_image,
arg4: nk_color,
);
}
extern "C" {
pub fn nk_draw_text(
arg1: *mut nk_command_buffer,
arg2: nk_rect,
text: *const ::std::os::raw::c_char,
len: ::std::os::raw::c_int,
arg3: *const nk_user_font,
arg4: nk_color,
arg5: nk_color,
);
}
extern "C" {
pub fn nk_push_scissor(arg1: *mut nk_command_buffer, arg2: nk_rect);
}
extern "C" {
pub fn nk_push_custom(
arg1: *mut nk_command_buffer,
arg2: nk_rect,
arg3: nk_command_custom_callback,
usr: nk_handle,
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct nk_mouse_button {
pub down: ::std::os::raw::c_int,
pub clicked: ::std::os::raw::c_uint,
pub clicked_pos: nk_vec2,
}
#[test]
fn bindgen_test_layout_nk_mouse_button() {
assert_eq!(
::std::mem::size_of::<nk_mouse_button>(),
16usize,
concat!("Size of: ", stringify!(nk_mouse_button))
);
assert_eq!(
::std::mem::align_of::<nk_mouse_button>(),
4usize,
concat!("Alignment of ", stringify!(nk_mouse_button))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_mouse_button>())).down as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_mouse_button),
"::",
stringify!(down)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_mouse_button>())).clicked as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(nk_mouse_button),
"::",
stringify!(clicked)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_mouse_button>())).clicked_pos as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_mouse_button),
"::",
stringify!(clicked_pos)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct nk_mouse {
pub buttons: [nk_mouse_button; 4usize],
pub pos: nk_vec2,
pub prev: nk_vec2,
pub delta: nk_vec2,
pub scroll_delta: nk_vec2,
pub grab: ::std::os::raw::c_uchar,
pub grabbed: ::std::os::raw::c_uchar,
pub ungrab: ::std::os::raw::c_uchar,
}
#[test]
fn bindgen_test_layout_nk_mouse() {
assert_eq!(
::std::mem::size_of::<nk_mouse>(),
100usize,
concat!("Size of: ", stringify!(nk_mouse))
);
assert_eq!(
::std::mem::align_of::<nk_mouse>(),
4usize,
concat!("Alignment of ", stringify!(nk_mouse))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_mouse>())).buttons as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_mouse),
"::",
stringify!(buttons)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_mouse>())).pos as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(nk_mouse),
"::",
stringify!(pos)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_mouse>())).prev as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(nk_mouse),
"::",
stringify!(prev)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_mouse>())).delta as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(nk_mouse),
"::",
stringify!(delta)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_mouse>())).scroll_delta as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(nk_mouse),
"::",
stringify!(scroll_delta)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_mouse>())).grab as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(nk_mouse),
"::",
stringify!(grab)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_mouse>())).grabbed as *const _ as usize },
97usize,
concat!(
"Offset of field: ",
stringify!(nk_mouse),
"::",
stringify!(grabbed)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_mouse>())).ungrab as *const _ as usize },
98usize,
concat!(
"Offset of field: ",
stringify!(nk_mouse),
"::",
stringify!(ungrab)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct nk_key {
pub down: ::std::os::raw::c_int,
pub clicked: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_nk_key() {
assert_eq!(
::std::mem::size_of::<nk_key>(),
8usize,
concat!("Size of: ", stringify!(nk_key))
);
assert_eq!(
::std::mem::align_of::<nk_key>(),
4usize,
concat!("Alignment of ", stringify!(nk_key))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_key>())).down as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_key),
"::",
stringify!(down)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_key>())).clicked as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(nk_key),
"::",
stringify!(clicked)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct nk_keyboard {
pub keys: [nk_key; 30usize],
pub text: [::std::os::raw::c_char; 16usize],
pub text_len: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_nk_keyboard() {
assert_eq!(
::std::mem::size_of::<nk_keyboard>(),
260usize,
concat!("Size of: ", stringify!(nk_keyboard))
);
assert_eq!(
::std::mem::align_of::<nk_keyboard>(),
4usize,
concat!("Alignment of ", stringify!(nk_keyboard))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_keyboard>())).keys as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_keyboard),
"::",
stringify!(keys)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_keyboard>())).text as *const _ as usize },
240usize,
concat!(
"Offset of field: ",
stringify!(nk_keyboard),
"::",
stringify!(text)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_keyboard>())).text_len as *const _ as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(nk_keyboard),
"::",
stringify!(text_len)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct nk_input {
pub keyboard: nk_keyboard,
pub mouse: nk_mouse,
}
#[test]
fn bindgen_test_layout_nk_input() {
assert_eq!(
::std::mem::size_of::<nk_input>(),
360usize,
concat!("Size of: ", stringify!(nk_input))
);
assert_eq!(
::std::mem::align_of::<nk_input>(),
4usize,
concat!("Alignment of ", stringify!(nk_input))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_input>())).keyboard as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_input),
"::",
stringify!(keyboard)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_input>())).mouse as *const _ as usize },
260usize,
concat!(
"Offset of field: ",
stringify!(nk_input),
"::",
stringify!(mouse)
)
);
}
extern "C" {
pub fn nk_input_has_mouse_click(
arg1: *const nk_input,
arg2: nk_buttons,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_input_has_mouse_click_in_rect(
arg1: *const nk_input,
arg2: nk_buttons,
arg3: nk_rect,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_input_has_mouse_click_down_in_rect(
arg1: *const nk_input,
arg2: nk_buttons,
arg3: nk_rect,
down: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_input_is_mouse_click_in_rect(
arg1: *const nk_input,
arg2: nk_buttons,
arg3: nk_rect,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_input_is_mouse_click_down_in_rect(
i: *const nk_input,
id: nk_buttons,
b: nk_rect,
down: ::std::os::raw::c_int,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_input_any_mouse_click_in_rect(
arg1: *const nk_input,
arg2: nk_rect,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_input_is_mouse_prev_hovering_rect(
arg1: *const nk_input,
arg2: nk_rect,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_input_is_mouse_hovering_rect(
arg1: *const nk_input,
arg2: nk_rect,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_input_mouse_clicked(
arg1: *const nk_input,
arg2: nk_buttons,
arg3: nk_rect,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_input_is_mouse_down(arg1: *const nk_input, arg2: nk_buttons)
-> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_input_is_mouse_pressed(
arg1: *const nk_input,
arg2: nk_buttons,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_input_is_mouse_released(
arg1: *const nk_input,
arg2: nk_buttons,
) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_input_is_key_pressed(arg1: *const nk_input, arg2: nk_keys) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_input_is_key_released(arg1: *const nk_input, arg2: nk_keys) -> ::std::os::raw::c_int;
}
extern "C" {
pub fn nk_input_is_key_down(arg1: *const nk_input, arg2: nk_keys) -> ::std::os::raw::c_int;
}
pub type nk_draw_index = nk_ushort;
pub const nk_draw_list_stroke_NK_STROKE_OPEN: nk_draw_list_stroke = 0;
pub const nk_draw_list_stroke_NK_STROKE_CLOSED: nk_draw_list_stroke = 1;
pub type nk_draw_list_stroke = u32;
pub const nk_draw_vertex_layout_attribute_NK_VERTEX_POSITION: nk_draw_vertex_layout_attribute = 0;
pub const nk_draw_vertex_layout_attribute_NK_VERTEX_COLOR: nk_draw_vertex_layout_attribute = 1;
pub const nk_draw_vertex_layout_attribute_NK_VERTEX_TEXCOORD: nk_draw_vertex_layout_attribute = 2;
pub const nk_draw_vertex_layout_attribute_NK_VERTEX_ATTRIBUTE_COUNT:
nk_draw_vertex_layout_attribute = 3;
pub type nk_draw_vertex_layout_attribute = u32;
pub const nk_draw_vertex_layout_format_NK_FORMAT_SCHAR: nk_draw_vertex_layout_format = 0;
pub const nk_draw_vertex_layout_format_NK_FORMAT_SSHORT: nk_draw_vertex_layout_format = 1;
pub const nk_draw_vertex_layout_format_NK_FORMAT_SINT: nk_draw_vertex_layout_format = 2;
pub const nk_draw_vertex_layout_format_NK_FORMAT_UCHAR: nk_draw_vertex_layout_format = 3;
pub const nk_draw_vertex_layout_format_NK_FORMAT_USHORT: nk_draw_vertex_layout_format = 4;
pub const nk_draw_vertex_layout_format_NK_FORMAT_UINT: nk_draw_vertex_layout_format = 5;
pub const nk_draw_vertex_layout_format_NK_FORMAT_FLOAT: nk_draw_vertex_layout_format = 6;
pub const nk_draw_vertex_layout_format_NK_FORMAT_DOUBLE: nk_draw_vertex_layout_format = 7;
pub const nk_draw_vertex_layout_format_NK_FORMAT_COLOR_BEGIN: nk_draw_vertex_layout_format = 8;
pub const nk_draw_vertex_layout_format_NK_FORMAT_R8G8B8: nk_draw_vertex_layout_format = 8;
pub const nk_draw_vertex_layout_format_NK_FORMAT_R16G15B16: nk_draw_vertex_layout_format = 9;
pub const nk_draw_vertex_layout_format_NK_FORMAT_R32G32B32: nk_draw_vertex_layout_format = 10;
pub const nk_draw_vertex_layout_format_NK_FORMAT_R8G8B8A8: nk_draw_vertex_layout_format = 11;
pub const nk_draw_vertex_layout_format_NK_FORMAT_B8G8R8A8: nk_draw_vertex_layout_format = 12;
pub const nk_draw_vertex_layout_format_NK_FORMAT_R16G15B16A16: nk_draw_vertex_layout_format = 13;
pub const nk_draw_vertex_layout_format_NK_FORMAT_R32G32B32A32: nk_draw_vertex_layout_format = 14;
pub const nk_draw_vertex_layout_format_NK_FORMAT_R32G32B32A32_FLOAT: nk_draw_vertex_layout_format =
15;
pub const nk_draw_vertex_layout_format_NK_FORMAT_R32G32B32A32_DOUBLE: nk_draw_vertex_layout_format =
16;
pub const nk_draw_vertex_layout_format_NK_FORMAT_RGB32: nk_draw_vertex_layout_format = 17;
pub const nk_draw_vertex_layout_format_NK_FORMAT_RGBA32: nk_draw_vertex_layout_format = 18;
pub const nk_draw_vertex_layout_format_NK_FORMAT_COLOR_END: nk_draw_vertex_layout_format = 18;
pub const nk_draw_vertex_layout_format_NK_FORMAT_COUNT: nk_draw_vertex_layout_format = 19;
pub type nk_draw_vertex_layout_format = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nk_draw_vertex_layout_element {
pub attribute: nk_draw_vertex_layout_attribute,
pub format: nk_draw_vertex_layout_format,
pub offset: nk_size,
}
#[test]
fn bindgen_test_layout_nk_draw_vertex_layout_element() {
assert_eq!(
::std::mem::size_of::<nk_draw_vertex_layout_element>(),
16usize,
concat!("Size of: ", stringify!(nk_draw_vertex_layout_element))
);
assert_eq!(
::std::mem::align_of::<nk_draw_vertex_layout_element>(),
8usize,
concat!("Alignment of ", stringify!(nk_draw_vertex_layout_element))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_draw_vertex_layout_element>())).attribute as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(nk_draw_vertex_layout_element),
"::",
stringify!(attribute)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_draw_vertex_layout_element>())).format as *const _ as usize
},
4usize,
concat!(
"Offset of field: ",
stringify!(nk_draw_vertex_layout_element),
"::",
stringify!(format)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_draw_vertex_layout_element>())).offset as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(nk_draw_vertex_layout_element),
"::",
stringify!(offset)
)
);
}
impl Default for nk_draw_vertex_layout_element {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_draw_command {
pub elem_count: ::std::os::raw::c_uint,
pub clip_rect: nk_rect,
pub texture: nk_handle,
pub userdata: nk_handle,
}
#[test]
fn bindgen_test_layout_nk_draw_command() {
assert_eq!(
::std::mem::size_of::<nk_draw_command>(),
40usize,
concat!("Size of: ", stringify!(nk_draw_command))
);
assert_eq!(
::std::mem::align_of::<nk_draw_command>(),
8usize,
concat!("Alignment of ", stringify!(nk_draw_command))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_draw_command>())).elem_count as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_draw_command),
"::",
stringify!(elem_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_draw_command>())).clip_rect as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(nk_draw_command),
"::",
stringify!(clip_rect)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_draw_command>())).texture as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(nk_draw_command),
"::",
stringify!(texture)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_draw_command>())).userdata as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_draw_command),
"::",
stringify!(userdata)
)
);
}
impl Default for nk_draw_command {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_draw_list {
pub clip_rect: nk_rect,
pub circle_vtx: [nk_vec2; 12usize],
pub config: nk_convert_config,
pub buffer: *mut nk_buffer,
pub vertices: *mut nk_buffer,
pub elements: *mut nk_buffer,
pub element_count: ::std::os::raw::c_uint,
pub vertex_count: ::std::os::raw::c_uint,
pub cmd_count: ::std::os::raw::c_uint,
pub cmd_offset: nk_size,
pub path_count: ::std::os::raw::c_uint,
pub path_offset: ::std::os::raw::c_uint,
pub line_AA: nk_anti_aliasing,
pub shape_AA: nk_anti_aliasing,
pub userdata: nk_handle,
}
#[test]
fn bindgen_test_layout_nk_draw_list() {
assert_eq!(
::std::mem::size_of::<nk_draw_list>(),
248usize,
concat!("Size of: ", stringify!(nk_draw_list))
);
assert_eq!(
::std::mem::align_of::<nk_draw_list>(),
8usize,
concat!("Alignment of ", stringify!(nk_draw_list))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_draw_list>())).clip_rect as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_draw_list),
"::",
stringify!(clip_rect)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_draw_list>())).circle_vtx as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(nk_draw_list),
"::",
stringify!(circle_vtx)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_draw_list>())).config as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(nk_draw_list),
"::",
stringify!(config)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_draw_list>())).buffer as *const _ as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(nk_draw_list),
"::",
stringify!(buffer)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_draw_list>())).vertices as *const _ as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(nk_draw_list),
"::",
stringify!(vertices)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_draw_list>())).elements as *const _ as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(nk_draw_list),
"::",
stringify!(elements)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_draw_list>())).element_count as *const _ as usize },
200usize,
concat!(
"Offset of field: ",
stringify!(nk_draw_list),
"::",
stringify!(element_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_draw_list>())).vertex_count as *const _ as usize },
204usize,
concat!(
"Offset of field: ",
stringify!(nk_draw_list),
"::",
stringify!(vertex_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_draw_list>())).cmd_count as *const _ as usize },
208usize,
concat!(
"Offset of field: ",
stringify!(nk_draw_list),
"::",
stringify!(cmd_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_draw_list>())).cmd_offset as *const _ as usize },
216usize,
concat!(
"Offset of field: ",
stringify!(nk_draw_list),
"::",
stringify!(cmd_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_draw_list>())).path_count as *const _ as usize },
224usize,
concat!(
"Offset of field: ",
stringify!(nk_draw_list),
"::",
stringify!(path_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_draw_list>())).path_offset as *const _ as usize },
228usize,
concat!(
"Offset of field: ",
stringify!(nk_draw_list),
"::",
stringify!(path_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_draw_list>())).line_AA as *const _ as usize },
232usize,
concat!(
"Offset of field: ",
stringify!(nk_draw_list),
"::",
stringify!(line_AA)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_draw_list>())).shape_AA as *const _ as usize },
236usize,
concat!(
"Offset of field: ",
stringify!(nk_draw_list),
"::",
stringify!(shape_AA)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_draw_list>())).userdata as *const _ as usize },
240usize,
concat!(
"Offset of field: ",
stringify!(nk_draw_list),
"::",
stringify!(userdata)
)
);
}
impl Default for nk_draw_list {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
pub fn nk_draw_list_init(arg1: *mut nk_draw_list);
}
extern "C" {
pub fn nk_draw_list_setup(
arg1: *mut nk_draw_list,
arg2: *const nk_convert_config,
cmds: *mut nk_buffer,
vertices: *mut nk_buffer,
elements: *mut nk_buffer,
line_aa: nk_anti_aliasing,
shape_aa: nk_anti_aliasing,
);
}
extern "C" {
pub fn nk__draw_list_begin(
arg1: *const nk_draw_list,
arg2: *const nk_buffer,
) -> *const nk_draw_command;
}
extern "C" {
pub fn nk__draw_list_next(
arg1: *const nk_draw_command,
arg2: *const nk_buffer,
arg3: *const nk_draw_list,
) -> *const nk_draw_command;
}
extern "C" {
pub fn nk__draw_list_end(
arg1: *const nk_draw_list,
arg2: *const nk_buffer,
) -> *const nk_draw_command;
}
extern "C" {
pub fn nk_draw_list_path_clear(arg1: *mut nk_draw_list);
}
extern "C" {
pub fn nk_draw_list_path_line_to(arg1: *mut nk_draw_list, pos: nk_vec2);
}
extern "C" {
pub fn nk_draw_list_path_arc_to_fast(
arg1: *mut nk_draw_list,
center: nk_vec2,
radius: f32,
a_min: ::std::os::raw::c_int,
a_max: ::std::os::raw::c_int,
);
}
extern "C" {
pub fn nk_draw_list_path_arc_to(
arg1: *mut nk_draw_list,
center: nk_vec2,
radius: f32,
a_min: f32,
a_max: f32,
segments: ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn nk_draw_list_path_rect_to(
arg1: *mut nk_draw_list,
a: nk_vec2,
b: nk_vec2,
rounding: f32,
);
}
extern "C" {
pub fn nk_draw_list_path_curve_to(
arg1: *mut nk_draw_list,
p2: nk_vec2,
p3: nk_vec2,
p4: nk_vec2,
num_segments: ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn nk_draw_list_path_fill(arg1: *mut nk_draw_list, arg2: nk_color);
}
extern "C" {
pub fn nk_draw_list_path_stroke(
arg1: *mut nk_draw_list,
arg2: nk_color,
closed: nk_draw_list_stroke,
thickness: f32,
);
}
extern "C" {
pub fn nk_draw_list_stroke_line(
arg1: *mut nk_draw_list,
a: nk_vec2,
b: nk_vec2,
arg2: nk_color,
thickness: f32,
);
}
extern "C" {
pub fn nk_draw_list_stroke_rect(
arg1: *mut nk_draw_list,
rect: nk_rect,
arg2: nk_color,
rounding: f32,
thickness: f32,
);
}
extern "C" {
pub fn nk_draw_list_stroke_triangle(
arg1: *mut nk_draw_list,
a: nk_vec2,
b: nk_vec2,
c: nk_vec2,
arg2: nk_color,
thickness: f32,
);
}
extern "C" {
pub fn nk_draw_list_stroke_circle(
arg1: *mut nk_draw_list,
center: nk_vec2,
radius: f32,
arg2: nk_color,
segs: ::std::os::raw::c_uint,
thickness: f32,
);
}
extern "C" {
pub fn nk_draw_list_stroke_curve(
arg1: *mut nk_draw_list,
p0: nk_vec2,
cp0: nk_vec2,
cp1: nk_vec2,
p1: nk_vec2,
arg2: nk_color,
segments: ::std::os::raw::c_uint,
thickness: f32,
);
}
extern "C" {
pub fn nk_draw_list_stroke_poly_line(
arg1: *mut nk_draw_list,
pnts: *const nk_vec2,
cnt: ::std::os::raw::c_uint,
arg2: nk_color,
arg3: nk_draw_list_stroke,
thickness: f32,
arg4: nk_anti_aliasing,
);
}
extern "C" {
pub fn nk_draw_list_fill_rect(
arg1: *mut nk_draw_list,
rect: nk_rect,
arg2: nk_color,
rounding: f32,
);
}
extern "C" {
pub fn nk_draw_list_fill_rect_multi_color(
arg1: *mut nk_draw_list,
rect: nk_rect,
left: nk_color,
top: nk_color,
right: nk_color,
bottom: nk_color,
);
}
extern "C" {
pub fn nk_draw_list_fill_triangle(
arg1: *mut nk_draw_list,
a: nk_vec2,
b: nk_vec2,
c: nk_vec2,
arg2: nk_color,
);
}
extern "C" {
pub fn nk_draw_list_fill_circle(
arg1: *mut nk_draw_list,
center: nk_vec2,
radius: f32,
col: nk_color,
segs: ::std::os::raw::c_uint,
);
}
extern "C" {
pub fn nk_draw_list_fill_poly_convex(
arg1: *mut nk_draw_list,
points: *const nk_vec2,
count: ::std::os::raw::c_uint,
arg2: nk_color,
arg3: nk_anti_aliasing,
);
}
extern "C" {
pub fn nk_draw_list_add_image(
arg1: *mut nk_draw_list,
texture: nk_image,
rect: nk_rect,
arg2: nk_color,
);
}
extern "C" {
pub fn nk_draw_list_add_text(
arg1: *mut nk_draw_list,
arg2: *const nk_user_font,
arg3: nk_rect,
text: *const ::std::os::raw::c_char,
len: ::std::os::raw::c_int,
font_height: f32,
arg4: nk_color,
);
}
extern "C" {
pub fn nk_draw_list_push_userdata(arg1: *mut nk_draw_list, userdata: nk_handle);
}
pub const nk_style_item_type_NK_STYLE_ITEM_COLOR: nk_style_item_type = 0;
pub const nk_style_item_type_NK_STYLE_ITEM_IMAGE: nk_style_item_type = 1;
pub type nk_style_item_type = u32;
#[repr(C)]
#[derive(Copy, Clone)]
pub union nk_style_item_data {
pub image: nk_image,
pub color: nk_color,
_bindgen_union_align: [u64; 3usize],
}
#[test]
fn bindgen_test_layout_nk_style_item_data() {
assert_eq!(
::std::mem::size_of::<nk_style_item_data>(),
24usize,
concat!("Size of: ", stringify!(nk_style_item_data))
);
assert_eq!(
::std::mem::align_of::<nk_style_item_data>(),
8usize,
concat!("Alignment of ", stringify!(nk_style_item_data))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_item_data>())).image as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_style_item_data),
"::",
stringify!(image)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_item_data>())).color as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_style_item_data),
"::",
stringify!(color)
)
);
}
impl Default for nk_style_item_data {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_style_item {
pub type_: nk_style_item_type,
pub data: nk_style_item_data,
}
#[test]
fn bindgen_test_layout_nk_style_item() {
assert_eq!(
::std::mem::size_of::<nk_style_item>(),
32usize,
concat!("Size of: ", stringify!(nk_style_item))
);
assert_eq!(
::std::mem::align_of::<nk_style_item>(),
8usize,
concat!("Alignment of ", stringify!(nk_style_item))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_item>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_style_item),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_item>())).data as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_style_item),
"::",
stringify!(data)
)
);
}
impl Default for nk_style_item {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct nk_style_text {
pub color: nk_color,
pub padding: nk_vec2,
}
#[test]
fn bindgen_test_layout_nk_style_text() {
assert_eq!(
::std::mem::size_of::<nk_style_text>(),
12usize,
concat!("Size of: ", stringify!(nk_style_text))
);
assert_eq!(
::std::mem::align_of::<nk_style_text>(),
4usize,
concat!("Alignment of ", stringify!(nk_style_text))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_text>())).color as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_style_text),
"::",
stringify!(color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_text>())).padding as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(nk_style_text),
"::",
stringify!(padding)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_style_button {
pub normal: nk_style_item,
pub hover: nk_style_item,
pub active: nk_style_item,
pub border_color: nk_color,
pub text_background: nk_color,
pub text_normal: nk_color,
pub text_hover: nk_color,
pub text_active: nk_color,
pub text_alignment: nk_flags,
pub border: f32,
pub rounding: f32,
pub padding: nk_vec2,
pub image_padding: nk_vec2,
pub touch_padding: nk_vec2,
pub userdata: nk_handle,
pub draw_begin: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut nk_command_buffer, userdata: nk_handle),
>,
pub draw_end: ::std::option::Option<
unsafe extern "C" fn(arg1: *mut nk_command_buffer, userdata: nk_handle),
>,
}
#[test]
fn bindgen_test_layout_nk_style_button() {
assert_eq!(
::std::mem::size_of::<nk_style_button>(),
176usize,
concat!("Size of: ", stringify!(nk_style_button))
);
assert_eq!(
::std::mem::align_of::<nk_style_button>(),
8usize,
concat!("Alignment of ", stringify!(nk_style_button))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_button>())).normal as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_style_button),
"::",
stringify!(normal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_button>())).hover as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_style_button),
"::",
stringify!(hover)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_button>())).active as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(nk_style_button),
"::",
stringify!(active)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_button>())).border_color as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(nk_style_button),
"::",
stringify!(border_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_button>())).text_background as *const _ as usize },
100usize,
concat!(
"Offset of field: ",
stringify!(nk_style_button),
"::",
stringify!(text_background)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_button>())).text_normal as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(nk_style_button),
"::",
stringify!(text_normal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_button>())).text_hover as *const _ as usize },
108usize,
concat!(
"Offset of field: ",
stringify!(nk_style_button),
"::",
stringify!(text_hover)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_button>())).text_active as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(nk_style_button),
"::",
stringify!(text_active)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_button>())).text_alignment as *const _ as usize },
116usize,
concat!(
"Offset of field: ",
stringify!(nk_style_button),
"::",
stringify!(text_alignment)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_button>())).border as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(nk_style_button),
"::",
stringify!(border)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_button>())).rounding as *const _ as usize },
124usize,
concat!(
"Offset of field: ",
stringify!(nk_style_button),
"::",
stringify!(rounding)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_button>())).padding as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(nk_style_button),
"::",
stringify!(padding)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_button>())).image_padding as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(nk_style_button),
"::",
stringify!(image_padding)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_button>())).touch_padding as *const _ as usize },
144usize,
concat!(
"Offset of field: ",
stringify!(nk_style_button),
"::",
stringify!(touch_padding)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_button>())).userdata as *const _ as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(nk_style_button),
"::",
stringify!(userdata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_button>())).draw_begin as *const _ as usize },
160usize,
concat!(
"Offset of field: ",
stringify!(nk_style_button),
"::",
stringify!(draw_begin)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_button>())).draw_end as *const _ as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(nk_style_button),
"::",
stringify!(draw_end)
)
);
}
impl Default for nk_style_button {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_style_toggle {
pub normal: nk_style_item,
pub hover: nk_style_item,
pub active: nk_style_item,
pub border_color: nk_color,
pub cursor_normal: nk_style_item,
pub cursor_hover: nk_style_item,
pub text_normal: nk_color,
pub text_hover: nk_color,
pub text_active: nk_color,
pub text_background: nk_color,
pub text_alignment: nk_flags,
pub padding: nk_vec2,
pub touch_padding: nk_vec2,
pub spacing: f32,
pub border: f32,
pub userdata: nk_handle,
pub draw_begin:
::std::option::Option<unsafe extern "C" fn(arg1: *mut nk_command_buffer, arg2: nk_handle)>,
pub draw_end:
::std::option::Option<unsafe extern "C" fn(arg1: *mut nk_command_buffer, arg2: nk_handle)>,
}
#[test]
fn bindgen_test_layout_nk_style_toggle() {
assert_eq!(
::std::mem::size_of::<nk_style_toggle>(),
240usize,
concat!("Size of: ", stringify!(nk_style_toggle))
);
assert_eq!(
::std::mem::align_of::<nk_style_toggle>(),
8usize,
concat!("Alignment of ", stringify!(nk_style_toggle))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_toggle>())).normal as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_style_toggle),
"::",
stringify!(normal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_toggle>())).hover as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_style_toggle),
"::",
stringify!(hover)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_toggle>())).active as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(nk_style_toggle),
"::",
stringify!(active)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_toggle>())).border_color as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(nk_style_toggle),
"::",
stringify!(border_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_toggle>())).cursor_normal as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(nk_style_toggle),
"::",
stringify!(cursor_normal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_toggle>())).cursor_hover as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(nk_style_toggle),
"::",
stringify!(cursor_hover)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_toggle>())).text_normal as *const _ as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(nk_style_toggle),
"::",
stringify!(text_normal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_toggle>())).text_hover as *const _ as usize },
172usize,
concat!(
"Offset of field: ",
stringify!(nk_style_toggle),
"::",
stringify!(text_hover)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_toggle>())).text_active as *const _ as usize },
176usize,
concat!(
"Offset of field: ",
stringify!(nk_style_toggle),
"::",
stringify!(text_active)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_toggle>())).text_background as *const _ as usize },
180usize,
concat!(
"Offset of field: ",
stringify!(nk_style_toggle),
"::",
stringify!(text_background)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_toggle>())).text_alignment as *const _ as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(nk_style_toggle),
"::",
stringify!(text_alignment)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_toggle>())).padding as *const _ as usize },
188usize,
concat!(
"Offset of field: ",
stringify!(nk_style_toggle),
"::",
stringify!(padding)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_toggle>())).touch_padding as *const _ as usize },
196usize,
concat!(
"Offset of field: ",
stringify!(nk_style_toggle),
"::",
stringify!(touch_padding)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_toggle>())).spacing as *const _ as usize },
204usize,
concat!(
"Offset of field: ",
stringify!(nk_style_toggle),
"::",
stringify!(spacing)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_toggle>())).border as *const _ as usize },
208usize,
concat!(
"Offset of field: ",
stringify!(nk_style_toggle),
"::",
stringify!(border)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_toggle>())).userdata as *const _ as usize },
216usize,
concat!(
"Offset of field: ",
stringify!(nk_style_toggle),
"::",
stringify!(userdata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_toggle>())).draw_begin as *const _ as usize },
224usize,
concat!(
"Offset of field: ",
stringify!(nk_style_toggle),
"::",
stringify!(draw_begin)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_toggle>())).draw_end as *const _ as usize },
232usize,
concat!(
"Offset of field: ",
stringify!(nk_style_toggle),
"::",
stringify!(draw_end)
)
);
}
impl Default for nk_style_toggle {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_style_selectable {
pub normal: nk_style_item,
pub hover: nk_style_item,
pub pressed: nk_style_item,
pub normal_active: nk_style_item,
pub hover_active: nk_style_item,
pub pressed_active: nk_style_item,
pub text_normal: nk_color,
pub text_hover: nk_color,
pub text_pressed: nk_color,
pub text_normal_active: nk_color,
pub text_hover_active: nk_color,
pub text_pressed_active: nk_color,
pub text_background: nk_color,
pub text_alignment: nk_flags,
pub rounding: f32,
pub padding: nk_vec2,
pub touch_padding: nk_vec2,
pub image_padding: nk_vec2,
pub userdata: nk_handle,
pub draw_begin:
::std::option::Option<unsafe extern "C" fn(arg1: *mut nk_command_buffer, arg2: nk_handle)>,
pub draw_end:
::std::option::Option<unsafe extern "C" fn(arg1: *mut nk_command_buffer, arg2: nk_handle)>,
}
#[test]
fn bindgen_test_layout_nk_style_selectable() {
assert_eq!(
::std::mem::size_of::<nk_style_selectable>(),
280usize,
concat!("Size of: ", stringify!(nk_style_selectable))
);
assert_eq!(
::std::mem::align_of::<nk_style_selectable>(),
8usize,
concat!("Alignment of ", stringify!(nk_style_selectable))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_selectable>())).normal as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_style_selectable),
"::",
stringify!(normal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_selectable>())).hover as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_style_selectable),
"::",
stringify!(hover)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_selectable>())).pressed as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(nk_style_selectable),
"::",
stringify!(pressed)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_selectable>())).normal_active as *const _ as usize
},
96usize,
concat!(
"Offset of field: ",
stringify!(nk_style_selectable),
"::",
stringify!(normal_active)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_selectable>())).hover_active as *const _ as usize
},
128usize,
concat!(
"Offset of field: ",
stringify!(nk_style_selectable),
"::",
stringify!(hover_active)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_selectable>())).pressed_active as *const _ as usize
},
160usize,
concat!(
"Offset of field: ",
stringify!(nk_style_selectable),
"::",
stringify!(pressed_active)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_selectable>())).text_normal as *const _ as usize },
192usize,
concat!(
"Offset of field: ",
stringify!(nk_style_selectable),
"::",
stringify!(text_normal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_selectable>())).text_hover as *const _ as usize },
196usize,
concat!(
"Offset of field: ",
stringify!(nk_style_selectable),
"::",
stringify!(text_hover)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_selectable>())).text_pressed as *const _ as usize
},
200usize,
concat!(
"Offset of field: ",
stringify!(nk_style_selectable),
"::",
stringify!(text_pressed)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_selectable>())).text_normal_active as *const _ as usize
},
204usize,
concat!(
"Offset of field: ",
stringify!(nk_style_selectable),
"::",
stringify!(text_normal_active)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_selectable>())).text_hover_active as *const _ as usize
},
208usize,
concat!(
"Offset of field: ",
stringify!(nk_style_selectable),
"::",
stringify!(text_hover_active)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_selectable>())).text_pressed_active as *const _ as usize
},
212usize,
concat!(
"Offset of field: ",
stringify!(nk_style_selectable),
"::",
stringify!(text_pressed_active)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_selectable>())).text_background as *const _ as usize
},
216usize,
concat!(
"Offset of field: ",
stringify!(nk_style_selectable),
"::",
stringify!(text_background)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_selectable>())).text_alignment as *const _ as usize
},
220usize,
concat!(
"Offset of field: ",
stringify!(nk_style_selectable),
"::",
stringify!(text_alignment)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_selectable>())).rounding as *const _ as usize },
224usize,
concat!(
"Offset of field: ",
stringify!(nk_style_selectable),
"::",
stringify!(rounding)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_selectable>())).padding as *const _ as usize },
228usize,
concat!(
"Offset of field: ",
stringify!(nk_style_selectable),
"::",
stringify!(padding)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_selectable>())).touch_padding as *const _ as usize
},
236usize,
concat!(
"Offset of field: ",
stringify!(nk_style_selectable),
"::",
stringify!(touch_padding)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_selectable>())).image_padding as *const _ as usize
},
244usize,
concat!(
"Offset of field: ",
stringify!(nk_style_selectable),
"::",
stringify!(image_padding)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_selectable>())).userdata as *const _ as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(nk_style_selectable),
"::",
stringify!(userdata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_selectable>())).draw_begin as *const _ as usize },
264usize,
concat!(
"Offset of field: ",
stringify!(nk_style_selectable),
"::",
stringify!(draw_begin)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_selectable>())).draw_end as *const _ as usize },
272usize,
concat!(
"Offset of field: ",
stringify!(nk_style_selectable),
"::",
stringify!(draw_end)
)
);
}
impl Default for nk_style_selectable {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_style_slider {
pub normal: nk_style_item,
pub hover: nk_style_item,
pub active: nk_style_item,
pub border_color: nk_color,
pub bar_normal: nk_color,
pub bar_hover: nk_color,
pub bar_active: nk_color,
pub bar_filled: nk_color,
pub cursor_normal: nk_style_item,
pub cursor_hover: nk_style_item,
pub cursor_active: nk_style_item,
pub border: f32,
pub rounding: f32,
pub bar_height: f32,
pub padding: nk_vec2,
pub spacing: nk_vec2,
pub cursor_size: nk_vec2,
pub show_buttons: ::std::os::raw::c_int,
pub inc_button: nk_style_button,
pub dec_button: nk_style_button,
pub inc_symbol: nk_symbol_type,
pub dec_symbol: nk_symbol_type,
pub userdata: nk_handle,
pub draw_begin:
::std::option::Option<unsafe extern "C" fn(arg1: *mut nk_command_buffer, arg2: nk_handle)>,
pub draw_end:
::std::option::Option<unsafe extern "C" fn(arg1: *mut nk_command_buffer, arg2: nk_handle)>,
}
#[test]
fn bindgen_test_layout_nk_style_slider() {
assert_eq!(
::std::mem::size_of::<nk_style_slider>(),
640usize,
concat!("Size of: ", stringify!(nk_style_slider))
);
assert_eq!(
::std::mem::align_of::<nk_style_slider>(),
8usize,
concat!("Alignment of ", stringify!(nk_style_slider))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_slider>())).normal as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_style_slider),
"::",
stringify!(normal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_slider>())).hover as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_style_slider),
"::",
stringify!(hover)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_slider>())).active as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(nk_style_slider),
"::",
stringify!(active)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_slider>())).border_color as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(nk_style_slider),
"::",
stringify!(border_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_slider>())).bar_normal as *const _ as usize },
100usize,
concat!(
"Offset of field: ",
stringify!(nk_style_slider),
"::",
stringify!(bar_normal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_slider>())).bar_hover as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(nk_style_slider),
"::",
stringify!(bar_hover)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_slider>())).bar_active as *const _ as usize },
108usize,
concat!(
"Offset of field: ",
stringify!(nk_style_slider),
"::",
stringify!(bar_active)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_slider>())).bar_filled as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(nk_style_slider),
"::",
stringify!(bar_filled)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_slider>())).cursor_normal as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(nk_style_slider),
"::",
stringify!(cursor_normal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_slider>())).cursor_hover as *const _ as usize },
152usize,
concat!(
"Offset of field: ",
stringify!(nk_style_slider),
"::",
stringify!(cursor_hover)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_slider>())).cursor_active as *const _ as usize },
184usize,
concat!(
"Offset of field: ",
stringify!(nk_style_slider),
"::",
stringify!(cursor_active)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_slider>())).border as *const _ as usize },
216usize,
concat!(
"Offset of field: ",
stringify!(nk_style_slider),
"::",
stringify!(border)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_slider>())).rounding as *const _ as usize },
220usize,
concat!(
"Offset of field: ",
stringify!(nk_style_slider),
"::",
stringify!(rounding)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_slider>())).bar_height as *const _ as usize },
224usize,
concat!(
"Offset of field: ",
stringify!(nk_style_slider),
"::",
stringify!(bar_height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_slider>())).padding as *const _ as usize },
228usize,
concat!(
"Offset of field: ",
stringify!(nk_style_slider),
"::",
stringify!(padding)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_slider>())).spacing as *const _ as usize },
236usize,
concat!(
"Offset of field: ",
stringify!(nk_style_slider),
"::",
stringify!(spacing)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_slider>())).cursor_size as *const _ as usize },
244usize,
concat!(
"Offset of field: ",
stringify!(nk_style_slider),
"::",
stringify!(cursor_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_slider>())).show_buttons as *const _ as usize },
252usize,
concat!(
"Offset of field: ",
stringify!(nk_style_slider),
"::",
stringify!(show_buttons)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_slider>())).inc_button as *const _ as usize },
256usize,
concat!(
"Offset of field: ",
stringify!(nk_style_slider),
"::",
stringify!(inc_button)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_slider>())).dec_button as *const _ as usize },
432usize,
concat!(
"Offset of field: ",
stringify!(nk_style_slider),
"::",
stringify!(dec_button)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_slider>())).inc_symbol as *const _ as usize },
608usize,
concat!(
"Offset of field: ",
stringify!(nk_style_slider),
"::",
stringify!(inc_symbol)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_slider>())).dec_symbol as *const _ as usize },
612usize,
concat!(
"Offset of field: ",
stringify!(nk_style_slider),
"::",
stringify!(dec_symbol)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_slider>())).userdata as *const _ as usize },
616usize,
concat!(
"Offset of field: ",
stringify!(nk_style_slider),
"::",
stringify!(userdata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_slider>())).draw_begin as *const _ as usize },
624usize,
concat!(
"Offset of field: ",
stringify!(nk_style_slider),
"::",
stringify!(draw_begin)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_slider>())).draw_end as *const _ as usize },
632usize,
concat!(
"Offset of field: ",
stringify!(nk_style_slider),
"::",
stringify!(draw_end)
)
);
}
impl Default for nk_style_slider {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_style_progress {
pub normal: nk_style_item,
pub hover: nk_style_item,
pub active: nk_style_item,
pub border_color: nk_color,
pub cursor_normal: nk_style_item,
pub cursor_hover: nk_style_item,
pub cursor_active: nk_style_item,
pub cursor_border_color: nk_color,
pub rounding: f32,
pub border: f32,
pub cursor_border: f32,
pub cursor_rounding: f32,
pub padding: nk_vec2,
pub userdata: nk_handle,
pub draw_begin:
::std::option::Option<unsafe extern "C" fn(arg1: *mut nk_command_buffer, arg2: nk_handle)>,
pub draw_end:
::std::option::Option<unsafe extern "C" fn(arg1: *mut nk_command_buffer, arg2: nk_handle)>,
}
#[test]
fn bindgen_test_layout_nk_style_progress() {
assert_eq!(
::std::mem::size_of::<nk_style_progress>(),
256usize,
concat!("Size of: ", stringify!(nk_style_progress))
);
assert_eq!(
::std::mem::align_of::<nk_style_progress>(),
8usize,
concat!("Alignment of ", stringify!(nk_style_progress))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_progress>())).normal as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_style_progress),
"::",
stringify!(normal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_progress>())).hover as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_style_progress),
"::",
stringify!(hover)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_progress>())).active as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(nk_style_progress),
"::",
stringify!(active)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_progress>())).border_color as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(nk_style_progress),
"::",
stringify!(border_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_progress>())).cursor_normal as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(nk_style_progress),
"::",
stringify!(cursor_normal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_progress>())).cursor_hover as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(nk_style_progress),
"::",
stringify!(cursor_hover)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_progress>())).cursor_active as *const _ as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(nk_style_progress),
"::",
stringify!(cursor_active)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_progress>())).cursor_border_color as *const _ as usize
},
200usize,
concat!(
"Offset of field: ",
stringify!(nk_style_progress),
"::",
stringify!(cursor_border_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_progress>())).rounding as *const _ as usize },
204usize,
concat!(
"Offset of field: ",
stringify!(nk_style_progress),
"::",
stringify!(rounding)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_progress>())).border as *const _ as usize },
208usize,
concat!(
"Offset of field: ",
stringify!(nk_style_progress),
"::",
stringify!(border)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_progress>())).cursor_border as *const _ as usize },
212usize,
concat!(
"Offset of field: ",
stringify!(nk_style_progress),
"::",
stringify!(cursor_border)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_progress>())).cursor_rounding as *const _ as usize
},
216usize,
concat!(
"Offset of field: ",
stringify!(nk_style_progress),
"::",
stringify!(cursor_rounding)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_progress>())).padding as *const _ as usize },
220usize,
concat!(
"Offset of field: ",
stringify!(nk_style_progress),
"::",
stringify!(padding)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_progress>())).userdata as *const _ as usize },
232usize,
concat!(
"Offset of field: ",
stringify!(nk_style_progress),
"::",
stringify!(userdata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_progress>())).draw_begin as *const _ as usize },
240usize,
concat!(
"Offset of field: ",
stringify!(nk_style_progress),
"::",
stringify!(draw_begin)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_progress>())).draw_end as *const _ as usize },
248usize,
concat!(
"Offset of field: ",
stringify!(nk_style_progress),
"::",
stringify!(draw_end)
)
);
}
impl Default for nk_style_progress {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_style_scrollbar {
pub normal: nk_style_item,
pub hover: nk_style_item,
pub active: nk_style_item,
pub border_color: nk_color,
pub cursor_normal: nk_style_item,
pub cursor_hover: nk_style_item,
pub cursor_active: nk_style_item,
pub cursor_border_color: nk_color,
pub border: f32,
pub rounding: f32,
pub border_cursor: f32,
pub rounding_cursor: f32,
pub padding: nk_vec2,
pub show_buttons: ::std::os::raw::c_int,
pub inc_button: nk_style_button,
pub dec_button: nk_style_button,
pub inc_symbol: nk_symbol_type,
pub dec_symbol: nk_symbol_type,
pub userdata: nk_handle,
pub draw_begin:
::std::option::Option<unsafe extern "C" fn(arg1: *mut nk_command_buffer, arg2: nk_handle)>,
pub draw_end:
::std::option::Option<unsafe extern "C" fn(arg1: *mut nk_command_buffer, arg2: nk_handle)>,
}
#[test]
fn bindgen_test_layout_nk_style_scrollbar() {
assert_eq!(
::std::mem::size_of::<nk_style_scrollbar>(),
616usize,
concat!("Size of: ", stringify!(nk_style_scrollbar))
);
assert_eq!(
::std::mem::align_of::<nk_style_scrollbar>(),
8usize,
concat!("Alignment of ", stringify!(nk_style_scrollbar))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_scrollbar>())).normal as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_style_scrollbar),
"::",
stringify!(normal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_scrollbar>())).hover as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_style_scrollbar),
"::",
stringify!(hover)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_scrollbar>())).active as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(nk_style_scrollbar),
"::",
stringify!(active)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_scrollbar>())).border_color as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(nk_style_scrollbar),
"::",
stringify!(border_color)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_scrollbar>())).cursor_normal as *const _ as usize
},
104usize,
concat!(
"Offset of field: ",
stringify!(nk_style_scrollbar),
"::",
stringify!(cursor_normal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_scrollbar>())).cursor_hover as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(nk_style_scrollbar),
"::",
stringify!(cursor_hover)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_scrollbar>())).cursor_active as *const _ as usize
},
168usize,
concat!(
"Offset of field: ",
stringify!(nk_style_scrollbar),
"::",
stringify!(cursor_active)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_scrollbar>())).cursor_border_color as *const _ as usize
},
200usize,
concat!(
"Offset of field: ",
stringify!(nk_style_scrollbar),
"::",
stringify!(cursor_border_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_scrollbar>())).border as *const _ as usize },
204usize,
concat!(
"Offset of field: ",
stringify!(nk_style_scrollbar),
"::",
stringify!(border)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_scrollbar>())).rounding as *const _ as usize },
208usize,
concat!(
"Offset of field: ",
stringify!(nk_style_scrollbar),
"::",
stringify!(rounding)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_scrollbar>())).border_cursor as *const _ as usize
},
212usize,
concat!(
"Offset of field: ",
stringify!(nk_style_scrollbar),
"::",
stringify!(border_cursor)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_scrollbar>())).rounding_cursor as *const _ as usize
},
216usize,
concat!(
"Offset of field: ",
stringify!(nk_style_scrollbar),
"::",
stringify!(rounding_cursor)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_scrollbar>())).padding as *const _ as usize },
220usize,
concat!(
"Offset of field: ",
stringify!(nk_style_scrollbar),
"::",
stringify!(padding)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_scrollbar>())).show_buttons as *const _ as usize },
228usize,
concat!(
"Offset of field: ",
stringify!(nk_style_scrollbar),
"::",
stringify!(show_buttons)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_scrollbar>())).inc_button as *const _ as usize },
232usize,
concat!(
"Offset of field: ",
stringify!(nk_style_scrollbar),
"::",
stringify!(inc_button)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_scrollbar>())).dec_button as *const _ as usize },
408usize,
concat!(
"Offset of field: ",
stringify!(nk_style_scrollbar),
"::",
stringify!(dec_button)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_scrollbar>())).inc_symbol as *const _ as usize },
584usize,
concat!(
"Offset of field: ",
stringify!(nk_style_scrollbar),
"::",
stringify!(inc_symbol)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_scrollbar>())).dec_symbol as *const _ as usize },
588usize,
concat!(
"Offset of field: ",
stringify!(nk_style_scrollbar),
"::",
stringify!(dec_symbol)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_scrollbar>())).userdata as *const _ as usize },
592usize,
concat!(
"Offset of field: ",
stringify!(nk_style_scrollbar),
"::",
stringify!(userdata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_scrollbar>())).draw_begin as *const _ as usize },
600usize,
concat!(
"Offset of field: ",
stringify!(nk_style_scrollbar),
"::",
stringify!(draw_begin)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_scrollbar>())).draw_end as *const _ as usize },
608usize,
concat!(
"Offset of field: ",
stringify!(nk_style_scrollbar),
"::",
stringify!(draw_end)
)
);
}
impl Default for nk_style_scrollbar {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_style_edit {
pub normal: nk_style_item,
pub hover: nk_style_item,
pub active: nk_style_item,
pub border_color: nk_color,
pub scrollbar: nk_style_scrollbar,
pub cursor_normal: nk_color,
pub cursor_hover: nk_color,
pub cursor_text_normal: nk_color,
pub cursor_text_hover: nk_color,
pub text_normal: nk_color,
pub text_hover: nk_color,
pub text_active: nk_color,
pub selected_normal: nk_color,
pub selected_hover: nk_color,
pub selected_text_normal: nk_color,
pub selected_text_hover: nk_color,
pub border: f32,
pub rounding: f32,
pub cursor_size: f32,
pub scrollbar_size: nk_vec2,
pub padding: nk_vec2,
pub row_padding: f32,
}
#[test]
fn bindgen_test_layout_nk_style_edit() {
assert_eq!(
::std::mem::size_of::<nk_style_edit>(),
800usize,
concat!("Size of: ", stringify!(nk_style_edit))
);
assert_eq!(
::std::mem::align_of::<nk_style_edit>(),
8usize,
concat!("Alignment of ", stringify!(nk_style_edit))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_edit>())).normal as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_style_edit),
"::",
stringify!(normal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_edit>())).hover as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_style_edit),
"::",
stringify!(hover)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_edit>())).active as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(nk_style_edit),
"::",
stringify!(active)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_edit>())).border_color as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(nk_style_edit),
"::",
stringify!(border_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_edit>())).scrollbar as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(nk_style_edit),
"::",
stringify!(scrollbar)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_edit>())).cursor_normal as *const _ as usize },
720usize,
concat!(
"Offset of field: ",
stringify!(nk_style_edit),
"::",
stringify!(cursor_normal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_edit>())).cursor_hover as *const _ as usize },
724usize,
concat!(
"Offset of field: ",
stringify!(nk_style_edit),
"::",
stringify!(cursor_hover)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_edit>())).cursor_text_normal as *const _ as usize
},
728usize,
concat!(
"Offset of field: ",
stringify!(nk_style_edit),
"::",
stringify!(cursor_text_normal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_edit>())).cursor_text_hover as *const _ as usize },
732usize,
concat!(
"Offset of field: ",
stringify!(nk_style_edit),
"::",
stringify!(cursor_text_hover)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_edit>())).text_normal as *const _ as usize },
736usize,
concat!(
"Offset of field: ",
stringify!(nk_style_edit),
"::",
stringify!(text_normal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_edit>())).text_hover as *const _ as usize },
740usize,
concat!(
"Offset of field: ",
stringify!(nk_style_edit),
"::",
stringify!(text_hover)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_edit>())).text_active as *const _ as usize },
744usize,
concat!(
"Offset of field: ",
stringify!(nk_style_edit),
"::",
stringify!(text_active)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_edit>())).selected_normal as *const _ as usize },
748usize,
concat!(
"Offset of field: ",
stringify!(nk_style_edit),
"::",
stringify!(selected_normal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_edit>())).selected_hover as *const _ as usize },
752usize,
concat!(
"Offset of field: ",
stringify!(nk_style_edit),
"::",
stringify!(selected_hover)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_edit>())).selected_text_normal as *const _ as usize
},
756usize,
concat!(
"Offset of field: ",
stringify!(nk_style_edit),
"::",
stringify!(selected_text_normal)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_edit>())).selected_text_hover as *const _ as usize
},
760usize,
concat!(
"Offset of field: ",
stringify!(nk_style_edit),
"::",
stringify!(selected_text_hover)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_edit>())).border as *const _ as usize },
764usize,
concat!(
"Offset of field: ",
stringify!(nk_style_edit),
"::",
stringify!(border)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_edit>())).rounding as *const _ as usize },
768usize,
concat!(
"Offset of field: ",
stringify!(nk_style_edit),
"::",
stringify!(rounding)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_edit>())).cursor_size as *const _ as usize },
772usize,
concat!(
"Offset of field: ",
stringify!(nk_style_edit),
"::",
stringify!(cursor_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_edit>())).scrollbar_size as *const _ as usize },
776usize,
concat!(
"Offset of field: ",
stringify!(nk_style_edit),
"::",
stringify!(scrollbar_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_edit>())).padding as *const _ as usize },
784usize,
concat!(
"Offset of field: ",
stringify!(nk_style_edit),
"::",
stringify!(padding)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_edit>())).row_padding as *const _ as usize },
792usize,
concat!(
"Offset of field: ",
stringify!(nk_style_edit),
"::",
stringify!(row_padding)
)
);
}
impl Default for nk_style_edit {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_style_property {
pub normal: nk_style_item,
pub hover: nk_style_item,
pub active: nk_style_item,
pub border_color: nk_color,
pub label_normal: nk_color,
pub label_hover: nk_color,
pub label_active: nk_color,
pub sym_left: nk_symbol_type,
pub sym_right: nk_symbol_type,
pub border: f32,
pub rounding: f32,
pub padding: nk_vec2,
pub edit: nk_style_edit,
pub inc_button: nk_style_button,
pub dec_button: nk_style_button,
pub userdata: nk_handle,
pub draw_begin:
::std::option::Option<unsafe extern "C" fn(arg1: *mut nk_command_buffer, arg2: nk_handle)>,
pub draw_end:
::std::option::Option<unsafe extern "C" fn(arg1: *mut nk_command_buffer, arg2: nk_handle)>,
}
#[test]
fn bindgen_test_layout_nk_style_property() {
assert_eq!(
::std::mem::size_of::<nk_style_property>(),
1312usize,
concat!("Size of: ", stringify!(nk_style_property))
);
assert_eq!(
::std::mem::align_of::<nk_style_property>(),
8usize,
concat!("Alignment of ", stringify!(nk_style_property))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_property>())).normal as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_style_property),
"::",
stringify!(normal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_property>())).hover as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_style_property),
"::",
stringify!(hover)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_property>())).active as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(nk_style_property),
"::",
stringify!(active)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_property>())).border_color as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(nk_style_property),
"::",
stringify!(border_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_property>())).label_normal as *const _ as usize },
100usize,
concat!(
"Offset of field: ",
stringify!(nk_style_property),
"::",
stringify!(label_normal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_property>())).label_hover as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(nk_style_property),
"::",
stringify!(label_hover)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_property>())).label_active as *const _ as usize },
108usize,
concat!(
"Offset of field: ",
stringify!(nk_style_property),
"::",
stringify!(label_active)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_property>())).sym_left as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(nk_style_property),
"::",
stringify!(sym_left)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_property>())).sym_right as *const _ as usize },
116usize,
concat!(
"Offset of field: ",
stringify!(nk_style_property),
"::",
stringify!(sym_right)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_property>())).border as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(nk_style_property),
"::",
stringify!(border)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_property>())).rounding as *const _ as usize },
124usize,
concat!(
"Offset of field: ",
stringify!(nk_style_property),
"::",
stringify!(rounding)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_property>())).padding as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(nk_style_property),
"::",
stringify!(padding)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_property>())).edit as *const _ as usize },
136usize,
concat!(
"Offset of field: ",
stringify!(nk_style_property),
"::",
stringify!(edit)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_property>())).inc_button as *const _ as usize },
936usize,
concat!(
"Offset of field: ",
stringify!(nk_style_property),
"::",
stringify!(inc_button)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_property>())).dec_button as *const _ as usize },
1112usize,
concat!(
"Offset of field: ",
stringify!(nk_style_property),
"::",
stringify!(dec_button)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_property>())).userdata as *const _ as usize },
1288usize,
concat!(
"Offset of field: ",
stringify!(nk_style_property),
"::",
stringify!(userdata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_property>())).draw_begin as *const _ as usize },
1296usize,
concat!(
"Offset of field: ",
stringify!(nk_style_property),
"::",
stringify!(draw_begin)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_property>())).draw_end as *const _ as usize },
1304usize,
concat!(
"Offset of field: ",
stringify!(nk_style_property),
"::",
stringify!(draw_end)
)
);
}
impl Default for nk_style_property {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_style_chart {
pub background: nk_style_item,
pub border_color: nk_color,
pub selected_color: nk_color,
pub color: nk_color,
pub border: f32,
pub rounding: f32,
pub padding: nk_vec2,
}
#[test]
fn bindgen_test_layout_nk_style_chart() {
assert_eq!(
::std::mem::size_of::<nk_style_chart>(),
64usize,
concat!("Size of: ", stringify!(nk_style_chart))
);
assert_eq!(
::std::mem::align_of::<nk_style_chart>(),
8usize,
concat!("Alignment of ", stringify!(nk_style_chart))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_chart>())).background as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_style_chart),
"::",
stringify!(background)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_chart>())).border_color as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_style_chart),
"::",
stringify!(border_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_chart>())).selected_color as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(nk_style_chart),
"::",
stringify!(selected_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_chart>())).color as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(nk_style_chart),
"::",
stringify!(color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_chart>())).border as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(nk_style_chart),
"::",
stringify!(border)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_chart>())).rounding as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(nk_style_chart),
"::",
stringify!(rounding)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_chart>())).padding as *const _ as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(nk_style_chart),
"::",
stringify!(padding)
)
);
}
impl Default for nk_style_chart {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_style_combo {
pub normal: nk_style_item,
pub hover: nk_style_item,
pub active: nk_style_item,
pub border_color: nk_color,
pub label_normal: nk_color,
pub label_hover: nk_color,
pub label_active: nk_color,
pub symbol_normal: nk_color,
pub symbol_hover: nk_color,
pub symbol_active: nk_color,
pub button: nk_style_button,
pub sym_normal: nk_symbol_type,
pub sym_hover: nk_symbol_type,
pub sym_active: nk_symbol_type,
pub border: f32,
pub rounding: f32,
pub content_padding: nk_vec2,
pub button_padding: nk_vec2,
pub spacing: nk_vec2,
}
#[test]
fn bindgen_test_layout_nk_style_combo() {
assert_eq!(
::std::mem::size_of::<nk_style_combo>(),
352usize,
concat!("Size of: ", stringify!(nk_style_combo))
);
assert_eq!(
::std::mem::align_of::<nk_style_combo>(),
8usize,
concat!("Alignment of ", stringify!(nk_style_combo))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_combo>())).normal as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_style_combo),
"::",
stringify!(normal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_combo>())).hover as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_style_combo),
"::",
stringify!(hover)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_combo>())).active as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(nk_style_combo),
"::",
stringify!(active)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_combo>())).border_color as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(nk_style_combo),
"::",
stringify!(border_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_combo>())).label_normal as *const _ as usize },
100usize,
concat!(
"Offset of field: ",
stringify!(nk_style_combo),
"::",
stringify!(label_normal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_combo>())).label_hover as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(nk_style_combo),
"::",
stringify!(label_hover)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_combo>())).label_active as *const _ as usize },
108usize,
concat!(
"Offset of field: ",
stringify!(nk_style_combo),
"::",
stringify!(label_active)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_combo>())).symbol_normal as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(nk_style_combo),
"::",
stringify!(symbol_normal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_combo>())).symbol_hover as *const _ as usize },
116usize,
concat!(
"Offset of field: ",
stringify!(nk_style_combo),
"::",
stringify!(symbol_hover)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_combo>())).symbol_active as *const _ as usize },
120usize,
concat!(
"Offset of field: ",
stringify!(nk_style_combo),
"::",
stringify!(symbol_active)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_combo>())).button as *const _ as usize },
128usize,
concat!(
"Offset of field: ",
stringify!(nk_style_combo),
"::",
stringify!(button)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_combo>())).sym_normal as *const _ as usize },
304usize,
concat!(
"Offset of field: ",
stringify!(nk_style_combo),
"::",
stringify!(sym_normal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_combo>())).sym_hover as *const _ as usize },
308usize,
concat!(
"Offset of field: ",
stringify!(nk_style_combo),
"::",
stringify!(sym_hover)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_combo>())).sym_active as *const _ as usize },
312usize,
concat!(
"Offset of field: ",
stringify!(nk_style_combo),
"::",
stringify!(sym_active)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_combo>())).border as *const _ as usize },
316usize,
concat!(
"Offset of field: ",
stringify!(nk_style_combo),
"::",
stringify!(border)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_combo>())).rounding as *const _ as usize },
320usize,
concat!(
"Offset of field: ",
stringify!(nk_style_combo),
"::",
stringify!(rounding)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_combo>())).content_padding as *const _ as usize },
324usize,
concat!(
"Offset of field: ",
stringify!(nk_style_combo),
"::",
stringify!(content_padding)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_combo>())).button_padding as *const _ as usize },
332usize,
concat!(
"Offset of field: ",
stringify!(nk_style_combo),
"::",
stringify!(button_padding)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_combo>())).spacing as *const _ as usize },
340usize,
concat!(
"Offset of field: ",
stringify!(nk_style_combo),
"::",
stringify!(spacing)
)
);
}
impl Default for nk_style_combo {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_style_tab {
pub background: nk_style_item,
pub border_color: nk_color,
pub text: nk_color,
pub tab_maximize_button: nk_style_button,
pub tab_minimize_button: nk_style_button,
pub node_maximize_button: nk_style_button,
pub node_minimize_button: nk_style_button,
pub sym_minimize: nk_symbol_type,
pub sym_maximize: nk_symbol_type,
pub border: f32,
pub rounding: f32,
pub indent: f32,
pub padding: nk_vec2,
pub spacing: nk_vec2,
}
#[test]
fn bindgen_test_layout_nk_style_tab() {
assert_eq!(
::std::mem::size_of::<nk_style_tab>(),
784usize,
concat!("Size of: ", stringify!(nk_style_tab))
);
assert_eq!(
::std::mem::align_of::<nk_style_tab>(),
8usize,
concat!("Alignment of ", stringify!(nk_style_tab))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_tab>())).background as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_style_tab),
"::",
stringify!(background)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_tab>())).border_color as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_style_tab),
"::",
stringify!(border_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_tab>())).text as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(nk_style_tab),
"::",
stringify!(text)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_tab>())).tab_maximize_button as *const _ as usize
},
40usize,
concat!(
"Offset of field: ",
stringify!(nk_style_tab),
"::",
stringify!(tab_maximize_button)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_tab>())).tab_minimize_button as *const _ as usize
},
216usize,
concat!(
"Offset of field: ",
stringify!(nk_style_tab),
"::",
stringify!(tab_minimize_button)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_tab>())).node_maximize_button as *const _ as usize
},
392usize,
concat!(
"Offset of field: ",
stringify!(nk_style_tab),
"::",
stringify!(node_maximize_button)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_tab>())).node_minimize_button as *const _ as usize
},
568usize,
concat!(
"Offset of field: ",
stringify!(nk_style_tab),
"::",
stringify!(node_minimize_button)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_tab>())).sym_minimize as *const _ as usize },
744usize,
concat!(
"Offset of field: ",
stringify!(nk_style_tab),
"::",
stringify!(sym_minimize)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_tab>())).sym_maximize as *const _ as usize },
748usize,
concat!(
"Offset of field: ",
stringify!(nk_style_tab),
"::",
stringify!(sym_maximize)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_tab>())).border as *const _ as usize },
752usize,
concat!(
"Offset of field: ",
stringify!(nk_style_tab),
"::",
stringify!(border)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_tab>())).rounding as *const _ as usize },
756usize,
concat!(
"Offset of field: ",
stringify!(nk_style_tab),
"::",
stringify!(rounding)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_tab>())).indent as *const _ as usize },
760usize,
concat!(
"Offset of field: ",
stringify!(nk_style_tab),
"::",
stringify!(indent)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_tab>())).padding as *const _ as usize },
764usize,
concat!(
"Offset of field: ",
stringify!(nk_style_tab),
"::",
stringify!(padding)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_tab>())).spacing as *const _ as usize },
772usize,
concat!(
"Offset of field: ",
stringify!(nk_style_tab),
"::",
stringify!(spacing)
)
);
}
impl Default for nk_style_tab {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub const nk_style_header_align_NK_HEADER_LEFT: nk_style_header_align = 0;
pub const nk_style_header_align_NK_HEADER_RIGHT: nk_style_header_align = 1;
pub type nk_style_header_align = u32;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_style_window_header {
pub normal: nk_style_item,
pub hover: nk_style_item,
pub active: nk_style_item,
pub close_button: nk_style_button,
pub minimize_button: nk_style_button,
pub close_symbol: nk_symbol_type,
pub minimize_symbol: nk_symbol_type,
pub maximize_symbol: nk_symbol_type,
pub label_normal: nk_color,
pub label_hover: nk_color,
pub label_active: nk_color,
pub align: nk_style_header_align,
pub padding: nk_vec2,
pub label_padding: nk_vec2,
pub spacing: nk_vec2,
}
#[test]
fn bindgen_test_layout_nk_style_window_header() {
assert_eq!(
::std::mem::size_of::<nk_style_window_header>(),
504usize,
concat!("Size of: ", stringify!(nk_style_window_header))
);
assert_eq!(
::std::mem::align_of::<nk_style_window_header>(),
8usize,
concat!("Alignment of ", stringify!(nk_style_window_header))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_window_header>())).normal as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window_header),
"::",
stringify!(normal)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_window_header>())).hover as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window_header),
"::",
stringify!(hover)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_window_header>())).active as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window_header),
"::",
stringify!(active)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_window_header>())).close_button as *const _ as usize
},
96usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window_header),
"::",
stringify!(close_button)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_window_header>())).minimize_button as *const _ as usize
},
272usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window_header),
"::",
stringify!(minimize_button)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_window_header>())).close_symbol as *const _ as usize
},
448usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window_header),
"::",
stringify!(close_symbol)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_window_header>())).minimize_symbol as *const _ as usize
},
452usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window_header),
"::",
stringify!(minimize_symbol)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_window_header>())).maximize_symbol as *const _ as usize
},
456usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window_header),
"::",
stringify!(maximize_symbol)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_window_header>())).label_normal as *const _ as usize
},
460usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window_header),
"::",
stringify!(label_normal)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_window_header>())).label_hover as *const _ as usize
},
464usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window_header),
"::",
stringify!(label_hover)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_window_header>())).label_active as *const _ as usize
},
468usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window_header),
"::",
stringify!(label_active)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_window_header>())).align as *const _ as usize },
472usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window_header),
"::",
stringify!(align)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_window_header>())).padding as *const _ as usize },
476usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window_header),
"::",
stringify!(padding)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_window_header>())).label_padding as *const _ as usize
},
484usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window_header),
"::",
stringify!(label_padding)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_window_header>())).spacing as *const _ as usize },
492usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window_header),
"::",
stringify!(spacing)
)
);
}
impl Default for nk_style_window_header {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_style_window {
pub header: nk_style_window_header,
pub fixed_background: nk_style_item,
pub background: nk_color,
pub border_color: nk_color,
pub popup_border_color: nk_color,
pub combo_border_color: nk_color,
pub contextual_border_color: nk_color,
pub menu_border_color: nk_color,
pub group_border_color: nk_color,
pub tooltip_border_color: nk_color,
pub scaler: nk_style_item,
pub border: f32,
pub combo_border: f32,
pub contextual_border: f32,
pub menu_border: f32,
pub group_border: f32,
pub tooltip_border: f32,
pub popup_border: f32,
pub min_row_height_padding: f32,
pub rounding: f32,
pub spacing: nk_vec2,
pub scrollbar_size: nk_vec2,
pub min_size: nk_vec2,
pub padding: nk_vec2,
pub group_padding: nk_vec2,
pub popup_padding: nk_vec2,
pub combo_padding: nk_vec2,
pub contextual_padding: nk_vec2,
pub menu_padding: nk_vec2,
pub tooltip_padding: nk_vec2,
}
#[test]
fn bindgen_test_layout_nk_style_window() {
assert_eq!(
::std::mem::size_of::<nk_style_window>(),
720usize,
concat!("Size of: ", stringify!(nk_style_window))
);
assert_eq!(
::std::mem::align_of::<nk_style_window>(),
8usize,
concat!("Alignment of ", stringify!(nk_style_window))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_window>())).header as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window),
"::",
stringify!(header)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_window>())).fixed_background as *const _ as usize
},
504usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window),
"::",
stringify!(fixed_background)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_window>())).background as *const _ as usize },
536usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window),
"::",
stringify!(background)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_window>())).border_color as *const _ as usize },
540usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window),
"::",
stringify!(border_color)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_window>())).popup_border_color as *const _ as usize
},
544usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window),
"::",
stringify!(popup_border_color)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_window>())).combo_border_color as *const _ as usize
},
548usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window),
"::",
stringify!(combo_border_color)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_window>())).contextual_border_color as *const _ as usize
},
552usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window),
"::",
stringify!(contextual_border_color)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_window>())).menu_border_color as *const _ as usize
},
556usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window),
"::",
stringify!(menu_border_color)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_window>())).group_border_color as *const _ as usize
},
560usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window),
"::",
stringify!(group_border_color)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_window>())).tooltip_border_color as *const _ as usize
},
564usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window),
"::",
stringify!(tooltip_border_color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_window>())).scaler as *const _ as usize },
568usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window),
"::",
stringify!(scaler)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_window>())).border as *const _ as usize },
600usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window),
"::",
stringify!(border)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_window>())).combo_border as *const _ as usize },
604usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window),
"::",
stringify!(combo_border)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_window>())).contextual_border as *const _ as usize
},
608usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window),
"::",
stringify!(contextual_border)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_window>())).menu_border as *const _ as usize },
612usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window),
"::",
stringify!(menu_border)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_window>())).group_border as *const _ as usize },
616usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window),
"::",
stringify!(group_border)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_window>())).tooltip_border as *const _ as usize },
620usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window),
"::",
stringify!(tooltip_border)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_window>())).popup_border as *const _ as usize },
624usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window),
"::",
stringify!(popup_border)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_window>())).min_row_height_padding as *const _ as usize
},
628usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window),
"::",
stringify!(min_row_height_padding)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_window>())).rounding as *const _ as usize },
632usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window),
"::",
stringify!(rounding)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_window>())).spacing as *const _ as usize },
636usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window),
"::",
stringify!(spacing)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_window>())).scrollbar_size as *const _ as usize },
644usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window),
"::",
stringify!(scrollbar_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_window>())).min_size as *const _ as usize },
652usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window),
"::",
stringify!(min_size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_window>())).padding as *const _ as usize },
660usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window),
"::",
stringify!(padding)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_window>())).group_padding as *const _ as usize },
668usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window),
"::",
stringify!(group_padding)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_window>())).popup_padding as *const _ as usize },
676usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window),
"::",
stringify!(popup_padding)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_window>())).combo_padding as *const _ as usize },
684usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window),
"::",
stringify!(combo_padding)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_style_window>())).contextual_padding as *const _ as usize
},
692usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window),
"::",
stringify!(contextual_padding)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_window>())).menu_padding as *const _ as usize },
700usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window),
"::",
stringify!(menu_padding)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style_window>())).tooltip_padding as *const _ as usize },
708usize,
concat!(
"Offset of field: ",
stringify!(nk_style_window),
"::",
stringify!(tooltip_padding)
)
);
}
impl Default for nk_style_window {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_style {
pub font: *const nk_user_font,
pub cursors: [*const nk_cursor; 7usize],
pub cursor_active: *const nk_cursor,
pub cursor_last: *mut nk_cursor,
pub cursor_visible: ::std::os::raw::c_int,
pub text: nk_style_text,
pub button: nk_style_button,
pub contextual_button: nk_style_button,
pub menu_button: nk_style_button,
pub option: nk_style_toggle,
pub checkbox: nk_style_toggle,
pub selectable: nk_style_selectable,
pub slider: nk_style_slider,
pub progress: nk_style_progress,
pub property: nk_style_property,
pub edit: nk_style_edit,
pub chart: nk_style_chart,
pub scrollh: nk_style_scrollbar,
pub scrollv: nk_style_scrollbar,
pub tab: nk_style_tab,
pub combo: nk_style_combo,
pub window: nk_style_window,
}
#[test]
fn bindgen_test_layout_nk_style() {
assert_eq!(
::std::mem::size_of::<nk_style>(),
7544usize,
concat!("Size of: ", stringify!(nk_style))
);
assert_eq!(
::std::mem::align_of::<nk_style>(),
8usize,
concat!("Alignment of ", stringify!(nk_style))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style>())).font as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_style),
"::",
stringify!(font)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style>())).cursors as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_style),
"::",
stringify!(cursors)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style>())).cursor_active as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(nk_style),
"::",
stringify!(cursor_active)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style>())).cursor_last as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(nk_style),
"::",
stringify!(cursor_last)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style>())).cursor_visible as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(nk_style),
"::",
stringify!(cursor_visible)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style>())).text as *const _ as usize },
84usize,
concat!(
"Offset of field: ",
stringify!(nk_style),
"::",
stringify!(text)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style>())).button as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(nk_style),
"::",
stringify!(button)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style>())).contextual_button as *const _ as usize },
272usize,
concat!(
"Offset of field: ",
stringify!(nk_style),
"::",
stringify!(contextual_button)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style>())).menu_button as *const _ as usize },
448usize,
concat!(
"Offset of field: ",
stringify!(nk_style),
"::",
stringify!(menu_button)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style>())).option as *const _ as usize },
624usize,
concat!(
"Offset of field: ",
stringify!(nk_style),
"::",
stringify!(option)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style>())).checkbox as *const _ as usize },
864usize,
concat!(
"Offset of field: ",
stringify!(nk_style),
"::",
stringify!(checkbox)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style>())).selectable as *const _ as usize },
1104usize,
concat!(
"Offset of field: ",
stringify!(nk_style),
"::",
stringify!(selectable)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style>())).slider as *const _ as usize },
1384usize,
concat!(
"Offset of field: ",
stringify!(nk_style),
"::",
stringify!(slider)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style>())).progress as *const _ as usize },
2024usize,
concat!(
"Offset of field: ",
stringify!(nk_style),
"::",
stringify!(progress)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style>())).property as *const _ as usize },
2280usize,
concat!(
"Offset of field: ",
stringify!(nk_style),
"::",
stringify!(property)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style>())).edit as *const _ as usize },
3592usize,
concat!(
"Offset of field: ",
stringify!(nk_style),
"::",
stringify!(edit)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style>())).chart as *const _ as usize },
4392usize,
concat!(
"Offset of field: ",
stringify!(nk_style),
"::",
stringify!(chart)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style>())).scrollh as *const _ as usize },
4456usize,
concat!(
"Offset of field: ",
stringify!(nk_style),
"::",
stringify!(scrollh)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style>())).scrollv as *const _ as usize },
5072usize,
concat!(
"Offset of field: ",
stringify!(nk_style),
"::",
stringify!(scrollv)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style>())).tab as *const _ as usize },
5688usize,
concat!(
"Offset of field: ",
stringify!(nk_style),
"::",
stringify!(tab)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style>())).combo as *const _ as usize },
6472usize,
concat!(
"Offset of field: ",
stringify!(nk_style),
"::",
stringify!(combo)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_style>())).window as *const _ as usize },
6824usize,
concat!(
"Offset of field: ",
stringify!(nk_style),
"::",
stringify!(window)
)
);
}
impl Default for nk_style {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
extern "C" {
pub fn nk_style_item_image(img: nk_image) -> nk_style_item;
}
extern "C" {
pub fn nk_style_item_color(arg1: nk_color) -> nk_style_item;
}
extern "C" {
pub fn nk_style_item_hide() -> nk_style_item;
}
pub const nk_panel_type_NK_PANEL_NONE: nk_panel_type = 0;
pub const nk_panel_type_NK_PANEL_WINDOW: nk_panel_type = 1;
pub const nk_panel_type_NK_PANEL_GROUP: nk_panel_type = 2;
pub const nk_panel_type_NK_PANEL_POPUP: nk_panel_type = 4;
pub const nk_panel_type_NK_PANEL_CONTEXTUAL: nk_panel_type = 16;
pub const nk_panel_type_NK_PANEL_COMBO: nk_panel_type = 32;
pub const nk_panel_type_NK_PANEL_MENU: nk_panel_type = 64;
pub const nk_panel_type_NK_PANEL_TOOLTIP: nk_panel_type = 128;
pub type nk_panel_type = u32;
pub const nk_panel_set_NK_PANEL_SET_NONBLOCK: nk_panel_set = 240;
pub const nk_panel_set_NK_PANEL_SET_POPUP: nk_panel_set = 244;
pub const nk_panel_set_NK_PANEL_SET_SUB: nk_panel_set = 246;
pub type nk_panel_set = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nk_chart_slot {
pub type_: nk_chart_type,
pub color: nk_color,
pub highlight: nk_color,
pub min: f32,
pub max: f32,
pub range: f32,
pub count: ::std::os::raw::c_int,
pub last: nk_vec2,
pub index: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_nk_chart_slot() {
assert_eq!(
::std::mem::size_of::<nk_chart_slot>(),
40usize,
concat!("Size of: ", stringify!(nk_chart_slot))
);
assert_eq!(
::std::mem::align_of::<nk_chart_slot>(),
4usize,
concat!("Alignment of ", stringify!(nk_chart_slot))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_chart_slot>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_chart_slot),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_chart_slot>())).color as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(nk_chart_slot),
"::",
stringify!(color)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_chart_slot>())).highlight as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_chart_slot),
"::",
stringify!(highlight)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_chart_slot>())).min as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(nk_chart_slot),
"::",
stringify!(min)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_chart_slot>())).max as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(nk_chart_slot),
"::",
stringify!(max)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_chart_slot>())).range as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(nk_chart_slot),
"::",
stringify!(range)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_chart_slot>())).count as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(nk_chart_slot),
"::",
stringify!(count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_chart_slot>())).last as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(nk_chart_slot),
"::",
stringify!(last)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_chart_slot>())).index as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(nk_chart_slot),
"::",
stringify!(index)
)
);
}
impl Default for nk_chart_slot {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nk_chart {
pub slot: ::std::os::raw::c_int,
pub x: f32,
pub y: f32,
pub w: f32,
pub h: f32,
pub slots: [nk_chart_slot; 4usize],
}
#[test]
fn bindgen_test_layout_nk_chart() {
assert_eq!(
::std::mem::size_of::<nk_chart>(),
180usize,
concat!("Size of: ", stringify!(nk_chart))
);
assert_eq!(
::std::mem::align_of::<nk_chart>(),
4usize,
concat!("Alignment of ", stringify!(nk_chart))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_chart>())).slot as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_chart),
"::",
stringify!(slot)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_chart>())).x as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(nk_chart),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_chart>())).y as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_chart),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_chart>())).w as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(nk_chart),
"::",
stringify!(w)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_chart>())).h as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(nk_chart),
"::",
stringify!(h)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_chart>())).slots as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(nk_chart),
"::",
stringify!(slots)
)
);
}
impl Default for nk_chart {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub const nk_panel_row_layout_type_NK_LAYOUT_DYNAMIC_FIXED: nk_panel_row_layout_type = 0;
pub const nk_panel_row_layout_type_NK_LAYOUT_DYNAMIC_ROW: nk_panel_row_layout_type = 1;
pub const nk_panel_row_layout_type_NK_LAYOUT_DYNAMIC_FREE: nk_panel_row_layout_type = 2;
pub const nk_panel_row_layout_type_NK_LAYOUT_DYNAMIC: nk_panel_row_layout_type = 3;
pub const nk_panel_row_layout_type_NK_LAYOUT_STATIC_FIXED: nk_panel_row_layout_type = 4;
pub const nk_panel_row_layout_type_NK_LAYOUT_STATIC_ROW: nk_panel_row_layout_type = 5;
pub const nk_panel_row_layout_type_NK_LAYOUT_STATIC_FREE: nk_panel_row_layout_type = 6;
pub const nk_panel_row_layout_type_NK_LAYOUT_STATIC: nk_panel_row_layout_type = 7;
pub const nk_panel_row_layout_type_NK_LAYOUT_TEMPLATE: nk_panel_row_layout_type = 8;
pub const nk_panel_row_layout_type_NK_LAYOUT_COUNT: nk_panel_row_layout_type = 9;
pub type nk_panel_row_layout_type = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nk_row_layout {
pub type_: nk_panel_row_layout_type,
pub index: ::std::os::raw::c_int,
pub height: f32,
pub min_height: f32,
pub columns: ::std::os::raw::c_int,
pub ratio: *const f32,
pub item_width: f32,
pub item_height: f32,
pub item_offset: f32,
pub filled: f32,
pub item: nk_rect,
pub tree_depth: ::std::os::raw::c_int,
pub templates: [f32; 16usize],
}
#[test]
fn bindgen_test_layout_nk_row_layout() {
assert_eq!(
::std::mem::size_of::<nk_row_layout>(),
136usize,
concat!("Size of: ", stringify!(nk_row_layout))
);
assert_eq!(
::std::mem::align_of::<nk_row_layout>(),
8usize,
concat!("Alignment of ", stringify!(nk_row_layout))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_row_layout>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_row_layout),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_row_layout>())).index as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(nk_row_layout),
"::",
stringify!(index)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_row_layout>())).height as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_row_layout),
"::",
stringify!(height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_row_layout>())).min_height as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(nk_row_layout),
"::",
stringify!(min_height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_row_layout>())).columns as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(nk_row_layout),
"::",
stringify!(columns)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_row_layout>())).ratio as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(nk_row_layout),
"::",
stringify!(ratio)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_row_layout>())).item_width as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_row_layout),
"::",
stringify!(item_width)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_row_layout>())).item_height as *const _ as usize },
36usize,
concat!(
"Offset of field: ",
stringify!(nk_row_layout),
"::",
stringify!(item_height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_row_layout>())).item_offset as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(nk_row_layout),
"::",
stringify!(item_offset)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_row_layout>())).filled as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(nk_row_layout),
"::",
stringify!(filled)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_row_layout>())).item as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(nk_row_layout),
"::",
stringify!(item)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_row_layout>())).tree_depth as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(nk_row_layout),
"::",
stringify!(tree_depth)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_row_layout>())).templates as *const _ as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(nk_row_layout),
"::",
stringify!(templates)
)
);
}
impl Default for nk_row_layout {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct nk_popup_buffer {
pub begin: nk_size,
pub parent: nk_size,
pub last: nk_size,
pub end: nk_size,
pub active: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_nk_popup_buffer() {
assert_eq!(
::std::mem::size_of::<nk_popup_buffer>(),
40usize,
concat!("Size of: ", stringify!(nk_popup_buffer))
);
assert_eq!(
::std::mem::align_of::<nk_popup_buffer>(),
8usize,
concat!("Alignment of ", stringify!(nk_popup_buffer))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_popup_buffer>())).begin as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_popup_buffer),
"::",
stringify!(begin)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_popup_buffer>())).parent as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_popup_buffer),
"::",
stringify!(parent)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_popup_buffer>())).last as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(nk_popup_buffer),
"::",
stringify!(last)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_popup_buffer>())).end as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(nk_popup_buffer),
"::",
stringify!(end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_popup_buffer>())).active as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_popup_buffer),
"::",
stringify!(active)
)
);
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct nk_menu_state {
pub x: f32,
pub y: f32,
pub w: f32,
pub h: f32,
pub offset: nk_scroll,
}
#[test]
fn bindgen_test_layout_nk_menu_state() {
assert_eq!(
::std::mem::size_of::<nk_menu_state>(),
24usize,
concat!("Size of: ", stringify!(nk_menu_state))
);
assert_eq!(
::std::mem::align_of::<nk_menu_state>(),
4usize,
concat!("Alignment of ", stringify!(nk_menu_state))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_menu_state>())).x as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_menu_state),
"::",
stringify!(x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_menu_state>())).y as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(nk_menu_state),
"::",
stringify!(y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_menu_state>())).w as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_menu_state),
"::",
stringify!(w)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_menu_state>())).h as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(nk_menu_state),
"::",
stringify!(h)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_menu_state>())).offset as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(nk_menu_state),
"::",
stringify!(offset)
)
);
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nk_panel {
pub type_: nk_panel_type,
pub flags: nk_flags,
pub bounds: nk_rect,
pub offset_x: *mut nk_uint,
pub offset_y: *mut nk_uint,
pub at_x: f32,
pub at_y: f32,
pub max_x: f32,
pub footer_height: f32,
pub header_height: f32,
pub border: f32,
pub has_scrolling: ::std::os::raw::c_uint,
pub clip: nk_rect,
pub menu: nk_menu_state,
pub row: nk_row_layout,
pub chart: nk_chart,
pub buffer: *mut nk_command_buffer,
pub parent: *mut nk_panel,
}
#[test]
fn bindgen_test_layout_nk_panel() {
assert_eq!(
::std::mem::size_of::<nk_panel>(),
448usize,
concat!("Size of: ", stringify!(nk_panel))
);
assert_eq!(
::std::mem::align_of::<nk_panel>(),
8usize,
concat!("Alignment of ", stringify!(nk_panel))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_panel>())).type_ as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_panel),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_panel>())).flags as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(nk_panel),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_panel>())).bounds as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_panel),
"::",
stringify!(bounds)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_panel>())).offset_x as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(nk_panel),
"::",
stringify!(offset_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_panel>())).offset_y as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_panel),
"::",
stringify!(offset_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_panel>())).at_x as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(nk_panel),
"::",
stringify!(at_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_panel>())).at_y as *const _ as usize },
44usize,
concat!(
"Offset of field: ",
stringify!(nk_panel),
"::",
stringify!(at_y)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_panel>())).max_x as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(nk_panel),
"::",
stringify!(max_x)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_panel>())).footer_height as *const _ as usize },
52usize,
concat!(
"Offset of field: ",
stringify!(nk_panel),
"::",
stringify!(footer_height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_panel>())).header_height as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(nk_panel),
"::",
stringify!(header_height)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_panel>())).border as *const _ as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(nk_panel),
"::",
stringify!(border)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_panel>())).has_scrolling as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(nk_panel),
"::",
stringify!(has_scrolling)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_panel>())).clip as *const _ as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(nk_panel),
"::",
stringify!(clip)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_panel>())).menu as *const _ as usize },
84usize,
concat!(
"Offset of field: ",
stringify!(nk_panel),
"::",
stringify!(menu)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_panel>())).row as *const _ as usize },
112usize,
concat!(
"Offset of field: ",
stringify!(nk_panel),
"::",
stringify!(row)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_panel>())).chart as *const _ as usize },
248usize,
concat!(
"Offset of field: ",
stringify!(nk_panel),
"::",
stringify!(chart)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_panel>())).buffer as *const _ as usize },
432usize,
concat!(
"Offset of field: ",
stringify!(nk_panel),
"::",
stringify!(buffer)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_panel>())).parent as *const _ as usize },
440usize,
concat!(
"Offset of field: ",
stringify!(nk_panel),
"::",
stringify!(parent)
)
);
}
impl Default for nk_panel {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
pub const nk_window_flags_NK_WINDOW_PRIVATE: nk_window_flags = 2048;
pub const nk_window_flags_NK_WINDOW_DYNAMIC: nk_window_flags = 2048;
pub const nk_window_flags_NK_WINDOW_ROM: nk_window_flags = 4096;
pub const nk_window_flags_NK_WINDOW_NOT_INTERACTIVE: nk_window_flags = 5120;
pub const nk_window_flags_NK_WINDOW_HIDDEN: nk_window_flags = 8192;
pub const nk_window_flags_NK_WINDOW_CLOSED: nk_window_flags = 16384;
pub const nk_window_flags_NK_WINDOW_MINIMIZED: nk_window_flags = 32768;
pub const nk_window_flags_NK_WINDOW_REMOVE_ROM: nk_window_flags = 65536;
pub type nk_window_flags = u32;
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nk_popup_state {
pub win: *mut nk_window,
pub type_: nk_panel_type,
pub buf: nk_popup_buffer,
pub name: nk_hash,
pub active: ::std::os::raw::c_int,
pub combo_count: ::std::os::raw::c_uint,
pub con_count: ::std::os::raw::c_uint,
pub con_old: ::std::os::raw::c_uint,
pub active_con: ::std::os::raw::c_uint,
pub header: nk_rect,
}
#[test]
fn bindgen_test_layout_nk_popup_state() {
assert_eq!(
::std::mem::size_of::<nk_popup_state>(),
96usize,
concat!("Size of: ", stringify!(nk_popup_state))
);
assert_eq!(
::std::mem::align_of::<nk_popup_state>(),
8usize,
concat!("Alignment of ", stringify!(nk_popup_state))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_popup_state>())).win as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_popup_state),
"::",
stringify!(win)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_popup_state>())).type_ as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_popup_state),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_popup_state>())).buf as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(nk_popup_state),
"::",
stringify!(buf)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_popup_state>())).name as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(nk_popup_state),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_popup_state>())).active as *const _ as usize },
60usize,
concat!(
"Offset of field: ",
stringify!(nk_popup_state),
"::",
stringify!(active)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_popup_state>())).combo_count as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(nk_popup_state),
"::",
stringify!(combo_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_popup_state>())).con_count as *const _ as usize },
68usize,
concat!(
"Offset of field: ",
stringify!(nk_popup_state),
"::",
stringify!(con_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_popup_state>())).con_old as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(nk_popup_state),
"::",
stringify!(con_old)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_popup_state>())).active_con as *const _ as usize },
76usize,
concat!(
"Offset of field: ",
stringify!(nk_popup_state),
"::",
stringify!(active_con)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_popup_state>())).header as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(nk_popup_state),
"::",
stringify!(header)
)
);
}
impl Default for nk_popup_state {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Default, Copy, Clone)]
pub struct nk_edit_state {
pub name: nk_hash,
pub seq: ::std::os::raw::c_uint,
pub old: ::std::os::raw::c_uint,
pub active: ::std::os::raw::c_int,
pub prev: ::std::os::raw::c_int,
pub cursor: ::std::os::raw::c_int,
pub sel_start: ::std::os::raw::c_int,
pub sel_end: ::std::os::raw::c_int,
pub scrollbar: nk_scroll,
pub mode: ::std::os::raw::c_uchar,
pub single_line: ::std::os::raw::c_uchar,
}
#[test]
fn bindgen_test_layout_nk_edit_state() {
assert_eq!(
::std::mem::size_of::<nk_edit_state>(),
44usize,
concat!("Size of: ", stringify!(nk_edit_state))
);
assert_eq!(
::std::mem::align_of::<nk_edit_state>(),
4usize,
concat!("Alignment of ", stringify!(nk_edit_state))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_edit_state>())).name as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_edit_state),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_edit_state>())).seq as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(nk_edit_state),
"::",
stringify!(seq)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_edit_state>())).old as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_edit_state),
"::",
stringify!(old)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_edit_state>())).active as *const _ as usize },
12usize,
concat!(
"Offset of field: ",
stringify!(nk_edit_state),
"::",
stringify!(active)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_edit_state>())).prev as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(nk_edit_state),
"::",
stringify!(prev)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_edit_state>())).cursor as *const _ as usize },
20usize,
concat!(
"Offset of field: ",
stringify!(nk_edit_state),
"::",
stringify!(cursor)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_edit_state>())).sel_start as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(nk_edit_state),
"::",
stringify!(sel_start)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_edit_state>())).sel_end as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(nk_edit_state),
"::",
stringify!(sel_end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_edit_state>())).scrollbar as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_edit_state),
"::",
stringify!(scrollbar)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_edit_state>())).mode as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(nk_edit_state),
"::",
stringify!(mode)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_edit_state>())).single_line as *const _ as usize },
41usize,
concat!(
"Offset of field: ",
stringify!(nk_edit_state),
"::",
stringify!(single_line)
)
);
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_property_state {
pub active: ::std::os::raw::c_int,
pub prev: ::std::os::raw::c_int,
pub buffer: [::std::os::raw::c_char; 64usize],
pub length: ::std::os::raw::c_int,
pub cursor: ::std::os::raw::c_int,
pub select_start: ::std::os::raw::c_int,
pub select_end: ::std::os::raw::c_int,
pub name: nk_hash,
pub seq: ::std::os::raw::c_uint,
pub old: ::std::os::raw::c_uint,
pub state: ::std::os::raw::c_int,
}
#[test]
fn bindgen_test_layout_nk_property_state() {
assert_eq!(
::std::mem::size_of::<nk_property_state>(),
104usize,
concat!("Size of: ", stringify!(nk_property_state))
);
assert_eq!(
::std::mem::align_of::<nk_property_state>(),
4usize,
concat!("Alignment of ", stringify!(nk_property_state))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_property_state>())).active as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_property_state),
"::",
stringify!(active)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_property_state>())).prev as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(nk_property_state),
"::",
stringify!(prev)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_property_state>())).buffer as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_property_state),
"::",
stringify!(buffer)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_property_state>())).length as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(nk_property_state),
"::",
stringify!(length)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_property_state>())).cursor as *const _ as usize },
76usize,
concat!(
"Offset of field: ",
stringify!(nk_property_state),
"::",
stringify!(cursor)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_property_state>())).select_start as *const _ as usize },
80usize,
concat!(
"Offset of field: ",
stringify!(nk_property_state),
"::",
stringify!(select_start)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_property_state>())).select_end as *const _ as usize },
84usize,
concat!(
"Offset of field: ",
stringify!(nk_property_state),
"::",
stringify!(select_end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_property_state>())).name as *const _ as usize },
88usize,
concat!(
"Offset of field: ",
stringify!(nk_property_state),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_property_state>())).seq as *const _ as usize },
92usize,
concat!(
"Offset of field: ",
stringify!(nk_property_state),
"::",
stringify!(seq)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_property_state>())).old as *const _ as usize },
96usize,
concat!(
"Offset of field: ",
stringify!(nk_property_state),
"::",
stringify!(old)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_property_state>())).state as *const _ as usize },
100usize,
concat!(
"Offset of field: ",
stringify!(nk_property_state),
"::",
stringify!(state)
)
);
}
impl Default for nk_property_state {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_window {
pub seq: ::std::os::raw::c_uint,
pub name: nk_hash,
pub name_string: [::std::os::raw::c_char; 64usize],
pub flags: nk_flags,
pub bounds: nk_rect,
pub scrollbar: nk_scroll,
pub buffer: nk_command_buffer,
pub layout: *mut nk_panel,
pub scrollbar_hiding_timer: f32,
pub property: nk_property_state,
pub popup: nk_popup_state,
pub edit: nk_edit_state,
pub scrolled: ::std::os::raw::c_uint,
pub tables: *mut nk_table,
pub table_count: ::std::os::raw::c_uint,
pub next: *mut nk_window,
pub prev: *mut nk_window,
pub parent: *mut nk_window,
}
#[test]
fn bindgen_test_layout_nk_window() {
assert_eq!(
::std::mem::size_of::<nk_window>(),
472usize,
concat!("Size of: ", stringify!(nk_window))
);
assert_eq!(
::std::mem::align_of::<nk_window>(),
8usize,
concat!("Alignment of ", stringify!(nk_window))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_window>())).seq as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_window),
"::",
stringify!(seq)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_window>())).name as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(nk_window),
"::",
stringify!(name)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_window>())).name_string as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_window),
"::",
stringify!(name_string)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_window>())).flags as *const _ as usize },
72usize,
concat!(
"Offset of field: ",
stringify!(nk_window),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_window>())).bounds as *const _ as usize },
76usize,
concat!(
"Offset of field: ",
stringify!(nk_window),
"::",
stringify!(bounds)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_window>())).scrollbar as *const _ as usize },
92usize,
concat!(
"Offset of field: ",
stringify!(nk_window),
"::",
stringify!(scrollbar)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_window>())).buffer as *const _ as usize },
104usize,
concat!(
"Offset of field: ",
stringify!(nk_window),
"::",
stringify!(buffer)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_window>())).layout as *const _ as usize },
168usize,
concat!(
"Offset of field: ",
stringify!(nk_window),
"::",
stringify!(layout)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_window>())).scrollbar_hiding_timer as *const _ as usize
},
176usize,
concat!(
"Offset of field: ",
stringify!(nk_window),
"::",
stringify!(scrollbar_hiding_timer)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_window>())).property as *const _ as usize },
180usize,
concat!(
"Offset of field: ",
stringify!(nk_window),
"::",
stringify!(property)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_window>())).popup as *const _ as usize },
288usize,
concat!(
"Offset of field: ",
stringify!(nk_window),
"::",
stringify!(popup)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_window>())).edit as *const _ as usize },
384usize,
concat!(
"Offset of field: ",
stringify!(nk_window),
"::",
stringify!(edit)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_window>())).scrolled as *const _ as usize },
428usize,
concat!(
"Offset of field: ",
stringify!(nk_window),
"::",
stringify!(scrolled)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_window>())).tables as *const _ as usize },
432usize,
concat!(
"Offset of field: ",
stringify!(nk_window),
"::",
stringify!(tables)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_window>())).table_count as *const _ as usize },
440usize,
concat!(
"Offset of field: ",
stringify!(nk_window),
"::",
stringify!(table_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_window>())).next as *const _ as usize },
448usize,
concat!(
"Offset of field: ",
stringify!(nk_window),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_window>())).prev as *const _ as usize },
456usize,
concat!(
"Offset of field: ",
stringify!(nk_window),
"::",
stringify!(prev)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_window>())).parent as *const _ as usize },
464usize,
concat!(
"Offset of field: ",
stringify!(nk_window),
"::",
stringify!(parent)
)
);
}
impl Default for nk_window {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_config_stack_style_item_element {
pub address: *mut nk_style_item,
pub old_value: nk_style_item,
}
#[test]
fn bindgen_test_layout_nk_config_stack_style_item_element() {
assert_eq!(
::std::mem::size_of::<nk_config_stack_style_item_element>(),
40usize,
concat!("Size of: ", stringify!(nk_config_stack_style_item_element))
);
assert_eq!(
::std::mem::align_of::<nk_config_stack_style_item_element>(),
8usize,
concat!(
"Alignment of ",
stringify!(nk_config_stack_style_item_element)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_config_stack_style_item_element>())).address as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(nk_config_stack_style_item_element),
"::",
stringify!(address)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_config_stack_style_item_element>())).old_value as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(nk_config_stack_style_item_element),
"::",
stringify!(old_value)
)
);
}
impl Default for nk_config_stack_style_item_element {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nk_config_stack_float_element {
pub address: *mut f32,
pub old_value: f32,
}
#[test]
fn bindgen_test_layout_nk_config_stack_float_element() {
assert_eq!(
::std::mem::size_of::<nk_config_stack_float_element>(),
16usize,
concat!("Size of: ", stringify!(nk_config_stack_float_element))
);
assert_eq!(
::std::mem::align_of::<nk_config_stack_float_element>(),
8usize,
concat!("Alignment of ", stringify!(nk_config_stack_float_element))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_config_stack_float_element>())).address as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(nk_config_stack_float_element),
"::",
stringify!(address)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_config_stack_float_element>())).old_value as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(nk_config_stack_float_element),
"::",
stringify!(old_value)
)
);
}
impl Default for nk_config_stack_float_element {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nk_config_stack_vec2_element {
pub address: *mut nk_vec2,
pub old_value: nk_vec2,
}
#[test]
fn bindgen_test_layout_nk_config_stack_vec2_element() {
assert_eq!(
::std::mem::size_of::<nk_config_stack_vec2_element>(),
16usize,
concat!("Size of: ", stringify!(nk_config_stack_vec2_element))
);
assert_eq!(
::std::mem::align_of::<nk_config_stack_vec2_element>(),
8usize,
concat!("Alignment of ", stringify!(nk_config_stack_vec2_element))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_config_stack_vec2_element>())).address as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(nk_config_stack_vec2_element),
"::",
stringify!(address)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_config_stack_vec2_element>())).old_value as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(nk_config_stack_vec2_element),
"::",
stringify!(old_value)
)
);
}
impl Default for nk_config_stack_vec2_element {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nk_config_stack_flags_element {
pub address: *mut nk_flags,
pub old_value: nk_flags,
}
#[test]
fn bindgen_test_layout_nk_config_stack_flags_element() {
assert_eq!(
::std::mem::size_of::<nk_config_stack_flags_element>(),
16usize,
concat!("Size of: ", stringify!(nk_config_stack_flags_element))
);
assert_eq!(
::std::mem::align_of::<nk_config_stack_flags_element>(),
8usize,
concat!("Alignment of ", stringify!(nk_config_stack_flags_element))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_config_stack_flags_element>())).address as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(nk_config_stack_flags_element),
"::",
stringify!(address)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_config_stack_flags_element>())).old_value as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(nk_config_stack_flags_element),
"::",
stringify!(old_value)
)
);
}
impl Default for nk_config_stack_flags_element {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nk_config_stack_color_element {
pub address: *mut nk_color,
pub old_value: nk_color,
}
#[test]
fn bindgen_test_layout_nk_config_stack_color_element() {
assert_eq!(
::std::mem::size_of::<nk_config_stack_color_element>(),
16usize,
concat!("Size of: ", stringify!(nk_config_stack_color_element))
);
assert_eq!(
::std::mem::align_of::<nk_config_stack_color_element>(),
8usize,
concat!("Alignment of ", stringify!(nk_config_stack_color_element))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_config_stack_color_element>())).address as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(nk_config_stack_color_element),
"::",
stringify!(address)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_config_stack_color_element>())).old_value as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(nk_config_stack_color_element),
"::",
stringify!(old_value)
)
);
}
impl Default for nk_config_stack_color_element {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nk_config_stack_user_font_element {
pub address: *mut *const nk_user_font,
pub old_value: *const nk_user_font,
}
#[test]
fn bindgen_test_layout_nk_config_stack_user_font_element() {
assert_eq!(
::std::mem::size_of::<nk_config_stack_user_font_element>(),
16usize,
concat!("Size of: ", stringify!(nk_config_stack_user_font_element))
);
assert_eq!(
::std::mem::align_of::<nk_config_stack_user_font_element>(),
8usize,
concat!(
"Alignment of ",
stringify!(nk_config_stack_user_font_element)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_config_stack_user_font_element>())).address as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(nk_config_stack_user_font_element),
"::",
stringify!(address)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_config_stack_user_font_element>())).old_value as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(nk_config_stack_user_font_element),
"::",
stringify!(old_value)
)
);
}
impl Default for nk_config_stack_user_font_element {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nk_config_stack_button_behavior_element {
pub address: *mut nk_button_behavior,
pub old_value: nk_button_behavior,
}
#[test]
fn bindgen_test_layout_nk_config_stack_button_behavior_element() {
assert_eq!(
::std::mem::size_of::<nk_config_stack_button_behavior_element>(),
16usize,
concat!(
"Size of: ",
stringify!(nk_config_stack_button_behavior_element)
)
);
assert_eq!(
::std::mem::align_of::<nk_config_stack_button_behavior_element>(),
8usize,
concat!(
"Alignment of ",
stringify!(nk_config_stack_button_behavior_element)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_config_stack_button_behavior_element>())).address as *const _
as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(nk_config_stack_button_behavior_element),
"::",
stringify!(address)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_config_stack_button_behavior_element>())).old_value
as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(nk_config_stack_button_behavior_element),
"::",
stringify!(old_value)
)
);
}
impl Default for nk_config_stack_button_behavior_element {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_config_stack_style_item {
pub head: ::std::os::raw::c_int,
pub elements: [nk_config_stack_style_item_element; 16usize],
}
#[test]
fn bindgen_test_layout_nk_config_stack_style_item() {
assert_eq!(
::std::mem::size_of::<nk_config_stack_style_item>(),
648usize,
concat!("Size of: ", stringify!(nk_config_stack_style_item))
);
assert_eq!(
::std::mem::align_of::<nk_config_stack_style_item>(),
8usize,
concat!("Alignment of ", stringify!(nk_config_stack_style_item))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_config_stack_style_item>())).head as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_config_stack_style_item),
"::",
stringify!(head)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_config_stack_style_item>())).elements as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(nk_config_stack_style_item),
"::",
stringify!(elements)
)
);
}
impl Default for nk_config_stack_style_item {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nk_config_stack_float {
pub head: ::std::os::raw::c_int,
pub elements: [nk_config_stack_float_element; 32usize],
}
#[test]
fn bindgen_test_layout_nk_config_stack_float() {
assert_eq!(
::std::mem::size_of::<nk_config_stack_float>(),
520usize,
concat!("Size of: ", stringify!(nk_config_stack_float))
);
assert_eq!(
::std::mem::align_of::<nk_config_stack_float>(),
8usize,
concat!("Alignment of ", stringify!(nk_config_stack_float))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_config_stack_float>())).head as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_config_stack_float),
"::",
stringify!(head)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_config_stack_float>())).elements as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_config_stack_float),
"::",
stringify!(elements)
)
);
}
impl Default for nk_config_stack_float {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nk_config_stack_vec2 {
pub head: ::std::os::raw::c_int,
pub elements: [nk_config_stack_vec2_element; 16usize],
}
#[test]
fn bindgen_test_layout_nk_config_stack_vec2() {
assert_eq!(
::std::mem::size_of::<nk_config_stack_vec2>(),
264usize,
concat!("Size of: ", stringify!(nk_config_stack_vec2))
);
assert_eq!(
::std::mem::align_of::<nk_config_stack_vec2>(),
8usize,
concat!("Alignment of ", stringify!(nk_config_stack_vec2))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_config_stack_vec2>())).head as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_config_stack_vec2),
"::",
stringify!(head)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_config_stack_vec2>())).elements as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_config_stack_vec2),
"::",
stringify!(elements)
)
);
}
impl Default for nk_config_stack_vec2 {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nk_config_stack_flags {
pub head: ::std::os::raw::c_int,
pub elements: [nk_config_stack_flags_element; 32usize],
}
#[test]
fn bindgen_test_layout_nk_config_stack_flags() {
assert_eq!(
::std::mem::size_of::<nk_config_stack_flags>(),
520usize,
concat!("Size of: ", stringify!(nk_config_stack_flags))
);
assert_eq!(
::std::mem::align_of::<nk_config_stack_flags>(),
8usize,
concat!("Alignment of ", stringify!(nk_config_stack_flags))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_config_stack_flags>())).head as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_config_stack_flags),
"::",
stringify!(head)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_config_stack_flags>())).elements as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_config_stack_flags),
"::",
stringify!(elements)
)
);
}
impl Default for nk_config_stack_flags {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nk_config_stack_color {
pub head: ::std::os::raw::c_int,
pub elements: [nk_config_stack_color_element; 32usize],
}
#[test]
fn bindgen_test_layout_nk_config_stack_color() {
assert_eq!(
::std::mem::size_of::<nk_config_stack_color>(),
520usize,
concat!("Size of: ", stringify!(nk_config_stack_color))
);
assert_eq!(
::std::mem::align_of::<nk_config_stack_color>(),
8usize,
concat!("Alignment of ", stringify!(nk_config_stack_color))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_config_stack_color>())).head as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_config_stack_color),
"::",
stringify!(head)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_config_stack_color>())).elements as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_config_stack_color),
"::",
stringify!(elements)
)
);
}
impl Default for nk_config_stack_color {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nk_config_stack_user_font {
pub head: ::std::os::raw::c_int,
pub elements: [nk_config_stack_user_font_element; 8usize],
}
#[test]
fn bindgen_test_layout_nk_config_stack_user_font() {
assert_eq!(
::std::mem::size_of::<nk_config_stack_user_font>(),
136usize,
concat!("Size of: ", stringify!(nk_config_stack_user_font))
);
assert_eq!(
::std::mem::align_of::<nk_config_stack_user_font>(),
8usize,
concat!("Alignment of ", stringify!(nk_config_stack_user_font))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_config_stack_user_font>())).head as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_config_stack_user_font),
"::",
stringify!(head)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_config_stack_user_font>())).elements as *const _ as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(nk_config_stack_user_font),
"::",
stringify!(elements)
)
);
}
impl Default for nk_config_stack_user_font {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct nk_config_stack_button_behavior {
pub head: ::std::os::raw::c_int,
pub elements: [nk_config_stack_button_behavior_element; 8usize],
}
#[test]
fn bindgen_test_layout_nk_config_stack_button_behavior() {
assert_eq!(
::std::mem::size_of::<nk_config_stack_button_behavior>(),
136usize,
concat!("Size of: ", stringify!(nk_config_stack_button_behavior))
);
assert_eq!(
::std::mem::align_of::<nk_config_stack_button_behavior>(),
8usize,
concat!("Alignment of ", stringify!(nk_config_stack_button_behavior))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_config_stack_button_behavior>())).head as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(nk_config_stack_button_behavior),
"::",
stringify!(head)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_config_stack_button_behavior>())).elements as *const _
as usize
},
8usize,
concat!(
"Offset of field: ",
stringify!(nk_config_stack_button_behavior),
"::",
stringify!(elements)
)
);
}
impl Default for nk_config_stack_button_behavior {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_configuration_stacks {
pub style_items: nk_config_stack_style_item,
pub floats: nk_config_stack_float,
pub vectors: nk_config_stack_vec2,
pub flags: nk_config_stack_flags,
pub colors: nk_config_stack_color,
pub fonts: nk_config_stack_user_font,
pub button_behaviors: nk_config_stack_button_behavior,
}
#[test]
fn bindgen_test_layout_nk_configuration_stacks() {
assert_eq!(
::std::mem::size_of::<nk_configuration_stacks>(),
2744usize,
concat!("Size of: ", stringify!(nk_configuration_stacks))
);
assert_eq!(
::std::mem::align_of::<nk_configuration_stacks>(),
8usize,
concat!("Alignment of ", stringify!(nk_configuration_stacks))
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_configuration_stacks>())).style_items as *const _ as usize
},
0usize,
concat!(
"Offset of field: ",
stringify!(nk_configuration_stacks),
"::",
stringify!(style_items)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_configuration_stacks>())).floats as *const _ as usize },
648usize,
concat!(
"Offset of field: ",
stringify!(nk_configuration_stacks),
"::",
stringify!(floats)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_configuration_stacks>())).vectors as *const _ as usize },
1168usize,
concat!(
"Offset of field: ",
stringify!(nk_configuration_stacks),
"::",
stringify!(vectors)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_configuration_stacks>())).flags as *const _ as usize },
1432usize,
concat!(
"Offset of field: ",
stringify!(nk_configuration_stacks),
"::",
stringify!(flags)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_configuration_stacks>())).colors as *const _ as usize },
1952usize,
concat!(
"Offset of field: ",
stringify!(nk_configuration_stacks),
"::",
stringify!(colors)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_configuration_stacks>())).fonts as *const _ as usize },
2472usize,
concat!(
"Offset of field: ",
stringify!(nk_configuration_stacks),
"::",
stringify!(fonts)
)
);
assert_eq!(
unsafe {
&(*(::std::ptr::null::<nk_configuration_stacks>())).button_behaviors as *const _
as usize
},
2608usize,
concat!(
"Offset of field: ",
stringify!(nk_configuration_stacks),
"::",
stringify!(button_behaviors)
)
);
}
impl Default for nk_configuration_stacks {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_table {
pub seq: ::std::os::raw::c_uint,
pub size: ::std::os::raw::c_uint,
pub keys: [nk_hash; 59usize],
pub values: [nk_uint; 59usize],
pub next: *mut nk_table,
pub prev: *mut nk_table,
}
#[test]
fn bindgen_test_layout_nk_table() {
assert_eq!(
::std::mem::size_of::<nk_table>(),
496usize,
concat!("Size of: ", stringify!(nk_table))
);
assert_eq!(
::std::mem::align_of::<nk_table>(),
8usize,
concat!("Alignment of ", stringify!(nk_table))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_table>())).seq as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_table),
"::",
stringify!(seq)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_table>())).size as *const _ as usize },
4usize,
concat!(
"Offset of field: ",
stringify!(nk_table),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_table>())).keys as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_table),
"::",
stringify!(keys)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_table>())).values as *const _ as usize },
244usize,
concat!(
"Offset of field: ",
stringify!(nk_table),
"::",
stringify!(values)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_table>())).next as *const _ as usize },
480usize,
concat!(
"Offset of field: ",
stringify!(nk_table),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_table>())).prev as *const _ as usize },
488usize,
concat!(
"Offset of field: ",
stringify!(nk_table),
"::",
stringify!(prev)
)
);
}
impl Default for nk_table {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub union nk_page_data {
pub tbl: nk_table,
pub pan: nk_panel,
pub win: nk_window,
_bindgen_union_align: [u64; 62usize],
}
#[test]
fn bindgen_test_layout_nk_page_data() {
assert_eq!(
::std::mem::size_of::<nk_page_data>(),
496usize,
concat!("Size of: ", stringify!(nk_page_data))
);
assert_eq!(
::std::mem::align_of::<nk_page_data>(),
8usize,
concat!("Alignment of ", stringify!(nk_page_data))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_page_data>())).tbl as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_page_data),
"::",
stringify!(tbl)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_page_data>())).pan as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_page_data),
"::",
stringify!(pan)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_page_data>())).win as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_page_data),
"::",
stringify!(win)
)
);
}
impl Default for nk_page_data {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_page_element {
pub data: nk_page_data,
pub next: *mut nk_page_element,
pub prev: *mut nk_page_element,
}
#[test]
fn bindgen_test_layout_nk_page_element() {
assert_eq!(
::std::mem::size_of::<nk_page_element>(),
512usize,
concat!("Size of: ", stringify!(nk_page_element))
);
assert_eq!(
::std::mem::align_of::<nk_page_element>(),
8usize,
concat!("Alignment of ", stringify!(nk_page_element))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_page_element>())).data as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_page_element),
"::",
stringify!(data)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_page_element>())).next as *const _ as usize },
496usize,
concat!(
"Offset of field: ",
stringify!(nk_page_element),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_page_element>())).prev as *const _ as usize },
504usize,
concat!(
"Offset of field: ",
stringify!(nk_page_element),
"::",
stringify!(prev)
)
);
}
impl Default for nk_page_element {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_page {
pub size: ::std::os::raw::c_uint,
pub next: *mut nk_page,
pub win: [nk_page_element; 1usize],
}
#[test]
fn bindgen_test_layout_nk_page() {
assert_eq!(
::std::mem::size_of::<nk_page>(),
528usize,
concat!("Size of: ", stringify!(nk_page))
);
assert_eq!(
::std::mem::align_of::<nk_page>(),
8usize,
concat!("Alignment of ", stringify!(nk_page))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_page>())).size as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_page),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_page>())).next as *const _ as usize },
8usize,
concat!(
"Offset of field: ",
stringify!(nk_page),
"::",
stringify!(next)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_page>())).win as *const _ as usize },
16usize,
concat!(
"Offset of field: ",
stringify!(nk_page),
"::",
stringify!(win)
)
);
}
impl Default for nk_page {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_pool {
pub alloc: nk_allocator,
pub type_: nk_allocation_type,
pub page_count: ::std::os::raw::c_uint,
pub pages: *mut nk_page,
pub freelist: *mut nk_page_element,
pub capacity: ::std::os::raw::c_uint,
pub size: nk_size,
pub cap: nk_size,
}
#[test]
fn bindgen_test_layout_nk_pool() {
assert_eq!(
::std::mem::size_of::<nk_pool>(),
72usize,
concat!("Size of: ", stringify!(nk_pool))
);
assert_eq!(
::std::mem::align_of::<nk_pool>(),
8usize,
concat!("Alignment of ", stringify!(nk_pool))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_pool>())).alloc as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_pool),
"::",
stringify!(alloc)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_pool>())).type_ as *const _ as usize },
24usize,
concat!(
"Offset of field: ",
stringify!(nk_pool),
"::",
stringify!(type_)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_pool>())).page_count as *const _ as usize },
28usize,
concat!(
"Offset of field: ",
stringify!(nk_pool),
"::",
stringify!(page_count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_pool>())).pages as *const _ as usize },
32usize,
concat!(
"Offset of field: ",
stringify!(nk_pool),
"::",
stringify!(pages)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_pool>())).freelist as *const _ as usize },
40usize,
concat!(
"Offset of field: ",
stringify!(nk_pool),
"::",
stringify!(freelist)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_pool>())).capacity as *const _ as usize },
48usize,
concat!(
"Offset of field: ",
stringify!(nk_pool),
"::",
stringify!(capacity)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_pool>())).size as *const _ as usize },
56usize,
concat!(
"Offset of field: ",
stringify!(nk_pool),
"::",
stringify!(size)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_pool>())).cap as *const _ as usize },
64usize,
concat!(
"Offset of field: ",
stringify!(nk_pool),
"::",
stringify!(cap)
)
);
}
impl Default for nk_pool {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct nk_context {
pub input: nk_input,
pub style: nk_style,
pub memory: nk_buffer,
pub clip: nk_clipboard,
pub last_widget_state: nk_flags,
pub button_behavior: nk_button_behavior,
pub stacks: nk_configuration_stacks,
pub delta_time_seconds: f32,
pub draw_list: nk_draw_list,
pub userdata: nk_handle,
pub text_edit: nk_text_edit,
pub overlay: nk_command_buffer,
pub build: ::std::os::raw::c_int,
pub use_pool: ::std::os::raw::c_int,
pub pool: nk_pool,
pub begin: *mut nk_window,
pub end: *mut nk_window,
pub active: *mut nk_window,
pub current: *mut nk_window,
pub freelist: *mut nk_page_element,
pub count: ::std::os::raw::c_uint,
pub seq: ::std::os::raw::c_uint,
}
#[test]
fn bindgen_test_layout_nk_context() {
assert_eq!(
::std::mem::size_of::<nk_context>(),
16640usize,
concat!("Size of: ", stringify!(nk_context))
);
assert_eq!(
::std::mem::align_of::<nk_context>(),
8usize,
concat!("Alignment of ", stringify!(nk_context))
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_context>())).input as *const _ as usize },
0usize,
concat!(
"Offset of field: ",
stringify!(nk_context),
"::",
stringify!(input)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_context>())).style as *const _ as usize },
360usize,
concat!(
"Offset of field: ",
stringify!(nk_context),
"::",
stringify!(style)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_context>())).memory as *const _ as usize },
7904usize,
concat!(
"Offset of field: ",
stringify!(nk_context),
"::",
stringify!(memory)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_context>())).clip as *const _ as usize },
8024usize,
concat!(
"Offset of field: ",
stringify!(nk_context),
"::",
stringify!(clip)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_context>())).last_widget_state as *const _ as usize },
8048usize,
concat!(
"Offset of field: ",
stringify!(nk_context),
"::",
stringify!(last_widget_state)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_context>())).button_behavior as *const _ as usize },
8052usize,
concat!(
"Offset of field: ",
stringify!(nk_context),
"::",
stringify!(button_behavior)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_context>())).stacks as *const _ as usize },
8056usize,
concat!(
"Offset of field: ",
stringify!(nk_context),
"::",
stringify!(stacks)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_context>())).delta_time_seconds as *const _ as usize },
10800usize,
concat!(
"Offset of field: ",
stringify!(nk_context),
"::",
stringify!(delta_time_seconds)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_context>())).draw_list as *const _ as usize },
10808usize,
concat!(
"Offset of field: ",
stringify!(nk_context),
"::",
stringify!(draw_list)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_context>())).userdata as *const _ as usize },
11056usize,
concat!(
"Offset of field: ",
stringify!(nk_context),
"::",
stringify!(userdata)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_context>())).text_edit as *const _ as usize },
11064usize,
concat!(
"Offset of field: ",
stringify!(nk_context),
"::",
stringify!(text_edit)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_context>())).overlay as *const _ as usize },
16448usize,
concat!(
"Offset of field: ",
stringify!(nk_context),
"::",
stringify!(overlay)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_context>())).build as *const _ as usize },
16512usize,
concat!(
"Offset of field: ",
stringify!(nk_context),
"::",
stringify!(build)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_context>())).use_pool as *const _ as usize },
16516usize,
concat!(
"Offset of field: ",
stringify!(nk_context),
"::",
stringify!(use_pool)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_context>())).pool as *const _ as usize },
16520usize,
concat!(
"Offset of field: ",
stringify!(nk_context),
"::",
stringify!(pool)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_context>())).begin as *const _ as usize },
16592usize,
concat!(
"Offset of field: ",
stringify!(nk_context),
"::",
stringify!(begin)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_context>())).end as *const _ as usize },
16600usize,
concat!(
"Offset of field: ",
stringify!(nk_context),
"::",
stringify!(end)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_context>())).active as *const _ as usize },
16608usize,
concat!(
"Offset of field: ",
stringify!(nk_context),
"::",
stringify!(active)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_context>())).current as *const _ as usize },
16616usize,
concat!(
"Offset of field: ",
stringify!(nk_context),
"::",
stringify!(current)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_context>())).freelist as *const _ as usize },
16624usize,
concat!(
"Offset of field: ",
stringify!(nk_context),
"::",
stringify!(freelist)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_context>())).count as *const _ as usize },
16632usize,
concat!(
"Offset of field: ",
stringify!(nk_context),
"::",
stringify!(count)
)
);
assert_eq!(
unsafe { &(*(::std::ptr::null::<nk_context>())).seq as *const _ as usize },
16636usize,
concat!(
"Offset of field: ",
stringify!(nk_context),
"::",
stringify!(seq)
)
);
}
impl Default for nk_context {
fn default() -> Self {
unsafe { ::std::mem::zeroed() }
}
}