#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum wlr_edges {
WLR_EDGE_NONE = 0,
WLR_EDGE_TOP = 1,
WLR_EDGE_BOTTOM = 2,
WLR_EDGE_LEFT = 4,
WLR_EDGE_RIGHT = 8,
}
pub type va_list = __builtin_va_list;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum wlr_log_importance {
WLR_SILENT = 0,
WLR_ERROR = 1,
WLR_INFO = 2,
WLR_DEBUG = 3,
WLR_LOG_IMPORTANCE_LAST = 4,
}
pub type wlr_log_func_t =
::std::option::Option<unsafe extern "C" fn(importance: wlr_log_importance,
fmt: *const libc::c_char,
args: *mut __va_list_tag)>;
extern "C" {
pub fn wlr_log_init(verbosity: wlr_log_importance,
callback: wlr_log_func_t);
}
extern "C" {
pub fn wlr_log_get_verbosity() -> wlr_log_importance;
}
extern "C" {
pub fn _wlr_log(verbosity: wlr_log_importance,
format: *const libc::c_char, ...);
}
extern "C" {
pub fn _wlr_vlog(verbosity: wlr_log_importance,
format: *const libc::c_char, args: *mut __va_list_tag);
}
extern "C" {
pub fn _wlr_strip_path(filepath: *const libc::c_char)
-> *const libc::c_char;
}
pub type __uint8_t = libc::c_uchar;
pub type __int16_t = libc::c_short;
pub type __uint16_t = libc::c_ushort;
pub type __int32_t = libc::c_int;
pub type __uint32_t = libc::c_uint;
pub type pixman_bool_t = libc::c_int;
pub type pixman_fixed_16_16_t = i32;
pub type pixman_fixed_t = pixman_fixed_16_16_t;
#[repr(C)]
#[derive(Debug, Default, Copy)]
pub struct pixman_color {
pub red: u16,
pub green: u16,
pub blue: u16,
pub alpha: u16,
}
#[test]
fn bindgen_test_layout_pixman_color() {
assert_eq!(::std::mem::size_of::<pixman_color>() , 8usize , concat ! (
"Size of: " , stringify ! ( pixman_color ) ));
assert_eq! (::std::mem::align_of::<pixman_color>() , 2usize , concat ! (
"Alignment of " , stringify ! ( pixman_color ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_color ) ) . red as * const _ as
usize } , 0usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_color ) , "::" ,
stringify ! ( red ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_color ) ) . green as * const _ as
usize } , 2usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_color ) , "::" ,
stringify ! ( green ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_color ) ) . blue as * const _ as
usize } , 4usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_color ) , "::" ,
stringify ! ( blue ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_color ) ) . alpha as * const _ as
usize } , 6usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_color ) , "::" ,
stringify ! ( alpha ) ));
}
impl Clone for pixman_color {
fn clone(&self) -> Self { *self }
}
pub type pixman_color_t = pixman_color;
#[repr(C)]
#[derive(Debug, Default, Copy)]
pub struct pixman_point_fixed {
pub x: pixman_fixed_t,
pub y: pixman_fixed_t,
}
#[test]
fn bindgen_test_layout_pixman_point_fixed() {
assert_eq!(::std::mem::size_of::<pixman_point_fixed>() , 8usize , concat !
( "Size of: " , stringify ! ( pixman_point_fixed ) ));
assert_eq! (::std::mem::align_of::<pixman_point_fixed>() , 4usize , concat
! ( "Alignment of " , stringify ! ( pixman_point_fixed ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_point_fixed ) ) . x as * const _
as usize } , 0usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_point_fixed ) ,
"::" , stringify ! ( x ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_point_fixed ) ) . y as * const _
as usize } , 4usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_point_fixed ) ,
"::" , stringify ! ( y ) ));
}
impl Clone for pixman_point_fixed {
fn clone(&self) -> Self { *self }
}
pub type pixman_point_fixed_t = pixman_point_fixed;
#[repr(C)]
#[derive(Debug, Default, Copy)]
pub struct pixman_line_fixed {
pub p1: pixman_point_fixed_t,
pub p2: pixman_point_fixed_t,
}
#[test]
fn bindgen_test_layout_pixman_line_fixed() {
assert_eq!(::std::mem::size_of::<pixman_line_fixed>() , 16usize , concat !
( "Size of: " , stringify ! ( pixman_line_fixed ) ));
assert_eq! (::std::mem::align_of::<pixman_line_fixed>() , 4usize , concat
! ( "Alignment of " , stringify ! ( pixman_line_fixed ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_line_fixed ) ) . p1 as * const _
as usize } , 0usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_line_fixed ) ,
"::" , stringify ! ( p1 ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_line_fixed ) ) . p2 as * const _
as usize } , 8usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_line_fixed ) ,
"::" , stringify ! ( p2 ) ));
}
impl Clone for pixman_line_fixed {
fn clone(&self) -> Self { *self }
}
pub type pixman_line_fixed_t = pixman_line_fixed;
#[repr(C)]
#[derive(Debug, Default, Copy)]
pub struct pixman_vector {
pub vector: [pixman_fixed_t; 3usize],
}
#[test]
fn bindgen_test_layout_pixman_vector() {
assert_eq!(::std::mem::size_of::<pixman_vector>() , 12usize , concat ! (
"Size of: " , stringify ! ( pixman_vector ) ));
assert_eq! (::std::mem::align_of::<pixman_vector>() , 4usize , concat ! (
"Alignment of " , stringify ! ( pixman_vector ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_vector ) ) . vector as * const _
as usize } , 0usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_vector ) , "::"
, stringify ! ( vector ) ));
}
impl Clone for pixman_vector {
fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Default, Copy)]
pub struct pixman_transform {
pub matrix: [[pixman_fixed_t; 3usize]; 3usize],
}
#[test]
fn bindgen_test_layout_pixman_transform() {
assert_eq!(::std::mem::size_of::<pixman_transform>() , 36usize , concat !
( "Size of: " , stringify ! ( pixman_transform ) ));
assert_eq! (::std::mem::align_of::<pixman_transform>() , 4usize , concat !
( "Alignment of " , stringify ! ( pixman_transform ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_transform ) ) . matrix as * const
_ as usize } , 0usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_transform ) ,
"::" , stringify ! ( matrix ) ));
}
impl Clone for pixman_transform {
fn clone(&self) -> Self { *self }
}
pub type pixman_transform_t = pixman_transform;
#[repr(C)]
#[derive(Debug, Default, Copy)]
pub struct pixman_box16 {
pub x1: i16,
pub y1: i16,
pub x2: i16,
pub y2: i16,
}
#[test]
fn bindgen_test_layout_pixman_box16() {
assert_eq!(::std::mem::size_of::<pixman_box16>() , 8usize , concat ! (
"Size of: " , stringify ! ( pixman_box16 ) ));
assert_eq! (::std::mem::align_of::<pixman_box16>() , 2usize , concat ! (
"Alignment of " , stringify ! ( pixman_box16 ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_box16 ) ) . x1 as * const _ as
usize } , 0usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_box16 ) , "::" ,
stringify ! ( x1 ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_box16 ) ) . y1 as * const _ as
usize } , 2usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_box16 ) , "::" ,
stringify ! ( y1 ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_box16 ) ) . x2 as * const _ as
usize } , 4usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_box16 ) , "::" ,
stringify ! ( x2 ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_box16 ) ) . y2 as * const _ as
usize } , 6usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_box16 ) , "::" ,
stringify ! ( y2 ) ));
}
impl Clone for pixman_box16 {
fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pixman_image {
_unused: [u8; 0],
}
pub type pixman_image_t = pixman_image;
extern "C" {
pub fn pixman_transform_init_identity(matrix: *mut pixman_transform);
}
extern "C" {
pub fn pixman_transform_point_3d(transform: *const pixman_transform,
vector: *mut pixman_vector)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_transform_point(transform: *const pixman_transform,
vector: *mut pixman_vector)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_transform_multiply(dst: *mut pixman_transform,
l: *const pixman_transform,
r: *const pixman_transform)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_transform_init_scale(t: *mut pixman_transform,
sx: pixman_fixed_t,
sy: pixman_fixed_t);
}
extern "C" {
pub fn pixman_transform_scale(forward: *mut pixman_transform,
reverse: *mut pixman_transform,
sx: pixman_fixed_t, sy: pixman_fixed_t)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_transform_init_rotate(t: *mut pixman_transform,
cos: pixman_fixed_t,
sin: pixman_fixed_t);
}
extern "C" {
pub fn pixman_transform_rotate(forward: *mut pixman_transform,
reverse: *mut pixman_transform,
c: pixman_fixed_t, s: pixman_fixed_t)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_transform_init_translate(t: *mut pixman_transform,
tx: pixman_fixed_t,
ty: pixman_fixed_t);
}
extern "C" {
pub fn pixman_transform_translate(forward: *mut pixman_transform,
reverse: *mut pixman_transform,
tx: pixman_fixed_t, ty: pixman_fixed_t)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_transform_bounds(matrix: *const pixman_transform,
b: *mut pixman_box16) -> pixman_bool_t;
}
extern "C" {
pub fn pixman_transform_invert(dst: *mut pixman_transform,
src: *const pixman_transform)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_transform_is_identity(t: *const pixman_transform)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_transform_is_scale(t: *const pixman_transform)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_transform_is_int_translate(t: *const pixman_transform)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_transform_is_inverse(a: *const pixman_transform,
b: *const pixman_transform)
-> pixman_bool_t;
}
#[repr(C)]
#[derive(Debug, Default, Copy)]
pub struct pixman_f_transform {
pub m: [[f64; 3usize]; 3usize],
}
#[test]
fn bindgen_test_layout_pixman_f_transform() {
assert_eq!(::std::mem::size_of::<pixman_f_transform>() , 72usize , concat
! ( "Size of: " , stringify ! ( pixman_f_transform ) ));
assert_eq! (::std::mem::align_of::<pixman_f_transform>() , 8usize , concat
! ( "Alignment of " , stringify ! ( pixman_f_transform ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_f_transform ) ) . m as * const _
as usize } , 0usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_f_transform ) ,
"::" , stringify ! ( m ) ));
}
impl Clone for pixman_f_transform {
fn clone(&self) -> Self { *self }
}
#[repr(C)]
#[derive(Debug, Default, Copy)]
pub struct pixman_f_vector {
pub v: [f64; 3usize],
}
#[test]
fn bindgen_test_layout_pixman_f_vector() {
assert_eq!(::std::mem::size_of::<pixman_f_vector>() , 24usize , concat ! (
"Size of: " , stringify ! ( pixman_f_vector ) ));
assert_eq! (::std::mem::align_of::<pixman_f_vector>() , 8usize , concat !
( "Alignment of " , stringify ! ( pixman_f_vector ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_f_vector ) ) . v as * const _ as
usize } , 0usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_f_vector ) ,
"::" , stringify ! ( v ) ));
}
impl Clone for pixman_f_vector {
fn clone(&self) -> Self { *self }
}
extern "C" {
pub fn pixman_transform_from_pixman_f_transform(t: *mut pixman_transform,
ft:
*const pixman_f_transform)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_f_transform_from_pixman_transform(ft:
*mut pixman_f_transform,
t:
*const pixman_transform);
}
extern "C" {
pub fn pixman_f_transform_invert(dst: *mut pixman_f_transform,
src: *const pixman_f_transform)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_f_transform_point(t: *const pixman_f_transform,
v: *mut pixman_f_vector) -> pixman_bool_t;
}
extern "C" {
pub fn pixman_f_transform_point_3d(t: *const pixman_f_transform,
v: *mut pixman_f_vector);
}
extern "C" {
pub fn pixman_f_transform_multiply(dst: *mut pixman_f_transform,
l: *const pixman_f_transform,
r: *const pixman_f_transform);
}
extern "C" {
pub fn pixman_f_transform_init_scale(t: *mut pixman_f_transform, sx: f64,
sy: f64);
}
extern "C" {
pub fn pixman_f_transform_scale(forward: *mut pixman_f_transform,
reverse: *mut pixman_f_transform, sx: f64,
sy: f64) -> pixman_bool_t;
}
extern "C" {
pub fn pixman_f_transform_init_rotate(t: *mut pixman_f_transform,
cos: f64, sin: f64);
}
extern "C" {
pub fn pixman_f_transform_rotate(forward: *mut pixman_f_transform,
reverse: *mut pixman_f_transform, c: f64,
s: f64) -> pixman_bool_t;
}
extern "C" {
pub fn pixman_f_transform_init_translate(t: *mut pixman_f_transform,
tx: f64, ty: f64);
}
extern "C" {
pub fn pixman_f_transform_translate(forward: *mut pixman_f_transform,
reverse: *mut pixman_f_transform,
tx: f64, ty: f64) -> pixman_bool_t;
}
extern "C" {
pub fn pixman_f_transform_bounds(t: *const pixman_f_transform,
b: *mut pixman_box16) -> pixman_bool_t;
}
extern "C" {
pub fn pixman_f_transform_init_identity(t: *mut pixman_f_transform);
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum pixman_repeat_t {
PIXMAN_REPEAT_NONE = 0,
PIXMAN_REPEAT_NORMAL = 1,
PIXMAN_REPEAT_PAD = 2,
PIXMAN_REPEAT_REFLECT = 3,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum pixman_filter_t {
PIXMAN_FILTER_FAST = 0,
PIXMAN_FILTER_GOOD = 1,
PIXMAN_FILTER_BEST = 2,
PIXMAN_FILTER_NEAREST = 3,
PIXMAN_FILTER_BILINEAR = 4,
PIXMAN_FILTER_CONVOLUTION = 5,
PIXMAN_FILTER_SEPARABLE_CONVOLUTION = 6,
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum pixman_op_t {
PIXMAN_OP_CLEAR = 0,
PIXMAN_OP_SRC = 1,
PIXMAN_OP_DST = 2,
PIXMAN_OP_OVER = 3,
PIXMAN_OP_OVER_REVERSE = 4,
PIXMAN_OP_IN = 5,
PIXMAN_OP_IN_REVERSE = 6,
PIXMAN_OP_OUT = 7,
PIXMAN_OP_OUT_REVERSE = 8,
PIXMAN_OP_ATOP = 9,
PIXMAN_OP_ATOP_REVERSE = 10,
PIXMAN_OP_XOR = 11,
PIXMAN_OP_ADD = 12,
PIXMAN_OP_SATURATE = 13,
PIXMAN_OP_DISJOINT_CLEAR = 16,
PIXMAN_OP_DISJOINT_SRC = 17,
PIXMAN_OP_DISJOINT_DST = 18,
PIXMAN_OP_DISJOINT_OVER = 19,
PIXMAN_OP_DISJOINT_OVER_REVERSE = 20,
PIXMAN_OP_DISJOINT_IN = 21,
PIXMAN_OP_DISJOINT_IN_REVERSE = 22,
PIXMAN_OP_DISJOINT_OUT = 23,
PIXMAN_OP_DISJOINT_OUT_REVERSE = 24,
PIXMAN_OP_DISJOINT_ATOP = 25,
PIXMAN_OP_DISJOINT_ATOP_REVERSE = 26,
PIXMAN_OP_DISJOINT_XOR = 27,
PIXMAN_OP_CONJOINT_CLEAR = 32,
PIXMAN_OP_CONJOINT_SRC = 33,
PIXMAN_OP_CONJOINT_DST = 34,
PIXMAN_OP_CONJOINT_OVER = 35,
PIXMAN_OP_CONJOINT_OVER_REVERSE = 36,
PIXMAN_OP_CONJOINT_IN = 37,
PIXMAN_OP_CONJOINT_IN_REVERSE = 38,
PIXMAN_OP_CONJOINT_OUT = 39,
PIXMAN_OP_CONJOINT_OUT_REVERSE = 40,
PIXMAN_OP_CONJOINT_ATOP = 41,
PIXMAN_OP_CONJOINT_ATOP_REVERSE = 42,
PIXMAN_OP_CONJOINT_XOR = 43,
PIXMAN_OP_MULTIPLY = 48,
PIXMAN_OP_SCREEN = 49,
PIXMAN_OP_OVERLAY = 50,
PIXMAN_OP_DARKEN = 51,
PIXMAN_OP_LIGHTEN = 52,
PIXMAN_OP_COLOR_DODGE = 53,
PIXMAN_OP_COLOR_BURN = 54,
PIXMAN_OP_HARD_LIGHT = 55,
PIXMAN_OP_SOFT_LIGHT = 56,
PIXMAN_OP_DIFFERENCE = 57,
PIXMAN_OP_EXCLUSION = 58,
PIXMAN_OP_HSL_HUE = 59,
PIXMAN_OP_HSL_SATURATION = 60,
PIXMAN_OP_HSL_COLOR = 61,
PIXMAN_OP_HSL_LUMINOSITY = 62,
}
#[repr(C)]
#[derive(Debug, Default, Copy)]
pub struct pixman_region16_data {
pub size: libc::c_long,
pub numRects: libc::c_long,
}
#[test]
fn bindgen_test_layout_pixman_region16_data() {
assert_eq!(::std::mem::size_of::<pixman_region16_data>() , 16usize ,
concat ! ( "Size of: " , stringify ! ( pixman_region16_data )
));
assert_eq! (::std::mem::align_of::<pixman_region16_data>() , 8usize ,
concat ! (
"Alignment of " , stringify ! ( pixman_region16_data ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_region16_data ) ) . size as *
const _ as usize } , 0usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_region16_data )
, "::" , stringify ! ( size ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_region16_data ) ) . numRects as *
const _ as usize } , 8usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_region16_data )
, "::" , stringify ! ( numRects ) ));
}
impl Clone for pixman_region16_data {
fn clone(&self) -> Self { *self }
}
pub type pixman_region16_data_t = pixman_region16_data;
pub type pixman_box16_t = pixman_box16;
#[repr(C)]
#[derive(Debug, Default, Copy)]
pub struct pixman_rectangle16 {
pub x: i16,
pub y: i16,
pub width: u16,
pub height: u16,
}
#[test]
fn bindgen_test_layout_pixman_rectangle16() {
assert_eq!(::std::mem::size_of::<pixman_rectangle16>() , 8usize , concat !
( "Size of: " , stringify ! ( pixman_rectangle16 ) ));
assert_eq! (::std::mem::align_of::<pixman_rectangle16>() , 2usize , concat
! ( "Alignment of " , stringify ! ( pixman_rectangle16 ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_rectangle16 ) ) . x as * const _
as usize } , 0usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_rectangle16 ) ,
"::" , stringify ! ( x ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_rectangle16 ) ) . y as * const _
as usize } , 2usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_rectangle16 ) ,
"::" , stringify ! ( y ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_rectangle16 ) ) . width as * const
_ as usize } , 4usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_rectangle16 ) ,
"::" , stringify ! ( width ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_rectangle16 ) ) . height as *
const _ as usize } , 6usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_rectangle16 ) ,
"::" , stringify ! ( height ) ));
}
impl Clone for pixman_rectangle16 {
fn clone(&self) -> Self { *self }
}
pub type pixman_rectangle16_t = pixman_rectangle16;
#[repr(C)]
#[derive(Debug, Copy)]
pub struct pixman_region16 {
pub extents: pixman_box16_t,
pub data: *mut pixman_region16_data_t,
}
#[test]
fn bindgen_test_layout_pixman_region16() {
assert_eq!(::std::mem::size_of::<pixman_region16>() , 16usize , concat ! (
"Size of: " , stringify ! ( pixman_region16 ) ));
assert_eq! (::std::mem::align_of::<pixman_region16>() , 8usize , concat !
( "Alignment of " , stringify ! ( pixman_region16 ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_region16 ) ) . extents as * const
_ as usize } , 0usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_region16 ) ,
"::" , stringify ! ( extents ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_region16 ) ) . data as * const _
as usize } , 8usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_region16 ) ,
"::" , stringify ! ( data ) ));
}
impl Clone for pixman_region16 {
fn clone(&self) -> Self { *self }
}
impl Default for pixman_region16 {
fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type pixman_region16_t = pixman_region16;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum pixman_region_overlap_t {
PIXMAN_REGION_OUT = 0,
PIXMAN_REGION_IN = 1,
PIXMAN_REGION_PART = 2,
}
extern "C" {
pub fn pixman_region_set_static_pointers(empty_box: *mut pixman_box16_t,
empty_data:
*mut pixman_region16_data_t,
broken_data:
*mut pixman_region16_data_t);
}
extern "C" {
pub fn pixman_region_init(region: *mut pixman_region16_t);
}
extern "C" {
pub fn pixman_region_init_rect(region: *mut pixman_region16_t,
x: libc::c_int, y: libc::c_int,
width: libc::c_uint, height: libc::c_uint);
}
extern "C" {
pub fn pixman_region_init_rects(region: *mut pixman_region16_t,
boxes: *const pixman_box16_t,
count: libc::c_int) -> pixman_bool_t;
}
extern "C" {
pub fn pixman_region_init_with_extents(region: *mut pixman_region16_t,
extents: *mut pixman_box16_t);
}
extern "C" {
pub fn pixman_region_init_from_image(region: *mut pixman_region16_t,
image: *mut pixman_image_t);
}
extern "C" {
pub fn pixman_region_fini(region: *mut pixman_region16_t);
}
extern "C" {
pub fn pixman_region_translate(region: *mut pixman_region16_t,
x: libc::c_int, y: libc::c_int);
}
extern "C" {
pub fn pixman_region_copy(dest: *mut pixman_region16_t,
source: *mut pixman_region16_t)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_region_intersect(new_reg: *mut pixman_region16_t,
reg1: *mut pixman_region16_t,
reg2: *mut pixman_region16_t)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_region_union(new_reg: *mut pixman_region16_t,
reg1: *mut pixman_region16_t,
reg2: *mut pixman_region16_t) -> pixman_bool_t;
}
extern "C" {
pub fn pixman_region_union_rect(dest: *mut pixman_region16_t,
source: *mut pixman_region16_t,
x: libc::c_int, y: libc::c_int,
width: libc::c_uint, height: libc::c_uint)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_region_intersect_rect(dest: *mut pixman_region16_t,
source: *mut pixman_region16_t,
x: libc::c_int, y: libc::c_int,
width: libc::c_uint,
height: libc::c_uint)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_region_subtract(reg_d: *mut pixman_region16_t,
reg_m: *mut pixman_region16_t,
reg_s: *mut pixman_region16_t)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_region_inverse(new_reg: *mut pixman_region16_t,
reg1: *mut pixman_region16_t,
inv_rect: *mut pixman_box16_t)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_region_contains_point(region: *mut pixman_region16_t,
x: libc::c_int, y: libc::c_int,
box_: *mut pixman_box16_t)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_region_contains_rectangle(region: *mut pixman_region16_t,
prect: *mut pixman_box16_t)
-> pixman_region_overlap_t;
}
extern "C" {
pub fn pixman_region_not_empty(region: *mut pixman_region16_t)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_region_extents(region: *mut pixman_region16_t)
-> *mut pixman_box16_t;
}
extern "C" {
pub fn pixman_region_n_rects(region: *mut pixman_region16_t)
-> libc::c_int;
}
extern "C" {
pub fn pixman_region_rectangles(region: *mut pixman_region16_t,
n_rects: *mut libc::c_int)
-> *mut pixman_box16_t;
}
extern "C" {
pub fn pixman_region_equal(region1: *mut pixman_region16_t,
region2: *mut pixman_region16_t)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_region_selfcheck(region: *mut pixman_region16_t)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_region_reset(region: *mut pixman_region16_t,
box_: *mut pixman_box16_t);
}
extern "C" {
pub fn pixman_region_clear(region: *mut pixman_region16_t);
}
#[repr(C)]
#[derive(Debug, Default, Copy)]
pub struct pixman_region32_data {
pub size: libc::c_long,
pub numRects: libc::c_long,
}
#[test]
fn bindgen_test_layout_pixman_region32_data() {
assert_eq!(::std::mem::size_of::<pixman_region32_data>() , 16usize ,
concat ! ( "Size of: " , stringify ! ( pixman_region32_data )
));
assert_eq! (::std::mem::align_of::<pixman_region32_data>() , 8usize ,
concat ! (
"Alignment of " , stringify ! ( pixman_region32_data ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_region32_data ) ) . size as *
const _ as usize } , 0usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_region32_data )
, "::" , stringify ! ( size ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_region32_data ) ) . numRects as *
const _ as usize } , 8usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_region32_data )
, "::" , stringify ! ( numRects ) ));
}
impl Clone for pixman_region32_data {
fn clone(&self) -> Self { *self }
}
pub type pixman_region32_data_t = pixman_region32_data;
#[repr(C)]
#[derive(Debug, Default, Copy)]
pub struct pixman_box32 {
pub x1: i32,
pub y1: i32,
pub x2: i32,
pub y2: i32,
}
#[test]
fn bindgen_test_layout_pixman_box32() {
assert_eq!(::std::mem::size_of::<pixman_box32>() , 16usize , concat ! (
"Size of: " , stringify ! ( pixman_box32 ) ));
assert_eq! (::std::mem::align_of::<pixman_box32>() , 4usize , concat ! (
"Alignment of " , stringify ! ( pixman_box32 ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_box32 ) ) . x1 as * const _ as
usize } , 0usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_box32 ) , "::" ,
stringify ! ( x1 ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_box32 ) ) . y1 as * const _ as
usize } , 4usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_box32 ) , "::" ,
stringify ! ( y1 ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_box32 ) ) . x2 as * const _ as
usize } , 8usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_box32 ) , "::" ,
stringify ! ( x2 ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_box32 ) ) . y2 as * const _ as
usize } , 12usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_box32 ) , "::" ,
stringify ! ( y2 ) ));
}
impl Clone for pixman_box32 {
fn clone(&self) -> Self { *self }
}
pub type pixman_box32_t = pixman_box32;
#[repr(C)]
#[derive(Debug, Copy)]
pub struct pixman_region32 {
pub extents: pixman_box32_t,
pub data: *mut pixman_region32_data_t,
}
#[test]
fn bindgen_test_layout_pixman_region32() {
assert_eq!(::std::mem::size_of::<pixman_region32>() , 24usize , concat ! (
"Size of: " , stringify ! ( pixman_region32 ) ));
assert_eq! (::std::mem::align_of::<pixman_region32>() , 8usize , concat !
( "Alignment of " , stringify ! ( pixman_region32 ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_region32 ) ) . extents as * const
_ as usize } , 0usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_region32 ) ,
"::" , stringify ! ( extents ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_region32 ) ) . data as * const _
as usize } , 16usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_region32 ) ,
"::" , stringify ! ( data ) ));
}
impl Clone for pixman_region32 {
fn clone(&self) -> Self { *self }
}
impl Default for pixman_region32 {
fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type pixman_region32_t = pixman_region32;
extern "C" {
pub fn pixman_region32_init(region: *mut pixman_region32_t);
}
extern "C" {
pub fn pixman_region32_init_rect(region: *mut pixman_region32_t,
x: libc::c_int, y: libc::c_int,
width: libc::c_uint,
height: libc::c_uint);
}
extern "C" {
pub fn pixman_region32_init_rects(region: *mut pixman_region32_t,
boxes: *const pixman_box32_t,
count: libc::c_int) -> pixman_bool_t;
}
extern "C" {
pub fn pixman_region32_init_with_extents(region: *mut pixman_region32_t,
extents: *mut pixman_box32_t);
}
extern "C" {
pub fn pixman_region32_init_from_image(region: *mut pixman_region32_t,
image: *mut pixman_image_t);
}
extern "C" {
pub fn pixman_region32_fini(region: *mut pixman_region32_t);
}
extern "C" {
pub fn pixman_region32_translate(region: *mut pixman_region32_t,
x: libc::c_int, y: libc::c_int);
}
extern "C" {
pub fn pixman_region32_copy(dest: *mut pixman_region32_t,
source: *mut pixman_region32_t)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_region32_intersect(new_reg: *mut pixman_region32_t,
reg1: *mut pixman_region32_t,
reg2: *mut pixman_region32_t)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_region32_union(new_reg: *mut pixman_region32_t,
reg1: *mut pixman_region32_t,
reg2: *mut pixman_region32_t)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_region32_intersect_rect(dest: *mut pixman_region32_t,
source: *mut pixman_region32_t,
x: libc::c_int, y: libc::c_int,
width: libc::c_uint,
height: libc::c_uint)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_region32_union_rect(dest: *mut pixman_region32_t,
source: *mut pixman_region32_t,
x: libc::c_int, y: libc::c_int,
width: libc::c_uint,
height: libc::c_uint) -> pixman_bool_t;
}
extern "C" {
pub fn pixman_region32_subtract(reg_d: *mut pixman_region32_t,
reg_m: *mut pixman_region32_t,
reg_s: *mut pixman_region32_t)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_region32_inverse(new_reg: *mut pixman_region32_t,
reg1: *mut pixman_region32_t,
inv_rect: *mut pixman_box32_t)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_region32_contains_point(region: *mut pixman_region32_t,
x: libc::c_int, y: libc::c_int,
box_: *mut pixman_box32_t)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_region32_contains_rectangle(region: *mut pixman_region32_t,
prect: *mut pixman_box32_t)
-> pixman_region_overlap_t;
}
extern "C" {
pub fn pixman_region32_not_empty(region: *mut pixman_region32_t)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_region32_extents(region: *mut pixman_region32_t)
-> *mut pixman_box32_t;
}
extern "C" {
pub fn pixman_region32_n_rects(region: *mut pixman_region32_t)
-> libc::c_int;
}
extern "C" {
pub fn pixman_region32_rectangles(region: *mut pixman_region32_t,
n_rects: *mut libc::c_int)
-> *mut pixman_box32_t;
}
extern "C" {
pub fn pixman_region32_equal(region1: *mut pixman_region32_t,
region2: *mut pixman_region32_t)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_region32_selfcheck(region: *mut pixman_region32_t)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_region32_reset(region: *mut pixman_region32_t,
box_: *mut pixman_box32_t);
}
extern "C" {
pub fn pixman_region32_clear(region: *mut pixman_region32_t);
}
extern "C" {
pub fn pixman_blt(src_bits: *mut u32, dst_bits: *mut u32,
src_stride: libc::c_int, dst_stride: libc::c_int,
src_bpp: libc::c_int, dst_bpp: libc::c_int,
src_x: libc::c_int, src_y: libc::c_int,
dest_x: libc::c_int, dest_y: libc::c_int,
width: libc::c_int, height: libc::c_int)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_fill(bits: *mut u32, stride: libc::c_int, bpp: libc::c_int,
x: libc::c_int, y: libc::c_int, width: libc::c_int,
height: libc::c_int, _xor: u32) -> pixman_bool_t;
}
extern "C" {
pub fn pixman_version() -> libc::c_int;
}
extern "C" {
pub fn pixman_version_string() -> *const libc::c_char;
}
#[repr(C)]
#[derive(Copy)]
pub struct pixman_indexed {
pub color: pixman_bool_t,
pub rgba: [u32; 256usize],
pub ent: [pixman_index_type; 32768usize],
}
#[test]
fn bindgen_test_layout_pixman_indexed() {
assert_eq!(::std::mem::size_of::<pixman_indexed>() , 33796usize , concat !
( "Size of: " , stringify ! ( pixman_indexed ) ));
assert_eq! (::std::mem::align_of::<pixman_indexed>() , 4usize , concat ! (
"Alignment of " , stringify ! ( pixman_indexed ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_indexed ) ) . color as * const _
as usize } , 0usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_indexed ) , "::"
, stringify ! ( color ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_indexed ) ) . rgba as * const _ as
usize } , 4usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_indexed ) , "::"
, stringify ! ( rgba ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_indexed ) ) . ent as * const _ as
usize } , 1028usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_indexed ) , "::"
, stringify ! ( ent ) ));
}
impl Clone for pixman_indexed {
fn clone(&self) -> Self { *self }
}
impl Default for pixman_indexed {
fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
pub type pixman_indexed_t = pixman_indexed;
#[repr(C)]
#[derive(Debug, Default, Copy)]
pub struct pixman_gradient_stop {
pub x: pixman_fixed_t,
pub color: pixman_color_t,
}
#[test]
fn bindgen_test_layout_pixman_gradient_stop() {
assert_eq!(::std::mem::size_of::<pixman_gradient_stop>() , 12usize ,
concat ! ( "Size of: " , stringify ! ( pixman_gradient_stop )
));
assert_eq! (::std::mem::align_of::<pixman_gradient_stop>() , 4usize ,
concat ! (
"Alignment of " , stringify ! ( pixman_gradient_stop ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_gradient_stop ) ) . x as * const _
as usize } , 0usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_gradient_stop )
, "::" , stringify ! ( x ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_gradient_stop ) ) . color as *
const _ as usize } , 4usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_gradient_stop )
, "::" , stringify ! ( color ) ));
}
impl Clone for pixman_gradient_stop {
fn clone(&self) -> Self { *self }
}
pub type pixman_gradient_stop_t = pixman_gradient_stop;
pub type pixman_read_memory_func_t =
::std::option::Option<unsafe extern "C" fn(src: *const libc::c_void,
size: libc::c_int) -> u32>;
pub type pixman_write_memory_func_t =
::std::option::Option<unsafe extern "C" fn(dst: *mut libc::c_void,
value: u32,
size: libc::c_int)>;
pub type pixman_image_destroy_func_t =
::std::option::Option<unsafe extern "C" fn(image: *mut pixman_image_t,
data: *mut libc::c_void)>;
pub type pixman_index_type = u8;
pub const pixman_format_code_t_PIXMAN_x4c4: pixman_format_code_t =
pixman_format_code_t::PIXMAN_c8;
pub const pixman_format_code_t_PIXMAN_x4g4: pixman_format_code_t =
pixman_format_code_t::PIXMAN_g8;
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum pixman_format_code_t {
PIXMAN_a8r8g8b8 = 537036936,
PIXMAN_x8r8g8b8 = 537004168,
PIXMAN_a8b8g8r8 = 537102472,
PIXMAN_x8b8g8r8 = 537069704,
PIXMAN_b8g8r8a8 = 537430152,
PIXMAN_b8g8r8x8 = 537397384,
PIXMAN_r8g8b8a8 = 537495688,
PIXMAN_r8g8b8x8 = 537462920,
PIXMAN_x14r6g6b6 = 537003622,
PIXMAN_x2r10g10b10 = 537004714,
PIXMAN_a2r10g10b10 = 537012906,
PIXMAN_x2b10g10r10 = 537070250,
PIXMAN_a2b10g10r10 = 537078442,
PIXMAN_a8r8g8b8_sRGB = 537561224,
PIXMAN_r8g8b8 = 402786440,
PIXMAN_b8g8r8 = 402851976,
PIXMAN_r5g6b5 = 268567909,
PIXMAN_b5g6r5 = 268633445,
PIXMAN_a1r5g5b5 = 268571989,
PIXMAN_x1r5g5b5 = 268567893,
PIXMAN_a1b5g5r5 = 268637525,
PIXMAN_x1b5g5r5 = 268633429,
PIXMAN_a4r4g4b4 = 268584004,
PIXMAN_x4r4g4b4 = 268567620,
PIXMAN_a4b4g4r4 = 268649540,
PIXMAN_x4b4g4r4 = 268633156,
PIXMAN_a8 = 134316032,
PIXMAN_r3g3b2 = 134349618,
PIXMAN_b2g3r3 = 134415154,
PIXMAN_a2r2g2b2 = 134357538,
PIXMAN_a2b2g2r2 = 134423074,
PIXMAN_c8 = 134479872,
PIXMAN_g8 = 134545408,
PIXMAN_x4a4 = 134299648,
PIXMAN_a4 = 67190784,
PIXMAN_r1g2b1 = 67240225,
PIXMAN_b1g2r1 = 67305761,
PIXMAN_a1r1g1b1 = 67244305,
PIXMAN_a1b1g1r1 = 67309841,
PIXMAN_c4 = 67371008,
PIXMAN_g4 = 67436544,
PIXMAN_a1 = 16846848,
PIXMAN_g1 = 17104896,
PIXMAN_yuy2 = 268828672,
PIXMAN_yv12 = 201785344,
}
extern "C" {
pub fn pixman_format_supported_destination(format: pixman_format_code_t)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_format_supported_source(format: pixman_format_code_t)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_image_create_solid_fill(color: *const pixman_color_t)
-> *mut pixman_image_t;
}
extern "C" {
pub fn pixman_image_create_linear_gradient(p1:
*const pixman_point_fixed_t,
p2:
*const pixman_point_fixed_t,
stops:
*const pixman_gradient_stop_t,
n_stops: libc::c_int)
-> *mut pixman_image_t;
}
extern "C" {
pub fn pixman_image_create_radial_gradient(inner:
*const pixman_point_fixed_t,
outer:
*const pixman_point_fixed_t,
inner_radius: pixman_fixed_t,
outer_radius: pixman_fixed_t,
stops:
*const pixman_gradient_stop_t,
n_stops: libc::c_int)
-> *mut pixman_image_t;
}
extern "C" {
pub fn pixman_image_create_conical_gradient(center:
*const pixman_point_fixed_t,
angle: pixman_fixed_t,
stops:
*const pixman_gradient_stop_t,
n_stops: libc::c_int)
-> *mut pixman_image_t;
}
extern "C" {
pub fn pixman_image_create_bits(format: pixman_format_code_t,
width: libc::c_int, height: libc::c_int,
bits: *mut u32,
rowstride_bytes: libc::c_int)
-> *mut pixman_image_t;
}
extern "C" {
pub fn pixman_image_create_bits_no_clear(format: pixman_format_code_t,
width: libc::c_int,
height: libc::c_int,
bits: *mut u32,
rowstride_bytes: libc::c_int)
-> *mut pixman_image_t;
}
extern "C" {
pub fn pixman_image_ref(image: *mut pixman_image_t)
-> *mut pixman_image_t;
}
extern "C" {
pub fn pixman_image_unref(image: *mut pixman_image_t) -> pixman_bool_t;
}
extern "C" {
pub fn pixman_image_set_destroy_function(image: *mut pixman_image_t,
function:
pixman_image_destroy_func_t,
data: *mut libc::c_void);
}
extern "C" {
pub fn pixman_image_get_destroy_data(image: *mut pixman_image_t)
-> *mut libc::c_void;
}
extern "C" {
pub fn pixman_image_set_clip_region(image: *mut pixman_image_t,
region: *mut pixman_region16_t)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_image_set_clip_region32(image: *mut pixman_image_t,
region: *mut pixman_region32_t)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_image_set_has_client_clip(image: *mut pixman_image_t,
clien_clip: pixman_bool_t);
}
extern "C" {
pub fn pixman_image_set_transform(image: *mut pixman_image_t,
transform: *const pixman_transform_t)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_image_set_repeat(image: *mut pixman_image_t,
repeat: pixman_repeat_t);
}
extern "C" {
pub fn pixman_image_set_filter(image: *mut pixman_image_t,
filter: pixman_filter_t,
filter_params: *const pixman_fixed_t,
n_filter_params: libc::c_int)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_image_set_source_clipping(image: *mut pixman_image_t,
source_clipping: pixman_bool_t);
}
extern "C" {
pub fn pixman_image_set_alpha_map(image: *mut pixman_image_t,
alpha_map: *mut pixman_image_t, x: i16,
y: i16);
}
extern "C" {
pub fn pixman_image_set_component_alpha(image: *mut pixman_image_t,
component_alpha: pixman_bool_t);
}
extern "C" {
pub fn pixman_image_get_component_alpha(image: *mut pixman_image_t)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_image_set_accessors(image: *mut pixman_image_t,
read_func: pixman_read_memory_func_t,
write_func: pixman_write_memory_func_t);
}
extern "C" {
pub fn pixman_image_set_indexed(image: *mut pixman_image_t,
indexed: *const pixman_indexed_t);
}
extern "C" {
pub fn pixman_image_get_data(image: *mut pixman_image_t) -> *mut u32;
}
extern "C" {
pub fn pixman_image_get_width(image: *mut pixman_image_t) -> libc::c_int;
}
extern "C" {
pub fn pixman_image_get_height(image: *mut pixman_image_t) -> libc::c_int;
}
extern "C" {
pub fn pixman_image_get_stride(image: *mut pixman_image_t) -> libc::c_int;
}
extern "C" {
pub fn pixman_image_get_depth(image: *mut pixman_image_t) -> libc::c_int;
}
extern "C" {
pub fn pixman_image_get_format(image: *mut pixman_image_t)
-> pixman_format_code_t;
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum pixman_kernel_t {
PIXMAN_KERNEL_IMPULSE = 0,
PIXMAN_KERNEL_BOX = 1,
PIXMAN_KERNEL_LINEAR = 2,
PIXMAN_KERNEL_CUBIC = 3,
PIXMAN_KERNEL_GAUSSIAN = 4,
PIXMAN_KERNEL_LANCZOS2 = 5,
PIXMAN_KERNEL_LANCZOS3 = 6,
PIXMAN_KERNEL_LANCZOS3_STRETCHED = 7,
}
extern "C" {
pub fn pixman_filter_create_separable_convolution(n_values:
*mut libc::c_int,
scale_x: pixman_fixed_t,
scale_y: pixman_fixed_t,
reconstruct_x:
pixman_kernel_t,
reconstruct_y:
pixman_kernel_t,
sample_x:
pixman_kernel_t,
sample_y:
pixman_kernel_t,
subsample_bits_x:
libc::c_int,
subsample_bits_y:
libc::c_int)
-> *mut pixman_fixed_t;
}
extern "C" {
pub fn pixman_image_fill_rectangles(op: pixman_op_t,
image: *mut pixman_image_t,
color: *const pixman_color_t,
n_rects: libc::c_int,
rects: *const pixman_rectangle16_t)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_image_fill_boxes(op: pixman_op_t, dest: *mut pixman_image_t,
color: *const pixman_color_t,
n_boxes: libc::c_int,
boxes: *const pixman_box32_t)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_compute_composite_region(region: *mut pixman_region16_t,
src_image: *mut pixman_image_t,
mask_image: *mut pixman_image_t,
dest_image: *mut pixman_image_t,
src_x: i16, src_y: i16,
mask_x: i16, mask_y: i16,
dest_x: i16, dest_y: i16,
width: u16, height: u16)
-> pixman_bool_t;
}
extern "C" {
pub fn pixman_image_composite(op: pixman_op_t, src: *mut pixman_image_t,
mask: *mut pixman_image_t,
dest: *mut pixman_image_t, src_x: i16,
src_y: i16, mask_x: i16, mask_y: i16,
dest_x: i16, dest_y: i16, width: u16,
height: u16);
}
extern "C" {
pub fn pixman_image_composite32(op: pixman_op_t, src: *mut pixman_image_t,
mask: *mut pixman_image_t,
dest: *mut pixman_image_t, src_x: i32,
src_y: i32, mask_x: i32, mask_y: i32,
dest_x: i32, dest_y: i32, width: i32,
height: i32);
}
extern "C" {
pub fn pixman_disable_out_of_bounds_workaround();
}
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct pixman_glyph_cache_t {
_unused: [u8; 0],
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct pixman_glyph_t {
pub x: libc::c_int,
pub y: libc::c_int,
pub glyph: *const libc::c_void,
}
#[test]
fn bindgen_test_layout_pixman_glyph_t() {
assert_eq!(::std::mem::size_of::<pixman_glyph_t>() , 16usize , concat ! (
"Size of: " , stringify ! ( pixman_glyph_t ) ));
assert_eq! (::std::mem::align_of::<pixman_glyph_t>() , 8usize , concat ! (
"Alignment of " , stringify ! ( pixman_glyph_t ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_glyph_t ) ) . x as * const _ as
usize } , 0usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_glyph_t ) , "::"
, stringify ! ( x ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_glyph_t ) ) . y as * const _ as
usize } , 4usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_glyph_t ) , "::"
, stringify ! ( y ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_glyph_t ) ) . glyph as * const _
as usize } , 8usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_glyph_t ) , "::"
, stringify ! ( glyph ) ));
}
impl Clone for pixman_glyph_t {
fn clone(&self) -> Self { *self }
}
impl Default for pixman_glyph_t {
fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
pub fn pixman_glyph_cache_create() -> *mut pixman_glyph_cache_t;
}
extern "C" {
pub fn pixman_glyph_cache_destroy(cache: *mut pixman_glyph_cache_t);
}
extern "C" {
pub fn pixman_glyph_cache_freeze(cache: *mut pixman_glyph_cache_t);
}
extern "C" {
pub fn pixman_glyph_cache_thaw(cache: *mut pixman_glyph_cache_t);
}
extern "C" {
pub fn pixman_glyph_cache_lookup(cache: *mut pixman_glyph_cache_t,
font_key: *mut libc::c_void,
glyph_key: *mut libc::c_void)
-> *const libc::c_void;
}
extern "C" {
pub fn pixman_glyph_cache_insert(cache: *mut pixman_glyph_cache_t,
font_key: *mut libc::c_void,
glyph_key: *mut libc::c_void,
origin_x: libc::c_int,
origin_y: libc::c_int,
glyph_image: *mut pixman_image_t)
-> *const libc::c_void;
}
extern "C" {
pub fn pixman_glyph_cache_remove(cache: *mut pixman_glyph_cache_t,
font_key: *mut libc::c_void,
glyph_key: *mut libc::c_void);
}
extern "C" {
pub fn pixman_glyph_get_extents(cache: *mut pixman_glyph_cache_t,
n_glyphs: libc::c_int,
glyphs: *mut pixman_glyph_t,
extents: *mut pixman_box32_t);
}
extern "C" {
pub fn pixman_glyph_get_mask_format(cache: *mut pixman_glyph_cache_t,
n_glyphs: libc::c_int,
glyphs: *const pixman_glyph_t)
-> pixman_format_code_t;
}
extern "C" {
pub fn pixman_composite_glyphs(op: pixman_op_t, src: *mut pixman_image_t,
dest: *mut pixman_image_t,
mask_format: pixman_format_code_t,
src_x: i32, src_y: i32, mask_x: i32,
mask_y: i32, dest_x: i32, dest_y: i32,
width: i32, height: i32,
cache: *mut pixman_glyph_cache_t,
n_glyphs: libc::c_int,
glyphs: *const pixman_glyph_t);
}
extern "C" {
pub fn pixman_composite_glyphs_no_mask(op: pixman_op_t,
src: *mut pixman_image_t,
dest: *mut pixman_image_t,
src_x: i32, src_y: i32,
dest_x: i32, dest_y: i32,
cache: *mut pixman_glyph_cache_t,
n_glyphs: libc::c_int,
glyphs: *const pixman_glyph_t);
}
#[repr(C)]
#[derive(Debug, Default, Copy)]
pub struct pixman_edge {
pub x: pixman_fixed_t,
pub e: pixman_fixed_t,
pub stepx: pixman_fixed_t,
pub signdx: pixman_fixed_t,
pub dy: pixman_fixed_t,
pub dx: pixman_fixed_t,
pub stepx_small: pixman_fixed_t,
pub stepx_big: pixman_fixed_t,
pub dx_small: pixman_fixed_t,
pub dx_big: pixman_fixed_t,
}
#[test]
fn bindgen_test_layout_pixman_edge() {
assert_eq!(::std::mem::size_of::<pixman_edge>() , 40usize , concat ! (
"Size of: " , stringify ! ( pixman_edge ) ));
assert_eq! (::std::mem::align_of::<pixman_edge>() , 4usize , concat ! (
"Alignment of " , stringify ! ( pixman_edge ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_edge ) ) . x as * const _ as usize
} , 0usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_edge ) , "::" ,
stringify ! ( x ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_edge ) ) . e as * const _ as usize
} , 4usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_edge ) , "::" ,
stringify ! ( e ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_edge ) ) . stepx as * const _ as
usize } , 8usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_edge ) , "::" ,
stringify ! ( stepx ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_edge ) ) . signdx as * const _ as
usize } , 12usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_edge ) , "::" ,
stringify ! ( signdx ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_edge ) ) . dy as * const _ as
usize } , 16usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_edge ) , "::" ,
stringify ! ( dy ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_edge ) ) . dx as * const _ as
usize } , 20usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_edge ) , "::" ,
stringify ! ( dx ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_edge ) ) . stepx_small as * const
_ as usize } , 24usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_edge ) , "::" ,
stringify ! ( stepx_small ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_edge ) ) . stepx_big as * const _
as usize } , 28usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_edge ) , "::" ,
stringify ! ( stepx_big ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_edge ) ) . dx_small as * const _
as usize } , 32usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_edge ) , "::" ,
stringify ! ( dx_small ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_edge ) ) . dx_big as * const _ as
usize } , 36usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_edge ) , "::" ,
stringify ! ( dx_big ) ));
}
impl Clone for pixman_edge {
fn clone(&self) -> Self { *self }
}
pub type pixman_edge_t = pixman_edge;
#[repr(C)]
#[derive(Debug, Default, Copy)]
pub struct pixman_trapezoid {
pub top: pixman_fixed_t,
pub bottom: pixman_fixed_t,
pub left: pixman_line_fixed_t,
pub right: pixman_line_fixed_t,
}
#[test]
fn bindgen_test_layout_pixman_trapezoid() {
assert_eq!(::std::mem::size_of::<pixman_trapezoid>() , 40usize , concat !
( "Size of: " , stringify ! ( pixman_trapezoid ) ));
assert_eq! (::std::mem::align_of::<pixman_trapezoid>() , 4usize , concat !
( "Alignment of " , stringify ! ( pixman_trapezoid ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_trapezoid ) ) . top as * const _
as usize } , 0usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_trapezoid ) ,
"::" , stringify ! ( top ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_trapezoid ) ) . bottom as * const
_ as usize } , 4usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_trapezoid ) ,
"::" , stringify ! ( bottom ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_trapezoid ) ) . left as * const _
as usize } , 8usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_trapezoid ) ,
"::" , stringify ! ( left ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_trapezoid ) ) . right as * const _
as usize } , 24usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_trapezoid ) ,
"::" , stringify ! ( right ) ));
}
impl Clone for pixman_trapezoid {
fn clone(&self) -> Self { *self }
}
pub type pixman_trapezoid_t = pixman_trapezoid;
#[repr(C)]
#[derive(Debug, Default, Copy)]
pub struct pixman_trap {
pub top: pixman_span_fix_t,
pub bot: pixman_span_fix_t,
}
#[test]
fn bindgen_test_layout_pixman_trap() {
assert_eq!(::std::mem::size_of::<pixman_trap>() , 24usize , concat ! (
"Size of: " , stringify ! ( pixman_trap ) ));
assert_eq! (::std::mem::align_of::<pixman_trap>() , 4usize , concat ! (
"Alignment of " , stringify ! ( pixman_trap ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_trap ) ) . top as * const _ as
usize } , 0usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_trap ) , "::" ,
stringify ! ( top ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_trap ) ) . bot as * const _ as
usize } , 12usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_trap ) , "::" ,
stringify ! ( bot ) ));
}
impl Clone for pixman_trap {
fn clone(&self) -> Self { *self }
}
pub type pixman_trap_t = pixman_trap;
#[repr(C)]
#[derive(Debug, Default, Copy)]
pub struct pixman_span_fix {
pub l: pixman_fixed_t,
pub r: pixman_fixed_t,
pub y: pixman_fixed_t,
}
#[test]
fn bindgen_test_layout_pixman_span_fix() {
assert_eq!(::std::mem::size_of::<pixman_span_fix>() , 12usize , concat ! (
"Size of: " , stringify ! ( pixman_span_fix ) ));
assert_eq! (::std::mem::align_of::<pixman_span_fix>() , 4usize , concat !
( "Alignment of " , stringify ! ( pixman_span_fix ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_span_fix ) ) . l as * const _ as
usize } , 0usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_span_fix ) ,
"::" , stringify ! ( l ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_span_fix ) ) . r as * const _ as
usize } , 4usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_span_fix ) ,
"::" , stringify ! ( r ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_span_fix ) ) . y as * const _ as
usize } , 8usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_span_fix ) ,
"::" , stringify ! ( y ) ));
}
impl Clone for pixman_span_fix {
fn clone(&self) -> Self { *self }
}
pub type pixman_span_fix_t = pixman_span_fix;
#[repr(C)]
#[derive(Debug, Default, Copy)]
pub struct pixman_triangle {
pub p1: pixman_point_fixed_t,
pub p2: pixman_point_fixed_t,
pub p3: pixman_point_fixed_t,
}
#[test]
fn bindgen_test_layout_pixman_triangle() {
assert_eq!(::std::mem::size_of::<pixman_triangle>() , 24usize , concat ! (
"Size of: " , stringify ! ( pixman_triangle ) ));
assert_eq! (::std::mem::align_of::<pixman_triangle>() , 4usize , concat !
( "Alignment of " , stringify ! ( pixman_triangle ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_triangle ) ) . p1 as * const _ as
usize } , 0usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_triangle ) ,
"::" , stringify ! ( p1 ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_triangle ) ) . p2 as * const _ as
usize } , 8usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_triangle ) ,
"::" , stringify ! ( p2 ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const pixman_triangle ) ) . p3 as * const _ as
usize } , 16usize , concat ! (
"Alignment of field: " , stringify ! ( pixman_triangle ) ,
"::" , stringify ! ( p3 ) ));
}
impl Clone for pixman_triangle {
fn clone(&self) -> Self { *self }
}
pub type pixman_triangle_t = pixman_triangle;
extern "C" {
pub fn pixman_sample_ceil_y(y: pixman_fixed_t, bpp: libc::c_int)
-> pixman_fixed_t;
}
extern "C" {
pub fn pixman_sample_floor_y(y: pixman_fixed_t, bpp: libc::c_int)
-> pixman_fixed_t;
}
extern "C" {
pub fn pixman_edge_step(e: *mut pixman_edge_t, n: libc::c_int);
}
extern "C" {
pub fn pixman_edge_init(e: *mut pixman_edge_t, bpp: libc::c_int,
y_start: pixman_fixed_t, x_top: pixman_fixed_t,
y_top: pixman_fixed_t, x_bot: pixman_fixed_t,
y_bot: pixman_fixed_t);
}
extern "C" {
pub fn pixman_line_fixed_edge_init(e: *mut pixman_edge_t,
bpp: libc::c_int, y: pixman_fixed_t,
line: *const pixman_line_fixed_t,
x_off: libc::c_int,
y_off: libc::c_int);
}
extern "C" {
pub fn pixman_rasterize_edges(image: *mut pixman_image_t,
l: *mut pixman_edge_t,
r: *mut pixman_edge_t, t: pixman_fixed_t,
b: pixman_fixed_t);
}
extern "C" {
pub fn pixman_add_traps(image: *mut pixman_image_t, x_off: i16,
y_off: i16, ntrap: libc::c_int,
traps: *const pixman_trap_t);
}
extern "C" {
pub fn pixman_add_trapezoids(image: *mut pixman_image_t, x_off: i16,
y_off: libc::c_int, ntraps: libc::c_int,
traps: *const pixman_trapezoid_t);
}
extern "C" {
pub fn pixman_rasterize_trapezoid(image: *mut pixman_image_t,
trap: *const pixman_trapezoid_t,
x_off: libc::c_int, y_off: libc::c_int);
}
extern "C" {
pub fn pixman_composite_trapezoids(op: pixman_op_t,
src: *mut pixman_image_t,
dst: *mut pixman_image_t,
mask_format: pixman_format_code_t,
x_src: libc::c_int, y_src: libc::c_int,
x_dst: libc::c_int, y_dst: libc::c_int,
n_traps: libc::c_int,
traps: *const pixman_trapezoid_t);
}
extern "C" {
pub fn pixman_composite_triangles(op: pixman_op_t,
src: *mut pixman_image_t,
dst: *mut pixman_image_t,
mask_format: pixman_format_code_t,
x_src: libc::c_int, y_src: libc::c_int,
x_dst: libc::c_int, y_dst: libc::c_int,
n_tris: libc::c_int,
tris: *const pixman_triangle_t);
}
extern "C" {
pub fn pixman_add_triangles(image: *mut pixman_image_t, x_off: i32,
y_off: i32, n_tris: libc::c_int,
tris: *const pixman_triangle_t);
}
#[repr(u32)]
#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
pub enum wl_output_transform {
WL_OUTPUT_TRANSFORM_NORMAL = 0,
WL_OUTPUT_TRANSFORM_90 = 1,
WL_OUTPUT_TRANSFORM_180 = 2,
WL_OUTPUT_TRANSFORM_270 = 3,
WL_OUTPUT_TRANSFORM_FLIPPED = 4,
WL_OUTPUT_TRANSFORM_FLIPPED_90 = 5,
WL_OUTPUT_TRANSFORM_FLIPPED_180 = 6,
WL_OUTPUT_TRANSFORM_FLIPPED_270 = 7,
}
extern "C" {
pub fn wlr_region_scale(dst: *mut pixman_region32_t,
src: *mut pixman_region32_t, scale: f32);
}
extern "C" {
pub fn wlr_region_transform(dst: *mut pixman_region32_t,
src: *mut pixman_region32_t,
transform: wl_output_transform,
width: libc::c_int, height: libc::c_int);
}
extern "C" {
pub fn wlr_region_expand(dst: *mut pixman_region32_t,
src: *mut pixman_region32_t,
distance: libc::c_int);
}
extern "C" {
pub fn wlr_region_rotated_bounds(dst: *mut pixman_region32_t,
src: *mut pixman_region32_t,
rotation: f32, ox: libc::c_int,
oy: libc::c_int);
}
extern "C" {
pub fn wlr_region_confine(region: *mut pixman_region32_t, x1: f64,
y1: f64, x2: f64, y2: f64, x2_out: *mut f64,
y2_out: *mut f64) -> bool;
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct wlr_xcursor_image {
pub width: u32,
pub height: u32,
pub hotspot_x: u32,
pub hotspot_y: u32,
pub delay: u32,
pub buffer: *mut u8,
}
#[test]
fn bindgen_test_layout_wlr_xcursor_image() {
assert_eq!(::std::mem::size_of::<wlr_xcursor_image>() , 32usize , concat !
( "Size of: " , stringify ! ( wlr_xcursor_image ) ));
assert_eq! (::std::mem::align_of::<wlr_xcursor_image>() , 8usize , concat
! ( "Alignment of " , stringify ! ( wlr_xcursor_image ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const wlr_xcursor_image ) ) . width as * const
_ as usize } , 0usize , concat ! (
"Alignment of field: " , stringify ! ( wlr_xcursor_image ) ,
"::" , stringify ! ( width ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const wlr_xcursor_image ) ) . height as * const
_ as usize } , 4usize , concat ! (
"Alignment of field: " , stringify ! ( wlr_xcursor_image ) ,
"::" , stringify ! ( height ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const wlr_xcursor_image ) ) . hotspot_x as *
const _ as usize } , 8usize , concat ! (
"Alignment of field: " , stringify ! ( wlr_xcursor_image ) ,
"::" , stringify ! ( hotspot_x ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const wlr_xcursor_image ) ) . hotspot_y as *
const _ as usize } , 12usize , concat ! (
"Alignment of field: " , stringify ! ( wlr_xcursor_image ) ,
"::" , stringify ! ( hotspot_y ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const wlr_xcursor_image ) ) . delay as * const
_ as usize } , 16usize , concat ! (
"Alignment of field: " , stringify ! ( wlr_xcursor_image ) ,
"::" , stringify ! ( delay ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const wlr_xcursor_image ) ) . buffer as * const
_ as usize } , 24usize , concat ! (
"Alignment of field: " , stringify ! ( wlr_xcursor_image ) ,
"::" , stringify ! ( buffer ) ));
}
impl Clone for wlr_xcursor_image {
fn clone(&self) -> Self { *self }
}
impl Default for wlr_xcursor_image {
fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct wlr_xcursor {
pub image_count: libc::c_uint,
pub images: *mut *mut wlr_xcursor_image,
pub name: *mut libc::c_char,
pub total_delay: u32,
}
#[test]
fn bindgen_test_layout_wlr_xcursor() {
assert_eq!(::std::mem::size_of::<wlr_xcursor>() , 32usize , concat ! (
"Size of: " , stringify ! ( wlr_xcursor ) ));
assert_eq! (::std::mem::align_of::<wlr_xcursor>() , 8usize , concat ! (
"Alignment of " , stringify ! ( wlr_xcursor ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const wlr_xcursor ) ) . image_count as * const
_ as usize } , 0usize , concat ! (
"Alignment of field: " , stringify ! ( wlr_xcursor ) , "::" ,
stringify ! ( image_count ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const wlr_xcursor ) ) . images as * const _ as
usize } , 8usize , concat ! (
"Alignment of field: " , stringify ! ( wlr_xcursor ) , "::" ,
stringify ! ( images ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const wlr_xcursor ) ) . name as * const _ as
usize } , 16usize , concat ! (
"Alignment of field: " , stringify ! ( wlr_xcursor ) , "::" ,
stringify ! ( name ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const wlr_xcursor ) ) . total_delay as * const
_ as usize } , 24usize , concat ! (
"Alignment of field: " , stringify ! ( wlr_xcursor ) , "::" ,
stringify ! ( total_delay ) ));
}
impl Clone for wlr_xcursor {
fn clone(&self) -> Self { *self }
}
impl Default for wlr_xcursor {
fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
#[repr(C)]
#[derive(Debug, Copy)]
pub struct wlr_xcursor_theme {
pub cursor_count: libc::c_uint,
pub cursors: *mut *mut wlr_xcursor,
pub name: *mut libc::c_char,
pub size: libc::c_int,
}
#[test]
fn bindgen_test_layout_wlr_xcursor_theme() {
assert_eq!(::std::mem::size_of::<wlr_xcursor_theme>() , 32usize , concat !
( "Size of: " , stringify ! ( wlr_xcursor_theme ) ));
assert_eq! (::std::mem::align_of::<wlr_xcursor_theme>() , 8usize , concat
! ( "Alignment of " , stringify ! ( wlr_xcursor_theme ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const wlr_xcursor_theme ) ) . cursor_count as *
const _ as usize } , 0usize , concat ! (
"Alignment of field: " , stringify ! ( wlr_xcursor_theme ) ,
"::" , stringify ! ( cursor_count ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const wlr_xcursor_theme ) ) . cursors as *
const _ as usize } , 8usize , concat ! (
"Alignment of field: " , stringify ! ( wlr_xcursor_theme ) ,
"::" , stringify ! ( cursors ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const wlr_xcursor_theme ) ) . name as * const _
as usize } , 16usize , concat ! (
"Alignment of field: " , stringify ! ( wlr_xcursor_theme ) ,
"::" , stringify ! ( name ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const wlr_xcursor_theme ) ) . size as * const _
as usize } , 24usize , concat ! (
"Alignment of field: " , stringify ! ( wlr_xcursor_theme ) ,
"::" , stringify ! ( size ) ));
}
impl Clone for wlr_xcursor_theme {
fn clone(&self) -> Self { *self }
}
impl Default for wlr_xcursor_theme {
fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}
extern "C" {
pub fn wlr_xcursor_theme_load(name: *const libc::c_char,
size: libc::c_int)
-> *mut wlr_xcursor_theme;
}
extern "C" {
pub fn wlr_xcursor_theme_destroy(theme: *mut wlr_xcursor_theme);
}
extern "C" {
pub fn wlr_xcursor_theme_get_cursor(theme: *mut wlr_xcursor_theme,
name: *const libc::c_char)
-> *mut wlr_xcursor;
}
extern "C" {
pub fn wlr_xcursor_frame(cursor: *mut wlr_xcursor, time: u32)
-> libc::c_int;
}
extern "C" {
pub fn wlr_xcursor_get_resize_name(edges: wlr_edges)
-> *const libc::c_char;
}
pub type __builtin_va_list = [__va_list_tag; 1usize];
#[repr(C)]
#[derive(Debug, Copy)]
pub struct __va_list_tag {
pub gp_offset: libc::c_uint,
pub fp_offset: libc::c_uint,
pub overflow_arg_area: *mut libc::c_void,
pub reg_save_area: *mut libc::c_void,
}
#[test]
fn bindgen_test_layout___va_list_tag() {
assert_eq!(::std::mem::size_of::<__va_list_tag>() , 24usize , concat ! (
"Size of: " , stringify ! ( __va_list_tag ) ));
assert_eq! (::std::mem::align_of::<__va_list_tag>() , 8usize , concat ! (
"Alignment of " , stringify ! ( __va_list_tag ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const __va_list_tag ) ) . gp_offset as * const
_ as usize } , 0usize , concat ! (
"Alignment of field: " , stringify ! ( __va_list_tag ) , "::"
, stringify ! ( gp_offset ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const __va_list_tag ) ) . fp_offset as * const
_ as usize } , 4usize , concat ! (
"Alignment of field: " , stringify ! ( __va_list_tag ) , "::"
, stringify ! ( fp_offset ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const __va_list_tag ) ) . overflow_arg_area as
* const _ as usize } , 8usize , concat ! (
"Alignment of field: " , stringify ! ( __va_list_tag ) , "::"
, stringify ! ( overflow_arg_area ) ));
assert_eq! (unsafe {
& ( * ( 0 as * const __va_list_tag ) ) . reg_save_area as *
const _ as usize } , 16usize , concat ! (
"Alignment of field: " , stringify ! ( __va_list_tag ) , "::"
, stringify ! ( reg_save_area ) ));
}
impl Clone for __va_list_tag {
fn clone(&self) -> Self { *self }
}
impl Default for __va_list_tag {
fn default() -> Self { unsafe { ::std::mem::zeroed() } }
}